lib/glesv2: intro `read_pixels`

[nit.git] / lib / glesv2 / glesv2.nit

diff --git a/lib/glesv2/glesv2.nit b/lib/glesv2/glesv2.nit
index 814ec68..30ccd68 100644 (file)
--- a/lib/glesv2/glesv2.nit
+++ b/lib/glesv2/glesv2.nit
@@ -328,8 +328,13 @@ end
 # An OpenGL ES 2.0 error code
 extern class GLError
        super GLEnum
+
+       # Is there no error?
        fun is_ok: Bool do return is_no_error
+
+       # Is this not an error?
        fun is_no_error: Bool `{ return recv == GL_NO_ERROR; `}
+
        fun is_invalid_enum: Bool `{ return recv == GL_INVALID_ENUM; `}
        fun is_invalid_value: Bool `{ return recv == GL_INVALID_VALUE; `}
        fun is_invalid_operation: Bool `{ return recv == GL_INVALID_OPERATION; `}
@@ -420,6 +425,11 @@ class GLES
        # Set the viewport
        fun viewport(x, y, width, height: Int) `{ glViewport(x, y, width, height); `}
 
+       # Specify mapping of depth values from normalized device coordinates to window coordinates
+       #
+       # Default at `gl_depth_range(0.0, 1.0)`
+       fun depth_range(near, far: Float) `{ glDepthRangef(near, far); `}
+
        # Define front- and back-facing polygons
        #
        # Front-facing polygons are clockwise if `value`, counter-clockwise otherwise.
@@ -473,6 +483,38 @@ class GLES
        # Should always return `true` in OpenGL ES 2.0 and 3.0.
        fun shader_compiler: Bool do return get_bool(0x8DFA)
 
+       # Enable or disable writing into the depth buffer
+       fun depth_mask(value: Bool) `{ glDepthMask(value); `}
+
+       # Set the scale and units used to calculate depth values
+       fun polygon_offset(factor, units: Float) `{ glPolygonOffset(factor, units); `}
+
+       # Specify the width of rasterized lines
+       fun line_width(width: Float) `{ glLineWidth(width); `}
+
+       # Set the pixel arithmetic for the blending operations
+       #
+       # Defaultvalues before assignation:
+       # * `src_factor`: `GLBlendFactor::one`
+       # * `dst_factor`: `GLBlendFactor::zero`
+       fun blend_func(src_factor, dst_factor: GLBlendFactor) `{
+               glBlendFunc(src_factor, dst_factor);
+       `}
+
+       # Specify the value used for depth buffer comparisons
+       #
+       # Default value is `GLDepthFunc::less`
+       #
+       # Foreign: glDepthFunc
+       fun depth_func(func: GLDepthFunc) `{ glDepthFunc(func); `}
+
+       # Copy a block of pixels from the framebuffer of `fomat` and `typ` at `data`
+       #
+       # Foreign: glReadPixel
+       fun read_pixels(x, y, width, height: Int, format: GLPixelFormat, typ: GLPixelType, data: Pointer) `{
+               glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
+       `}
+
        # Set the texture minifying function
        #
        # Foreign: glTexParameter with GL_TEXTURE_MIN_FILTER
@@ -500,6 +542,11 @@ class GLES
        fun tex_parameter_wrap_t(target: GLTextureTarget, value: GLTextureWrap) `{
                glTexParameteri(target, GL_TEXTURE_WRAP_T, value);
        `}
+
+       # Render primitives from array data
+       #
+       # Foreign: glDrawArrays
+       fun draw_arrays(mode: GLDrawMode, from, count: Int) `{ glDrawArrays(mode, from, count); `}
 end
 
 # Float related data types of OpenGL ES 2.0 shaders
@@ -543,6 +590,83 @@ extern class GLDataType
        fun is_sampler_cube: Bool `{ return recv == GL_SAMPLER_CUBE; `}
 end
 
+# Kind of primitives to render with `GLES::draw_arrays`
+extern class GLDrawMode
+       super GLEnum
+
+       new points `{ return GL_POINTS; `}
+       new line_strip `{ return GL_LINE_STRIP; `}
+       new line_loop `{ return GL_LINE_LOOP; `}
+       new lines `{ return GL_LINES; `}
+       new triangle_strip `{ return GL_TRIANGLE_STRIP; `}
+       new triangle_fan `{ return GL_TRIANGLE_FAN; `}
+       new triangles `{ return GL_TRIANGLES; `}
+end
+
+# Pixel arithmetic for blending operations
+#
+# Used by `GLES::blend_func`
+extern class GLBlendFactor
+       super GLEnum
+
+       new zero `{ return GL_ZERO; `}
+       new one `{ return GL_ONE; `}
+       new src_color `{ return GL_SRC_COLOR; `}
+       new one_minus_src_color `{ return GL_ONE_MINUS_SRC_COLOR; `}
+       new dst_color `{ return GL_DST_COLOR; `}
+       new one_minus_dst_color `{ return GL_ONE_MINUS_DST_COLOR; `}
+       new src_alpha `{ return GL_SRC_ALPHA; `}
+       new one_minus_src_alpha `{ return GL_ONE_MINUS_SRC_ALPHA; `}
+       new dst_alpha `{ return GL_DST_ALPHA; `}
+       new one_minus_dst_alpha `{ return GL_ONE_MINUS_DST_ALPHA; `}
+       new constant_color `{ return GL_CONSTANT_COLOR; `}
+       new one_minus_constant_color `{ return GL_ONE_MINUS_CONSTANT_COLOR; `}
+       new constant_alpha `{ return GL_CONSTANT_ALPHA; `}
+       new one_minus_constant_alpha `{ return GL_ONE_MINUS_CONSTANT_ALPHA; `}
+
+       # Used for destination only
+       new src_alpha_saturate `{ return GL_SRC_ALPHA_SATURATE; `}
+end
+
+# Condition under which a pixel will be drawn
+#
+# Used by `GLES::depth_func`
+extern class GLDepthFunc
+       super GLEnum
+
+        new never `{ return GL_NEVER; `}
+        new less `{ return GL_LESS; `}
+        new equal `{ return GL_EQUAL; `}
+        new lequal `{ return GL_LEQUAL; `}
+        new greater `{ return GL_GREATER; `}
+        new not_equal `{ return GL_NOTEQUAL; `}
+        new gequal `{ return GL_GEQUAL; `}
+        new always `{ return GL_ALWAYS; `}
+end
+
+# Format of pixel data
+#
+# Used by `GLES::read_pixels`
+extern class GLPixelFormat
+       super GLEnum
+
+       new alpha `{ return GL_ALPHA; `}
+       new rgb `{ return GL_RGB; `}
+       new rgba `{ return GL_RGBA; `}
+end
+
+# Data type of pixel data
+#
+# Used by `GLES::read_pixels`
+extern class GLPixelType
+       super GLEnum
+
+       new unsigned_byte `{ return GL_UNSIGNED_BYTE; `}
+       new unsigned_short_5_6_5 `{ return GL_UNSIGNED_SHORT_5_6_5; `}
+       new unsigned_short_4_4_4_4 `{ return GL_UNSIGNED_SHORT_4_4_4_4; `}
+       new unsigned_short_5_5_5_1 `{ return GL_UNSIGNED_SHORT_5_5_5_1; `}
+end
+
 # Set of buffers as a bitwise OR mask, used by `GLES::clear`
 #
 # ~~~