/* dstep /path/to/ndk-r9d/platforms/android-9/arch-x86/usr/include/GLES/gl.h -o gl.d*/

module GLES.gl;

import core.stdc.config;

version (Android):
extern (C):
@system:
nothrow:
@nogc:

alias void GLvoid;
alias char GLchar;
alias uint GLenum;
alias ubyte GLboolean;
alias uint GLbitfield;
alias byte GLbyte;
alias short GLshort;
alias int GLint;
alias int GLsizei;
alias ubyte GLubyte;
alias ushort GLushort;
alias uint GLuint;
alias float GLfloat;
alias float GLclampf;
alias int GLfixed;
alias int GLclampx;
alias c_long GLintptr;
alias c_long GLsizeiptr;

enum GL_VERSION_ES_CM_1_0          = 1;
enum GL_VERSION_ES_CL_1_0          = 1;
enum GL_VERSION_ES_CM_1_1          = 1;
enum GL_VERSION_ES_CL_1_1          = 1;
enum GL_DEPTH_BUFFER_BIT               = 0x00000100;
enum GL_STENCIL_BUFFER_BIT             = 0x00000400;
enum GL_COLOR_BUFFER_BIT               = 0x00004000;
enum GL_FALSE                          = 0;
enum GL_TRUE                           = 1;
enum GL_POINTS                         = 0x0000;
enum GL_LINES                          = 0x0001;
enum GL_LINE_LOOP                      = 0x0002;
enum GL_LINE_STRIP                     = 0x0003;
enum GL_TRIANGLES                      = 0x0004;
enum GL_TRIANGLE_STRIP                 = 0x0005;
enum GL_TRIANGLE_FAN                   = 0x0006;
enum GL_NEVER                          = 0x0200;
enum GL_LESS                           = 0x0201;
enum GL_EQUAL                          = 0x0202;
enum GL_LEQUAL                         = 0x0203;
enum GL_GREATER                        = 0x0204;
enum GL_NOTEQUAL                       = 0x0205;
enum GL_GEQUAL                         = 0x0206;
enum GL_ALWAYS                         = 0x0207;
enum GL_ZERO                           = 0;
enum GL_ONE                            = 1;
enum GL_SRC_COLOR                      = 0x0300;
enum GL_ONE_MINUS_SRC_COLOR            = 0x0301;
enum GL_SRC_ALPHA                      = 0x0302;
enum GL_ONE_MINUS_SRC_ALPHA            = 0x0303;
enum GL_DST_ALPHA                      = 0x0304;
enum GL_ONE_MINUS_DST_ALPHA            = 0x0305;
enum GL_DST_COLOR                      = 0x0306;
enum GL_ONE_MINUS_DST_COLOR            = 0x0307;
enum GL_SRC_ALPHA_SATURATE             = 0x0308;
enum GL_CLIP_PLANE0                    = 0x3000;
enum GL_CLIP_PLANE1                    = 0x3001;
enum GL_CLIP_PLANE2                    = 0x3002;
enum GL_CLIP_PLANE3                    = 0x3003;
enum GL_CLIP_PLANE4                    = 0x3004;
enum GL_CLIP_PLANE5                    = 0x3005;
enum GL_FRONT                          = 0x0404;
enum GL_BACK                           = 0x0405;
enum GL_FRONT_AND_BACK                 = 0x0408;
enum GL_FOG                            = 0x0B60;
enum GL_LIGHTING                       = 0x0B50;
enum GL_TEXTURE_2D                     = 0x0DE1;
enum GL_CULL_FACE                      = 0x0B44;
enum GL_ALPHA_TEST                     = 0x0BC0;
enum GL_BLEND                          = 0x0BE2;
enum GL_COLOR_LOGIC_OP                 = 0x0BF2;
enum GL_DITHER                         = 0x0BD0;
enum GL_STENCIL_TEST                   = 0x0B90;
enum GL_DEPTH_TEST                     = 0x0B71;
enum GL_POINT_SMOOTH                   = 0x0B10;
enum GL_LINE_SMOOTH                    = 0x0B20;
enum GL_COLOR_MATERIAL                 = 0x0B57;
enum GL_NORMALIZE                      = 0x0BA1;
enum GL_RESCALE_NORMAL                 = 0x803A;
enum GL_VERTEX_ARRAY                   = 0x8074;
enum GL_NORMAL_ARRAY                   = 0x8075;
enum GL_COLOR_ARRAY                    = 0x8076;
enum GL_TEXTURE_COORD_ARRAY            = 0x8078;
enum GL_MULTISAMPLE                    = 0x809D;
enum GL_SAMPLE_ALPHA_TO_COVERAGE       = 0x809E;
enum GL_SAMPLE_ALPHA_TO_ONE            = 0x809F;
enum GL_SAMPLE_COVERAGE                = 0x80A0;
enum GL_NO_ERROR                       = 0;
enum GL_INVALID_ENUM                   = 0x0500;
enum GL_INVALID_VALUE                  = 0x0501;
enum GL_INVALID_OPERATION              = 0x0502;
enum GL_STACK_OVERFLOW                 = 0x0503;
enum GL_STACK_UNDERFLOW                = 0x0504;
enum GL_OUT_OF_MEMORY                  = 0x0505;
enum GL_EXP                            = 0x0800;
enum GL_EXP2                           = 0x0801;
enum GL_FOG_DENSITY                    = 0x0B62;
enum GL_FOG_START                      = 0x0B63;
enum GL_FOG_END                        = 0x0B64;
enum GL_FOG_MODE                       = 0x0B65;
enum GL_FOG_COLOR                      = 0x0B66;
enum GL_CW                             = 0x0900;
enum GL_CCW                            = 0x0901;
enum GL_CURRENT_COLOR                  = 0x0B00;
enum GL_CURRENT_NORMAL                 = 0x0B02;
enum GL_CURRENT_TEXTURE_COORDS         = 0x0B03;
enum GL_POINT_SIZE                     = 0x0B11;
enum GL_POINT_SIZE_MIN                 = 0x8126;
enum GL_POINT_SIZE_MAX                 = 0x8127;
enum GL_POINT_FADE_THRESHOLD_SIZE      = 0x8128;
enum GL_POINT_DISTANCE_ATTENUATION     = 0x8129;
enum GL_SMOOTH_POINT_SIZE_RANGE        = 0x0B12;
enum GL_LINE_WIDTH                     = 0x0B21;
enum GL_SMOOTH_LINE_WIDTH_RANGE        = 0x0B22;
enum GL_ALIASED_POINT_SIZE_RANGE       = 0x846D;
enum GL_ALIASED_LINE_WIDTH_RANGE       = 0x846E;
enum GL_CULL_FACE_MODE                 = 0x0B45;
enum GL_FRONT_FACE                     = 0x0B46;
enum GL_SHADE_MODEL                    = 0x0B54;
enum GL_DEPTH_RANGE                    = 0x0B70;
enum GL_DEPTH_WRITEMASK                = 0x0B72;
enum GL_DEPTH_CLEAR_VALUE              = 0x0B73;
enum GL_DEPTH_FUNC                     = 0x0B74;
enum GL_STENCIL_CLEAR_VALUE            = 0x0B91;
enum GL_STENCIL_FUNC                   = 0x0B92;
enum GL_STENCIL_VALUE_MASK             = 0x0B93;
enum GL_STENCIL_FAIL                   = 0x0B94;
enum GL_STENCIL_PASS_DEPTH_FAIL        = 0x0B95;
enum GL_STENCIL_PASS_DEPTH_PASS        = 0x0B96;
enum GL_STENCIL_REF                    = 0x0B97;
enum GL_STENCIL_WRITEMASK              = 0x0B98;
enum GL_MATRIX_MODE                    = 0x0BA0;
enum GL_VIEWPORT                       = 0x0BA2;
enum GL_MODELVIEW_STACK_DEPTH          = 0x0BA3;
enum GL_PROJECTION_STACK_DEPTH         = 0x0BA4;
enum GL_TEXTURE_STACK_DEPTH            = 0x0BA5;
enum GL_MODELVIEW_MATRIX               = 0x0BA6;
enum GL_PROJECTION_MATRIX              = 0x0BA7;
enum GL_TEXTURE_MATRIX                 = 0x0BA8;
enum GL_ALPHA_TEST_FUNC                = 0x0BC1;
enum GL_ALPHA_TEST_REF                 = 0x0BC2;
enum GL_BLEND_DST                      = 0x0BE0;
enum GL_BLEND_SRC                      = 0x0BE1;
enum GL_LOGIC_OP_MODE                  = 0x0BF0;
enum GL_SCISSOR_BOX                    = 0x0C10;
enum GL_SCISSOR_TEST                   = 0x0C11;
enum GL_COLOR_CLEAR_VALUE              = 0x0C22;
enum GL_COLOR_WRITEMASK                = 0x0C23;
enum GL_UNPACK_ALIGNMENT               = 0x0CF5;
enum GL_PACK_ALIGNMENT                 = 0x0D05;
enum GL_MAX_LIGHTS                     = 0x0D31;
enum GL_MAX_CLIP_PLANES                = 0x0D32;
enum GL_MAX_TEXTURE_SIZE               = 0x0D33;
enum GL_MAX_MODELVIEW_STACK_DEPTH      = 0x0D36;
enum GL_MAX_PROJECTION_STACK_DEPTH     = 0x0D38;
enum GL_MAX_TEXTURE_STACK_DEPTH        = 0x0D39;
enum GL_MAX_VIEWPORT_DIMS              = 0x0D3A;
enum GL_MAX_TEXTURE_UNITS              = 0x84E2;
enum GL_SUBPIXEL_BITS                  = 0x0D50;
enum GL_RED_BITS                       = 0x0D52;
enum GL_GREEN_BITS                     = 0x0D53;
enum GL_BLUE_BITS                      = 0x0D54;
enum GL_ALPHA_BITS                     = 0x0D55;
enum GL_DEPTH_BITS                     = 0x0D56;
enum GL_STENCIL_BITS                   = 0x0D57;
enum GL_POLYGON_OFFSET_UNITS           = 0x2A00;
enum GL_POLYGON_OFFSET_FILL            = 0x8037;
enum GL_POLYGON_OFFSET_FACTOR          = 0x8038;
enum GL_TEXTURE_BINDING_2D             = 0x8069;
enum GL_VERTEX_ARRAY_SIZE              = 0x807A;
enum GL_VERTEX_ARRAY_TYPE              = 0x807B;
enum GL_VERTEX_ARRAY_STRIDE            = 0x807C;
enum GL_NORMAL_ARRAY_TYPE              = 0x807E;
enum GL_NORMAL_ARRAY_STRIDE            = 0x807F;
enum GL_COLOR_ARRAY_SIZE               = 0x8081;
enum GL_COLOR_ARRAY_TYPE               = 0x8082;
enum GL_COLOR_ARRAY_STRIDE             = 0x8083;
enum GL_TEXTURE_COORD_ARRAY_SIZE       = 0x8088;
enum GL_TEXTURE_COORD_ARRAY_TYPE       = 0x8089;
enum GL_TEXTURE_COORD_ARRAY_STRIDE     = 0x808A;
enum GL_VERTEX_ARRAY_POINTER           = 0x808E;
enum GL_NORMAL_ARRAY_POINTER           = 0x808F;
enum GL_COLOR_ARRAY_POINTER            = 0x8090;
enum GL_TEXTURE_COORD_ARRAY_POINTER    = 0x8092;
enum GL_SAMPLE_BUFFERS                 = 0x80A8;
enum GL_SAMPLES                        = 0x80A9;
enum GL_SAMPLE_COVERAGE_VALUE          = 0x80AA;
enum GL_SAMPLE_COVERAGE_INVERT         = 0x80AB;
enum GL_NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2;
enum GL_COMPRESSED_TEXTURE_FORMATS     = 0x86A3;
enum GL_DONT_CARE                      = 0x1100;
enum GL_FASTEST                        = 0x1101;
enum GL_NICEST                         = 0x1102;
enum GL_PERSPECTIVE_CORRECTION_HINT    = 0x0C50;
enum GL_POINT_SMOOTH_HINT              = 0x0C51;
enum GL_LINE_SMOOTH_HINT               = 0x0C52;
enum GL_FOG_HINT                       = 0x0C54;
enum GL_GENERATE_MIPMAP_HINT           = 0x8192;
enum GL_LIGHT_MODEL_AMBIENT            = 0x0B53;
enum GL_LIGHT_MODEL_TWO_SIDE           = 0x0B52;
enum GL_AMBIENT                        = 0x1200;
enum GL_DIFFUSE                        = 0x1201;
enum GL_SPECULAR                       = 0x1202;
enum GL_POSITION                       = 0x1203;
enum GL_SPOT_DIRECTION                 = 0x1204;
enum GL_SPOT_EXPONENT                  = 0x1205;
enum GL_SPOT_CUTOFF                    = 0x1206;
enum GL_CONSTANT_ATTENUATION           = 0x1207;
enum GL_LINEAR_ATTENUATION             = 0x1208;
enum GL_QUADRATIC_ATTENUATION          = 0x1209;
enum GL_BYTE                           = 0x1400;
enum GL_UNSIGNED_BYTE                  = 0x1401;
enum GL_SHORT                          = 0x1402;
enum GL_UNSIGNED_SHORT                 = 0x1403;
enum GL_FLOAT                          = 0x1406;
enum GL_FIXED                          = 0x140C;
enum GL_CLEAR                          = 0x1500;
enum GL_AND                            = 0x1501;
enum GL_AND_REVERSE                    = 0x1502;
enum GL_COPY                           = 0x1503;
enum GL_AND_INVERTED                   = 0x1504;
enum GL_NOOP                           = 0x1505;
enum GL_XOR                            = 0x1506;
enum GL_OR                             = 0x1507;
enum GL_NOR                            = 0x1508;
enum GL_EQUIV                          = 0x1509;
enum GL_INVERT                         = 0x150A;
enum GL_OR_REVERSE                     = 0x150B;
enum GL_COPY_INVERTED                  = 0x150C;
enum GL_OR_INVERTED                    = 0x150D;
enum GL_NAND                           = 0x150E;
enum GL_SET                            = 0x150F;
enum GL_EMISSION                       = 0x1600;
enum GL_SHININESS                      = 0x1601;
enum GL_AMBIENT_AND_DIFFUSE            = 0x1602;
enum GL_MODELVIEW                      = 0x1700;
enum GL_PROJECTION                     = 0x1701;
enum GL_TEXTURE                        = 0x1702;
enum GL_ALPHA                          = 0x1906;
enum GL_RGB                            = 0x1907;
enum GL_RGBA                           = 0x1908;
enum GL_LUMINANCE                      = 0x1909;
enum GL_LUMINANCE_ALPHA                = 0x190A;
enum GL_UNSIGNED_SHORT_4_4_4_4         = 0x8033;
enum GL_UNSIGNED_SHORT_5_5_5_1         = 0x8034;
enum GL_UNSIGNED_SHORT_5_6_5           = 0x8363;
enum GL_FLAT                           = 0x1D00;
enum GL_SMOOTH                         = 0x1D01;
enum GL_KEEP                           = 0x1E00;
enum GL_REPLACE                        = 0x1E01;
enum GL_INCR                           = 0x1E02;
enum GL_DECR                           = 0x1E03;
enum GL_VENDOR                         = 0x1F00;
enum GL_RENDERER                       = 0x1F01;
enum GL_VERSION                        = 0x1F02;
enum GL_EXTENSIONS                     = 0x1F03;
enum GL_MODULATE                       = 0x2100;
enum GL_DECAL                          = 0x2101;
enum GL_ADD                            = 0x0104;
enum GL_TEXTURE_ENV_MODE               = 0x2200;
enum GL_TEXTURE_ENV_COLOR              = 0x2201;
enum GL_TEXTURE_ENV                    = 0x2300;
enum GL_NEAREST                        = 0x2600;
enum GL_LINEAR                         = 0x2601;
enum GL_NEAREST_MIPMAP_NEAREST         = 0x2700;
enum GL_LINEAR_MIPMAP_NEAREST          = 0x2701;
enum GL_NEAREST_MIPMAP_LINEAR          = 0x2702;
enum GL_LINEAR_MIPMAP_LINEAR           = 0x2703;
enum GL_TEXTURE_MAG_FILTER             = 0x2800;
enum GL_TEXTURE_MIN_FILTER             = 0x2801;
enum GL_TEXTURE_WRAP_S                 = 0x2802;
enum GL_TEXTURE_WRAP_T                 = 0x2803;
enum GL_GENERATE_MIPMAP                = 0x8191;
enum GL_TEXTURE0                       = 0x84C0;
enum GL_TEXTURE1                       = 0x84C1;
enum GL_TEXTURE2                       = 0x84C2;
enum GL_TEXTURE3                       = 0x84C3;
enum GL_TEXTURE4                       = 0x84C4;
enum GL_TEXTURE5                       = 0x84C5;
enum GL_TEXTURE6                       = 0x84C6;
enum GL_TEXTURE7                       = 0x84C7;
enum GL_TEXTURE8                       = 0x84C8;
enum GL_TEXTURE9                       = 0x84C9;
enum GL_TEXTURE10                      = 0x84CA;
enum GL_TEXTURE11                      = 0x84CB;
enum GL_TEXTURE12                      = 0x84CC;
enum GL_TEXTURE13                      = 0x84CD;
enum GL_TEXTURE14                      = 0x84CE;
enum GL_TEXTURE15                      = 0x84CF;
enum GL_TEXTURE16                      = 0x84D0;
enum GL_TEXTURE17                      = 0x84D1;
enum GL_TEXTURE18                      = 0x84D2;
enum GL_TEXTURE19                      = 0x84D3;
enum GL_TEXTURE20                      = 0x84D4;
enum GL_TEXTURE21                      = 0x84D5;
enum GL_TEXTURE22                      = 0x84D6;
enum GL_TEXTURE23                      = 0x84D7;
enum GL_TEXTURE24                      = 0x84D8;
enum GL_TEXTURE25                      = 0x84D9;
enum GL_TEXTURE26                      = 0x84DA;
enum GL_TEXTURE27                      = 0x84DB;
enum GL_TEXTURE28                      = 0x84DC;
enum GL_TEXTURE29                      = 0x84DD;
enum GL_TEXTURE30                      = 0x84DE;
enum GL_TEXTURE31                      = 0x84DF;
enum GL_ACTIVE_TEXTURE                 = 0x84E0;
enum GL_CLIENT_ACTIVE_TEXTURE          = 0x84E1;
enum GL_REPEAT                         = 0x2901;
enum GL_CLAMP_TO_EDGE                  = 0x812F;
enum GL_LIGHT0                         = 0x4000;
enum GL_LIGHT1                         = 0x4001;
enum GL_LIGHT2                         = 0x4002;
enum GL_LIGHT3                         = 0x4003;
enum GL_LIGHT4                         = 0x4004;
enum GL_LIGHT5                         = 0x4005;
enum GL_LIGHT6                         = 0x4006;
enum GL_LIGHT7                         = 0x4007;
enum GL_ARRAY_BUFFER                   = 0x8892;
enum GL_ELEMENT_ARRAY_BUFFER           = 0x8893;
enum GL_ARRAY_BUFFER_BINDING               = 0x8894;
enum GL_ELEMENT_ARRAY_BUFFER_BINDING       = 0x8895;
enum GL_VERTEX_ARRAY_BUFFER_BINDING        = 0x8896;
enum GL_NORMAL_ARRAY_BUFFER_BINDING        = 0x8897;
enum GL_COLOR_ARRAY_BUFFER_BINDING         = 0x8898;
enum GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A;
enum GL_STATIC_DRAW                    = 0x88E4;
enum GL_DYNAMIC_DRAW                   = 0x88E8;
enum GL_BUFFER_SIZE                    = 0x8764;
enum GL_BUFFER_USAGE                   = 0x8765;
enum GL_SUBTRACT                       = 0x84E7;
enum GL_COMBINE                        = 0x8570;
enum GL_COMBINE_RGB                    = 0x8571;
enum GL_COMBINE_ALPHA                  = 0x8572;
enum GL_RGB_SCALE                      = 0x8573;
enum GL_ADD_SIGNED                     = 0x8574;
enum GL_INTERPOLATE                    = 0x8575;
enum GL_CONSTANT                       = 0x8576;
enum GL_PRIMARY_COLOR                  = 0x8577;
enum GL_PREVIOUS                       = 0x8578;
enum GL_OPERAND0_RGB                   = 0x8590;
enum GL_OPERAND1_RGB                   = 0x8591;
enum GL_OPERAND2_RGB                   = 0x8592;
enum GL_OPERAND0_ALPHA                 = 0x8598;
enum GL_OPERAND1_ALPHA                 = 0x8599;
enum GL_OPERAND2_ALPHA                 = 0x859A;
enum GL_ALPHA_SCALE                    = 0x0D1C;
enum GL_SRC0_RGB                       = 0x8580;
enum GL_SRC1_RGB                       = 0x8581;
enum GL_SRC2_RGB                       = 0x8582;
enum GL_SRC0_ALPHA                     = 0x8588;
enum GL_SRC1_ALPHA                     = 0x8589;
enum GL_SRC2_ALPHA                     = 0x858A;
enum GL_DOT3_RGB                       = 0x86AE;
enum GL_DOT3_RGBA                      = 0x86AF;

