--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dstep/opengl/gl.d	Sun Jan 03 22:06:11 2010 +0100
@@ -0,0 +1,616 @@
+/**
+ * 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);
+}
\ No newline at end of file