return glGetUniformLocation(self, c_name);
`}
- # Query information on this program
- fun query(pname: Int): Int `{
- int val;
- glGetProgramiv(self, pname, &val);
- return val;
- `}
-
# Is this program linked?
- fun is_linked: Bool do return query(0x8B82) != 0
+ fun is_linked: Bool do return glGetProgramiv(self, gl_LINK_STATUS) != 0
# Has this program been deleted?
- fun is_deleted: Bool do return query(0x8B80) != 0
+ fun is_deleted: Bool do return glGetProgramiv(self, gl_DELETE_STATUS) != 0
# Boolean result of `validate`, must be called after `validate`
- fun is_validated: Bool do return query(0x8B83) != 0
-
- # Retrieve the information log of this program
- #
- # Useful with `link` and `validate`
- fun info_log: String import NativeString.to_s `{
- int size;
- glGetProgramiv(self, GL_INFO_LOG_LENGTH, &size);
- GLchar *msg = malloc(size);
- glGetProgramInfoLog(self, size, NULL, msg);
- return NativeString_to_s(msg);
- `}
+ fun is_validated: Bool do return glGetProgramiv(self, gl_VALIDATE_STATUS) != 0
# Number of active uniform in this program
#
# This should be the number of uniforms declared in all shader, except
# unused uniforms which may have been optimized out.
- fun n_active_uniforms: Int do return query(0x8B86)
+ fun n_active_uniforms: Int do return glGetProgramiv(self, gl_ACTIVE_UNIFORMS)
- # Length of the longest uniform name in this program, including `\n`
- fun active_uniform_max_length: Int do return query(0x8B87)
+ # Length of the longest uniform name in this program, including the null byte
+ fun active_uniform_max_length: Int do return glGetProgramiv(self, gl_ACTIVE_UNIFORM_MAX_LENGTH)
# Number of active attributes in this program
#
# This should be the number of uniforms declared in all shader, except
# unused uniforms which may have been optimized out.
- fun n_active_attributes: Int do return query(0x8B89)
+ fun n_active_attributes: Int do return glGetProgramiv(self, gl_ACTIVE_ATTRIBUTES)
- # Length of the longest uniform name in this program, including `\n`
- fun active_attribute_max_length: Int do return query(0x8B8A)
+ # Length of the longest attribute name in this program, including the null byte
+ fun active_attribute_max_length: Int do return glGetProgramiv(self, gl_ACTIVE_ATTRIBUTE_MAX_LENGTH)
# Number of shaders attached to this program
- fun n_attached_shaders: Int do return query(0x8B85)
+ fun n_attached_shaders: Int do return glGetProgramiv(self, gl_ATTACHED_SHADERS)
# Name of the active attribute at `index`
fun active_attrib_name(index: Int): String
do
var max_size = active_attribute_max_length
- return active_attrib_name_native(index, max_size).to_s
+ var cname = new CString(max_size)
+ active_attrib_name_native(index, max_size, cname)
+ return cname.to_s
end
- private fun active_attrib_name_native(index, max_size: Int): NativeString `{
+
+ private fun active_attrib_name_native(index, max_size: Int, name: CString) `{
// We get more values than we need, for compatibility. At least the
// NVidia driver tries to fill them even if NULL.
- char *name = malloc(max_size);
int size;
GLenum type;
glGetActiveAttrib(self, index, max_size, NULL, &size, &type, name);
- return name;
`}
# Size of the active attribute at `index`
# Type of the active attribute at `index`
#
# May only be float related data types (single float, vectors and matrix).
- fun active_attrib_type(index: Int): GLFloatDataType `{
+ fun active_attrib_type(index: Int): GLDataType `{
int size;
GLenum type;
glGetActiveAttrib(self, index, 0, NULL, &size, &type, NULL);
# Name of the active uniform at `index`
fun active_uniform_name(index: Int): String
do
- var max_size = active_attribute_max_length
- return active_uniform_name_native(index, max_size).to_s
+ var max_size = active_uniform_max_length
+ var cname = new CString(max_size)
+ active_uniform_name_native(index, max_size, cname)
+ return cname.to_s
end
- private fun active_uniform_name_native(index, max_size: Int): NativeString `{
- char *name = malloc(max_size);
+
+ private fun active_uniform_name_native(index, max_size: Int, name: CString) `{
int size;
GLenum type;
glGetActiveUniform(self, index, max_size, NULL, &size, &type, name);
- return name;
`}
# Size of the active uniform at `index`
# Delete the `program` object
fun glDeleteProgram(program: GLProgram) `{ glDeleteProgram(program); `}
-# Determine if `name` corresponds to a program object
+# Does `name` corresponds to a program object?
fun glIsProgram(name: GLProgram): Bool `{ return glIsProgram(name); `}
# Attach a `shader` to `program`
# Detach `shader` from `program`
fun glDetachShader(program: GLProgram, shader: GLShader) `{ glDetachShader(program, shader); `}
+# Parameter value from a `program` object
+fun glGetProgramiv(program: GLProgram, pname: GLGetParameterName): Int `{
+ int value;
+ glGetProgramiv(program, pname, &value);
+ return value;
+`}
+
+# The information log for the `program` object
+fun glGetProgramInfoLog(program: GLProgram): String
+do
+ var size = glGetProgramiv(program, gl_INFO_LOG_LENGTH)
+ var buf = new CString(size)
+ native_glGetProgramInfoLog(program, size, buf)
+ return buf.to_s_with_length(size)
+end
+
+# Return the program information log in `buf`
+private fun native_glGetProgramInfoLog(program: GLProgram, buf_size: Int, buf: CString): Int `{
+ int length;
+ glGetProgramInfoLog(program, buf_size, &length, buf);
+ return length;
+`}
+
# Abstract OpenGL ES shader object, implemented by `GLFragmentShader` and `GLVertexShader`
extern class GLShader `{GLuint`}
# was created from a binary file.
fun source: nullable String
do
- var size = query(0x8B88)
+ var size = glGetShaderiv(self, gl_SHADER_SOURCE_LENGTH)
if size == 0 then return null
return source_native(size).to_s
end
- private fun source_native(size: Int): NativeString `{
+ private fun source_native(size: Int): CString `{
GLchar *code = malloc(size);
glGetShaderSource(self, size, NULL, code);
return code;
`}
- # Query information on this shader
- protected fun query(pname: Int): Int `{
- int val;
- glGetShaderiv(self, pname, &val);
- return val;
- `}
-
# Has this shader been compiled?
- fun is_compiled: Bool do return query(0x8B81) != 0
+ fun is_compiled: Bool do return glGetShaderiv(self, gl_COMPILE_STATUS) != 0
# Has this shader been deleted?
- fun is_deleted: Bool do return query(0x8B80) != 0
+ fun is_deleted: Bool do return glGetShaderiv(self, gl_DELETE_STATUS) != 0
+end
- # Retrieve the information log of this shader
- #
- # Useful with `link` and `validate`
- fun info_log: String import NativeString.to_s `{
- int size;
- glGetShaderiv(self, GL_INFO_LOG_LENGTH, &size);
- GLchar *msg = malloc(size);
- glGetShaderInfoLog(self, size, NULL, msg);
- return NativeString_to_s(msg);
- `}
+# Get a parameter value from a `shader` object
+fun glGetShaderiv(shader: GLShader, pname: GLGetParameterName): Int `{
+ int val;
+ glGetShaderiv(shader, pname, &val);
+ return val;
+`}
+
+# Shader parameter
+extern class GLGetParameterName
+ super GLEnum
+end
+
+fun gl_INFO_LOG_LENGTH: GLGetParameterName `{ return GL_INFO_LOG_LENGTH; `}
+fun gl_DELETE_STATUS: GLGetParameterName `{ return GL_DELETE_STATUS; `}
+
+fun gl_SHADER_TYPE: GLGetParameterName `{ return GL_SHADER_TYPE; `}
+fun gl_COMPILE_STATUS: GLGetParameterName `{ return GL_COMPILE_STATUS; `}
+fun gl_SHADER_SOURCE_LENGTH: GLGetParameterName `{ return GL_SHADER_SOURCE_LENGTH; `}
+
+fun gl_ACTIVE_ATTRIBUTES: GLGetParameterName `{ return GL_ACTIVE_ATTRIBUTES; `}
+fun gl_ACTIVE_ATTRIBUTE_MAX_LENGTH: GLGetParameterName `{ return GL_ACTIVE_ATTRIBUTE_MAX_LENGTH; `}
+fun gl_ACTIVE_UNIFORMS: GLGetParameterName `{ return GL_ACTIVE_UNIFORMS; `}
+fun gl_ACTIVE_UNIFORM_MAX_LENGTH: GLGetParameterName `{ return GL_ACTIVE_UNIFORM_MAX_LENGTH; `}
+fun gl_ATTACHED_SHADERS: GLGetParameterName `{ return GL_ATTACHED_SHADERS; `}
+fun gl_LINK_STATUS: GLGetParameterName `{ return GL_LINK_STATUS; `}
+fun gl_VALIDATE_STATUS: GLGetParameterName `{ return GL_VALIDATE_STATUS; `}
+
+# The information log for the `shader` object
+fun glGetShaderInfoLog(shader: GLShader): String
+do
+ var size = glGetShaderiv(shader, gl_INFO_LOG_LENGTH)
+ var buf = new CString(size)
+ native_glGetShaderInfoLog(shader, size, buf)
+ return buf.to_s_with_length(size)
end
+private fun native_glGetShaderInfoLog(shader: GLShader, buf_size: Int, buffer: CString): Int `{
+ int length;
+ glGetShaderInfoLog(shader, buf_size, &length, buffer);
+ return length;
+`}
+
# Shader type
extern class GLShaderType
super GLEnum
`}
# Replace the source code in the `shader` object with `code`
-fun glShaderSource(shader: GLShader, code: NativeString) `{
+fun glShaderSource(shader: GLShader, code: CString) `{
glShaderSource(shader, 1, (GLchar const **)&code, NULL);
`}
# Delete the `shader` object
fun glDeleteShader(shader: GLShader) `{ glDeleteShader(shader); `}
-# Determine if `name` corresponds to a shader object
+# Does `name` corresponds to a shader object?
fun glIsShader(name: GLShader): Bool `{ return glIsShader(name); `}
# An OpenGL ES 2.0 fragment shader
# Render primitives from array data
fun glDrawArrays(mode: GLDrawMode, from, count: Int) `{ glDrawArrays(mode, from, count); `}
+# Render primitives from array data by their index listed in `indices`
+fun glDrawElements(mode: GLDrawMode, count: Int, typ: GLDataType, indices: Pointer) `{
+ glDrawElements(mode, count, typ, indices);
+`}
+
+# Render primitives from array data, at `offset` in the element buffer
+fun glDrawElementsi(mode: GLDrawMode, count: Int, typ: GLDataType, offset: Int) `{
+ glDrawElements(mode, count, typ, (const GLvoid*)offset);
+`}
+
# Define an array of generic vertex attribute data
fun glVertexAttribPointer(index, size: Int, typ: GLDataType, normalized: Bool, stride: Int, array: NativeGLfloatArray) `{
glVertexAttribPointer(index, size, typ, normalized, stride, array);
`}
+# Define an array of generic vertex attribute data, at `offset` in the array buffer
+fun glVertexAttribPointeri(index, size: Int, typ: GLDataType, normalized: Bool, stride: Int, offset: Int) `{
+ glVertexAttribPointer(index, size, typ, normalized, stride, (const GLvoid*)offset);
+`}
+
# Specify the value of a generic vertex attribute
fun glVertexAttrib1f(index: Int, x: Float) `{ glVertexAttrib1f(index, x); `}
# Specify the value of a uniform variable for the current program object
fun glUniform4i(index, x, y, z, w: Int) `{ glUniform4i(index, x, y, z, w); `}
-# TODO glUniform*f
+# Specify the value of a uniform variable for the current program object
+fun glUniform1f(index: Int, x: Float) `{ glUniform1f(index, x); `}
+
+# Specify the value of a uniform variable for the current program object
+fun glUniform2f(index: Int, x, y: Float) `{ glUniform2f(index, x, y); `}
+
+# Specify the value of a uniform variable for the current program object
+fun glUniform3f(index: Int, x, y, z: Float) `{ glUniform3f(index, x, y, z); `}
+
+# Specify the value of a uniform variable for the current program object
+fun glUniform4f(index: Int, x, y, z, w: Float) `{ glUniform4f(index, x, y, z, w); `}
# Low level array of `Float`
class GLfloatArray
super CArray[Float]
redef type NATIVE: NativeGLfloatArray
- init do native_array = new NativeGLfloatArray(length)
+ redef init(length)
+ do
+ native_array = new NativeGLfloatArray(length)
+ end
# Create with the content of `array`
new from(array: Array[Float])
end
# Fill with the content of `array`
- fun fill_from(array: Array[Float])
+ #
+ # If `dst_offset` is set, the data is copied to the index `dst_offset`,
+ # otherwise, it is copied the beginning of `self`.
+ #
+ # Require: `length >= array.length + dst_offset or else 0`
+ fun fill_from(array: Array[Float], dst_offset: nullable Int)
do
- assert length >= array.length
+ dst_offset = dst_offset or else 0
+
+ assert length >= array.length + dst_offset
for k in [0..array.length[ do
- self[k] = array[k]
+ self[dst_offset+k] = array[k]
end
end
end
# Specify a two-dimensional texture image
fun glTexImage2D(target: GLTextureTarget, level: Int, internalformat: GLPixelFormat,
width, height, border: Int,
- format: GLPixelFormat, typ: GLPixelType, data: Pointer) `{
+ format: GLPixelFormat, typ: GLDataType, data: Pointer) `{
glTexImage2D(target, level, internalformat, width, height, border, format, typ, data);
`}
# Specify a two-dimensional texture subimage
fun glTexSubImage2D(target: GLTextureTarget,
level, xoffset, yoffset, width, height, border: Int,
- format: GLPixelFormat, typ: GLPixelType, data: Pointer) `{
+ format: GLPixelFormat, typ: GLDataType, data: Pointer) `{
glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, typ, data);
`}
glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
`}
+# Copy a block of pixels from the framebuffer of `fomat` and `typ` at `data`
+fun glReadPixels(x, y, width, height: Int, format: GLPixelFormat, typ: GLDataType, data: Pointer) `{
+ glReadPixels(x, y, width, height, format, typ, data);
+`}
+
# Texture minifying and magnifying function
extern class GLTexParameteri
super GLEnum
glGenRenderbuffers(n, (GLuint *)renderbuffers);
`}
-# Determine if `name` corresponds to a renderbuffer object
+# Does `name` corresponds to a renderbuffer object?
fun glIsRenderbuffer(name: Int): Bool `{
return glIsRenderbuffer(name);
`}
fun gl_RGB565: GLRenderbufferFormat `{ return GL_RGB565; `}
# 5 red, 5 green, 5 blue, 1 alpha bits format
-fun gl_RGB_A1: GLRenderbufferFormat `{ return GL_RGB5_A1; `}
+fun gl_RGB5_A1: GLRenderbufferFormat `{ return GL_RGB5_A1; `}
# 16 depth bits format
fun gl_DEPTH_COMPNENT16: GLRenderbufferFormat `{ return GL_DEPTH_COMPONENT16; `}
# OpenGL ES 2.0 services
class GLES
- # 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);
- `}
-
# Query the boolean value at `key`
private fun get_bool(key: Int): Bool `{
GLboolean val;
# 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, format, typ, data);
- `}
-
- # 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
# Generate and fill set of mipmaps for the texture object `target`
fun glGenerateMipmap(target: GLTextureTarget) `{ glGenerateMipmap(target); `}
+# Generate `n` buffer names
+fun glGenBuffers(n: Int): Array[Int]
+do
+ var array = new CIntArray(n)
+ native_glGenBuffers(n, array.native_array)
+ var a = array.to_a
+ array.destroy
+ return a
+end
+
+private fun native_glGenBuffers(n: Int, buffers: NativeCIntArray) `{
+ glGenBuffers(n, (GLuint *)buffers);
+`}
+
+# Does `name` corresponds to a buffer object?
+fun glIsBuffer(name: Int): Bool `{
+ return glIsBuffer(name);
+`}
+
+# Delete named buffer objects
+fun glDeleteBuffers(buffers: SequenceRead[Int])
+do
+ var n = buffers.length
+ var array = new CIntArray.from(buffers)
+ native_glDeleteBuffers(n, array.native_array)
+ array.destroy
+end
+
+private fun native_glDeleteBuffers(n: Int, buffers: NativeCIntArray) `{
+ return glDeleteBuffers(n, (const GLuint *)buffers);
+`}
+
+# Create and initialize a buffer object's data store
+fun glBufferData(target: GLArrayBuffer, size: Int, data: Pointer, usage: GLBufferUsage) `{
+ glBufferData(target, size, data, usage);
+`}
+
+# Update a subset of a buffer object's data store
+fun glBufferSubData(target: GLArrayBuffer, offset, size: Int, data: Pointer) `{
+ glBufferSubData(target, offset, size, data);
+`}
+
+# Expected usage of a buffer
+extern class GLBufferUsage
+ super GLEnum
+end
+
+# Data will be modified once and used a few times
+fun gl_STREAM_DRAW: GLBufferUsage `{ return GL_STREAM_DRAW; `}
+
+# Data will be modified once and used many times
+fun gl_STATIC_DRAW: GLBufferUsage `{ return GL_STATIC_DRAW; `}
+
+# Data will be modified repeatedly and used many times
+fun gl_DYNAMIC_DRAW: GLBufferUsage `{ return GL_DYNAMIC_DRAW; `}
+
# Bind the named `buffer` object
fun glBindBuffer(target: GLArrayBuffer, buffer: Int) `{ glBindBuffer(target, buffer); `}
return a
end
-private fun native_glGenFramebuffers(n: Int, textures: NativeCIntArray) `{
- glGenFramebuffers(n, (GLuint *)textures);
+private fun native_glGenFramebuffers(n: Int, framebuffers: NativeCIntArray) `{
+ glGenFramebuffers(n, (GLuint *)framebuffers);
`}
-# Determine if `name` corresponds to a framebuffer object
+# Does `name` corresponds to a framebuffer object?
fun glIsFramebuffer(name: Int): Bool `{
return glIsFramebuffer(name);
`}
var 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 self == GL_FLOAT; `}
- fun is_float_vec2: Bool `{ return self == GL_FLOAT_VEC2; `}
- fun is_float_vec3: Bool `{ return self == GL_FLOAT_VEC3; `}
- fun is_float_vec4: Bool `{ return self == GL_FLOAT_VEC4; `}
- fun is_float_mat2: Bool `{ return self == GL_FLOAT_MAT2; `}
- fun is_float_mat3: Bool `{ return self == GL_FLOAT_MAT3; `}
- fun is_float_mat4: Bool `{ return self == 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 self == GL_INT; `}
- fun is_int_vec2: Bool `{ return self == GL_INT_VEC2; `}
- fun is_int_vec3: Bool `{ return self == GL_INT_VEC3; `}
- fun is_int_vec4: Bool `{ return self == GL_INT_VEC4; `}
- fun is_bool: Bool `{ return self == GL_BOOL; `}
- fun is_bool_vec2: Bool `{ return self == GL_BOOL_VEC2; `}
- fun is_bool_vec3: Bool `{ return self == GL_BOOL_VEC3; `}
- fun is_bool_vec4: Bool `{ return self == GL_BOOL_VEC4; `}
- fun is_sampler_2d: Bool `{ return self == GL_SAMPLER_2D; `}
- fun is_sampler_cube: Bool `{ return self == GL_SAMPLER_CUBE; `}
+ super GLEnum
end
+fun gl_FLOAT: GLDataType `{ return GL_FLOAT; `}
+fun gl_FLOAT_VEC2: GLDataType `{ return GL_FLOAT_VEC2; `}
+fun gl_FLOAT_VEC3: GLDataType `{ return GL_FLOAT_VEC3; `}
+fun gl_FLOAT_VEC4: GLDataType `{ return GL_FLOAT_VEC4; `}
+fun gl_FLOAT_MAT2: GLDataType `{ return GL_FLOAT_MAT2; `}
+fun gl_FLOAT_MAT3: GLDataType `{ return GL_FLOAT_MAT3; `}
+fun gl_FLOAT_MAT4: GLDataType `{ return GL_FLOAT_MAT4; `}
+
+fun gl_BYTE: GLDataType `{ return GL_BYTE; `}
+fun gl_UNSIGNED_BYTE: GLDataType `{ return GL_UNSIGNED_BYTE; `}
+fun gl_SHORT: GLDataType `{ return GL_SHORT; `}
+fun gl_UNSIGNED_SHORT: GLDataType `{ return GL_UNSIGNED_SHORT; `}
+fun gl_INT: GLDataType `{ return GL_INT; `}
+fun gl_UNSIGNED_INT: GLDataType `{ return GL_UNSIGNED_INT; `}
+fun gl_FIXED: GLDataType `{ return GL_FIXED; `}
+fun gl_INT_VEC2: GLDataType `{ return GL_INT_VEC2; `}
+fun gl_INT_VEC3: GLDataType `{ return GL_INT_VEC3; `}
+fun gl_INT_VEC4: GLDataType `{ return GL_INT_VEC4; `}
+fun gl_BOOL: GLDataType `{ return GL_BOOL; `}
+fun gl_BOOL_VEC2: GLDataType `{ return GL_BOOL_VEC2; `}
+fun gl_BOOL_VEC3: GLDataType `{ return GL_BOOL_VEC3; `}
+fun gl_BOOL_VEC4: GLDataType `{ return GL_BOOL_VEC4; `}
+fun gl_SAMPLER_2D: GLDataType `{ return GL_SAMPLER_2D; `}
+fun gl_SAMPLER_CUBE: GLDataType `{ return GL_SAMPLER_CUBE; `}
+
+fun gl_UNSIGNED_SHORT_5_6_5: GLDataType `{ return GL_UNSIGNED_SHORT_5_6_5; `}
+fun gl_UNSIGNED_SHORT_4_4_4_4: GLDataType `{ return GL_UNSIGNED_SHORT_4_4_4_4; `}
+fun gl_UNSIGNED_SHORT_5_5_5_1: GLDataType `{ return GL_UNSIGNED_SHORT_5_5_5_1; `}
+
# Kind of primitives to render
extern class GLDrawMode
super GLEnum
fun gl_RGB: GLPixelFormat `{ return GL_RGB; `}
fun gl_RGBA: GLPixelFormat `{ return GL_RGBA; `}
-# Data type of pixel data
-extern class GLPixelType
- super GLEnum
-end
-
-fun gl_UNSIGNED_BYTE: GLPixelType `{ return GL_UNSIGNED_BYTE; `}
-fun gl_UNSIGNED_SHORT_5_6_5: GLPixelType `{ return GL_UNSIGNED_SHORT_5_6_5; `}
-fun gl_UNSIGNED_SHORT_4_4_4_4: GLPixelType `{ return GL_UNSIGNED_SHORT_4_4_4_4; `}
-fun gl_UNSIGNED_SHORT_5_5_5_1: GLPixelType `{ return GL_UNSIGNED_SHORT_5_5_5_1; `}
-
# Set of buffers as a bitwise OR mask
extern class GLBuffer `{ GLbitfield `}
# Bitwise OR with `other`
fun gl_DEPTH_BUFFER_BIT: GLBuffer `{ return GL_DEPTH_BUFFER_BIT; `}
fun gl_STENCIL_BUFFER_BIT: GLBuffer `{ return GL_STENCIL_BUFFER_BIT; `}
fun gl_COLOR_BUFFER_BIT: GLBuffer `{ return GL_COLOR_BUFFER_BIT; `}
+
+# Define front- and back-facing polygons, `gc_CCW` by default
+fun glFrontFace(mode: GLFrontFaceMode) `{ glFrontFace(mode); `}
+
+# Orientation of front-facing polygons
+extern class GLFrontFaceMode
+ super GLEnum
+end
+
+fun gl_CW: GLFrontFaceMode `{ return GL_CW; `}
+fun gl_CCW: GLFrontFaceMode `{ return GL_CCW; `}
+
+# Specify whether front- or back-facing polygons can be culled, default is `back` only
+fun glCullFace(mode: GLCullFaceMode) `{ glCullFace(mode); `}
+
+# Candidates for culling
+extern class GLCullFaceMode
+ super GLEnum
+end
+
+fun gl_FRONT: GLCullFaceMode `{ return GL_FRONT; `}
+fun gl_BACK: GLCullFaceMode `{ return GL_BACK; `}
+fun gl_FRONT_AND_BACK: GLCullFaceMode `{ return GL_FRONT_AND_BACK; `}
+
+# Specify mapping of depth values from normalized device coordinates to window coordinates
+#
+# Default at 0.0, 1.0.
+fun glDepthRangef(near, far: Float) `{ glDepthRangef(near, far); `}
+
+# Enable or disable writing into the depth buffer
+fun glDepthMask(value: Bool) `{ glDepthMask(value); `}
+
+# Specify the value used for depth buffer comparisons
+#
+# Default value is `gl_LESS`
+fun glDepthFunc(func: GLDepthFunc) `{ glDepthFunc(func); `}
+
+# Set the pixel arithmetic for the blending operations
+#
+# Default values:
+# * `src_factor`: `gl_ONE`
+# * `dst_factor`: `gl_ZERO`
+fun glBlendFunc(src_factor, dst_factor: GLBlendFactor) `{
+ glBlendFunc(src_factor, dst_factor);
+`}
+
+# Set the scale and units used to calculate depth values
+fun glPolygonOffset(factor, units: Float) `{ glPolygonOffset(factor, units); `}
+
+# Specify the width of rasterized lines
+fun glLineWidth(width: Float) `{ glLineWidth(width); `}
+
+# Get the value of the parameter `pname` at `offset`
+fun glGetBooleanv(pname: GLGetParameterName, offset: Int): Bool `{
+ GLboolean v[4];
+ glGetBooleanv(pname, v);
+ return v[offset];
+`}
+
+# Get the value of the parameter `pname` at `offset`
+fun glGetFloatv(pname: GLGetParameterName, offset: Int): Float `{
+ GLfloat v[4];
+ glGetFloatv(pname, v);
+ return v[offset];
+`}
+
+# Get the value of the parameter `pname` at `offset`
+fun glGetIntegerv(pname: GLGetParameterName, offset: Int): Int `{
+ GLint v[4];
+ glGetIntegerv(pname, v);
+ return v[offset];
+`}
+
+fun gl_COLOR_CLEAR_VALUE: GLGetParameterName `{ return GL_COLOR_CLEAR_VALUE; `}
+
+fun gl_MAX_TEXTURE_SIZE: GLGetParameterName `{ return GL_MAX_TEXTURE_SIZE; `}
+fun gl_MAX_VIEWPORT_DIMS: GLGetParameterName `{ return GL_MAX_VIEWPORT_DIMS; `}
+fun gl_MAX_VERTEX_ATTRIBS: GLGetParameterName `{ return GL_MAX_VERTEX_ATTRIBS; `}
+fun gl_MAX_VERTEX_UNIFORM_VECTORS: GLGetParameterName `{ return GL_MAX_VERTEX_UNIFORM_VECTORS; `}
+fun gl_MAX_VARYING_VECTORS: GLGetParameterName `{ return GL_MAX_VARYING_VECTORS; `}
+fun gl_MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLGetParameterName `{ return GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS; `}
+fun gl_MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLGetParameterName `{ return GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS; `}
+fun gl_MAX_TEXTURE_IMAGE_UNITS: GLGetParameterName `{ return GL_MAX_TEXTURE_IMAGE_UNITS; `}
+fun gl_MAX_FRAGMENT_UNIFORM_VECTORS: GLGetParameterName `{ return GL_MAX_FRAGMENT_UNIFORM_VECTORS; `}
+
+fun gl_ARRAY_BUFFER_BINDING: GLGetParameterName `{ return GL_ARRAY_BUFFER_BINDING; `}
+fun gl_ELEMENT_ARRAY_BUFFER_BINDING: GLGetParameterName `{ return GL_ELEMENT_ARRAY_BUFFER_BINDING; `}
+fun gl_TEXTURE_BINDING_2D: GLGetParameterName `{ return GL_TEXTURE_BINDING_2D; `}
+fun gl_TEXTURE_BINDING_CUBE_MAP: GLGetParameterName `{ return GL_TEXTURE_BINDING_CUBE_MAP; `}
+fun gl_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLGetParameterName `{ return GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING; `}
+fun gl_FRAMEBUFFER_BINDING: GLGetParameterName `{ return GL_FRAMEBUFFER_BINDING; `}
+fun gl_RENDERBUFFER_BINDING: GLGetParameterName `{ return GL_RENDERBUFFER_BINDING; `}