end
import android::aware
+intrude import c
in "C Header" `{
#include <GLES2/gl2.h>
new `{ return glCreateProgram(); `}
# Is this a valid program?
- fun is_ok: Bool `{ return glIsProgram(recv); `}
+ fun is_ok: Bool `{ return glIsProgram(self); `}
# Attach a `shader` to this program
- fun attach_shader(shader: GLShader) `{ glAttachShader(recv, shader); `}
+ fun attach_shader(shader: GLShader) `{ glAttachShader(self, shader); `}
# Set the location for the attribute by `name`
fun bind_attrib_location(index: Int, name: String) import String.to_cstring `{
GLchar *c_name = String_to_cstring(name);
- glBindAttribLocation(recv, index, c_name);
+ glBindAttribLocation(self, index, c_name);
`}
# Get the location of the attribute by `name`
# Returns `-1` if there is no active attribute named `name`.
fun attrib_location(name: String): Int import String.to_cstring `{
GLchar *c_name = String_to_cstring(name);
- return glGetAttribLocation(recv, c_name);
+ return glGetAttribLocation(self, c_name);
`}
# Get the location of the uniform by `name`
# Returns `-1` if there is no active uniform named `name`.
fun uniform_location(name: String): Int import String.to_cstring `{
GLchar *c_name = String_to_cstring(name);
- return glGetUniformLocation(recv, c_name);
+ return glGetUniformLocation(self, c_name);
`}
# Query information on this program
fun query(pname: Int): Int `{
int val;
- glGetProgramiv(recv, pname, &val);
+ glGetProgramiv(self, pname, &val);
return val;
`}
# Try to link this program
#
# Check result using `in_linked` and `info_log`.
- fun link `{ glLinkProgram(recv); `}
+ fun link `{ glLinkProgram(self); `}
# Is this program linked?
fun is_linked: Bool do return query(0x8B82) != 0
# Use this program for the following operations
- fun use `{ glUseProgram(recv); `}
+ fun use `{ glUseProgram(self); `}
# Delete this program
- fun delete `{ glDeleteProgram(recv); `}
+ fun delete `{ glDeleteProgram(self); `}
# Has this program been deleted?
fun is_deleted: Bool do return query(0x8B80) != 0
# Validate whether this program can be executed in the current OpenGL state
#
# Check results using `is_validated` and `info_log`.
- fun validate `{ glValidateProgram(recv); `}
+ fun validate `{ glValidateProgram(self); `}
# Boolean result of `validate`, must be called after `validate`
fun is_validated: Bool do return query(0x8B83) != 0
# Useful with `link` and `validate`
fun info_log: String import NativeString.to_s `{
int size;
- glGetProgramiv(recv, GL_INFO_LOG_LENGTH, &size);
+ glGetProgramiv(self, GL_INFO_LOG_LENGTH, &size);
GLchar *msg = malloc(size);
- glGetProgramInfoLog(recv, size, NULL, msg);
+ glGetProgramInfoLog(self, size, NULL, msg);
return NativeString_to_s(msg);
`}
char *name = malloc(max_size);
int size;
GLenum type;
- glGetActiveAttrib(recv, index, max_size, NULL, &size, &type, name);
+ glGetActiveAttrib(self, index, max_size, NULL, &size, &type, name);
return name;
`}
fun active_attrib_size(index: Int): Int `{
int size;
GLenum type;
- glGetActiveAttrib(recv, index, 0, NULL, &size, &type, NULL);
+ glGetActiveAttrib(self, index, 0, NULL, &size, &type, NULL);
return size;
`}
fun active_attrib_type(index: Int): GLFloatDataType `{
int size;
GLenum type;
- glGetActiveAttrib(recv, index, 0, NULL, &size, &type, NULL);
+ glGetActiveAttrib(self, index, 0, NULL, &size, &type, NULL);
return type;
`}
char *name = malloc(max_size);
int size;
GLenum type;
- glGetActiveUniform(recv, index, max_size, NULL, &size, &type, name);
+ glGetActiveUniform(self, index, max_size, NULL, &size, &type, name);
return name;
`}
fun active_uniform_size(index: Int): Int `{
int size;
GLenum type;
- glGetActiveUniform(recv, index, 0, NULL, &size, &type, NULL);
+ glGetActiveUniform(self, index, 0, NULL, &size, &type, NULL);
return size;
`}
fun active_uniform_type(index: Int): GLDataType `{
int size;
GLenum type = 0;
- glGetActiveUniform(recv, index, 0, NULL, &size, &type, NULL);
+ glGetActiveUniform(self, index, 0, NULL, &size, &type, NULL);
return type;
`}
end
extern class GLShader `{GLuint`}
# Set the source of the shader
fun source=(code: NativeString) `{
- glShaderSource(recv, 1, (GLchar const **)&code, NULL);
+ glShaderSource(self, 1, (GLchar const **)&code, NULL);
`}
# Source of the shader, if available
private fun source_native(size: Int): NativeString `{
GLchar *code = malloc(size);
- glGetShaderSource(recv, size, NULL, code);
+ glGetShaderSource(self, size, NULL, code);
return code;
`}
# Query information on this shader
protected fun query(pname: Int): Int `{
int val;
- glGetShaderiv(recv, pname, &val);
+ glGetShaderiv(self, pname, &val);
return val;
`}
# Try to compile `source` into a binary GPU program
#
# Check the result using `is_compiled` and `info_log`
- fun compile `{ glCompileShader(recv); `}
+ fun compile `{ glCompileShader(self); `}
# Has this shader been compiled?
fun is_compiled: Bool do return query(0x8B81) != 0
# Delete this shader
- fun delete `{ glDeleteShader(recv); `}
+ fun delete `{ glDeleteShader(self); `}
# Has this shader been deleted?
fun is_deleted: Bool do return query(0x8B80) != 0
# Is this a valid shader?
- fun is_ok: Bool `{ return glIsShader(recv); `}
+ fun is_ok: Bool `{ return glIsShader(self); `}
# Retrieve the information log of this shader
#
# Useful with `link` and `validate`
fun info_log: String import NativeString.to_s `{
int size;
- glGetShaderiv(recv, GL_INFO_LOG_LENGTH, &size);
+ glGetShaderiv(self, GL_INFO_LOG_LENGTH, &size);
GLchar *msg = malloc(size);
- glGetShaderInfoLog(recv, size, NULL, msg);
+ glGetShaderInfoLog(self, size, NULL, msg);
return NativeString_to_s(msg);
`}
end
# Number of data per vertex
var count: Int
- protected var glfloat_array: GLfloatArray
+ protected var glfloat_array: NativeGLfloatArray
init(index, count: Int, array: Array[Float])
do
self.index = index
self.count = count
- self.glfloat_array = new GLfloatArray(array)
+ self.glfloat_array = new NativeGLfloatArray(array.length)
+ for k in [0..array.length[ do
+ glfloat_array[k] = array[k]
+ end
end
fun attrib_pointer do attrib_pointer_intern(index, count, glfloat_array)
- private fun attrib_pointer_intern(index, count: Int, array: GLfloatArray) `{
+ private fun attrib_pointer_intern(index, count: Int, array: NativeGLfloatArray) `{
glVertexAttribPointer(index, count, GL_FLOAT, GL_FALSE, 0, array);
`}
- fun enable do enable_intern(index)
- private fun enable_intern(index: Int) `{ glEnableVertexAttribArray(index); `}
+ # Enable this vertex attribute array
+ fun enable do glEnableVertexAttribArray(index)
- fun draw_arrays_triangles do draw_arrays_triangles_intern(index, count)
- private fun draw_arrays_triangles_intern(index, count: Int) `{
- glDrawArrays(GL_TRIANGLES, index, count);
- `}
+ # Disable this vertex attribute array
+ fun disable do glDisableVertexAttribArray(index)
end
+# Enable the generic vertex attribute array at `index`
+fun glEnableVertexAttribArray(index: Int) `{ glEnableVertexAttribArray(index); `}
+
+# Disable the generic vertex attribute array at `index`
+fun glDisableVertexAttribArray(index: Int) `{ glDisableVertexAttribArray(index); `}
+
+# Render primitives from array data
+fun glDrawArrays(mode: GLDrawMode, from, count: Int) `{ glDrawArrays(mode, from, count); `}
+
+# 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);
+`}
+
+# Specify the value of a generic vertex attribute
+fun glVertexAttrib1f(index: Int, x: Float) `{ glVertexAttrib1f(index, x); `}
+
+# Specify the value of a generic vertex attribute
+fun glVertexAttrib2f(index: Int, x, y: Float) `{ glVertexAttrib2f(index, x, y); `}
+
+# Specify the value of a generic vertex attribute
+fun glVertexAttrib3f(index: Int, x, y, z: Float) `{ glVertexAttrib3f(index, x, y, z); `}
+
+# Specify the value of a generic vertex attribute
+fun glVertexAttrib4f(index: Int, x, y, z, w: Float) `{ glVertexAttrib4f(index, x, y, z, w); `}
+
+# Specify the value of a uniform variable for the current program object
+fun glUniform1i(index, x: Int) `{ glUniform1i(index, x); `}
+
+# Specify the value of a uniform variable for the current program object
+fun glUniform2i(index, x, y: Int) `{ glUniform2i(index, x, y); `}
+
+# Specify the value of a uniform variable for the current program object
+fun glUniform3i(index, x, y, z: Int) `{ glUniform3i(index, x, y, z); `}
+
+# 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
+
# Low level array of `Float`
-extern class GLfloatArray `{GLfloat *`}
- new (array: Array[Float]) import Array[Float].length, Array[Float].[] `{
- int i;
- int len = Array_of_Float_length(array);
- GLfloat *vertex_array = malloc(sizeof(GLfloat)*len);
- for (i = 0; i < len; i ++) vertex_array[i] = Array_of_Float__index(array, i);
- return vertex_array;
- `}
+class GLfloatArray
+ super CArray[Float]
+ redef type NATIVE: NativeGLfloatArray
+
+ init do native_array = new NativeGLfloatArray(length)
+
+ # Create with the content of `array`
+ new from(array: Array[Float])
+ do
+ var arr = new GLfloatArray(array.length)
+ arr.fill_from array
+ return arr
+ end
+
+ # Fill with the content of `array`
+ fun fill_from(array: Array[Float])
+ do
+ assert length >= array.length
+ for k in [0..array.length[ do
+ self[k] = array[k]
+ end
+ end
+end
+
+# An array of `GLfloat` in C (`GLfloat*`)
+extern class NativeGLfloatArray `{ GLfloat* `}
+ super NativeCArray
+ redef type E: Float
+
+ new(size: Int) `{ return calloc(size, sizeof(GLfloat)); `}
+
+ redef fun [](index) `{ return self[index]; `}
+ redef fun []=(index, val) `{ self[index] = val; `}
+
+ redef fun +(offset) `{ return self + offset; `}
end
# General type for OpenGL enumerations
extern class GLEnum `{ GLenum `}
- redef fun hash `{ return recv; `}
+ redef fun hash `{ return self; `}
redef fun ==(o) do return o != null and is_same_type(o) and o.hash == self.hash
end
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_no_error: Bool `{ return self == 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; `}
- fun is_invalid_framebuffer_operation: Bool `{ return recv == GL_INVALID_FRAMEBUFFER_OPERATION; `}
- fun is_out_of_memory: Bool `{ return recv == GL_OUT_OF_MEMORY; `}
+ fun is_invalid_enum: Bool `{ return self == GL_INVALID_ENUM; `}
+ fun is_invalid_value: Bool `{ return self == GL_INVALID_VALUE; `}
+ fun is_invalid_operation: Bool `{ return self == GL_INVALID_OPERATION; `}
+ fun is_invalid_framebuffer_operation: Bool `{ return self == GL_INVALID_FRAMEBUFFER_OPERATION; `}
+ fun is_out_of_memory: Bool `{ return self == GL_OUT_OF_MEMORY; `}
redef fun to_s
do
end
end
-protected fun assert_no_gl_error
+fun assert_no_gl_error
do
var error = gl.error
if not error.is_ok then
end
end
-# Texture minifying function
-#
-# Used by: `GLES::tex_parameter_min_filter`
-extern class GLTextureMinFilter
- super GLEnum
+# Does `name` corresponds to a texture?
+fun glIsTexture(name: Int): Bool `{ return glIsTexture(name); `}
- new nearest `{ return GL_NEAREST; `}
- new linear `{ return GL_LINEAR; `}
-end
+# Bind the named `texture` to a `target`
+fun glBindTexture(target: GLTextureTarget, texture: Int) `{ glBindTexture(target, texture); `}
-# Texture magnification function
-#
-# Used by: `GLES::tex_parameter_mag_filter`
-extern class GLTextureMagFilter
+# Set pixel storage modes
+fun glPixelStorei(parameter: GLPack, val: Int) `{ glPixelStorei(parameter, val); `}
+
+# Symbolic name of the parameter to be set with `glPixelStorei`
+extern class GLPack
super GLEnum
+end
- new nearest `{ return GL_NEAREST; `}
- new linear `{ return GL_LINEAR; `}
- new nearest_mipmap_nearest `{ return GL_NEAREST_MIPMAP_NEAREST; `}
- new linear_mipmap_nearest `{ return GL_LINEAR_MIPMAP_NEAREST; `}
- new nearest_mipmap_linear `{ return GL_NEAREST_MIPMAP_LINEAR; `}
- new linear_mipmap_linear `{ return GL_LINEAR_MIPMAP_LINEAR; `}
+# Parameter to specify the alignment requirements for the start of each pixel row in memory
+fun gl_PACK_ALIGNEMENT: GLPack `{ return GL_PACK_ALIGNMENT; `}
+
+# Parameter to specify the alignment requirements for the start of each pixel row in memory
+fun gl_UNPACK_ALIGNEMENT: GLPack `{ return GL_UNPACK_ALIGNMENT; `}
+
+# TODO GL_PACK_ROW_LENGTH, GL_PACK_IMAGE_HEIGHT, GL_PACK_SKIP_PIXELS, GL_PACK_SKIP_ROWS, GL_PACK_SKIP_IMAGES
+# GL_UNPACK_ROW_LENGTH, GL_UNPACK_IMAGE_HEIGHT, GL_UNPACK_SKIP_PIXELS, GL_UNPACK_SKIP_ROWS, GL_UNPACK_SKIP_IMAGES
+
+# Specify a two-dimensional texture image
+fun glTexImage2D(target: GLTextureTarget, level, internalformat, width, height, border: Int,
+ format: GLPixelFormat, typ: GLPixelType, data: NativeCByteArray) `{
+ glTexImage2D(target, level, internalformat, width, height, border, format, typ, data);
+`}
+
+# Texture minifying and magnifying function
+extern class GLTextureFilter
+ super GLEnum
end
+fun gl_NEAREST: GLTextureFilter `{ return GL_NEAREST; `}
+fun gl_LINEAR: GLTextureFilter `{ return GL_LINEAR; `}
+fun gl_NEAREST_MIPMAP_NEAREST: GLTextureFilter `{ return GL_NEAREST_MIPMAP_NEAREST; `}
+fun gl_LINEAR_MIPMAP_NEAREST: GLTextureFilter `{ return GL_LINEAR_MIPMAP_NEAREST; `}
+fun gl_NEAREST_MIPMAP_NINEAR: GLTextureFilter `{ return GL_NEAREST_MIPMAP_LINEAR; `}
+fun gl_LINEAR_MIPMAP_LINEAR: GLTextureFilter `{ return GL_LINEAR_MIPMAP_LINEAR; `}
+
# Wrap parameter of a texture
#
# Used by: `tex_parameter_wrap_*`
end
# Target texture
-#
-# Used by: `tex_parameter_*`
extern class GLTextureTarget
super GLEnum
-
- new flat `{ return GL_TEXTURE_2D; `}
- new cube_map `{ return GL_TEXTURE_CUBE_MAP; `}
end
+# Two-dimensional texture
+fun gl_TEXTURE_2D: GLTextureTarget `{ return GL_TEXTURE_2D; `}
+
+# Cube map texture
+fun gl_TEXTURE_CUBE_MAP: GLTextureTarget `{ return GL_TEXTURE_CUBE_MAP; `}
+
+# TODO GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
+# GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
+
# A server-side capability
class GLCap
redef fun hash do return val
redef fun ==(o) do return o != null and is_same_type(o) and o.hash == self.hash
end
+
+# Attach a renderbuffer object to a framebuffer object
+fun glFramebufferRenderbuffer(target: GLFramebufferTarget, attachment: GLAttachment,
+ renderbuffertarget: GLRenderbufferTarget, renderbuffer: Int) `{
+ glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+`}
+
+# Establish data storage, `format` and dimensions of the `target` renderbuffer object's image
+fun glRenderbufferStorage(target: GLRenderbufferTarget, format: GLRenderbufferFormat, width, height: Int) `{
+ glRenderbufferStorage(GL_RENDERBUFFER, format, width, height);
+`}
+
+# Format for a renderbuffer
+extern class GLRenderbufferFormat
+ super GLEnum
+end
+
+# 4 red, 4 green, 4 blue, 4 alpha bits format
+fun gl_RGBA4: GLRenderbufferFormat `{ return GL_RGBA4; `}
+
+# 5 red, 6 green, 5 blue bits format
+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; `}
+
+# 16 depth bits format
+fun gl_DEPTH_COMPNENT16: GLRenderbufferFormat `{ return GL_DEPTH_COMPONENT16; `}
+
+# 8 stencil bits format
+fun gl_STENCIL_INDEX8: GLRenderbufferFormat `{ return GL_STENCIL_INDEX8; `}
+
+# Renderbuffer attachment point to a framebuffer
+extern class GLAttachment
+ super GLEnum
+end
+
+# First color attachment point
+fun gl_COLOR_ATTACHMENT0: GLAttachment `{ return GL_COLOR_ATTACHMENT0; `}
+
+# Depth attachment point
+fun gl_DEPTH_ATTACHMENT: GLAttachment `{ return GL_DEPTH_ATTACHMENT; `}
+
+# Stencil attachment
+fun gl_STENCIL_ATTACHMENT: GLAttachment `{ return GL_STENCIL_ATTACHMENT; `}
+
redef class Sys
private var gles = new GLES is lazy
end
#
# 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);
+ glReadPixels(x, y, width, height, format, typ, data);
`}
# Set the texture minifying function
#
# Foreign: glTexParameter with GL_TEXTURE_MIN_FILTER
- fun tex_parameter_min_filter(target: GLTextureTarget, value: GLTextureMinFilter) `{
+ fun tex_parameter_min_filter(target: GLTextureTarget, value: GLTextureFilter) `{
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) `{
+ fun tex_parameter_mag_filter(target: GLTextureTarget, value: GLTextureFilter) `{
glTexParameteri(target, GL_TEXTURE_MAG_FILTER, value);
`}
var capabilities = new GLCapabilities is lazy
end
+# Bind `framebuffer` to a framebuffer target
+#
+# In OpenGL ES 2.0, `target` must be `gl_FRAMEBUFFER`.
+fun glBindFramebuffer(target: GLFramebufferTarget, framebuffer: Int) `{
+ glBindFramebuffer(target, framebuffer);
+`}
+
+# Target of `glBindFramebuffer`
+extern class GLFramebufferTarget
+ super GLEnum
+end
+
+# Target both reading and writing on the framebuffer with `glBindFramebuffer`
+fun gl_FRAMEBUFFER: GLFramebufferTarget `{ return GL_FRAMEBUFFER; `}
+
+# Bind `renderbuffer` to a renderbuffer target
+#
+# In OpenGL ES 2.0, `target` must be `gl_RENDERBUFFER`.
+fun glBindRenderbuffer(target: GLRenderbufferTarget, renderbuffer: Int) `{
+ glBindRenderbuffer(target, renderbuffer);
+`}
+
+# Target of `glBindRenderbuffer`
+extern class GLRenderbufferTarget
+ super GLEnum
+end
+
+# Target a renderbuffer with `glBindRenderbuffer`
+fun gl_RENDERBUFFER: GLRenderbufferTarget `{ return GL_RENDERBUFFER; `}
+
+# Specify implementation specific hints
+fun glHint(target: GLHintTarget, mode: GLHintMode) `{
+ glHint(target, mode);
+`}
+
+# Generate and fill set of mipmaps for the texture object `target`
+fun glGenerateMipmap(target: GLTextureTarget) `{ glGenerateMipmap(target); `}
+
+# Bind the named `buffer` object
+fun glBindBuffer(target: GLArrayBuffer, buffer: Int) `{ glBindBuffer(target, buffer); `}
+
+# Target to which bind the buffer with `glBindBuffer`
+extern class GLArrayBuffer
+ super GLEnum
+end
+
+# Array buffer target
+fun gl_ARRAY_BUFFER: GLArrayBuffer `{ return GL_ARRAY_BUFFER; `}
+
+# Element array buffer
+fun gl_ELEMENT_ARRAY_BUFFER: GLArrayBuffer `{ return GL_ELEMENT_ARRAY_BUFFER; `}
+
+# Completeness status of a framebuffer object
+fun glCheckFramebufferStatus(target: GLFramebufferTarget): GLFramebufferStatus `{
+ return glCheckFramebufferStatus(target);
+`}
+
+# Return value of `glCheckFramebufferStatus`
+extern class GLFramebufferStatus
+ super GLEnum
+
+ redef fun to_s
+ do
+ if self == gl_FRAMEBUFFER_COMPLETE then return "complete"
+ if self == gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT then return "incomplete attachment"
+ if self == gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS then return "incomplete dimension"
+ if self == gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT then return "incomplete missing attachment"
+ if self == gl_FRAMEBUFFER_UNSUPPORTED then return "unsupported"
+ return "unknown"
+ end
+end
+
+# The framebuffer is complete
+fun gl_FRAMEBUFFER_COMPLETE: GLFramebufferStatus `{
+ return GL_FRAMEBUFFER_COMPLETE;
+`}
+
+# Not all framebuffer attachment points are framebuffer attachment complete
+fun gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLFramebufferStatus `{
+ return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
+`}
+
+# Not all attached images have the same width and height
+fun gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLFramebufferStatus `{
+ return GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS;
+`}
+
+# No images are attached to the framebuffer
+fun gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLFramebufferStatus `{
+ return GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
+`}
+
+# The combination of internal formats of the attached images violates an implementation-dependent set of restrictions
+fun gl_FRAMEBUFFER_UNSUPPORTED: GLFramebufferStatus `{
+ return GL_FRAMEBUFFER_UNSUPPORTED;
+`}
+
+# Hint target for `glHint`
+extern class GLHintTarget
+ super GLEnum
+end
+
+# Indicates the quality of filtering when generating mipmap images
+fun gl_GENERATE_MIPMAP_HINT: GLHintTarget `{ return GL_GENERATE_MIPMAP_HINT; `}
+
+# Hint mode for `glHint`
+extern class GLHintMode
+ super GLEnum
+end
+
+# The most efficient option should be chosen
+fun gl_FASTEST: GLHintMode `{ return GL_FASTEST; `}
+
+# The most correct, or highest quality, option should be chosen
+fun gl_NICEST: GLHintMode `{ return GL_NICEST; `}
+
+# No preference
+fun gl_DONT_CARE: GLHintMode `{ return GL_DONT_CARE; `}
+
+# Attach a level of a texture object as a logical buffer to the currently bound framebuffer object
+fun glFramebufferTexture2D(target: GLFramebufferTarget, attachment: GLAttachment,
+ texture_target: GLTextureTarget, texture, level: Int) `{
+ glFramebufferTexture2D(target, attachment, texture_target, texture, level);
+`}
+
# 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)
+ var 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)
+ var 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)
+ var 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)
+ var 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)
+ var 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)
+ var 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)
+ var 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)
+ var 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)
+ var stencil_test: GLCap is lazy do return new GLCap(0x0B90)
end
# Float related data types of OpenGL ES 2.0 shaders
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; `}
+ 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)
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; `}
+ 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; `}
end
# Kind of primitives to render with `GLES::draw_arrays`
new `{ return 0; `}
# Add the color buffer to the returned buffer set
- fun color: GLBuffer `{ return recv | GL_COLOR_BUFFER_BIT; `}
+ fun color: GLBuffer `{ return self | GL_COLOR_BUFFER_BIT; `}
# Add the depth buffer to the returned buffer set
- fun depth: GLBuffer `{ return recv | GL_DEPTH_BUFFER_BIT; `}
+ fun depth: GLBuffer `{ return self | GL_DEPTH_BUFFER_BIT; `}
# Add the stencil buffer to the returned buffer set
- fun stencil: GLBuffer `{ return recv | GL_STENCIL_BUFFER_BIT; `}
+ fun stencil: GLBuffer `{ return self | GL_STENCIL_BUFFER_BIT; `}
end
nitlanguage / nit.git / blobdiff