Redefined classes

redef class Sys

glesv2 :: glesv2_stub $ Sys

The main class of the program.

All class definitions

redef class Sys

glesv2 :: glesv2_stub $ Sys

The main class of the program.
package_diagram glesv2::glesv2_stub glesv2_stub core core glesv2::glesv2_stub->core a_star-m a_star-m a_star-m->glesv2::glesv2_stub

Ancestors

module abstract_collection

core :: abstract_collection

Abstract collection classes and services.
module abstract_text

core :: abstract_text

Abstract class for manipulation of sequences of characters
module array

core :: array

This module introduces the standard array structure.
module bitset

core :: bitset

Services to handle BitSet
module bytes

core :: bytes

Services for byte streams and arrays
module circular_array

core :: circular_array

Efficient data structure to access both end of the sequence.
module codec_base

core :: codec_base

Base for codecs to use with streams
module codecs

core :: codecs

Group module for all codec-related manipulations
module collection

core :: collection

This module define several collection classes.
module environ

core :: environ

Access to the environment variables of the process
module error

core :: error

Standard error-management infrastructure.
module exec

core :: exec

Invocation and management of operating system sub-processes.
module file

core :: file

File manipulations (create, read, write, etc.)
module fixed_ints

core :: fixed_ints

Basic integers of fixed-precision
module fixed_ints_text

core :: fixed_ints_text

Text services to complement fixed_ints
module flat

core :: flat

All the array-based text representations
module gc

core :: gc

Access to the Nit internal garbage collection mechanism
module hash_collection

core :: hash_collection

Introduce HashMap and HashSet.
module iso8859_1

core :: iso8859_1

Codec for ISO8859-1 I/O
module kernel

core :: kernel

Most basic classes and methods.
module list

core :: list

This module handle double linked lists
module math

core :: math

Mathematical operations
module native

core :: native

Native structures for text and bytes
module numeric

core :: numeric

Advanced services for Numeric types
module protocol

core :: protocol

module queue

core :: queue

Queuing data structures and wrappers
module range

core :: range

Module for range of discrete objects.
module re

core :: re

Regular expression support for all services based on Pattern
module ropes

core :: ropes

Tree-based representation of a String.
module sorter

core :: sorter

This module contains classes used to compare things and sorts arrays.
module stream

core :: stream

Input and output streams of characters
module text

core :: text

All the classes and methods related to the manipulation of text entities
module time

core :: time

Management of time and dates
module union_find

core :: union_find

union–find algorithm using an efficient disjoint-set data structure
module utf8

core :: utf8

Codec for UTF-8 I/O

Parents

module core

core :: core

Standard classes and methods used by default by Nit programs and libraries.

Children

module a_star-m

a_star-m

