/**
 * Copyright: Copyright (c) 2009 Jacob Carlborg.
 * Authors: Jacob Carlborg
 * Version: Initial created: Sep 24, 2009 
 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost Software License 1.0)
 */
module dstep.opengl.gl;

import dstep.opengl.glext;

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 double GLdouble;
alias double GLclampd;
alias void GLvoid;
alias int GLintptr;
alias int GLsizeiptr;
alias byte GLchar;

extern (C)
{
	void glAccum (uint op, float value);
	void glAlphaFunc (uint func, float ref_);
	ubyte glAreTexturesResident (int n, GLuint* textures, char* residences);
	void glArrayElement (int i);
	void glBegin (uint mode);
	void glBindTexture (uint target, uint texture);
	void glBitmap (int width, int height, float xorig, float yorig, float xmove, float ymove, char* bitmap);
	void glBlendColor (float red, float green, float blue, float alpha);
	void glBlendEquation (uint mode);
	void glBlendEquationSeparate (uint modeRGB, uint modeAlpha);
	void glBlendFunc (uint sfactor, uint dfactor);
	void glCallList (uint list);
	void glCallLists (int n, uint type, GLvoid* lists);
	void glClear (uint mask);
	void glClearAccum (float red, float green, float blue, float alpha);
	void glClearColor (float red, float green, float blue, float alpha);
	void glClearDepth (double depth);
	void glClearIndex (float c);
	void glClearStencil (int s);
	void glClipPlane (uint plane, GLdouble* equation);
	void glColor3b (byte red, byte green, byte blue);
	void glColor3bv (char* v);
	void glColor3d (double red, double green, double blue);
	void glColor3dv (GLdouble* v);
	void glColor3f (float red, float green, float blue);
	void glColor3fv (GLfloat* v);
	void glColor3i (int red, int green, int blue);
	void glColor3iv (GLint* v);
	void glColor3s (short red, short green, short blue);
	void glColor3sv (GLshort* v);
	void glColor3ub (ubyte red, ubyte green, ubyte blue);
	void glColor3ubv (char* v);
	void glColor3ui (uint red, uint green, uint blue);
	void glColor3uiv (GLuint* v);
	void glColor3us (ushort red, ushort green, ushort blue);
	void glColor3usv (GLushort* v);
	void glColor4b (byte red, byte green, byte blue, byte alpha);
	void glColor4bv (char* v);
	void glColor4d (double red, double green, double blue, double alpha);
	void glColor4dv (GLdouble* v);
	void glColor4f (float red, float green, float blue, float alpha);
	void glColor4fv (GLfloat* v);
	void glColor4i (int red, int green, int blue, int alpha);
	void glColor4iv (GLint* v);
	void glColor4s (short red, short green, short blue, short alpha);
	void glColor4sv (GLshort* v);
	void glColor4ub (ubyte red, ubyte green, ubyte blue, ubyte alpha);
	void glColor4ubv (char* v);
	void glColor4ui (uint red, uint green, uint blue, uint alpha);
	void glColor4uiv (GLuint* v);
	void glColor4us (ushort red, ushort green, ushort blue, ushort alpha);
	void glColor4usv (GLushort* v);
	void glColorMask (ubyte red, ubyte green, ubyte blue, ubyte alpha);
	void glColorMaterial (uint face, uint mode);
	void glColorPointer (int size, uint type, int stride, GLvoid* pointer);
	void glColorSubTable (uint target, int start, int count, uint format, uint type, GLvoid* data);
	void glColorTable (uint target, uint internalformat, int width, uint format, uint type, GLvoid* table);
	void glColorTableParameterfv (uint target, uint pname, GLfloat* params);
	void glColorTableParameteriv (uint target, uint pname, GLint* params);
	void glConvolutionFilter1D (uint target, uint internalformat, int width, uint format, uint type, GLvoid* image);
	void glConvolutionFilter2D (uint target, uint internalformat, int width, int height, uint format, uint type, GLvoid* image);
	void glConvolutionParameterf (uint target, uint pname, float params);
	void glConvolutionParameterfv (uint target, uint pname, GLfloat* params);
	void glConvolutionParameteri (uint target, uint pname, int params);
	void glConvolutionParameteriv (uint target, uint pname, GLint* params);
	void glCopyColorSubTable (uint target, int start, int x, int y, int width);
	void glCopyColorTable (uint target, uint internalformat, int x, int y, int width);
	void glCopyConvolutionFilter1D (uint target, uint internalformat, int x, int y, int width);
	void glCopyConvolutionFilter2D (uint target, uint internalformat, int x, int y, int width, int height);
	void glCopyPixels (int x, int y, int width, int height, uint type);
	void glCopyTexImage1D (uint target, int level, uint internalformat, int x, int y, int width, int border);
	void glCopyTexImage2D (uint target, int level, uint internalformat, int x, int y, int width, int height, int border);
	void glCopyTexSubImage1D (uint target, int level, int xoffset, int x, int y, int width);
	void glCopyTexSubImage2D (uint target, int level, int xoffset, int yoffset, int x, int y, int width, int height);
	void glCopyTexSubImage3D (uint target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height);
	void glCullFace (uint mode);
	void glDeleteLists (uint list, int range);
	void glDeleteTextures (int n, GLuint* textures);
	void glDepthFunc (uint func);
	void glDepthMask (ubyte flag);
	void glDepthRange (double zNear, double zFar);
	void glDisable (uint cap);
	void glDisableClientState (uint array);
	void glDrawArrays (uint mode, int first, int count);
	void glDrawBuffer (uint mode);
	void glDrawElements (uint mode, int count, uint type, GLvoid* indices);
	void glDrawPixels (int width, int height, uint format, uint type, GLvoid* pixels);
	void glDrawRangeElements (uint mode, uint start, uint end, int count, uint type, GLvoid* indices);
	void glEdgeFlag (ubyte flag);
	void glEdgeFlagPointer (int stride, GLvoid* pointer);
	void glEdgeFlagv (char* flag);
	void glEnable (uint cap);
	void glEnableClientState (uint array);
	void glEnd ();
	void glEndList ();
	void glEvalCoord1d (double u);
	void glEvalCoord1dv (GLdouble* u);
	void glEvalCoord1f (float u);
	void glEvalCoord1fv (GLfloat* u);
	void glEvalCoord2d (double u, double v);
	void glEvalCoord2dv (GLdouble* u);
	void glEvalCoord2f (float u, float v);
	void glEvalCoord2fv (GLfloat* u);
	void glEvalMesh1 (uint mode, int i1, int i2);
	void glEvalMesh2 (uint mode, int i1, int i2, int j1, int j2);
	void glEvalPoint1 (int i);
	void glEvalPoint2 (int i, int j);
	void glFeedbackBuffer (int size, uint type, GLfloat* buffer);
	void glFinish ();
	void glFlush ();
	void glFogf (uint pname, float param);
	void glFogfv (uint pname, GLfloat* params);
	void glFogi (uint pname, int param);
	void glFogiv (uint pname, GLint* params);
	void glFrontFace (uint mode);
	void glFrustum (double left, double right, double bottom, double top, double zNear, double zFar);
	uint glGenLists (int range);
	void glGenTextures (int n, GLuint* textures);
	void glGetBooleanv (uint pname, char* params);
	void glGetClipPlane (uint plane, GLdouble* equation);
	void glGetColorTable (uint target, uint format, uint type, GLvoid* table);
	void glGetColorTableParameterfv (uint target, uint pname, GLfloat* params);
	void glGetColorTableParameteriv (uint target, uint pname, GLint* params);
	void glGetConvolutionFilter (uint target, uint format, uint type, GLvoid* image);
	void glGetConvolutionParameterfv (uint target, uint pname, GLfloat* params);
	void glGetConvolutionParameteriv (uint target, uint pname, GLint* params);
	void glGetDoublev (uint pname, GLdouble* params);
	uint glGetError ();
	void glGetFloatv (uint pname, GLfloat* params);
	void glGetHistogram (uint target, ubyte reset, uint format, uint type, GLvoid* values);
	void glGetHistogramParameterfv (uint target, uint pname, GLfloat* params);
	void glGetHistogramParameteriv (uint target, uint pname, GLint* params);
	void glGetIntegerv (uint pname, GLint* params);
	void glGetLightfv (uint light, uint pname, GLfloat* params);
	void glGetLightiv (uint light, uint pname, GLint* params);
	void glGetMapdv (uint target, uint query, GLdouble* v);
	void glGetMapfv (uint target, uint query, GLfloat* v);
	void glGetMapiv (uint target, uint query, GLint* v);
	void glGetMaterialfv (uint face, uint pname, GLfloat* params);
	void glGetMaterialiv (uint face, uint pname, GLint* params);
	void glGetMinmax (uint target, ubyte reset, uint format, uint type, GLvoid* values);
	void glGetMinmaxParameterfv (uint target, uint pname, GLfloat* params);
	void glGetMinmaxParameteriv (uint target, uint pname, GLint* params);
	void glGetPixelMapfv (uint map, GLfloat* values);
	void glGetPixelMapuiv (uint map, GLuint* values);
	void glGetPixelMapusv (uint map, GLushort* values);
	void glGetPointerv (uint pname, GLvoid** params);
	void glGetPolygonStipple (char* mask);
	void glGetSeparableFilter (uint target, uint format, uint type, GLvoid* row, GLvoid* column, GLvoid* span);
	char* glGetString (uint name);
	void glGetTexEnvfv (uint target, uint pname, GLfloat* params);
	void glGetTexEnviv (uint target, uint pname, GLint* params);
	void glGetTexGendv (uint coord, uint pname, GLdouble* params);
	void glGetTexGenfv (uint coord, uint pname, GLfloat* params);
	void glGetTexGeniv (uint coord, uint pname, GLint* params);
	void glGetTexImage (uint target, int level, uint format, uint type, GLvoid* pixels);
	void glGetTexLevelParameterfv (uint target, int level, uint pname, GLfloat* params);
	void glGetTexLevelParameteriv (uint target, int level, uint pname, GLint* params);
	void glGetTexParameterfv (uint target, uint pname, GLfloat* params);
	void glGetTexParameteriv (uint target, uint pname, GLint* params);
	void glHint (uint target, uint mode);
	void glHistogram (uint target, int width, uint internalformat, ubyte sink);
	void glIndexMask (uint mask);
	void glIndexPointer (uint type, int stride, GLvoid* pointer);
	void glIndexd (double c);
	void glIndexdv (GLdouble* c);
	void glIndexf (float c);
	void glIndexfv (GLfloat* c);
	void glIndexi (int c);
	void glIndexiv (GLint* c);
	void glIndexs (short c);
	void glIndexsv (GLshort* c);
	void glIndexub (ubyte c);
	void glIndexubv (char* c);
	void glInitNames ();
	void glInterleavedArrays (uint format, int stride, GLvoid* pointer);
	ubyte glIsEnabled (uint cap);
	ubyte glIsList (uint list);
	ubyte glIsTexture (uint texture);
	void glLightModelf (uint pname, float param);
	void glLightModelfv (uint pname, GLfloat* params);
	void glLightModeli (uint pname, int param);
	void glLightModeliv (uint pname, GLint* params);
	void glLightf (uint light, uint pname, float param);
	void glLightfv (uint light, uint pname, GLfloat* params);
	void glLighti (uint light, uint pname, int param);
	void glLightiv (uint light, uint pname, GLint* params);
	void glLineStipple (int factor, ushort pattern);
	void glLineWidth (float width);
	void glListBase (uint base);
	void glLoadIdentity ();
	void glLoadMatrixd (GLdouble* m);
	void glLoadMatrixf (GLfloat* m);
	void glLoadName (uint name);
	void glLogicOp (uint opcode);
	void glMap1d (uint target, double u1, double u2, int stride, int order, GLdouble* points);
	void glMap1f (uint target, float u1, float u2, int stride, int order, GLfloat* points);
	void glMap2d (uint target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, GLdouble* points);
	void glMap2f (uint target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, GLfloat* points);
	void glMapGrid1d (int un, double u1, double u2);
	void glMapGrid1f (int un, float u1, float u2);
	void glMapGrid2d (int un, double u1, double u2, int vn, double v1, double v2);
	void glMapGrid2f (int un, float u1, float u2, int vn, float v1, float v2);
	void glMaterialf (uint face, uint pname, float param);
	void glMaterialfv (uint face, uint pname, GLfloat* params);
	void glMateriali (uint face, uint pname, int param);
	void glMaterialiv (uint face, uint pname, GLint* params);
	void glMatrixMode (uint mode);
	void glMinmax (uint target, uint internalformat, ubyte sink);
	void glMultMatrixd (GLdouble* m);
	void glMultMatrixf (GLfloat* m);
	void glNewList (uint list, uint mode);
	void glNormal3b (byte nx, byte ny, byte nz);
	void glNormal3bv (char* v);
	void glNormal3d (double nx, double ny, double nz);
	void glNormal3dv (GLdouble* v);
	void glNormal3f (float nx, float ny, float nz);
	void glNormal3fv (GLfloat* v);
	void glNormal3i (int nx, int ny, int nz);
	void glNormal3iv (GLint* v);
	void glNormal3s (short nx, short ny, short nz);
	void glNormal3sv (GLshort* v);
	void glNormalPointer (uint type, int stride, GLvoid* pointer);
	void glOrtho (double left, double right, double bottom, double top, double zNear, double zFar);
	void glPassThrough (float token);
	void glPixelMapfv (uint map, int mapsize, GLfloat* values);
	void glPixelMapuiv (uint map, int mapsize, GLuint* values);
	void glPixelMapusv (uint map, int mapsize, GLushort* values);
	void glPixelStoref (uint pname, float param);
	void glPixelStorei (uint pname, int param);
	void glPixelTransferf (uint pname, float param);
	void glPixelTransferi (uint pname, int param);
	void glPixelZoom (float xfactor, float yfactor);
	void glPointSize (float size);
	void glPolygonMode (uint face, uint mode);
	void glPolygonOffset (float factor, float units);
	void glPolygonStipple (char* mask);
	void glPopAttrib ();
	void glPopClientAttrib ();
	void glPopMatrix ();
	void glPopName ();
	void glPrioritizeTextures (int n, GLuint* textures, GLclampf* priorities);
	void glPushAttrib (uint mask);
	void glPushClientAttrib (uint mask);
	void glPushMatrix ();
	void glPushName (uint name);
	void glRasterPos2d (double x, double y);
	void glRasterPos2dv (GLdouble* v);
	void glRasterPos2f (float x, float y);
	void glRasterPos2fv (GLfloat* v);
	void glRasterPos2i (int x, int y);
	void glRasterPos2iv (GLint* v);
	void glRasterPos2s (short x, short y);
	void glRasterPos2sv (GLshort* v);
	void glRasterPos3d (double x, double y, double z);
	void glRasterPos3dv (GLdouble* v);
	void glRasterPos3f (float x, float y, float z);
	void glRasterPos3fv (GLfloat* v);
	void glRasterPos3i (int x, int y, int z);
	void glRasterPos3iv (GLint* v);
	void glRasterPos3s (short x, short y, short z);
	void glRasterPos3sv (GLshort* v);
	void glRasterPos4d (double x, double y, double z, double w);
	void glRasterPos4dv (GLdouble* v);
	void glRasterPos4f (float x, float y, float z, float w);
	void glRasterPos4fv (GLfloat* v);
	void glRasterPos4i (int x, int y, int z, int w);
	void glRasterPos4iv (GLint* v);
	void glRasterPos4s (short x, short y, short z, short w);
	void glRasterPos4sv (GLshort* v);
	void glReadBuffer (uint mode);
	void glReadPixels (int x, int y, int width, int height, uint format, uint type, GLvoid* pixels);
	void glRectd (double x1, double y1, double x2, double y2);
	void glRectdv (GLdouble* v1, GLdouble* v2);
	void glRectf (float x1, float y1, float x2, float y2);
	void glRectfv (GLfloat* v1, GLfloat* v2);
	void glRecti (int x1, int y1, int x2, int y2);
	void glRectiv (GLint* v1, GLint* v2);
	void glRects (short x1, short y1, short x2, short y2);
	void glRectsv (GLshort* v1, GLshort* v2);
	int glRenderMode (uint mode);
	void glResetHistogram (uint target);
	void glResetMinmax (uint target);
	void glRotated (double angle, double x, double y, double z);
	void glRotatef (float angle, float x, float y, float z);
	void glScaled (double x, double y, double z);
	void glScalef (float x, float y, float z);
	void glScissor (int x, int y, int width, int height);
	void glSelectBuffer (int size, GLuint* buffer);
	void glSeparableFilter2D (uint target, uint internalformat, int width, int height, uint format, uint type, GLvoid* row, GLvoid* column);
	void glShadeModel (uint mode);
	void glStencilFunc (uint func, int ref_, uint mask);
	void glStencilMask (uint mask);
	void glStencilOp (uint fail, uint zfail, uint zpass);
	void glTexCoord1d (double s);
	void glTexCoord1dv (GLdouble* v);
	void glTexCoord1f (float s);
	void glTexCoord1fv (GLfloat* v);
	void glTexCoord1i (int s);
	void glTexCoord1iv (GLint* v);
	void glTexCoord1s (short s);
	void glTexCoord1sv (GLshort* v);
	void glTexCoord2d (double s, double t);
	void glTexCoord2dv (GLdouble* v);
	void glTexCoord2f (float s, float t);
	void glTexCoord2fv (GLfloat* v);
	void glTexCoord2i (int s, int t);
	void glTexCoord2iv (GLint* v);
	void glTexCoord2s (short s, short t);
	void glTexCoord2sv (GLshort* v);
	void glTexCoord3d (double s, double t, double r);
	void glTexCoord3dv (GLdouble* v);
	void glTexCoord3f (float s, float t, float r);
	void glTexCoord3fv (GLfloat* v);
	void glTexCoord3i (int s, int t, int r);
	void glTexCoord3iv (GLint* v);
	void glTexCoord3s (short s, short t, short r);
	void glTexCoord3sv (GLshort* v);
	void glTexCoord4d (double s, double t, double r, double q);
	void glTexCoord4dv (GLdouble* v);
	void glTexCoord4f (float s, float t, float r, float q);
	void glTexCoord4fv (GLfloat* v);
	void glTexCoord4i (int s, int t, int r, int q);
	void glTexCoord4iv (GLint* v);
	void glTexCoord4s (short s, short t, short r, short q);
	void glTexCoord4sv (GLshort* v);
	void glTexCoordPointer (int size, uint type, int stride, GLvoid* pointer);
	void glTexEnvf (uint target, uint pname, float param);
	void glTexEnvfv (uint target, uint pname, GLfloat* params);
	void glTexEnvi (uint target, uint pname, int param);
	void glTexEnviv (uint target, uint pname, GLint* params);
	void glTexGend (uint coord, uint pname, double param);
	void glTexGendv (uint coord, uint pname, GLdouble* params);
	void glTexGenf (uint coord, uint pname, float param);
	void glTexGenfv (uint coord, uint pname, GLfloat* params);
	void glTexGeni (uint coord, uint pname, int param);
	void glTexGeniv (uint coord, uint pname, GLint* params);
	void glTexImage1D (uint target, int level, uint internalformat, int width, int border, uint format, uint type, GLvoid* pixels);
	void glTexImage2D (uint target, int level, uint internalformat, int width, int height, int border, uint format, uint type, GLvoid* pixels);
	void glTexImage3D (uint target, int level, uint internalformat, int width, int height, int depth, int border, uint format, uint type, GLvoid* pixels);
	void glTexParameterf (uint target, uint pname, float param);
	void glTexParameterfv (uint target, uint pname, GLfloat* params);
	void glTexParameteri (uint target, uint pname, int param);
	void glTexParameteriv (uint target, uint pname, GLint* params);
	void glTexSubImage1D (uint target, int level, int xoffset, int width, uint format, uint type, GLvoid* pixels);
	void glTexSubImage2D (uint target, int level, int xoffset, int yoffset, int width, int height, uint format, uint type, GLvoid* pixels);
	void glTexSubImage3D (uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, uint type, GLvoid* pixels);
	void glTranslated (double x, double y, double z);
	void glTranslatef (float x, float y, float z);
	void glVertex2d (double x, double y);
	void glVertex2dv (GLdouble* v);
	void glVertex2f (float x, float y);
	void glVertex2fv (GLfloat* v);
	void glVertex2i (int x, int y);
	void glVertex2iv (GLint* v);
	void glVertex2s (short x, short y);
	void glVertex2sv (GLshort* v);
	void glVertex3d (double x, double y, double z);
	void glVertex3dv (GLdouble* v);
	void glVertex3f (float x, float y, float z);
	void glVertex3fv (GLfloat* v);
	void glVertex3i (int x, int y, int z);
	void glVertex3iv (GLint* v);
	void glVertex3s (short x, short y, short z);
	void glVertex3sv (GLshort* v);
	void glVertex4d (double x, double y, double z, double w);
	void glVertex4dv (GLdouble* v);
	void glVertex4f (float x, float y, float z, float w);
	void glVertex4fv (GLfloat* v);
	void glVertex4i (int x, int y, int z, int w);
	void glVertex4iv (GLint* v);
	void glVertex4s (short x, short y, short z, short w);
	void glVertex4sv (GLshort* v);
	void glVertexPointer (int size, uint type, int stride, GLvoid* pointer);
	void glViewport (int x, int y, int width, int height);
	void glSampleCoverage (float value, ubyte invert);
	void glSamplePass (uint pass);
	void glLoadTransposeMatrixf (GLfloat* m);
	void glLoadTransposeMatrixd (GLdouble* m);
	void glMultTransposeMatrixf (GLfloat* m);
	void glMultTransposeMatrixd (GLdouble* m);
	void glCompressedTexImage3D (uint target, int level, uint internalformat, int width, int height, int depth, int border, int imageSize, GLvoid* data);
	void glCompressedTexImage2D (uint target, int level, uint internalformat, int width, int height, int border, int imageSize, GLvoid* data);
	void glCompressedTexImage1D (uint target, int level, uint internalformat, int width, int border, int imageSize, GLvoid* data);
	void glCompressedTexSubImage3D (uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, int imageSize, GLvoid* data);
	void glCompressedTexSubImage2D (uint target, int level, int xoffset, int yoffset, int width, int height, uint format, int imageSize, GLvoid* data);
	void glCompressedTexSubImage1D (uint target, int level, int xoffset, int width, uint format, int imageSize, GLvoid* data);
	void glGetCompressedTexImage (uint target, int lod, GLvoid* img);
	void glActiveTexture (uint texture);
	void glClientActiveTexture (uint texture);
	void glMultiTexCoord1d (uint target, double s);
	void glMultiTexCoord1dv (uint target, GLdouble* v);
	void glMultiTexCoord1f (uint target, float s);
	void glMultiTexCoord1fv (uint target, GLfloat* v);
	void glMultiTexCoord1i (uint target, int s);
	void glMultiTexCoord1iv (uint target, GLint* v);
	void glMultiTexCoord1s (uint target, short s);
	void glMultiTexCoord1sv (uint target, GLshort* v);
	void glMultiTexCoord2d (uint target, double s, double t);
	void glMultiTexCoord2dv (uint target, GLdouble* v);
	void glMultiTexCoord2f (uint target, float s, float t);
	void glMultiTexCoord2fv (uint target, GLfloat* v);
	void glMultiTexCoord2i (uint target, int s, int t);
	void glMultiTexCoord2iv (uint target, GLint* v);
	void glMultiTexCoord2s (uint target, short s, short t);
	void glMultiTexCoord2sv (uint target, GLshort* v);
	void glMultiTexCoord3d (uint target, double s, double t, double r);
	void glMultiTexCoord3dv (uint target, GLdouble* v);
	void glMultiTexCoord3f (uint target, float s, float t, float r);
	void glMultiTexCoord3fv (uint target, GLfloat* v);
	void glMultiTexCoord3i (uint target, int s, int t, int r);
	void glMultiTexCoord3iv (uint target, GLint* v);
	void glMultiTexCoord3s (uint target, short s, short t, short r);
	void glMultiTexCoord3sv (uint target, GLshort* v);
	void glMultiTexCoord4d (uint target, double s, double t, double r, double q);
	void glMultiTexCoord4dv (uint target, GLdouble* v);
	void glMultiTexCoord4f (uint target, float s, float t, float r, float q);
	void glMultiTexCoord4fv (uint target, GLfloat* v);
	void glMultiTexCoord4i (uint target, int dummy, int s, int t, int r);
	void glMultiTexCoord4iv (uint target, GLint* v);
	void glMultiTexCoord4s (uint target, short s, short t, short r, short q);
	void glMultiTexCoord4sv (uint target, GLshort* v);
	void glFogCoordf (float coord);
	void glFogCoordfv (GLfloat* coord);
	void glFogCoordd (double coord);
	void glFogCoorddv (GLdouble* coord);
	void glFogCoordPointer (uint type, int stride, GLvoid* pointer);
	void glSecondaryColor3b (byte red, byte green, byte blue);
	void glSecondaryColor3bv (char* v);
	void glSecondaryColor3d (double red, double green, double blue);
	void glSecondaryColor3dv (GLdouble* v);
	void glSecondaryColor3f (float red, float green, float blue);
	void glSecondaryColor3fv (GLfloat* v);
	void glSecondaryColor3i (int red, int green, int blue);
	void glSecondaryColor3iv (GLint* v);
	void glSecondaryColor3s (short red, short green, short blue);
	void glSecondaryColor3sv (GLshort* v);
	void glSecondaryColor3ub (ubyte red, ubyte green, ubyte blue);
	void glSecondaryColor3ubv (char* v);
	void glSecondaryColor3ui (uint red, uint green, uint blue);
	void glSecondaryColor3uiv (GLuint* v);
	void glSecondaryColor3us (ushort red, ushort green, ushort blue);
	void glSecondaryColor3usv (GLushort* v);
	void glSecondaryColorPointer (int size, uint type, int stride, GLvoid* pointer);
	void glPointParameterf (uint pname, float param);
	void glPointParameterfv (uint pname, GLfloat* params);
	void glPointParameteri (uint pname, int param);
	void glPointParameteriv (uint pname, GLint* params);
	void glBlendFuncSeparate (uint srcRGB, uint dstRGB, uint srcAlpha, uint dstAlpha);
	void glMultiDrawArrays (uint mode, GLint* first, GLsizei* count, int primcount);
	void glMultiDrawElements (uint mode, GLsizei* count, uint type, GLvoid** indices, int primcount);
	void glWindowPos2d (double x, double y);
	void glWindowPos2dv (GLdouble* v);
	void glWindowPos2f (float x, float y);
	void glWindowPos2fv (GLfloat* v);
	void glWindowPos2i (int x, int y);
	void glWindowPos2iv (GLint* v);
	void glWindowPos2s (short x, short y);
	void glWindowPos2sv (GLshort* v);
	void glWindowPos3d (double x, double y, double z);
	void glWindowPos3dv (GLdouble* v);
	void glWindowPos3f (float x, float y, float z);
	void glWindowPos3fv (GLfloat* v);
	void glWindowPos3i (int x, int y, int z);
	void glWindowPos3iv (GLint* v);
	void glWindowPos3s (short x, short y, short z);
	void glWindowPos3sv (GLshort* v);
	void glGenQueries (int n, GLuint* ids);
	void glDeleteQueries (int n, GLuint* ids);
	ubyte glIsQuery (uint id);
	void glBeginQuery (uint target, uint id);
	void glEndQuery (uint target);
	void glGetQueryiv (uint target, uint pname, GLint* params);
	void glGetQueryObjectiv (uint id, uint pname, GLint* params);
	void glGetQueryObjectuiv (uint id, uint pname, GLuint* params);
	void glBindBuffer (uint target, uint buffer);
	void glDeleteBuffers (int n, GLuint* buffers);
	void glGenBuffers (int n, GLuint* buffers);
	ubyte glIsBuffer (uint buffer);
	void glBufferData (uint target, int size, GLvoid* data, uint usage);
	void glBufferSubData (uint target, int offset, int size, GLvoid* data);
	void glGetBufferSubData (uint target, int offset, int size, GLvoid* data);
	GLvoid* glMapBuffer (uint target, uint access);
	ubyte glUnmapBuffer (uint target);
	void glGetBufferParameteriv (uint target, uint pname, GLint* params);
	void glGetBufferPointerv (uint target, uint pname, GLvoid** params);
	void glDrawBuffers (int n, GLenum* bufs);
	void glVertexAttrib1d (uint index, double x);
	void glVertexAttrib1dv (uint index, GLdouble* v);
	void glVertexAttrib1f (uint index, float x);
	void glVertexAttrib1fv (uint index, GLfloat* v);
	void glVertexAttrib1s (uint index, short x);
	void glVertexAttrib1sv (uint index, GLshort* v);
	void glVertexAttrib2d (uint index, double x, double y);
	void glVertexAttrib2dv (uint index, GLdouble* v);
	void glVertexAttrib2f (uint index, float x, float y);
	void glVertexAttrib2fv (uint index, GLfloat* v);
	void glVertexAttrib2s (uint index, short x, short y);
	void glVertexAttrib2sv (uint index, GLshort* v);
	void glVertexAttrib3d (uint index, double x, double y, double z);
	void glVertexAttrib3dv (uint index, GLdouble* v);
	void glVertexAttrib3f (uint index, float x, float y, float z);
	void glVertexAttrib3fv (uint index, GLfloat* v);
	void glVertexAttrib3s (uint index, short x, short y, short z);
	void glVertexAttrib3sv (uint index, GLshort* v);
	void glVertexAttrib4Nbv (uint index, char* v);
	void glVertexAttrib4Niv (uint index, GLint* v);
	void glVertexAttrib4Nsv (uint index, GLshort* v);
	void glVertexAttrib4Nub (uint index, ubyte x, ubyte y, ubyte z, ubyte w);
	void glVertexAttrib4Nubv (uint index, char* v);
	void glVertexAttrib4Nuiv (uint index, GLuint* v);
	void glVertexAttrib4Nusv (uint index, GLushort* v);
	void glVertexAttrib4bv (uint index, char* v);
	void glVertexAttrib4d (uint index, double x, double y, double z, double w);
	void glVertexAttrib4dv (uint index, GLdouble* v);
	void glVertexAttrib4f (uint index, float x, float y, float z, float w);
	void glVertexAttrib4fv (uint index, GLfloat* v);
	void glVertexAttrib4iv (uint index, GLint* v);
	void glVertexAttrib4s (uint index, short x, short y, short z, short w);
	void glVertexAttrib4sv (uint index, GLshort* v);
	void glVertexAttrib4ubv (uint index, char* v);
	void glVertexAttrib4uiv (uint index, GLuint* v);
	void glVertexAttrib4usv (uint index, GLushort* v);
	void glVertexAttribPointer (uint index, int size, uint type, ubyte normalized, int stride, GLvoid* pointer);
	void glEnableVertexAttribArray (uint index);
	void glDisableVertexAttribArray (uint index);
	void glGetVertexAttribdv (uint index, uint pname, GLdouble* params);
	void glGetVertexAttribfv (uint index, uint pname, GLfloat* params);
	void glGetVertexAttribiv (uint index, uint pname, GLint* params);
	void glGetVertexAttribPointerv (uint index, uint pname, GLvoid** pointer);
	void glDeleteShader (uint shader);
	void glDetachShader (uint program, uint shader);
	uint glCreateShader (uint type);
	void glShaderSource (uint shader, int count, GLchar** string, GLint* length);
	void glCompileShader (uint shader);
	uint glCreateProgram ();
	void glAttachShader (uint program, uint shader);
	void glLinkProgram (uint program);
	void glUseProgram (uint program);
	void glDeleteProgram (uint program);
	void glValidateProgram (uint program);
	void glUniform1f (int location, float v0);
	void glUniform2f (int location, float v0, float v1);
	void glUniform3f (int location, float v0, float v1, float v2);
	void glUniform4f (int location, float v0, float v1, float v2, float v3);
	void glUniform1i (int location, int v0);
	void glUniform2i (int location, int v0, int v1);
	void glUniform3i (int location, int v0, int v1, int v2);
	void glUniform4i (int location, int v0, int v1, int v2, int v3);
	void glUniform1fv (int location, int count, GLfloat* value);
	void glUniform2fv (int location, int count, GLfloat* value);
	void glUniform3fv (int location, int count, GLfloat* value);
	void glUniform4fv (int location, int count, GLfloat* value);
	void glUniform1iv (int location, int count, GLint* value);
	void glUniform2iv (int location, int count, GLint* value);
	void glUniform3iv (int location, int count, GLint* value);
	void glUniform4iv (int location, int count, GLint* value);
	void glUniformMatrix2fv (int location, int count, ubyte transpose, GLfloat* value);
	void glUniformMatrix3fv (int location, int count, ubyte transpose, GLfloat* value);
	void glUniformMatrix4fv (int location, int count, ubyte transpose, GLfloat* value);
	ubyte glIsShader (uint shader);
	ubyte glIsProgram (uint program);
	void glGetShaderiv (uint shader, uint pname, GLint* params);
	void glGetProgramiv (uint program, uint pname, GLint* params);
	void glGetAttachedShaders (uint program, int maxCount, GLsizei* count, GLuint* shaders);
	void glGetShaderInfoLog (uint shader, int bufSize, GLsizei* length, char* infoLog);
	void glGetProgramInfoLog (uint program, int bufSize, GLsizei* length, char* infoLog);
	int glGetUniformLocation (uint program, char* name);
	void glGetActiveUniform (uint program, uint index, int bufSize, GLsizei* length, GLint* size, GLenum* type, char* name);
	void glGetUniformfv (uint program, int location, GLfloat* params);
	void glGetUniformiv (uint program, int location, GLint* params);
	void glGetShaderSource (uint shader, int bufSize, GLsizei* length, char* source);
	void glBindAttribLocation (uint program, uint index, char* name);
	void glGetActiveAttrib (uint program, uint index, int bufSize, GLsizei* length, GLint* size, GLenum* type, char* name);
	int glGetAttribLocation (uint program, char* name);
	void glStencilFuncSeparate (uint face, uint func, int ref_, uint mask);
	void glStencilOpSeparate (uint face, uint fail, uint zfail, uint zpass);
	void glStencilMaskSeparate (uint face, uint mask);
	void glUniformMatrix2x3fv (int location, int count, ubyte transpose, GLfloat* value);
	void glUniformMatrix3x2fv (int location, int count, ubyte transpose, GLfloat* value);
	void glUniformMatrix2x4fv (int location, int count, ubyte transpose, GLfloat* value);
	void glUniformMatrix4x2fv (int location, int count, ubyte transpose, GLfloat* value);
	void glUniformMatrix3x4fv (int location, int count, ubyte transpose, GLfloat* value);
	void glUniformMatrix4x3fv (int location, int count, ubyte transpose, GLfloat* value);
}