+ # Disable this server-side capability
+ fun disable do disable_native(val)
+ private fun disable_native(cap: Int) `{ glDisable(cap); `}
+
+ redef fun hash do return val
+ redef fun ==(o) do return o != null and is_same_type(o) and o.hash == self.hash
+end
+redef class Sys
+ private var gles = new GLES is lazy
+end
+
+# Entry points to OpenGL ES 2.0 services
+fun gl: GLES do return sys.gles
+
+# OpenGL ES 2.0 services
+class GLES
+
+ # Clear the color buffer to `red`, `green`, `blue` and `alpha`
+ fun clear_color(red, green, blue, alpha: Float) `{
+ glClearColor(red, green, blue, alpha);
+ `}
+
+ # 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.
+ fun front_face=(value: Bool) `{ glFrontFace(value? GL_CW: GL_CCW); `}
+
+ # Specify whether front- or back-facing polygons can be culled, default is `back` only
+ #
+ # One or both of `front` or `back` must be `true`. If you want to deactivate culling
+ # use `(new GLCap.cull_face).disable`.
+ #
+ # Require: `front or back`
+ fun cull_face(front, back: Bool)
+ do
+ assert not (front or back)
+ cull_face_native(front, back)
+ end
+
+ private fun cull_face_native(front, back: Bool) `{
+ glCullFace(front? back? GL_FRONT_AND_BACK: GL_BACK: GL_FRONT);
+ `}
+
+ # Clear the `buffer`
+ fun clear(buffer: GLBuffer) `{ glClear(buffer); `}
+
+ # Last error from OpenGL ES 2.0
+ fun error: GLError `{ return glGetError(); `}
+
+ # Query the boolean value at `key`
+ private fun get_bool(key: Int): Bool `{
+ GLboolean val;
+ glGetBooleanv(key, &val);
+ return val == GL_TRUE;
+ `}
+
+ # Query the floating point value at `key`
+ private fun get_float(key: Int): Float `{
+ GLfloat val;
+ glGetFloatv(key, &val);
+ return val;
+ `}
+
+ # Query the integer value at `key`
+ private fun get_int(key: Int): Int `{
+ GLint val;
+ glGetIntegerv(key, &val);
+ return val;
+ `}
+
+ # Does this driver support shader compilation?
+ #
+ # 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
+ fun tex_parameter_min_filter(target: GLTextureTarget, value: GLTextureMinFilter) `{
+ glTexParameteri(target, GL_TEXTURE_MIN_FILTER, value);
+ `}
+
+ # Set the texture magnification function
+ #
+ # Foreign: glTexParameter with GL_TEXTURE_MAG_FILTER
+ fun tex_parameter_mag_filter(target: GLTextureTarget, value: GLTextureMagFilter) `{
+ glTexParameteri(target, GL_TEXTURE_MAG_FILTER, value);
+ `}
+
+ # Set the texture wrap parameter for coordinates _s_
+ #
+ # Foreign: glTexParameter with GL_TEXTURE_WRAP_S
+ fun tex_parameter_wrap_s(target: GLTextureTarget, value: GLTextureWrap) `{
+ glTexParameteri(target, GL_TEXTURE_WRAP_S, value);
+ `}
+
+ # Set the texture wrap parameter for coordinates _t_
+ #
+ # Foreign: glTexParameter with GL_TEXTURE_WRAP_T
+ 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); `}
+
+ # OpenGL server-side capabilities
+ var capabilities = new GLCapabilities is lazy
+end
+
+# Entry point to OpenGL server-side capabilities
+class GLCapabilities
+
+ # GL capability: blend the computed fragment color values
+ #
+ # Foreign: GL_BLEND
+ fun blend: GLCap is lazy do return new GLCap(0x0BE2)
+
+ # GL capability: cull polygons based of their winding in window coordinates
+ #
+ # Foreign: GL_CULL_FACE
+ fun cull_face: GLCap is lazy do return new GLCap(0x0B44)
+
+ # GL capability: do depth comparisons and update the depth buffer
+ #
+ # Foreign: GL_DEPTH_TEST
+ fun depth_test: GLCap is lazy do return new GLCap(0x0B71)
+
+ # GL capability: dither color components or indices before they are written to the color buffer
+ #
+ # Foreign: GL_DITHER
+ fun dither: GLCap is lazy do return new GLCap(0x0BE2)
+
+ # GL capability: add an offset to depth values of a polygon fragment before depth test
+ #
+ # Foreign: GL_POLYGON_OFFSET_FILL
+ fun polygon_offset_fill: GLCap is lazy do return new GLCap(0x8037)
+
+ # GL capability: compute a temporary coverage value where each bit is determined by the alpha value at the corresponding location
+ #
+ # Foreign: GL_SAMPLE_ALPHA_TO_COVERAGE
+ fun sample_alpha_to_coverage: GLCap is lazy do return new GLCap(0x809E)
+
+ # GL capability: AND the fragment coverage with the temporary coverage value
+ #
+ # Foreign: GL_SAMPLE_COVERAGE
+ fun sample_coverage: GLCap is lazy do return new GLCap(0x80A0)
+
+ # GL capability: discard fragments that are outside the scissor rectangle
+ #
+ # Foreign: GL_SCISSOR_TEST
+ fun scissor_test: GLCap is lazy do return new GLCap(0x0C11)
+
+ # GL capability: do stencil testing and update the stencil buffer
+ #
+ # Foreign: GL_STENCIL_TEST
+ fun stencil_test: GLCap is lazy do return new GLCap(0x0B90)
+end
+
+# Float related data types of OpenGL ES 2.0 shaders
+#
+# Only data types supported by shader attributes, as seen with
+# `GLProgram::active_attrib_type`.
+extern class GLFloatDataType
+ super GLEnum
+
+ fun is_float: Bool `{ return recv == GL_FLOAT; `}
+ fun is_float_vec2: Bool `{ return recv == GL_FLOAT_VEC2; `}
+ fun is_float_vec3: Bool `{ return recv == GL_FLOAT_VEC3; `}
+ fun is_float_vec4: Bool `{ return recv == GL_FLOAT_VEC4; `}
+ fun is_float_mat2: Bool `{ return recv == GL_FLOAT_MAT2; `}
+ fun is_float_mat3: Bool `{ return recv == GL_FLOAT_MAT3; `}
+ fun is_float_mat4: Bool `{ return recv == GL_FLOAT_MAT4; `}
+
+ # Instances of `GLFloatDataType` can be equal to instances of `GLDataType`
+ redef fun ==(o)
+ do
+ return o != null and o isa GLFloatDataType and o.hash == self.hash
+ end
+end
+
+# All data types of OpenGL ES 2.0 shaders
+#
+# These types can be used by shader uniforms, as seen with
+# `GLProgram::active_uniform_type`.
+extern class GLDataType
+ super GLFloatDataType
+
+ fun is_int: Bool `{ return recv == GL_INT; `}
+ fun is_int_vec2: Bool `{ return recv == GL_INT_VEC2; `}
+ fun is_int_vec3: Bool `{ return recv == GL_INT_VEC3; `}
+ fun is_int_vec4: Bool `{ return recv == GL_INT_VEC4; `}
+ fun is_bool: Bool `{ return recv == GL_BOOL; `}
+ fun is_bool_vec2: Bool `{ return recv == GL_BOOL_VEC2; `}
+ fun is_bool_vec3: Bool `{ return recv == GL_BOOL_VEC3; `}
+ fun is_bool_vec4: Bool `{ return recv == GL_BOOL_VEC4; `}
+ fun is_sampler_2d: Bool `{ return recv == GL_SAMPLER_2D; `}
+ 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`
+#
+# ~~~
+# var buffers = (new GLBuffer).color.depth
+# gl.clear buffers
+# ~~~
+extern class GLBuffer `{ GLbitfield `}
+ # Get an empty set of buffers
+ new `{ return 0; `}
+
+ # Add the color buffer to the returned buffer set
+ fun color: GLBuffer `{ return recv | GL_COLOR_BUFFER_BIT; `}
+
+ # Add the depth buffer to the returned buffer set
+ fun depth: GLBuffer `{ return recv | GL_DEPTH_BUFFER_BIT; `}
+
+ # Add the stencil buffer to the returned buffer set
+ fun stencil: GLBuffer `{ return recv | GL_STENCIL_BUFFER_BIT; `}
+end