fun gl_ES_VERSION_2_0: Int `{ return GL_ES_VERSION_2_0; `}
fun gl_DEPTH_BUFFER_BIT: Int `{ return GL_DEPTH_BUFFER_BIT; `}
fun gl_STENCIL_BUFFER_BIT: Int `{ return GL_STENCIL_BUFFER_BIT; `}
fun gl_COLOR_BUFFER_BIT: Int `{ return GL_COLOR_BUFFER_BIT; `}
fun gl_FALSE: Int `{ return GL_FALSE; `}
fun gl_TRUE: Int `{ return GL_TRUE; `}
fun gl_POINTS: Int `{ return GL_POINTS; `}
fun gl_LINES: Int `{ return GL_LINES; `}
fun gl_LINE_LOOP: Int `{ return GL_LINE_LOOP; `}
fun gl_LINE_STRIP: Int `{ return GL_LINE_STRIP; `}
fun gl_TRIANGLES: Int `{ return GL_TRIANGLES; `}
fun gl_TRIANGLE_STRIP: Int `{ return GL_TRIANGLE_STRIP; `}
fun gl_TRIANGLE_FAN: Int `{ return GL_TRIANGLE_FAN; `}
fun gl_ZERO: Int `{ return GL_ZERO; `}
fun gl_ONE: Int `{ return GL_ONE; `}
fun gl_SRC_COLOR: Int `{ return GL_SRC_COLOR; `}
fun gl_ONE_MINUS_SRC_COLOR: Int `{ return GL_ONE_MINUS_SRC_COLOR; `}
fun gl_SRC_ALPHA: Int `{ return GL_SRC_ALPHA; `}
fun gl_ONE_MINUS_SRC_ALPHA: Int `{ return GL_ONE_MINUS_SRC_ALPHA; `}
fun gl_DST_ALPHA: Int `{ return GL_DST_ALPHA; `}
fun gl_ONE_MINUS_DST_ALPHA: Int `{ return GL_ONE_MINUS_DST_ALPHA; `}
fun gl_DST_COLOR: Int `{ return GL_DST_COLOR; `}
fun gl_ONE_MINUS_DST_COLOR: Int `{ return GL_ONE_MINUS_DST_COLOR; `}
fun gl_SRC_ALPHA_SATURATE: Int `{ return GL_SRC_ALPHA_SATURATE; `}
fun gl_FUNC_ADD: Int `{ return GL_FUNC_ADD; `}
fun gl_BLEND_EQUATION: Int `{ return GL_BLEND_EQUATION; `}
fun gl_BLEND_EQUATION_RGB: Int `{ return GL_BLEND_EQUATION_RGB; `}
fun gl_BLEND_EQUATION_ALPHA: Int `{ return GL_BLEND_EQUATION_ALPHA; `}
fun gl_FUNC_SUBTRACT: Int `{ return GL_FUNC_SUBTRACT; `}
fun gl_FUNC_REVERSE_SUBTRACT: Int `{ return GL_FUNC_REVERSE_SUBTRACT; `}
fun gl_BLEND_DST_RGB: Int `{ return GL_BLEND_DST_RGB; `}
fun gl_BLEND_SRC_RGB: Int `{ return GL_BLEND_SRC_RGB; `}
fun gl_BLEND_DST_ALPHA: Int `{ return GL_BLEND_DST_ALPHA; `}
fun gl_BLEND_SRC_ALPHA: Int `{ return GL_BLEND_SRC_ALPHA; `}
fun gl_CONSTANT_COLOR: Int `{ return GL_CONSTANT_COLOR; `}
fun gl_ONE_MINUS_CONSTANT_COLOR: Int `{ return GL_ONE_MINUS_CONSTANT_COLOR; `}
fun gl_CONSTANT_ALPHA: Int `{ return GL_CONSTANT_ALPHA; `}
fun gl_ONE_MINUS_CONSTANT_ALPHA: Int `{ return GL_ONE_MINUS_CONSTANT_ALPHA; `}
fun gl_BLEND_COLOR: Int `{ return GL_BLEND_COLOR; `}
fun gl_ARRAY_BUFFER: Int `{ return GL_ARRAY_BUFFER; `}
fun gl_ELEMENT_ARRAY_BUFFER: Int `{ return GL_ELEMENT_ARRAY_BUFFER; `}
fun gl_ARRAY_BUFFER_BINDING: Int `{ return GL_ARRAY_BUFFER_BINDING; `}
fun gl_ELEMENT_ARRAY_BUFFER_BINDING: Int `{ return GL_ELEMENT_ARRAY_BUFFER_BINDING; `}
fun gl_STREAM_DRAW: Int `{ return GL_STREAM_DRAW; `}
fun gl_STATIC_DRAW: Int `{ return GL_STATIC_DRAW; `}
fun gl_DYNAMIC_DRAW: Int `{ return GL_DYNAMIC_DRAW; `}
fun gl_BUFFER_SIZE: Int `{ return GL_BUFFER_SIZE; `}
fun gl_BUFFER_USAGE: Int `{ return GL_BUFFER_USAGE; `}
fun gl_CURRENT_VERTEX_ATTRIB: Int `{ return GL_CURRENT_VERTEX_ATTRIB; `}
fun gl_FRONT: Int `{ return GL_FRONT; `}
fun gl_BACK: Int `{ return GL_BACK; `}
fun gl_FRONT_AND_BACK: Int `{ return GL_FRONT_AND_BACK; `}
fun gl_TEXTURE_2D: Int `{ return GL_TEXTURE_2D; `}
fun gl_CULL_FACE: Int `{ return GL_CULL_FACE; `}
fun gl_BLEND: Int `{ return GL_BLEND; `}
fun gl_DITHER: Int `{ return GL_DITHER; `}
fun gl_STENCIL_TEST: Int `{ return GL_STENCIL_TEST; `}
fun gl_DEPTH_TEST: Int `{ return GL_DEPTH_TEST; `}
fun gl_SCISSOR_TEST: Int `{ return GL_SCISSOR_TEST; `}
fun gl_POLYGON_OFFSET_FILL: Int `{ return GL_POLYGON_OFFSET_FILL; `}
fun gl_SAMPLE_ALPHA_TO_COVERAGE: Int `{ return GL_SAMPLE_ALPHA_TO_COVERAGE; `}
fun gl_SAMPLE_COVERAGE: Int `{ return GL_SAMPLE_COVERAGE; `}
fun gl_NO_ERROR: Int `{ return GL_NO_ERROR; `}
fun gl_INVALID_ENUM: Int `{ return GL_INVALID_ENUM; `}
fun gl_INVALID_VALUE: Int `{ return GL_INVALID_VALUE; `}
fun gl_INVALID_OPERATION: Int `{ return GL_INVALID_OPERATION; `}
fun gl_OUT_OF_MEMORY: Int `{ return GL_OUT_OF_MEMORY; `}
fun gl_CW: Int `{ return GL_CW; `}
fun gl_CCW: Int `{ return GL_CCW; `}
fun gl_LINE_WIDTH: Int `{ return GL_LINE_WIDTH; `}
fun gl_ALIASED_POINT_SIZE_RANGE: Int `{ return GL_ALIASED_POINT_SIZE_RANGE; `}
fun gl_ALIASED_LINE_WIDTH_RANGE: Int `{ return GL_ALIASED_LINE_WIDTH_RANGE; `}
fun gl_CULL_FACE_MODE: Int `{ return GL_CULL_FACE_MODE; `}
fun gl_FRONT_FACE: Int `{ return GL_FRONT_FACE; `}
fun gl_DEPTH_RANGE: Int `{ return GL_DEPTH_RANGE; `}
fun gl_DEPTH_WRITEMASK: Int `{ return GL_DEPTH_WRITEMASK; `}
fun gl_DEPTH_CLEAR_VALUE: Int `{ return GL_DEPTH_CLEAR_VALUE; `}
fun gl_DEPTH_FUNC: Int `{ return GL_DEPTH_FUNC; `}
fun gl_STENCIL_CLEAR_VALUE: Int `{ return GL_STENCIL_CLEAR_VALUE; `}
fun gl_STENCIL_FUNC: Int `{ return GL_STENCIL_FUNC; `}
fun gl_STENCIL_FAIL: Int `{ return GL_STENCIL_FAIL; `}
fun gl_STENCIL_PASS_DEPTH_FAIL: Int `{ return GL_STENCIL_PASS_DEPTH_FAIL; `}
fun gl_STENCIL_PASS_DEPTH_PASS: Int `{ return GL_STENCIL_PASS_DEPTH_PASS; `}
fun gl_STENCIL_REF: Int `{ return GL_STENCIL_REF; `}
fun gl_STENCIL_VALUE_MASK: Int `{ return GL_STENCIL_VALUE_MASK; `}
fun gl_STENCIL_WRITEMASK: Int `{ return GL_STENCIL_WRITEMASK; `}
fun gl_STENCIL_BACK_FUNC: Int `{ return GL_STENCIL_BACK_FUNC; `}
fun gl_STENCIL_BACK_FAIL: Int `{ return GL_STENCIL_BACK_FAIL; `}
fun gl_STENCIL_BACK_PASS_DEPTH_FAIL: Int `{ return GL_STENCIL_BACK_PASS_DEPTH_FAIL; `}
fun gl_STENCIL_BACK_PASS_DEPTH_PASS: Int `{ return GL_STENCIL_BACK_PASS_DEPTH_PASS; `}
fun gl_STENCIL_BACK_REF: Int `{ return GL_STENCIL_BACK_REF; `}
fun gl_STENCIL_BACK_VALUE_MASK: Int `{ return GL_STENCIL_BACK_VALUE_MASK; `}
fun gl_STENCIL_BACK_WRITEMASK: Int `{ return GL_STENCIL_BACK_WRITEMASK; `}
fun gl_VIEWPORT: Int `{ return GL_VIEWPORT; `}
fun gl_SCISSOR_BOX: Int `{ return GL_SCISSOR_BOX; `}
fun gl_COLOR_CLEAR_VALUE: Int `{ return GL_COLOR_CLEAR_VALUE; `}
fun gl_COLOR_WRITEMASK: Int `{ return GL_COLOR_WRITEMASK; `}
fun gl_UNPACK_ALIGNMENT: Int `{ return GL_UNPACK_ALIGNMENT; `}
fun gl_PACK_ALIGNMENT: Int `{ return GL_PACK_ALIGNMENT; `}
fun gl_MAX_TEXTURE_SIZE: Int `{ return GL_MAX_TEXTURE_SIZE; `}
fun gl_MAX_VIEWPORT_DIMS: Int `{ return GL_MAX_VIEWPORT_DIMS; `}
fun gl_SUBPIXEL_BITS: Int `{ return GL_SUBPIXEL_BITS; `}
fun gl_RED_BITS: Int `{ return GL_RED_BITS; `}
fun gl_GREEN_BITS: Int `{ return GL_GREEN_BITS; `}
fun gl_BLUE_BITS: Int `{ return GL_BLUE_BITS; `}
fun gl_ALPHA_BITS: Int `{ return GL_ALPHA_BITS; `}
fun gl_DEPTH_BITS: Int `{ return GL_DEPTH_BITS; `}
fun gl_STENCIL_BITS: Int `{ return GL_STENCIL_BITS; `}
fun gl_POLYGON_OFFSET_UNITS: Int `{ return GL_POLYGON_OFFSET_UNITS; `}
fun gl_POLYGON_OFFSET_FACTOR: Int `{ return GL_POLYGON_OFFSET_FACTOR; `}
fun gl_TEXTURE_BINDING_2D: Int `{ return GL_TEXTURE_BINDING_2D; `}
fun gl_SAMPLE_BUFFERS: Int `{ return GL_SAMPLE_BUFFERS; `}
fun gl_SAMPLES: Int `{ return GL_SAMPLES; `}
fun gl_SAMPLE_COVERAGE_VALUE: Int `{ return GL_SAMPLE_COVERAGE_VALUE; `}
fun gl_SAMPLE_COVERAGE_INVERT: Int `{ return GL_SAMPLE_COVERAGE_INVERT; `}
fun gl_NUM_COMPRESSED_TEXTURE_FORMATS: Int `{ return GL_NUM_COMPRESSED_TEXTURE_FORMATS; `}
fun gl_COMPRESSED_TEXTURE_FORMATS: Int `{ return GL_COMPRESSED_TEXTURE_FORMATS; `}
fun gl_DONT_CARE: Int `{ return GL_DONT_CARE; `}
fun gl_FASTEST: Int `{ return GL_FASTEST; `}
fun gl_NICEST: Int `{ return GL_NICEST; `}
fun gl_GENERATE_MIPMAP_HINT: Int `{ return GL_GENERATE_MIPMAP_HINT; `}
fun gl_BYTE: Int `{ return GL_BYTE; `}
fun gl_UNSIGNED_BYTE: Int `{ return GL_UNSIGNED_BYTE; `}
fun gl_SHORT: Int `{ return GL_SHORT; `}
fun gl_UNSIGNED_SHORT: Int `{ return GL_UNSIGNED_SHORT; `}
fun gl_INT: Int `{ return GL_INT; `}
fun gl_UNSIGNED_INT: Int `{ return GL_UNSIGNED_INT; `}
fun gl_FLOAT: Int `{ return GL_FLOAT; `}
fun gl_FIXED: Int `{ return GL_FIXED; `}
fun gl_DEPTH_COMPONENT: Int `{ return GL_DEPTH_COMPONENT; `}
fun gl_ALPHA: Int `{ return GL_ALPHA; `}
fun gl_RGB: Int `{ return GL_RGB; `}
fun gl_RGBA: Int `{ return GL_RGBA; `}
fun gl_LUMINANCE: Int `{ return GL_LUMINANCE; `}
fun gl_LUMINANCE_ALPHA: Int `{ return GL_LUMINANCE_ALPHA; `}
fun gl_UNSIGNED_SHORT_4_4_4_4: Int `{ return GL_UNSIGNED_SHORT_4_4_4_4; `}
fun gl_UNSIGNED_SHORT_5_5_5_1: Int `{ return GL_UNSIGNED_SHORT_5_5_5_1; `}
fun gl_UNSIGNED_SHORT_5_6_5: Int `{ return GL_UNSIGNED_SHORT_5_6_5; `}
fun gl_FRAGMENT_SHADER: Int `{ return GL_FRAGMENT_SHADER; `}
fun gl_VERTEX_SHADER: Int `{ return GL_VERTEX_SHADER; `}
fun gl_MAX_VERTEX_ATTRIBS: Int `{ return GL_MAX_VERTEX_ATTRIBS; `}
fun gl_MAX_VERTEX_UNIFORM_VECTORS: Int `{ return GL_MAX_VERTEX_UNIFORM_VECTORS; `}
fun gl_MAX_VARYING_VECTORS: Int `{ return GL_MAX_VARYING_VECTORS; `}
fun gl_MAX_COMBINED_TEXTURE_IMAGE_UNITS: Int `{ return GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS; `}
fun gl_MAX_VERTEX_TEXTURE_IMAGE_UNITS: Int `{ return GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS; `}
fun gl_MAX_TEXTURE_IMAGE_UNITS: Int `{ return GL_MAX_TEXTURE_IMAGE_UNITS; `}
fun gl_MAX_FRAGMENT_UNIFORM_VECTORS: Int `{ return GL_MAX_FRAGMENT_UNIFORM_VECTORS; `}
fun gl_SHADER_TYPE: Int `{ return GL_SHADER_TYPE; `}
fun gl_DELETE_STATUS: Int `{ return GL_DELETE_STATUS; `}
fun gl_LINK_STATUS: Int `{ return GL_LINK_STATUS; `}
fun gl_VALIDATE_STATUS: Int `{ return GL_VALIDATE_STATUS; `}
fun gl_ATTACHED_SHADERS: Int `{ return GL_ATTACHED_SHADERS; `}
fun gl_ACTIVE_UNIFORMS: Int `{ return GL_ACTIVE_UNIFORMS; `}
fun gl_ACTIVE_UNIFORM_MAX_LENGTH: Int `{ return GL_ACTIVE_UNIFORM_MAX_LENGTH; `}
fun gl_ACTIVE_ATTRIBUTES: Int `{ return GL_ACTIVE_ATTRIBUTES; `}
fun gl_ACTIVE_ATTRIBUTE_MAX_LENGTH: Int `{ return GL_ACTIVE_ATTRIBUTE_MAX_LENGTH; `}
fun gl_SHADING_LANGUAGE_VERSION: Int `{ return GL_SHADING_LANGUAGE_VERSION; `}
fun gl_CURRENT_PROGRAM: Int `{ return GL_CURRENT_PROGRAM; `}
fun gl_NEVER: Int `{ return GL_NEVER; `}
fun gl_LESS: Int `{ return GL_LESS; `}
fun gl_EQUAL: Int `{ return GL_EQUAL; `}
fun gl_LEQUAL: Int `{ return GL_LEQUAL; `}
fun gl_GREATER: Int `{ return GL_GREATER; `}
fun gl_NOTEQUAL: Int `{ return GL_NOTEQUAL; `}
fun gl_GEQUAL: Int `{ return GL_GEQUAL; `}
fun gl_ALWAYS: Int `{ return GL_ALWAYS; `}
fun gl_KEEP: Int `{ return GL_KEEP; `}
fun gl_REPLACE: Int `{ return GL_REPLACE; `}
fun gl_INCR: Int `{ return GL_INCR; `}
fun gl_DECR: Int `{ return GL_DECR; `}
fun gl_INVERT: Int `{ return GL_INVERT; `}
fun gl_INCR_WRAP: Int `{ return GL_INCR_WRAP; `}
fun gl_DECR_WRAP: Int `{ return GL_DECR_WRAP; `}
fun gl_VENDOR: Int `{ return GL_VENDOR; `}
fun gl_RENDERER: Int `{ return GL_RENDERER; `}
fun gl_VERSION: Int `{ return GL_VERSION; `}
fun gl_EXTENSIONS: Int `{ return GL_EXTENSIONS; `}
fun gl_NEAREST: Int `{ return GL_NEAREST; `}
fun gl_LINEAR: Int `{ return GL_LINEAR; `}
fun gl_NEAREST_MIPMAP_NEAREST: Int `{ return GL_NEAREST_MIPMAP_NEAREST; `}
fun gl_LINEAR_MIPMAP_NEAREST: Int `{ return GL_LINEAR_MIPMAP_NEAREST; `}
fun gl_NEAREST_MIPMAP_LINEAR: Int `{ return GL_NEAREST_MIPMAP_LINEAR; `}
fun gl_LINEAR_MIPMAP_LINEAR: Int `{ return GL_LINEAR_MIPMAP_LINEAR; `}
fun gl_TEXTURE_MAG_FILTER: Int `{ return GL_TEXTURE_MAG_FILTER; `}
fun gl_TEXTURE_MIN_FILTER: Int `{ return GL_TEXTURE_MIN_FILTER; `}
fun gl_TEXTURE_WRAP_S: Int `{ return GL_TEXTURE_WRAP_S; `}
fun gl_TEXTURE_WRAP_T: Int `{ return GL_TEXTURE_WRAP_T; `}
fun gl_TEXTURE: Int `{ return GL_TEXTURE; `}
fun gl_TEXTURE_CUBE_MAP: Int `{ return GL_TEXTURE_CUBE_MAP; `}
fun gl_TEXTURE_BINDING_CUBE_MAP: Int `{ return GL_TEXTURE_BINDING_CUBE_MAP; `}
fun gl_TEXTURE_CUBE_MAP_POSITIVE_X: Int `{ return GL_TEXTURE_CUBE_MAP_POSITIVE_X; `}
fun gl_TEXTURE_CUBE_MAP_NEGATIVE_X: Int `{ return GL_TEXTURE_CUBE_MAP_NEGATIVE_X; `}
fun gl_TEXTURE_CUBE_MAP_POSITIVE_Y: Int `{ return GL_TEXTURE_CUBE_MAP_POSITIVE_Y; `}
fun gl_TEXTURE_CUBE_MAP_NEGATIVE_Y: Int `{ return GL_TEXTURE_CUBE_MAP_NEGATIVE_Y; `}
fun gl_TEXTURE_CUBE_MAP_POSITIVE_Z: Int `{ return GL_TEXTURE_CUBE_MAP_POSITIVE_Z; `}
fun gl_TEXTURE_CUBE_MAP_NEGATIVE_Z: Int `{ return GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; `}
fun gl_MAX_CUBE_MAP_TEXTURE_SIZE: Int `{ return GL_MAX_CUBE_MAP_TEXTURE_SIZE; `}
fun gl_TEXTURE0: Int `{ return GL_TEXTURE0; `}
fun gl_TEXTURE1: Int `{ return GL_TEXTURE1; `}
fun gl_TEXTURE2: Int `{ return GL_TEXTURE2; `}
fun gl_TEXTURE3: Int `{ return GL_TEXTURE3; `}
fun gl_TEXTURE4: Int `{ return GL_TEXTURE4; `}
fun gl_TEXTURE5: Int `{ return GL_TEXTURE5; `}
fun gl_TEXTURE6: Int `{ return GL_TEXTURE6; `}
fun gl_TEXTURE7: Int `{ return GL_TEXTURE7; `}
fun gl_TEXTURE8: Int `{ return GL_TEXTURE8; `}
fun gl_TEXTURE9: Int `{ return GL_TEXTURE9; `}
fun gl_TEXTURE10: Int `{ return GL_TEXTURE10; `}
fun gl_TEXTURE11: Int `{ return GL_TEXTURE11; `}
fun gl_TEXTURE12: Int `{ return GL_TEXTURE12; `}
fun gl_TEXTURE13: Int `{ return GL_TEXTURE13; `}
fun gl_TEXTURE14: Int `{ return GL_TEXTURE14; `}
fun gl_TEXTURE15: Int `{ return GL_TEXTURE15; `}
fun gl_TEXTURE16: Int `{ return GL_TEXTURE16; `}
fun gl_TEXTURE17: Int `{ return GL_TEXTURE17; `}
fun gl_TEXTURE18: Int `{ return GL_TEXTURE18; `}
fun gl_TEXTURE19: Int `{ return GL_TEXTURE19; `}
fun gl_TEXTURE20: Int `{ return GL_TEXTURE20; `}
fun gl_TEXTURE21: Int `{ return GL_TEXTURE21; `}
fun gl_TEXTURE22: Int `{ return GL_TEXTURE22; `}
fun gl_TEXTURE23: Int `{ return GL_TEXTURE23; `}
fun gl_TEXTURE24: Int `{ return GL_TEXTURE24; `}
fun gl_TEXTURE25: Int `{ return GL_TEXTURE25; `}
fun gl_TEXTURE26: Int `{ return GL_TEXTURE26; `}
fun gl_TEXTURE27: Int `{ return GL_TEXTURE27; `}
fun gl_TEXTURE28: Int `{ return GL_TEXTURE28; `}
fun gl_TEXTURE29: Int `{ return GL_TEXTURE29; `}
fun gl_TEXTURE30: Int `{ return GL_TEXTURE30; `}
fun gl_TEXTURE31: Int `{ return GL_TEXTURE31; `}
fun gl_ACTIVE_TEXTURE: Int `{ return GL_ACTIVE_TEXTURE; `}
fun gl_REPEAT: Int `{ return GL_REPEAT; `}
fun gl_CLAMP_TO_EDGE: Int `{ return GL_CLAMP_TO_EDGE; `}
fun gl_MIRRORED_REPEAT: Int `{ return GL_MIRRORED_REPEAT; `}
fun gl_FLOAT_VEC2: Int `{ return GL_FLOAT_VEC2; `}
fun gl_FLOAT_VEC3: Int `{ return GL_FLOAT_VEC3; `}
fun gl_FLOAT_VEC4: Int `{ return GL_FLOAT_VEC4; `}
fun gl_INT_VEC2: Int `{ return GL_INT_VEC2; `}
fun gl_INT_VEC3: Int `{ return GL_INT_VEC3; `}
fun gl_INT_VEC4: Int `{ return GL_INT_VEC4; `}
fun gl_BOOL: Int `{ return GL_BOOL; `}
fun gl_BOOL_VEC2: Int `{ return GL_BOOL_VEC2; `}
fun gl_BOOL_VEC3: Int `{ return GL_BOOL_VEC3; `}
fun gl_BOOL_VEC4: Int `{ return GL_BOOL_VEC4; `}
fun gl_FLOAT_MAT2: Int `{ return GL_FLOAT_MAT2; `}
fun gl_FLOAT_MAT3: Int `{ return GL_FLOAT_MAT3; `}
fun gl_FLOAT_MAT4: Int `{ return GL_FLOAT_MAT4; `}
fun gl_SAMPLER_2D: Int `{ return GL_SAMPLER_2D; `}
fun gl_SAMPLER_CUBE: Int `{ return GL_SAMPLER_CUBE; `}
fun gl_VERTEX_ATTRIB_ARRAY_ENABLED: Int `{ return GL_VERTEX_ATTRIB_ARRAY_ENABLED; `}
fun gl_VERTEX_ATTRIB_ARRAY_SIZE: Int `{ return GL_VERTEX_ATTRIB_ARRAY_SIZE; `}
fun gl_VERTEX_ATTRIB_ARRAY_STRIDE: Int `{ return GL_VERTEX_ATTRIB_ARRAY_STRIDE; `}
fun gl_VERTEX_ATTRIB_ARRAY_TYPE: Int `{ return GL_VERTEX_ATTRIB_ARRAY_TYPE; `}
fun gl_VERTEX_ATTRIB_ARRAY_NORMALIZED: Int `{ return GL_VERTEX_ATTRIB_ARRAY_NORMALIZED; `}
fun gl_VERTEX_ATTRIB_ARRAY_POINTER: Int `{ return GL_VERTEX_ATTRIB_ARRAY_POINTER; `}
fun gl_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: Int `{ return GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING; `}
fun gl_IMPLEMENTATION_COLOR_READ_TYPE: Int `{ return GL_IMPLEMENTATION_COLOR_READ_TYPE; `}
fun gl_IMPLEMENTATION_COLOR_READ_FORMAT: Int `{ return GL_IMPLEMENTATION_COLOR_READ_FORMAT; `}
fun gl_COMPILE_STATUS: Int `{ return GL_COMPILE_STATUS; `}
fun gl_INFO_LOG_LENGTH: Int `{ return GL_INFO_LOG_LENGTH; `}
fun gl_SHADER_SOURCE_LENGTH: Int `{ return GL_SHADER_SOURCE_LENGTH; `}
fun gl_SHADER_COMPILER: Int `{ return GL_SHADER_COMPILER; `}
fun gl_SHADER_BINARY_FORMATS: Int `{ return GL_SHADER_BINARY_FORMATS; `}
fun gl_NUM_SHADER_BINARY_FORMATS: Int `{ return GL_NUM_SHADER_BINARY_FORMATS; `}
fun gl_LOW_FLOAT: Int `{ return GL_LOW_FLOAT; `}
fun gl_MEDIUM_FLOAT: Int `{ return GL_MEDIUM_FLOAT; `}
fun gl_HIGH_FLOAT: Int `{ return GL_HIGH_FLOAT; `}
fun gl_LOW_INT: Int `{ return GL_LOW_INT; `}
fun gl_MEDIUM_INT: Int `{ return GL_MEDIUM_INT; `}
fun gl_HIGH_INT: Int `{ return GL_HIGH_INT; `}
fun gl_FRAMEBUFFER: Int `{ return GL_FRAMEBUFFER; `}
fun gl_RENDERBUFFER: Int `{ return GL_RENDERBUFFER; `}
fun gl_RGBA4: Int `{ return GL_RGBA4; `}
fun gl_RGB5_A1: Int `{ return GL_RGB5_A1; `}
fun gl_RGB565: Int `{ return GL_RGB565; `}
fun gl_DEPTH_COMPONENT16: Int `{ return GL_DEPTH_COMPONENT16; `}
fun gl_STENCIL_INDEX8: Int `{ return GL_STENCIL_INDEX8; `}
fun gl_RENDERBUFFER_WIDTH: Int `{ return GL_RENDERBUFFER_WIDTH; `}
fun gl_RENDERBUFFER_HEIGHT: Int `{ return GL_RENDERBUFFER_HEIGHT; `}
fun gl_RENDERBUFFER_INTERNAL_FORMAT: Int `{ return GL_RENDERBUFFER_INTERNAL_FORMAT; `}
fun gl_RENDERBUFFER_RED_SIZE: Int `{ return GL_RENDERBUFFER_RED_SIZE; `}
fun gl_RENDERBUFFER_GREEN_SIZE: Int `{ return GL_RENDERBUFFER_GREEN_SIZE; `}
fun gl_RENDERBUFFER_BLUE_SIZE: Int `{ return GL_RENDERBUFFER_BLUE_SIZE; `}
fun gl_RENDERBUFFER_ALPHA_SIZE: Int `{ return GL_RENDERBUFFER_ALPHA_SIZE; `}
fun gl_RENDERBUFFER_DEPTH_SIZE: Int `{ return GL_RENDERBUFFER_DEPTH_SIZE; `}
fun gl_RENDERBUFFER_STENCIL_SIZE: Int `{ return GL_RENDERBUFFER_STENCIL_SIZE; `}
fun gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: Int `{ return GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE; `}
fun gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: Int `{ return GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME; `}
fun gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: Int `{ return GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL; `}
fun gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: Int `{ return GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE; `}
fun gl_COLOR_ATTACHMENT0: Int `{ return GL_COLOR_ATTACHMENT0; `}
fun gl_DEPTH_ATTACHMENT: Int `{ return GL_DEPTH_ATTACHMENT; `}
fun gl_STENCIL_ATTACHMENT: Int `{ return GL_STENCIL_ATTACHMENT; `}
fun gl_NONE: Int `{ return GL_NONE; `}
fun gl_FRAMEBUFFER_COMPLETE: Int `{ return GL_FRAMEBUFFER_COMPLETE; `}
fun gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: Int `{ return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT; `}
fun gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: Int `{ return GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT; `}
fun gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: Int `{ return GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS; `}
fun gl_FRAMEBUFFER_UNSUPPORTED: Int `{ return GL_FRAMEBUFFER_UNSUPPORTED; `}
fun gl_FRAMEBUFFER_BINDING: Int `{ return GL_FRAMEBUFFER_BINDING; `}
fun gl_RENDERBUFFER_BINDING: Int `{ return GL_RENDERBUFFER_BINDING; `}
fun gl_MAX_RENDERBUFFER_SIZE: Int `{ return GL_MAX_RENDERBUFFER_SIZE; `}
fun gl_INVALID_FRAMEBUFFER_OPERATION: Int `{ return GL_INVALID_FRAMEBUFFER_OPERATION; `}
fun glActiveTexture `{ glActiveTexture(GLenum texture); `}
fun glAttachShader `{ glAttachShader(GLuint program, GLuint shader); `}
fun glBindAttribLocation `{ glBindAttribLocation(GLuint program, GLuint index, const GLchar *name); `}
fun glBindBuffer `{ glBindBuffer(GLenum target, GLuint buffer); `}
fun glBindFramebuffer `{ glBindFramebuffer(GLenum target, GLuint framebuffer); `}
fun glBindRenderbuffer `{ glBindRenderbuffer(GLenum target, GLuint renderbuffer); `}
fun glBindTexture `{ glBindTexture(GLenum target, GLuint texture); `}
fun glBlendColor `{ glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); `}
fun glBlendEquation `{ glBlendEquation(GLenum mode); `}
fun glBlendEquationSeparate `{ glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha); `}
fun glBlendFunc `{ glBlendFunc(GLenum sfactor, GLenum dfactor); `}
fun glBlendFuncSeparate `{ glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); `}
fun glBufferData `{ glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage); `}
fun glBufferSubData `{ glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); `}
fun glCheckFramebufferStatus: Int `{ return glCheckFramebufferStatus(GLenum target); `}
fun glClear `{ glClear(GLbitfield mask); `}
fun glClearColor `{ glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); `}
fun glClearDepthf `{ glClearDepthf(GLfloat d); `}
fun glClearStencil `{ glClearStencil(GLint s); `}
fun glColorMask `{ glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); `}
fun glCompileShader `{ glCompileShader(GLuint shader); `}
fun glCompressedTexImage2D `{ glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); `}
fun glCompressedTexSubImage2D `{ glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); `}
fun glCopyTexImage2D `{ glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); `}
fun glCopyTexSubImage2D `{ glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); `}
fun glCreateProgram: Int `{ return glCreateProgram(void); `}
fun glCreateShader: Int `{ return glCreateShader(GLenum type); `}
fun glCullFace `{ glCullFace(GLenum mode); `}
fun glDeleteBuffers `{ glDeleteBuffers(GLsizei n, const GLuint *buffers); `}
fun glDeleteFramebuffers `{ glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers); `}
fun glDeleteProgram `{ glDeleteProgram(GLuint program); `}
fun glDeleteRenderbuffers `{ glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers); `}
fun glDeleteShader `{ glDeleteShader(GLuint shader); `}
fun glDeleteTextures `{ glDeleteTextures(GLsizei n, const GLuint *textures); `}
fun glDepthFunc `{ glDepthFunc(GLenum func); `}
fun glDepthMask `{ glDepthMask(GLboolean flag); `}
fun glDepthRangef `{ glDepthRangef(GLfloat n, GLfloat f); `}
fun glDetachShader `{ glDetachShader(GLuint program, GLuint shader); `}
fun glDisable `{ glDisable(GLenum cap); `}
fun glDisableVertexAttribArray `{ glDisableVertexAttribArray(GLuint index); `}
fun glDrawArrays `{ glDrawArrays(GLenum mode, GLint first, GLsizei count); `}
fun glDrawElements `{ glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices); `}
fun glEnable `{ glEnable(GLenum cap); `}
fun glEnableVertexAttribArray `{ glEnableVertexAttribArray(GLuint index); `}
fun glFinish `{ glFinish(void); `}
fun glFlush `{ glFlush(void); `}
fun glFramebufferRenderbuffer `{ glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); `}
fun glFramebufferTexture2D `{ glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); `}
fun glFrontFace `{ glFrontFace(GLenum mode); `}
fun glGenBuffers `{ glGenBuffers(GLsizei n, GLuint *buffers); `}
fun glGenerateMipmap `{ glGenerateMipmap(GLenum target); `}
fun glGenFramebuffers `{ glGenFramebuffers(GLsizei n, GLuint *framebuffers); `}
fun glGenRenderbuffers `{ glGenRenderbuffers(GLsizei n, GLuint *renderbuffers); `}
fun glGenTextures `{ glGenTextures(GLsizei n, GLuint *textures); `}
fun glGetActiveAttrib `{ glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); `}
fun glGetActiveUniform `{ glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); `}
fun glGetAttachedShaders `{ glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); `}
fun glGetAttribLocation: Int `{ return glGetAttribLocation(GLuint program, const GLchar *name); `}
fun glGetBooleanv `{ glGetBooleanv(GLenum pname, GLboolean *data); `}
fun glGetBufferParameteriv `{ glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params); `}
fun glGetError: Int `{ return glGetError(void); `}
fun glGetFloatv `{ glGetFloatv(GLenum pname, GLfloat *data); `}
fun glGetFramebufferAttachmentParameteriv `{ glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params); `}
fun glGetIntegerv `{ glGetIntegerv(GLenum pname, GLint *data); `}
fun glGetProgramiv `{ glGetProgramiv(GLuint program, GLenum pname, GLint *params); `}
fun glGetProgramInfoLog `{ glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); `}
fun glGetRenderbufferParameteriv `{ glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params); `}
fun glGetShaderiv `{ glGetShaderiv(GLuint shader, GLenum pname, GLint *params); `}
fun glGetShaderInfoLog `{ glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); `}
fun glGetShaderPrecisionFormat `{ glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision); `}
fun glGetShaderSource `{ glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); `}
fun glGetTexParameterfv `{ glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params); `}
fun glGetTexParameteriv `{ glGetTexParameteriv(GLenum target, GLenum pname, GLint *params); `}
fun glGetUniformfv `{ glGetUniformfv(GLuint program, GLint location, GLfloat *params); `}
fun glGetUniformiv `{ glGetUniformiv(GLuint program, GLint location, GLint *params); `}
fun glGetUniformLocation: Int `{ return glGetUniformLocation(GLuint program, const GLchar *name); `}
fun glGetVertexAttribfv `{ glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params); `}
fun glGetVertexAttribiv `{ glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params); `}
fun glGetVertexAttribPointerv `{ glGetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer); `}
fun glHint `{ glHint(GLenum target, GLenum mode); `}
fun glIsBuffer: Int `{ return glIsBuffer(GLuint buffer); `}
fun glIsEnabled: Int `{ return glIsEnabled(GLenum cap); `}
fun glIsFramebuffer: Int `{ return glIsFramebuffer(GLuint framebuffer); `}
fun glIsProgram: Int `{ return glIsProgram(GLuint program); `}
fun glIsRenderbuffer: Int `{ return glIsRenderbuffer(GLuint renderbuffer); `}
fun glIsShader: Int `{ return glIsShader(GLuint shader); `}
fun glIsTexture: Int `{ return glIsTexture(GLuint texture); `}
fun glLineWidth `{ glLineWidth(GLfloat width); `}
fun glLinkProgram `{ glLinkProgram(GLuint program); `}
fun glPixelStorei `{ glPixelStorei(GLenum pname, GLint param); `}
fun glPolygonOffset `{ glPolygonOffset(GLfloat factor, GLfloat units); `}
fun glReadPixels `{ glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); `}
fun glReleaseShaderCompiler `{ glReleaseShaderCompiler(void); `}
fun glRenderbufferStorage `{ glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); `}
fun glSampleCoverage `{ glSampleCoverage(GLfloat value, GLboolean invert); `}
fun glScissor `{ glScissor(GLint x, GLint y, GLsizei width, GLsizei height); `}
fun glShaderBinary `{ glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length); `}
fun glShaderSource `{ glShaderSource(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); `}
fun glStencilFunc `{ glStencilFunc(GLenum func, GLint ref, GLuint mask); `}
fun glStencilFuncSeparate `{ glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask); `}
fun glStencilMask `{ glStencilMask(GLuint mask); `}
fun glStencilMaskSeparate `{ glStencilMaskSeparate(GLenum face, GLuint mask); `}
fun glStencilOp `{ glStencilOp(GLenum fail, GLenum zfail, GLenum zpass); `}
fun glStencilOpSeparate `{ glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); `}
fun glTexImage2D `{ glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); `}
fun glTexParameterf `{ glTexParameterf(GLenum target, GLenum pname, GLfloat param); `}
fun glTexParameterfv `{ glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params); `}
fun glTexParameteri `{ glTexParameteri(GLenum target, GLenum pname, GLint param); `}
fun glTexParameteriv `{ glTexParameteriv(GLenum target, GLenum pname, const GLint *params); `}
fun glTexSubImage2D `{ glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); `}
fun glUniform1f `{ glUniform1f(GLint location, GLfloat v0); `}
fun glUniform1fv `{ glUniform1fv(GLint location, GLsizei count, const GLfloat *value); `}
fun glUniform1i `{ glUniform1i(GLint location, GLint v0); `}
fun glUniform1iv `{ glUniform1iv(GLint location, GLsizei count, const GLint *value); `}
fun glUniform2f `{ glUniform2f(GLint location, GLfloat v0, GLfloat v1); `}
fun glUniform2fv `{ glUniform2fv(GLint location, GLsizei count, const GLfloat *value); `}
fun glUniform2i `{ glUniform2i(GLint location, GLint v0, GLint v1); `}
fun glUniform2iv `{ glUniform2iv(GLint location, GLsizei count, const GLint *value); `}
fun glUniform3f `{ glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); `}
fun glUniform3fv `{ glUniform3fv(GLint location, GLsizei count, const GLfloat *value); `}
fun glUniform3i `{ glUniform3i(GLint location, GLint v0, GLint v1, GLint v2); `}
fun glUniform3iv `{ glUniform3iv(GLint location, GLsizei count, const GLint *value); `}
fun glUniform4f `{ glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); `}
fun glUniform4fv `{ glUniform4fv(GLint location, GLsizei count, const GLfloat *value); `}
fun glUniform4i `{ glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); `}
fun glUniform4iv `{ glUniform4iv(GLint location, GLsizei count, const GLint *value); `}
fun glUniformMatrix2fv `{ glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); `}
fun glUniformMatrix3fv `{ glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); `}
fun glUniformMatrix4fv `{ glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); `}
fun glUseProgram `{ glUseProgram(GLuint program); `}
fun glValidateProgram `{ glValidateProgram(GLuint program); `}
fun glVertexAttrib1f `{ glVertexAttrib1f(GLuint index, GLfloat x); `}
fun glVertexAttrib1fv `{ glVertexAttrib1fv(GLuint index, const GLfloat *v); `}
fun glVertexAttrib2f `{ glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y); `}
fun glVertexAttrib2fv `{ glVertexAttrib2fv(GLuint index, const GLfloat *v); `}
fun glVertexAttrib3f `{ glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z); `}
fun glVertexAttrib3fv `{ glVertexAttrib3fv(GLuint index, const GLfloat *v); `}
fun glVertexAttrib4f `{ glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); `}
fun glVertexAttrib4fv `{ glVertexAttrib4fv(GLuint index, const GLfloat *v); `}
fun glVertexAttribPointer `{ glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); `}
fun glViewport `{ glViewport(GLint x, GLint y, GLsizei width, GLsizei height); `}
lib/glesv2/glesv2_stub.nit:1,1--443,81