void glAlphaFunc(GLenum func, GLclampf ref_);
void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
void glClearDepthf(GLclampf depth);
void glClipPlanef(GLenum plane, const(GLfloat)* equation);
void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
void glDepthRangef(GLclampf zNear, GLclampf zFar);
void glFogf(GLenum pname, GLfloat param);
void glFogfv(GLenum pname, const(GLfloat)* params);
void glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
void glGetClipPlanef(GLenum pname, GLfloat[4] eqn);
void glGetFloatv(GLenum pname, GLfloat* params);
void glGetLightfv(GLenum light, GLenum pname, GLfloat* params);
void glGetMaterialfv(GLenum face, GLenum pname, GLfloat* params);
void glGetTexEnvfv(GLenum env, GLenum pname, GLfloat* params);
void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params);
void glLightModelf(GLenum pname, GLfloat param);
void glLightModelfv(GLenum pname, const(GLfloat)* params);
void glLightf(GLenum light, GLenum pname, GLfloat param);
void glLightfv(GLenum light, GLenum pname, const(GLfloat)* params);
void glLineWidth(GLfloat width);
void glLoadMatrixf(const(GLfloat)* m);
void glMaterialf(GLenum face, GLenum pname, GLfloat param);
void glMaterialfv(GLenum face, GLenum pname, const(GLfloat)* params);
void glMultMatrixf(const(GLfloat)* m);
void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
void glPointParameterf(GLenum pname, GLfloat param);
void glPointParameterfv(GLenum pname, const(GLfloat)* params);
void glPointSize(GLfloat size);
void glPolygonOffset(GLfloat factor, GLfloat units);
void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
void glScalef(GLfloat x, GLfloat y, GLfloat z);
void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
void glTexEnvfv(GLenum target, GLenum pname, const(GLfloat)* params);
void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
void glTexParameterfv(GLenum target, GLenum pname, const(GLfloat)* params);
void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
void glActiveTexture(GLenum texture);
void glAlphaFuncx(GLenum func, GLclampx ref_);
void glBindBuffer(GLenum target, GLuint buffer);
void glBindTexture(GLenum target, GLuint texture);
void glBlendFunc(GLenum sfactor, GLenum dfactor);
void glBufferData(GLenum target, GLsizeiptr size, const(GLvoid)* data, GLenum usage);
void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const(GLvoid)* data);
void glClear(GLbitfield mask);
void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha);
void glClearDepthx(GLclampx depth);
void glClearStencil(GLint s);
void glClientActiveTexture(GLenum texture);
void glClipPlanex(GLenum plane, const(GLfixed)* equation);
void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
void glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
void glColorPointer(GLint size, GLenum type, GLsizei stride, const(GLvoid)* pointer);
void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const(GLvoid)* data);
void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const(GLvoid)* data);
void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
void glCullFace(GLenum mode);
void glDeleteBuffers(GLsizei n, const(GLuint)* buffers);
void glDeleteTextures(GLsizei n, const(GLuint)* textures);
void glDepthFunc(GLenum func);
void glDepthMask(GLboolean flag);
void glDepthRangex(GLclampx zNear, GLclampx zFar);
void glDisable(GLenum cap);
void glDisableClientState(GLenum array);
void glDrawArrays(GLenum mode, GLint first, GLsizei count);
void glDrawElements(GLenum mode, GLsizei count, GLenum type, const(GLvoid)* indices);
void glEnable(GLenum cap);
void glEnableClientState(GLenum array);
void glFinish();
void glFlush();
void glFogx(GLenum pname, GLfixed param);
void glFogxv(GLenum pname, const(GLfixed)* params);
void glFrontFace(GLenum mode);
void glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
void glGetBooleanv(GLenum pname, GLboolean* params);
void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params);
void glGetClipPlanex(GLenum pname, GLfixed[4] eqn);
void glGenBuffers(GLsizei n, GLuint* buffers);
void glGenTextures(GLsizei n, GLuint* textures);
GLenum glGetError();
void glGetFixedv(GLenum pname, GLfixed* params);
void glGetIntegerv(GLenum pname, GLint* params);
void glGetLightxv(GLenum light, GLenum pname, GLfixed* params);
void glGetMaterialxv(GLenum face, GLenum pname, GLfixed* params);
void glGetPointerv(GLenum pname, GLvoid** params);
const(GLubyte)* glGetString(GLenum name);
void glGetTexEnviv(GLenum env, GLenum pname, GLint* params);
void glGetTexEnvxv(GLenum env, GLenum pname, GLfixed* params);
void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params);
void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed* params);
void glHint(GLenum target, GLenum mode);
GLboolean glIsBuffer(GLuint buffer);
GLboolean glIsEnabled(GLenum cap);
GLboolean glIsTexture(GLuint texture);
void glLightModelx(GLenum pname, GLfixed param);
void glLightModelxv(GLenum pname, const(GLfixed)* params);
void glLightx(GLenum light, GLenum pname, GLfixed param);
void glLightxv(GLenum light, GLenum pname, const(GLfixed)* params);
void glLineWidthx(GLfixed width);
void glLoadIdentity();
void glLoadMatrixx(const(GLfixed)* m);
void glLogicOp(GLenum opcode);
void glMaterialx(GLenum face, GLenum pname, GLfixed param);
void glMaterialxv(GLenum face, GLenum pname, const(GLfixed)* params);
void glMatrixMode(GLenum mode);
void glMultMatrixx(const(GLfixed)* m);
void glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q);
void glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz);
void glNormalPointer(GLenum type, GLsizei stride, const(GLvoid)* pointer);
void glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
void glPixelStorei(GLenum pname, GLint param);
void glPointParameterx(GLenum pname, GLfixed param);
void glPointParameterxv(GLenum pname, const(GLfixed)* params);
void glPointSizex(GLfixed size);
void glPolygonOffsetx(GLfixed factor, GLfixed units);
void glPopMatrix();
void glPushMatrix();
void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels);
void glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
void glSampleCoverage(GLclampf value, GLboolean invert);
void glSampleCoveragex(GLclampx value, GLboolean invert);
void glScalex(GLfixed x, GLfixed y, GLfixed z);
void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
void glShadeModel(GLenum mode);
void glStencilFunc(GLenum func, GLint ref_, GLuint mask);
void glStencilMask(GLuint mask);
void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const(GLvoid)* pointer);
void glTexEnvi(GLenum target, GLenum pname, GLint param);
void glTexEnvx(GLenum target, GLenum pname, GLfixed param);
void glTexEnviv(GLenum target, GLenum pname, const(GLint)* params);
void glTexEnvxv(GLenum target, GLenum pname, const(GLfixed)* params);
void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const(GLvoid)* pixels);
void glTexParameteri(GLenum target, GLenum pname, GLint param);
void glTexParameterx(GLenum target, GLenum pname, GLfixed param);
void glTexParameteriv(GLenum target, GLenum pname, const(GLint)* params);
void glTexParameterxv(GLenum target, GLenum pname, const(GLfixed)* params);
void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const(GLvoid)* pixels);
void glTranslatex(GLfixed x, GLfixed y, GLfixed z);
void glVertexPointer(GLint size, GLenum type, GLsizei stride, const(GLvoid)* pointer);
void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);