changeset 42:0b9b286b67b6 trunk

[svn r46] fix for shift operations added a simple opengl binding in demos
author lindquist
date Fri, 19 Oct 2007 15:16:11 +0200
parents 835320b88ad6
children eb7bf7b7972e
files demos/gl.d demos/glfuncs.d demos/gltypes.d demos/sdl.d dmd/expression.c gen/toir.c lphobos/internal/objectimpl.d lphobos/std/intrinsic.d runalltests.d test/bug16.d
diffstat 10 files changed, 1154 insertions(+), 17 deletions(-) [+]
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/demos/gl.d	Fri Oct 19 15:16:11 2007 +0200
@@ -0,0 +1,6 @@
+module gl;
+
+public {
+    import gltypes;
+    import glfuncs;
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/demos/glfuncs.d	Fri Oct 19 15:16:11 2007 +0200
@@ -0,0 +1,406 @@
+/*
+ * Copyright (c) 2004-2006 Derelict Developers
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the names 'Derelict', 'DerelictGL', nor the names of its contributors
+ *   may be used to endorse or promote products derived from this software
+ *   without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Converted to a static binding by Tomas Lindquist Olsen <tomas@famolsen.dk>
+ */
+module glfuncs;
+
+import gltypes;
+
+extern(System):
+
+// Miscellaneous
+void glClearIndex(GLfloat c);
+void glClearColor(GLclampf,GLclampf,GLclampf,GLclampf);
+void glClear(GLbitfield);
+void glIndexMask(GLuint);
+void glColorMask(GLboolean,GLboolean,GLboolean,GLboolean);
+void glAlphaFunc(GLenum,GLclampf);
+void glBlendFunc(GLenum,GLenum);
+void glLogicOp(GLenum);
+void glCullFace(GLenum);
+void glFrontFace(GLenum);
+void glPointSize(GLfloat);
+void glLineWidth(GLfloat);
+void glLineStipple(GLint,GLushort);
+void glPolygonMode(GLenum,GLenum);
+void glPolygonOffset(GLfloat,GLfloat);
+void glPolygonStipple(GLubyte*);
+void glGetPolygonStipple(GLubyte*);
+void glEdgeFlag(GLboolean);
+void glEdgeFlagv(GLboolean*);
+void glScissor(GLint,GLint,GLsizei,GLsizei);
+void glClipPlane(GLenum,GLdouble*);
+void glGetClipPlane(GLenum,GLdouble*);
+void glDrawBuffer(GLenum);
+void glReadBuffer(GLenum);
+void glEnable(GLenum);
+void glDisable(GLenum);
+GLboolean glIsEnabled(GLenum);
+void glEnableClientState(GLenum);
+void glDisableClientState(GLenum);
+void glGetBooleanv(GLenum,GLboolean*);
+void glGetDoublev(GLenum,GLdouble*);
+void glGetFloatv(GLenum,GLfloat*);
+void glGetIntegerv(GLenum,GLint*);
+void glPushAttrib(GLbitfield);
+void glPopAttrib();
+void glPushClientAttrib(GLbitfield);
+void glPopClientAttrib();
+GLint glRenderMode(GLenum);
+GLenum glGetError();
+GLchar* glGetString(GLenum);
+void glFinish();
+void glFlush();
+void glHint(GLenum,GLenum);
+
+// Depth Buffer
+void glClearDepth(GLclampd);
+void glDepthFunc(GLenum);
+void glDepthMask(GLboolean);
+void glDepthRange(GLclampd,GLclampd);
+
+// Accumulation Buffer
+void glClearAccum(GLfloat,GLfloat,GLfloat,GLfloat);
+void glAccum(GLenum,GLfloat);
+
+// Transformation
+void glMatrixMode(GLenum);
+void glOrtho(GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble);
+void glFrustum(GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble);
+void glViewport(GLint,GLint,GLsizei,GLsizei);
+void glPushMatrix();
+void glPopMatrix();
+void glLoadIdentity();
+void glLoadMatrixd(GLdouble*);
+void glLoadMatrixf(GLfloat*);
+void glMultMatrixd(GLdouble*);
+void glMultMatrixf(GLfloat*);
+void glRotated(GLdouble,GLdouble,GLdouble,GLdouble);
+void glRotatef(GLfloat,GLfloat,GLfloat,GLfloat);
+void glScaled(GLdouble,GLdouble,GLdouble);
+void glScalef(GLfloat,GLfloat,GLfloat);
+void glTranslated(GLdouble,GLdouble,GLdouble);
+void glTranslatef(GLfloat,GLfloat,GLfloat);
+
+// Display Lists
+GLboolean glIsList(GLuint);
+void glDeleteLists(GLuint,GLsizei);
+GLuint glGenLists(GLsizei);
+void glNewList(GLuint,GLenum);
+void glEndList();
+void glCallList(GLuint);
+void glCallLists(GLsizei,GLenum,GLvoid*);
+void glListBase(GLuint);
+
+// Drawing Functions
+void glBegin(GLenum);
+void glEnd();
+void glVertex2d(GLdouble,GLdouble);
+void glVertex2f(GLfloat,GLfloat);
+void glVertex2i(GLint,GLint);
+void glVertex2s(GLshort,GLshort);
+void glVertex3d(GLdouble,GLdouble,GLdouble);
+void glVertex3f(GLfloat,GLfloat,GLfloat);
+void glVertex3i(GLint,GLint,GLint);
+void glVertex3s(GLshort,GLshort,GLshort);
+void glVertex4d(GLdouble,GLdouble,GLdouble,GLdouble);
+void glVertex4f(GLfloat,GLfloat,GLfloat,GLfloat);
+void glVertex4i(GLint,GLint,GLint,GLint);
+void glVertex4s(GLshort,GLshort,GLshort,GLshort);
+void glVertex2dv(GLdouble*);
+void glVertex2fv(GLfloat*);
+void glVertex2iv(GLint*);
+void glVertex2sv(GLshort*);
+void glVertex3dv(GLdouble*);
+void glVertex3fv(GLfloat*);
+void glVertex3iv(GLint*);
+void glVertex3sv(GLshort*);
+void glVertex4dv(GLdouble*);
+void glVertex4fv(GLfloat*);
+void glVertex4iv(GLint*);
+void glVertex4sv(GLshort*);
+void glNormal3b(GLbyte,GLbyte,GLbyte);
+void glNormal3d(GLdouble,GLdouble,GLdouble);
+void glNormal3f(GLfloat,GLfloat,GLfloat);
+void glNormal3i(GLint,GLint,GLint);
+void glNormal3s(GLshort,GLshort,GLshort);
+void glNormal3bv(GLbyte*);
+void glNormal3dv(GLdouble*);
+void glNormal3fv(GLfloat*);
+void glNormal3iv(GLint*);
+void glNormal3sv(GLshort*);
+void glIndexd(GLdouble);
+void glIndexf(GLfloat);
+void glIndexi(GLint);
+void glIndexs(GLshort);
+void glIndexub(GLubyte);
+void glIndexdv(GLdouble*);
+void glIndexfv(GLfloat*);
+void glIndexiv(GLint*);
+void glIndexsv(GLshort*);
+void glIndexubv(GLubyte*);
+void glColor3b(GLbyte,GLbyte,GLbyte);
+void glColor3d(GLdouble,GLdouble,GLdouble);
+void glColor3f(GLfloat,GLfloat,GLfloat);
+void glColor3i(GLint,GLint,GLint);
+void glColor3s(GLshort,GLshort,GLshort);
+void glColor3ub(GLubyte,GLubyte,GLubyte);
+void glColor3ui(GLuint,GLuint,GLuint);
+void glColor3us(GLushort,GLushort,GLushort);
+void glColor4b(GLbyte,GLbyte,GLbyte,GLbyte);
+void glColor4d(GLdouble,GLdouble,GLdouble,GLdouble);
+void glColor4f(GLfloat,GLfloat,GLfloat,GLfloat);
+void glColor4i(GLint,GLint,GLint,GLint);
+void glColor4s(GLshort,GLshort,GLshort,GLshort);
+void glColor4ub(GLubyte,GLubyte,GLubyte,GLubyte);
+void glColor4ui(GLuint,GLuint,GLuint,GLuint);
+void glColor4us(GLushort,GLushort,GLushort,GLushort);
+void glColor3bv(GLubyte*);
+void glColor3dv(GLdouble*);
+void glColor3fv(GLfloat*);
+void glColor3iv(GLint*);
+void glColor3sv(GLshort*);
+void glColor3ubv(GLubyte*);
+void glColor3uiv(GLuint*);
+void glColor3usv(GLushort*);
+void glColor4bv(GLbyte*);
+void glColor4dv(GLdouble*);
+void glColor4fv(GLfloat*);
+void glColor4iv(GLint*);
+void glColor4sv(GLshort*);
+void glColor4ubv(GLubyte*);
+void glColor4uiv(GLuint*);
+void glColor4usv(GLushort);
+void glTexCoord1d(GLdouble);
+void glTexCoord1f(GLfloat);
+void glTexCoord1i(GLint);
+void glTexCoord1s(GLshort);
+void glTexCoord2d(GLdouble,GLdouble);
+void glTexCoord2f(GLfloat,GLfloat);
+void glTexCoord2i(GLint,GLint);
+void glTexCoord2s(GLshort,GLshort);
+void glTexCoord3d(GLdouble,GLdouble,GLdouble);
+void glTexCoord3f(GLfloat,GLfloat,GLfloat);
+void glTexCoord3i(GLint,GLint,GLint);
+void glTexCoord3s(GLshort,GLshort,GLshort);
+void glTexCoord4d(GLdouble,GLdouble,GLdouble,GLdouble);
+void glTexCoord4f(GLfloat,GLfloat,GLfloat,GLfloat);
+void glTexCoord4i(GLint,GLint,GLint,GLint);
+void glTexCoord4s(GLshort,GLshort,GLshort,GLshort);
+void glTexCoord1dv(GLdouble*);
+void glTexCoord1fv(GLfloat*);
+void glTexCoord1iv(GLint*);
+void glTexCoord1sv(GLshort*);
+void glTexCoord2dv(GLdouble*);
+void glTexCoord2fv(GLfloat*);
+void glTexCoord2iv(GLint*);
+void glTexCoord2sv(GLshort*);
+void glTexCoord3dv(GLdouble*);
+void glTexCoord3fv(GLfloat*);
+void glTexCoord3iv(GLint*);
+void glTexCoord3sv(GLshort*);
+void glTexCoord4dv(GLdouble*);
+void glTexCoord4fv(GLfloat*);
+void glTexCoord4iv(GLint*);
+void glTexCoord4sv(GLshort*);
+void glRasterPos2d(GLdouble,GLdouble);
+void glRasterPos2f(GLfloat,GLfloat);
+void glRasterPos2i(GLint,GLint);
+void glRasterPos2s(GLshort,GLshort);
+void glRasterPos3d(GLdouble,GLdouble,GLdouble);
+void glRasterPos3f(GLfloat,GLfloat,GLfloat);
+void glRasterPos3i(GLint,GLint,GLint);
+void glRasterPos3s(GLshort,GLshort,GLshort);
+void glRasterPos4d(GLdouble,GLdouble,GLdouble,GLdouble);
+void glRasterPos4f(GLfloat,GLfloat,GLfloat,GLfloat);
+void glRasterPos4i(GLint,GLint,GLint,GLint);
+void glRasterPos4s(GLshort,GLshort,GLshort,GLshort);
+void glRasterPos2dv(GLdouble*);
+void glRasterPos2fv(GLfloat*);
+void glRasterPos2iv(GLint*);
+void glRasterPos2sv(GLshort*);
+void glRasterPos3dv(GLdouble*);
+void glRasterPos3fv(GLfloat*);
+void glRasterPos3iv(GLint*);
+void glRasterPos3sv(GLshort*);
+void glRasterPos4dv(GLdouble*);
+void glRasterPos4fv(GLfloat*);
+void glRasterPos4iv(GLint*);
+void glRasterPos4sv(GLshort*);
+void glRectd(GLdouble,GLdouble,GLdouble,GLdouble);
+void glRectf(GLfloat,GLfloat,GLfloat,GLfloat);
+void glRecti(GLint,GLint,GLint,GLint);
+void glRects(GLshort,GLshort,GLshort,GLshort);
+void glRectdv(GLdouble*);
+void glRectfv(GLfloat*);
+void glRectiv(GLint*);
+void glRectsv(GLshort*);
+
+// Lighting
+void glShadeModel(GLenum);
+void glLightf(GLenum,GLenum,GLfloat);
+void glLighti(GLenum,GLenum,GLint);
+void glLightfv(GLenum,GLenum,GLfloat*);
+void glLightiv(GLenum,GLenum,GLint*);
+void glGetLightfv(GLenum,GLenum,GLfloat*);
+void glGetLightiv(GLenum,GLenum,GLint*);
+void glLightModelf(GLenum,GLfloat);
+void glLightModeli(GLenum,GLint);
+void glLightModelfv(GLenum,GLfloat*);
+void glLightModeliv(GLenum,GLint*);
+void glMaterialf(GLenum,GLenum,GLfloat);
+void glMateriali(GLenum,GLenum,GLint);
+void glMaterialfv(GLenum,GLenum,GLfloat*);
+void glMaterialiv(GLenum,GLenum,GLint*);
+void glGetMaterialfv(GLenum,GLenum,GLfloat*);
+void glGetMaterialiv(GLenum,GLenum,GLint*);
+void glColorMaterial(GLenum,GLenum);
+
+// Raster functions
+void glPixelZoom(GLfloat,GLfloat);
+void glPixelStoref(GLenum,GLfloat);
+void glPixelStorei(GLenum,GLint);
+void glPixelTransferf(GLenum,GLfloat);
+void glPixelTransferi(GLenum,GLint);
+void glPixelMapfv(GLenum,GLint,GLfloat*);
+void glPixelMapuiv(GLenum,GLint,GLuint*);
+void glPixelMapusv(GLenum,GLint,GLushort*);
+void glGetPixelMapfv(GLenum,GLfloat*);
+void glGetPixelMapuiv(GLenum,GLuint*);
+void glGetPixelMapusv(GLenum,GLushort*);
+void glBitmap(GLsizei,GLsizei,GLfloat,GLfloat,GLfloat,GLfloat,GLubyte*);
+void glReadPixels(GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,GLvoid*);
+void glDrawPixels(GLsizei,GLsizei,GLenum,GLenum,GLvoid*);
+void glCopyPixels(GLint,GLint,GLsizei,GLsizei,GLenum);
+
+// Stenciling
+void glStencilFunc(GLenum,GLint,GLuint);
+void glStencilMask(GLuint);
+void glStencilOp(GLenum,GLenum,GLenum);
+void glClearStencil(GLint);
+
+// Texture mapping
+void glTexGend(GLenum,GLenum,GLdouble);
+void glTexGenf(GLenum,GLenum,GLfloat);
+void glTexGeni(GLenum,GLenum,GLint);
+void glTexGendv(GLenum,GLenum,GLdouble*);
+void glTexGenfv(GLenum,GLenum,GLfloat*);
+void glTexGeniv(GLenum,GLenum,GLint*);
+void glGetTexGendv(GLenum,GLenum,GLdouble*);
+void glGetTexGenfv(GLenum,GLenum,GLfloat*);
+void glGetTexGeniv(GLenum,GLenum,GLint*);
+void glTexEnvf(GLenum,GLenum,GLfloat);
+void glTexEnvi(GLenum,GLenum,GLint);
+void glTexEnvfv(GLenum,GLenum,GLfloat*);
+void glTexEnviv(GLenum,GLenum,GLint*);
+void glGetTexEnvfv(GLenum,GLenum,GLfloat*);
+void glGetTexEnviv(GLenum,GLenum,GLint*);
+void glTexParameterf(GLenum,GLenum,GLfloat);
+void glTexParameteri(GLenum,GLenum,GLint);
+void glTexParameterfv(GLenum,GLenum,GLfloat*);
+void glTexParameteriv(GLenum,GLenum,GLint*);
+void glGetTexParameterfv(GLenum,GLenum,GLfloat*);
+void glGetTexParameteriv(GLenum,GLenum,GLint*);
+void glGetTexLevelParameterfv(GLenum,GLint,GLenum,GLfloat*);
+void glGetTexLevelParameteriv(GLenum,GLint,GLenum,GLint*);
+void glTexImage1D(GLenum,GLint,GLint,GLsizei,GLint,GLenum,GLenum,GLvoid*);
+void glTexImage2D(GLenum,GLint,GLint,GLsizei,GLsizei,GLint,GLenum,GLenum,GLvoid*);
+void glGetTexImage(GLenum,GLint,GLenum,GLenum,GLvoid*);
+
+// Evaluators
+void glMap1d(GLenum,GLdouble,GLdouble,GLint,GLint,GLdouble*);
+void glMap1f(GLenum,GLfloat,GLfloat,GLint,GLint,GLfloat*);
+void glMap2d(GLenum,GLdouble,GLdouble,GLint,GLint,GLdouble,GLdouble,GLint,GLint,GLdouble*);
+void glMap2f(GLenum,GLfloat,GLfloat,GLint,GLint,GLfloat,GLfloat,GLint,GLint,GLfloat*);
+void glGetMapdv(GLenum,GLenum,GLdouble*);
+void glGetMapfv(GLenum,GLenum,GLfloat*);
+void glGetMapiv(GLenum,GLenum,GLint*);
+void glEvalCoord1d(GLdouble);
+void glEvalCoord1f(GLfloat);
+void glEvalCoord1dv(GLdouble*);
+void glEvalCoord1fv(GLfloat*);
+void glEvalCoord2d(GLdouble,GLdouble);
+void glEvalCoord2f(GLfloat,GLfloat);
+void glEvalCoord2dv(GLdouble*);
+void glEvalCoord2fv(GLfloat*);
+void glMapGrid1d(GLint,GLdouble,GLdouble);
+void glMapGrid1f(GLint,GLfloat,GLfloat);
+void glMapGrid2d(GLint,GLdouble,GLdouble,GLint,GLdouble,GLdouble);
+void glMapGrid2f(GLint,GLfloat,GLfloat,GLint,GLfloat,GLfloat);
+void glEvalPoint1(GLint);
+void glEvalPoint2(GLint,GLint);
+void glEvalMesh1(GLenum,GLint,GLint);
+void glEvalMesh2(GLenum,GLint,GLint,GLint,GLint);
+
+// Fog
+void glFogf(GLenum,GLfloat);
+void glFogi(GLenum,GLint);
+void glFogfv(GLenum,GLfloat*);
+void glFogiv(GLenum,GLint*);
+
+// Selection and Feedback
+void glFeedbackBuffer(GLsizei,GLenum,GLfloat*);
+void glPassThrough(GLfloat);
+void glSelectBuffer(GLsizei,GLuint*);
+void glInitNames();
+void glLoadName(GLuint);
+void glPushName(GLuint);
+void glPopName();
+
+// texture objects
+void glGenTextures(GLsizei,GLuint*);
+void glDeleteTextures(GLsizei,GLuint*);
+void glBindTexture(GLenum,GLuint);
+void glPrioritizeTextures(GLsizei,GLuint*,GLclampf*);
+GLboolean glAreTexturesResident(GLsizei,GLuint*,GLboolean*);
+GLboolean glIsTexture(GLuint);
+
+// texture mapping
+void glTexSubImage1D(GLenum,GLint,GLint,GLsizei,GLenum,GLenum,GLvoid*);
+void glTexSubImage2D(GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,GLvoid*);
+void glCopyTexImage1D(GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLint);
+void glCopyTexImage2D(GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLsizei,GLint);
+void glCopyTexSubImage1D(GLenum,GLint,GLint,GLint,GLint,GLsizei);
+void glCopyTexSubImage2D(GLenum,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei);
+
+// vertex arrays
+void glVertexPointer(GLint,GLenum,GLsizei,GLvoid*);
+void glNormalPointer(GLenum,GLsizei,GLvoid*);
+void glColorPointer(GLint,GLenum,GLsizei,GLvoid*);
+void glIndexPointer(GLenum,GLsizei,GLvoid*);
+void glTexCoordPointer(GLint,GLenum,GLsizei,GLvoid*);
+void glEdgeFlagPointer(GLsizei,GLvoid*);
+void glGetPointerv(GLenum,GLvoid**);
+void glArrayElement(GLint);
+void glDrawArrays(GLenum,GLint,GLsizei);
+void glDrawElements(GLenum,GLsizei,GLenum,GLvoid*);
+void glInterleavedArrays(GLenum,GLsizei,GLvoid*);
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/demos/gltypes.d	Fri Oct 19 15:16:11 2007 +0200
@@ -0,0 +1,665 @@
+/*
+ * Copyright (c) 2004-2006 Derelict Developers
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the names 'Derelict', 'DerelictGL', nor the names of its contributors
+ *   may be used to endorse or promote products derived from this software
+ *   without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Converted to a static binding by Tomas Lindquist Olsen <tomas@famolsen.dk>
+ */
+module gltypes;
+
+version(build) pragma(link,"GL");
+
+alias uint      GLenum;
+alias ubyte     GLboolean;
+alias uint      GLbitfield;
+alias void      GLvoid;
+alias byte      GLbyte;
+alias short     GLshort;
+alias int       GLint;
+alias ubyte     GLubyte;
+alias ushort    GLushort;
+alias uint      GLuint;
+alias int       GLsizei;
+alias float     GLfloat;
+alias float     GLclampf;
+alias double    GLdouble;
+alias double    GLclampd;
+alias char      GLchar;
+alias ptrdiff_t GLintptr;
+alias ptrdiff_t GLsizeiptr;
+
+// Boolean values
+enum : GLboolean {
+    GL_FALSE   = 0x0,
+    GL_TRUE    = 0x1,
+}
+
+enum : GLenum {
+    // Data types
+    GL_BYTE                                = 0x1400,
+    GL_UNSIGNED_BYTE                       = 0x1401,
+    GL_SHORT                               = 0x1402,
+    GL_UNSIGNED_SHORT                      = 0x1403,
+    GL_INT                                 = 0x1404,
+    GL_UNSIGNED_INT                        = 0x1405,
+    GL_FLOAT                               = 0x1406,
+    GL_DOUBLE                              = 0x140A,
+    GL_2_BYTES                             = 0x1407,
+    GL_3_BYTES                             = 0x1408,
+    GL_4_BYTES                             = 0x1409,
+
+    // Primitives
+    GL_POINTS                              = 0x0000,
+    GL_LINES                               = 0x0001,
+    GL_LINE_LOOP                           = 0x0002,
+    GL_LINE_STRIP                          = 0x0003,
+    GL_TRIANGLES                           = 0x0004,
+    GL_TRIANGLE_STRIP                      = 0x0005,
+    GL_TRIANGLE_FAN                        = 0x0006,
+    GL_QUADS                               = 0x0007,
+    GL_QUAD_STRIP                          = 0x0008,
+    GL_POLYGON                             = 0x0009,
+
+    // Vertex Arrays
+    GL_VERTEX_ARRAY                        = 0x8074,
+    GL_NORMAL_ARRAY                        = 0x8075,
+    GL_COLOR_ARRAY                         = 0x8076,
+    GL_INDEX_ARRAY                         = 0x8077,
+    GL_TEXTURE_COORD_ARRAY                 = 0x8078,
+    GL_EDGE_FLAG_ARRAY                     = 0x8079,
+    GL_VERTEX_ARRAY_SIZE                   = 0x807A,
+    GL_VERTEX_ARRAY_TYPE                   = 0x807B,
+    GL_VERTEX_ARRAY_STRIDE                 = 0x807C,
+    GL_NORMAL_ARRAY_TYPE                   = 0x807E,
+    GL_NORMAL_ARRAY_STRIDE                 = 0x807F,
+    GL_COLOR_ARRAY_SIZE                    = 0x8081,
+    GL_COLOR_ARRAY_TYPE                    = 0x8082,
+    GL_COLOR_ARRAY_STRIDE                  = 0x8083,
+    GL_INDEX_ARRAY_TYPE                    = 0x8085,
+    GL_INDEX_ARRAY_STRIDE                  = 0x8086,
+    GL_TEXTURE_COORD_ARRAY_SIZE            = 0x8088,
+    GL_TEXTURE_COORD_ARRAY_TYPE            = 0x8089,
+    GL_TEXTURE_COORD_ARRAY_STRIDE          = 0x808A,
+    GL_EDGE_FLAG_ARRAY_STRIDE              = 0x808C,
+    GL_VERTEX_ARRAY_POINTER                = 0x808E,
+    GL_NORMAL_ARRAY_POINTER                = 0x808F,
+    GL_COLOR_ARRAY_POINTER                 = 0x8090,
+    GL_INDEX_ARRAY_POINTER                 = 0x8091,
+    GL_TEXTURE_COORD_ARRAY_POINTER         = 0x8092,
+    GL_EDGE_FLAG_ARRAY_POINTER             = 0x8093,
+    GL_V2F                                 = 0x2A20,
+    GL_V3F                                 = 0x2A21,
+    GL_C4UB_V2F                            = 0x2A22,
+    GL_C4UB_V3F                            = 0x2A23,
+    GL_C3F_V3F                             = 0x2A24,
+    GL_N3F_V3F                             = 0x2A25,
+    GL_C4F_N3F_V3F                         = 0x2A26,
+    GL_T2F_V3F                             = 0x2A27,
+    GL_T4F_V4F                             = 0x2A28,
+    GL_T2F_C4UB_V3F                        = 0x2A29,
+    GL_T2F_C3F_V3F                         = 0x2A2A,
+    GL_T2F_N3F_V3F                         = 0x2A2B,
+    GL_T2F_C4F_N3F_V3F                     = 0x2A2C,
+    GL_T4F_C4F_N3F_V4F                     = 0x2A2D,
+
+    // Matrix Mode
+    GL_MATRIX_MODE                         = 0x0BA0,
+    GL_MODELVIEW                           = 0x1700,
+    GL_PROJECTION                          = 0x1701,
+    GL_TEXTURE                             = 0x1702,
+
+    // Points
+    GL_POINT_SMOOTH                        = 0x0B10,
+    GL_POINT_SIZE                          = 0x0B11,
+    GL_POINT_SIZE_GRANULARITY              = 0x0B13,
+    GL_POINT_SIZE_RANGE                    = 0x0B12,
+
+    // Lines
+    GL_LINE_SMOOTH                         = 0x0B20,
+    GL_LINE_STIPPLE                        = 0x0B24,
+    GL_LINE_STIPPLE_PATTERN                = 0x0B25,
+    GL_LINE_STIPPLE_REPEAT                 = 0x0B26,
+    GL_LINE_WIDTH                          = 0x0B21,
+    GL_LINE_WIDTH_GRANULARITY              = 0x0B23,
+    GL_LINE_WIDTH_RANGE                    = 0x0B22,
+
+    // Polygons
+    GL_POINT                               = 0x1B00,
+    GL_LINE                                = 0x1B01,
+    GL_FILL                                = 0x1B02,
+    GL_CW                                  = 0x0900,
+    GL_CCW                                 = 0x0901,
+    GL_FRONT                               = 0x0404,
+    GL_BACK                                = 0x0405,
+    GL_POLYGON_MODE                        = 0x0B40,
+    GL_POLYGON_SMOOTH                      = 0x0B41,
+    GL_POLYGON_STIPPLE                     = 0x0B42,
+    GL_EDGE_FLAG                           = 0x0B43,
+    GL_CULL_FACE                           = 0x0B44,
+    GL_CULL_FACE_MODE                      = 0x0B45,
+    GL_FRONT_FACE                          = 0x0B46,
+    GL_POLYGON_OFFSET_FACTOR               = 0x8038,
+    GL_POLYGON_OFFSET_UNITS                = 0x2A00,
+    GL_POLYGON_OFFSET_POINT                = 0x2A01,
+    GL_POLYGON_OFFSET_LINE                 = 0x2A02,
+    GL_POLYGON_OFFSET_FILL                 = 0x8037,
+
+    // Display Lists
+    GL_COMPILE                             = 0x1300,
+    GL_COMPILE_AND_EXECUTE                 = 0x1301,
+    GL_LIST_BASE                           = 0x0B32,
+    GL_LIST_INDEX                          = 0x0B33,
+    GL_LIST_MODE                           = 0x0B30,
+
+    // Depth buffer
+    GL_NEVER                               = 0x0200,
+    GL_LESS                                = 0x0201,
+    GL_EQUAL                               = 0x0202,
+    GL_LEQUAL                              = 0x0203,
+    GL_GREATER                             = 0x0204,
+    GL_NOTEQUAL                            = 0x0205,
+    GL_GEQUAL                              = 0x0206,
+    GL_ALWAYS                              = 0x0207,
+    GL_DEPTH_TEST                          = 0x0B71,
+    GL_DEPTH_BITS                          = 0x0D56,
+    GL_DEPTH_CLEAR_VALUE                   = 0x0B73,
+    GL_DEPTH_FUNC                          = 0x0B74,
+    GL_DEPTH_RANGE                         = 0x0B70,
+    GL_DEPTH_WRITEMASK                     = 0x0B72,
+    GL_DEPTH_COMPONENT                     = 0x1902,
+
+    // Lighting
+    GL_LIGHTING                            = 0x0B50,
+    GL_LIGHT0                              = 0x4000,
+    GL_LIGHT1                              = 0x4001,
+    GL_LIGHT2                              = 0x4002,
+    GL_LIGHT3                              = 0x4003,
+    GL_LIGHT4                              = 0x4004,
+    GL_LIGHT5                              = 0x4005,
+    GL_LIGHT6                              = 0x4006,
+    GL_LIGHT7                              = 0x4007,
+    GL_SPOT_EXPONENT                       = 0x1205,
+    GL_SPOT_CUTOFF                         = 0x1206,
+    GL_CONSTANT_ATTENUATION                = 0x1207,
+    GL_LINEAR_ATTENUATION                  = 0x1208,
+    GL_QUADRATIC_ATTENUATION               = 0x1209,
+    GL_AMBIENT                             = 0x1200,
+    GL_DIFFUSE                             = 0x1201,
+    GL_SPECULAR                            = 0x1202,
+    GL_SHININESS                           = 0x1601,
+    GL_EMISSION                            = 0x1600,
+    GL_POSITION                            = 0x1203,
+    GL_SPOT_DIRECTION                      = 0x1204,
+    GL_AMBIENT_AND_DIFFUSE                 = 0x1602,
+    GL_COLOR_INDEXES                       = 0x1603,
+    GL_LIGHT_MODEL_TWO_SIDE                = 0x0B52,
+    GL_LIGHT_MODEL_LOCAL_VIEWER            = 0x0B51,
+    GL_LIGHT_MODEL_AMBIENT                 = 0x0B53,
+    GL_FRONT_AND_BACK                      = 0x0408,
+    GL_SHADE_MODEL                         = 0x0B54,
+    GL_FLAT                                = 0x1D00,
+    GL_SMOOTH                              = 0x1D01,
+    GL_COLOR_MATERIAL                      = 0x0B57,
+    GL_COLOR_MATERIAL_FACE                 = 0x0B55,
+    GL_COLOR_MATERIAL_PARAMETER            = 0x0B56,
+    GL_NORMALIZE                           = 0x0BA1,
+
+    // User clipping planes
+    GL_CLIP_PLANE0                         = 0x3000,
+    GL_CLIP_PLANE1                         = 0x3001,
+    GL_CLIP_PLANE2                         = 0x3002,
+    GL_CLIP_PLANE3                         = 0x3003,
+    GL_CLIP_PLANE4                         = 0x3004,
+    GL_CLIP_PLANE5                         = 0x3005,
+
+    // Accumulation buffer
+    GL_ACCUM_RED_BITS                      = 0x0D58,
+    GL_ACCUM_GREEN_BITS                    = 0x0D59,
+    GL_ACCUM_BLUE_BITS                     = 0x0D5A,
+    GL_ACCUM_ALPHA_BITS                    = 0x0D5B,
+    GL_ACCUM_CLEAR_VALUE                   = 0x0B80,
+    GL_ACCUM                               = 0x0100,
+    GL_ADD                                 = 0x0104,
+    GL_LOAD                                = 0x0101,
+    GL_MULT                                = 0x0103,
+    GL_RETURN                              = 0x0102,
+
+    // Alpha testing
+    GL_ALPHA_TEST                          = 0x0BC0,
+    GL_ALPHA_TEST_REF                      = 0x0BC2,
+    GL_ALPHA_TEST_FUNC                     = 0x0BC1,
+
+    // Blending
+    GL_BLEND                               = 0x0BE2,
+    GL_BLEND_SRC                           = 0x0BE1,
+    GL_BLEND_DST                           = 0x0BE0,
+    GL_ZERO                                = 0x0,
+    GL_ONE                                 = 0x1,
+    GL_SRC_COLOR                           = 0x0300,
+    GL_ONE_MINUS_SRC_COLOR                 = 0x0301,
+    GL_SRC_ALPHA                           = 0x0302,
+    GL_ONE_MINUS_SRC_ALPHA                 = 0x0303,
+    GL_DST_ALPHA                           = 0x0304,
+    GL_ONE_MINUS_DST_ALPHA                 = 0x0305,
+    GL_DST_COLOR                           = 0x0306,
+    GL_ONE_MINUS_DST_COLOR                 = 0x0307,
+    GL_SRC_ALPHA_SATURATE                  = 0x0308,
+    GL_CONSTANT_COLOR                      = 0x8001,
+    GL_ONE_MINUS_CONSTANT_COLOR            = 0x8002,
+    GL_CONSTANT_ALPHA                      = 0x8003,
+    GL_ONE_MINUS_CONSTANT_ALPHA            = 0x8004,
+
+    // Render Mode
+    GL_FEEDBACK                            = 0x1C01,
+    GL_RENDER                              = 0x1C00,
+    GL_SELECT                              = 0x1C02,
+
+    // Feedback
+    GL_2D                                  = 0x0600,
+    GL_3D                                  = 0x0601,
+    GL_3D_COLOR                            = 0x0602,
+    GL_3D_COLOR_TEXTURE                    = 0x0603,
+    GL_4D_COLOR_TEXTURE                    = 0x0604,
+    GL_POINT_TOKEN                         = 0x0701,
+    GL_LINE_TOKEN                          = 0x0702,
+    GL_LINE_RESET_TOKEN                    = 0x0707,
+    GL_POLYGON_TOKEN                       = 0x0703,
+    GL_BITMAP_TOKEN                        = 0x0704,
+    GL_DRAW_PIXEL_TOKEN                    = 0x0705,
+    GL_COPY_PIXEL_TOKEN                    = 0x0706,
+    GL_PASS_THROUGH_TOKEN                  = 0x0700,
+    GL_FEEDBACK_BUFFER_POINTER             = 0x0DF0,
+    GL_FEEDBACK_BUFFER_SIZE                = 0x0DF1,
+    GL_FEEDBACK_BUFFER_TYPE                = 0x0DF2,
+
+    // Selection
+    GL_SELECTION_BUFFER_POINTER            = 0x0DF3,
+    GL_SELECTION_BUFFER_SIZE               = 0x0DF4,
+
+    // Fog
+    GL_FOG                                 = 0x0B60,
+    GL_FOG_MODE                            = 0x0B65,
+    GL_FOG_DENSITY                         = 0x0B62,
+    GL_FOG_COLOR                           = 0x0B66,
+    GL_FOG_INDEX                           = 0x0B61,
+    GL_FOG_START                           = 0x0B63,
+    GL_FOG_END                             = 0x0B64,
+    GL_LINEAR                              = 0x2601,
+    GL_EXP                                 = 0x0800,
+    GL_EXP2                                = 0x0801,
+
+    // Logic Ops
+    GL_LOGIC_OP                            = 0x0BF1,
+    GL_INDEX_LOGIC_OP                      = 0x0BF1,
+    GL_COLOR_LOGIC_OP                      = 0x0BF2,
+    GL_LOGIC_OP_MODE                       = 0x0BF0,
+    GL_CLEAR                               = 0x1500,
+    GL_SET                                 = 0x150F,
+    GL_COPY                                = 0x1503,
+    GL_COPY_INVERTED                       = 0x150C,
+    GL_NOOP                                = 0x1505,
+    GL_INVERT                              = 0x150A,
+    GL_AND                                 = 0x1501,
+    GL_NAND                                = 0x150E,
+    GL_OR                                  = 0x1507,
+    GL_NOR                                 = 0x1508,
+    GL_XOR                                 = 0x1506,
+    GL_EQUIV                               = 0x1509,
+    GL_AND_REVERSE                         = 0x1502,
+    GL_AND_INVERTED                        = 0x1504,
+    GL_OR_REVERSE                          = 0x150B,
+    GL_OR_INVERTED                         = 0x150D,
+
+    // Stencil
+    GL_STENCIL_TEST                        = 0x0B90,
+    GL_STENCIL_WRITEMASK                   = 0x0B98,
+    GL_STENCIL_BITS                        = 0x0D57,
+    GL_STENCIL_FUNC                        = 0x0B92,
+    GL_STENCIL_VALUE_MASK                  = 0x0B93,
+    GL_STENCIL_REF                         = 0x0B97,
+    GL_STENCIL_FAIL                        = 0x0B94,
+    GL_STENCIL_PASS_DEPTH_PASS             = 0x0B96,
+    GL_STENCIL_PASS_DEPTH_FAIL             = 0x0B95,
+    GL_STENCIL_CLEAR_VALUE                 = 0x0B91,
+    GL_STENCIL_INDEX                       = 0x1901,
+    GL_KEEP                                = 0x1E00,
+    GL_REPLACE                             = 0x1E01,
+    GL_INCR                                = 0x1E02,
+    GL_DECR                                = 0x1E03,
+
+    // Buffers, Pixel Drawing/Reading
+    GL_NONE                                = 0x0,
+    GL_LEFT                                = 0x0406,
+    GL_RIGHT                               = 0x0407,
+    GL_FRONT_LEFT                          = 0x0400,
+    GL_FRONT_RIGHT                         = 0x0401,
+    GL_BACK_LEFT                           = 0x0402,
+    GL_BACK_RIGHT                          = 0x0403,
+    GL_AUX0                                = 0x0409,
+    GL_AUX1                                = 0x040A,
+    GL_AUX2                                = 0x040B,
+    GL_AUX3                                = 0x040C,
+    GL_COLOR_INDEX                         = 0x1900,
+    GL_RED                                 = 0x1903,
+    GL_GREEN                               = 0x1904,
+    GL_BLUE                                = 0x1905,
+    GL_ALPHA                               = 0x1906,
+    GL_LUMINANCE                           = 0x1909,
+    GL_LUMINANCE_ALPHA                     = 0x190A,
+    GL_ALPHA_BITS                          = 0x0D55,
+    GL_RED_BITS                            = 0x0D52,
+    GL_GREEN_BITS                          = 0x0D53,
+    GL_BLUE_BITS                           = 0x0D54,
+    GL_INDEX_BITS                          = 0x0D51,
+    GL_SUBPIXEL_BITS                       = 0x0D50,
+    GL_AUX_BUFFERS                         = 0x0C00,
+    GL_READ_BUFFER                         = 0x0C02,
+    GL_DRAW_BUFFER                         = 0x0C01,
+    GL_DOUBLEBUFFER                        = 0x0C32,
+    GL_STEREO                              = 0x0C33,
+    GL_BITMAP                              = 0x1A00,
+    GL_COLOR                               = 0x1800,
+    GL_DEPTH                               = 0x1801,
+    GL_STENCIL                             = 0x1802,
+    GL_DITHER                              = 0x0BD0,
+    GL_RGB                                 = 0x1907,
+    GL_RGBA                                = 0x1908,
+
+    // Implementation limits
+    GL_MAX_LIST_NESTING                    = 0x0B31,
+    GL_MAX_ATTRIB_STACK_DEPTH              = 0x0D35,
+    GL_MAX_MODELVIEW_STACK_DEPTH           = 0x0D36,
+    GL_MAX_NAME_STACK_DEPTH                = 0x0D37,
+    GL_MAX_PROJECTION_STACK_DEPTH          = 0x0D38,
+    GL_MAX_TEXTURE_STACK_DEPTH             = 0x0D39,
+    GL_MAX_EVAL_ORDER                      = 0x0D30,
+    GL_MAX_LIGHTS                          = 0x0D31,
+    GL_MAX_CLIP_PLANES                     = 0x0D32,
+    GL_MAX_TEXTURE_SIZE                    = 0x0D33,
+    GL_MAX_PIXEL_MAP_TABLE                 = 0x0D34,
+    GL_MAX_VIEWPORT_DIMS                   = 0x0D3A,
+    GL_MAX_CLIENT_ATTRIB_STACK_DEPTH       = 0x0D3B,
+
+    // Gets
+    GL_ATTRIB_STACK_DEPTH                  = 0x0BB0,
+    GL_CLIENT_ATTRIB_STACK_DEPTH           = 0x0BB1,
+    GL_COLOR_CLEAR_VALUE                   = 0x0C22,
+    GL_COLOR_WRITEMASK                     = 0x0C23,
+    GL_CURRENT_INDEX                       = 0x0B01,
+    GL_CURRENT_COLOR                       = 0x0B00,
+    GL_CURRENT_NORMAL                      = 0x0B02,
+    GL_CURRENT_RASTER_COLOR                = 0x0B04,
+    GL_CURRENT_RASTER_DISTANCE             = 0x0B09,
+    GL_CURRENT_RASTER_INDEX                = 0x0B05,
+    GL_CURRENT_RASTER_POSITION             = 0x0B07,
+    GL_CURRENT_RASTER_TEXTURE_COORDS       = 0x0B06,
+    GL_CURRENT_RASTER_POSITION_VALID       = 0x0B08,
+    GL_CURRENT_TEXTURE_COORDS              = 0x0B03,
+    GL_INDEX_CLEAR_VALUE                   = 0x0C20,
+    GL_INDEX_MODE                          = 0x0C30,
+    GL_INDEX_WRITEMASK                     = 0x0C21,
+    GL_MODELVIEW_MATRIX                    = 0x0BA6,
+    GL_MODELVIEW_STACK_DEPTH               = 0x0BA3,
+    GL_NAME_STACK_DEPTH                    = 0x0D70,
+    GL_PROJECTION_MATRIX                   = 0x0BA7,
+    GL_PROJECTION_STACK_DEPTH              = 0x0BA4,
+    GL_RENDER_MODE                         = 0x0C40,
+    GL_RGBA_MODE                           = 0x0C31,
+    GL_TEXTURE_MATRIX                      = 0x0BA8,
+    GL_TEXTURE_STACK_DEPTH                 = 0x0BA5,
+    GL_VIEWPORT                            = 0x0BA2,
+
+    // Evaluators
+    GL_AUTO_NORMAL                         = 0x0D80,
+    GL_MAP1_COLOR_4                        = 0x0D90,
+    GL_MAP1_GRID_DOMAIN                    = 0x0DD0,
+    GL_MAP1_GRID_SEGMENTS                  = 0x0DD1,
+    GL_MAP1_INDEX                          = 0x0D91,
+    GL_MAP1_NORMAL                         = 0x0D92,
+    GL_MAP1_TEXTURE_COORD_1                = 0x0D93,
+    GL_MAP1_TEXTURE_COORD_2                = 0x0D94,
+    GL_MAP1_TEXTURE_COORD_3                = 0x0D95,
+    GL_MAP1_TEXTURE_COORD_4                = 0x0D96,
+    GL_MAP1_VERTEX_3                       = 0x0D97,
+    GL_MAP1_VERTEX_4                       = 0x0D98,
+    GL_MAP2_COLOR_4                        = 0x0DB0,
+    GL_MAP2_GRID_DOMAIN                    = 0x0DD2,
+    GL_MAP2_GRID_SEGMENTS                  = 0x0DD3,
+    GL_MAP2_INDEX                          = 0x0DB1,
+    GL_MAP2_NORMAL                         = 0x0DB2,
+    GL_MAP2_TEXTURE_COORD_1                = 0x0DB3,
+    GL_MAP2_TEXTURE_COORD_2                = 0x0DB4,
+    GL_MAP2_TEXTURE_COORD_3                = 0x0DB5,
+    GL_MAP2_TEXTURE_COORD_4                = 0x0DB6,
+    GL_MAP2_VERTEX_3                       = 0x0DB7,
+    GL_MAP2_VERTEX_4                       = 0x0DB8,
+    GL_COEFF                               = 0x0A00,
+    GL_DOMAIN                              = 0x0A02,
+    GL_ORDER                               = 0x0A01,
+
+    // Hints
+    GL_FOG_HINT                            = 0x0C54,
+    GL_LINE_SMOOTH_HINT                    = 0x0C52,
+    GL_PERSPECTIVE_CORRECTION_HINT         = 0x0C50,
+    GL_POINT_SMOOTH_HINT                   = 0x0C51,
+    GL_POLYGON_SMOOTH_HINT                 = 0x0C53,
+    GL_DONT_CARE                           = 0x1100,
+    GL_FASTEST                             = 0x1101,
+    GL_NICEST                              = 0x1102,
+
+    // Scissor box
+    GL_SCISSOR_TEST                        = 0x0C11,
+    GL_SCISSOR_BOX                         = 0x0C10,
+
+    // Pixel Mode / Transfer
+    GL_MAP_COLOR                           = 0x0D10,
+    GL_MAP_STENCIL                         = 0x0D11,
+    GL_INDEX_SHIFT                         = 0x0D12,
+    GL_INDEX_OFFSET                        = 0x0D13,
+    GL_RED_SCALE                           = 0x0D14,
+    GL_RED_BIAS                            = 0x0D15,
+    GL_GREEN_SCALE                         = 0x0D18,
+    GL_GREEN_BIAS                          = 0x0D19,
+    GL_BLUE_SCALE                          = 0x0D1A,
+    GL_BLUE_BIAS                           = 0x0D1B,
+    GL_ALPHA_SCALE                         = 0x0D1C,
+    GL_ALPHA_BIAS                          = 0x0D1D,
+    GL_DEPTH_SCALE                         = 0x0D1E,
+    GL_DEPTH_BIAS                          = 0x0D1F,
+    GL_PIXEL_MAP_S_TO_S_SIZE               = 0x0CB1,
+    GL_PIXEL_MAP_I_TO_I_SIZE               = 0x0CB0,
+    GL_PIXEL_MAP_I_TO_R_SIZE               = 0x0CB2,
+    GL_PIXEL_MAP_I_TO_G_SIZE               = 0x0CB3,
+    GL_PIXEL_MAP_I_TO_B_SIZE               = 0x0CB4,
+    GL_PIXEL_MAP_I_TO_A_SIZE               = 0x0CB5,
+    GL_PIXEL_MAP_R_TO_R_SIZE               = 0x0CB6,
+    GL_PIXEL_MAP_G_TO_G_SIZE               = 0x0CB7,
+    GL_PIXEL_MAP_B_TO_B_SIZE               = 0x0CB8,
+    GL_PIXEL_MAP_A_TO_A_SIZE               = 0x0CB9,
+    GL_PIXEL_MAP_S_TO_S                    = 0x0C71,
+    GL_PIXEL_MAP_I_TO_I                    = 0x0C70,
+    GL_PIXEL_MAP_I_TO_R                    = 0x0C72,
+    GL_PIXEL_MAP_I_TO_G                    = 0x0C73,
+    GL_PIXEL_MAP_I_TO_B                    = 0x0C74,
+    GL_PIXEL_MAP_I_TO_A                    = 0x0C75,
+    GL_PIXEL_MAP_R_TO_R                    = 0x0C76,
+    GL_PIXEL_MAP_G_TO_G                    = 0x0C77,
+    GL_PIXEL_MAP_B_TO_B                    = 0x0C78,
+    GL_PIXEL_MAP_A_TO_A                    = 0x0C79,
+    GL_PACK_ALIGNMENT                      = 0x0D05,
+    GL_PACK_LSB_FIRST                      = 0x0D01,
+    GL_PACK_ROW_LENGTH                     = 0x0D02,
+    GL_PACK_SKIP_PIXELS                    = 0x0D04,
+    GL_PACK_SKIP_ROWS                      = 0x0D03,
+    GL_PACK_SWAP_BYTES                     = 0x0D00,
+    GL_UNPACK_ALIGNMENT                    = 0x0CF5,
+    GL_UNPACK_LSB_FIRST                    = 0x0CF1,
+    GL_UNPACK_ROW_LENGTH                   = 0x0CF2,
+    GL_UNPACK_SKIP_PIXELS                  = 0x0CF4,
+    GL_UNPACK_SKIP_ROWS                    = 0x0CF3,
+    GL_UNPACK_SWAP_BYTES                   = 0x0CF0,
+    GL_ZOOM_X                              = 0x0D16,
+    GL_ZOOM_Y                              = 0x0D17,
+
+    // Texture mapping
+    GL_TEXTURE_ENV                         = 0x2300,
+    GL_TEXTURE_ENV_MODE                    = 0x2200,
+    GL_TEXTURE_1D                          = 0x0DE0,
+    GL_TEXTURE_2D                          = 0x0DE1,
+    GL_TEXTURE_WRAP_S                      = 0x2802,
+    GL_TEXTURE_WRAP_T                      = 0x2803,
+    GL_TEXTURE_MAG_FILTER                  = 0x2800,
+    GL_TEXTURE_MIN_FILTER                  = 0x2801,
+    GL_TEXTURE_ENV_COLOR                   = 0x2201,
+    GL_TEXTURE_GEN_S                       = 0x0C60,
+    GL_TEXTURE_GEN_T                       = 0x0C61,
+    GL_TEXTURE_GEN_MODE                    = 0x2500,
+    GL_TEXTURE_BORDER_COLOR                = 0x1004,
+    GL_TEXTURE_WIDTH                       = 0x1000,
+    GL_TEXTURE_HEIGHT                      = 0x1001,
+    GL_TEXTURE_BORDER                      = 0x1005,
+    GL_TEXTURE_COMPONENTS                  = 0x1003,
+    GL_TEXTURE_RED_SIZE                    = 0x805C,
+    GL_TEXTURE_GREEN_SIZE                  = 0x805D,
+    GL_TEXTURE_BLUE_SIZE                   = 0x805E,
+    GL_TEXTURE_ALPHA_SIZE                  = 0x805F,
+    GL_TEXTURE_LUMINANCE_SIZE              = 0x8060,
+    GL_TEXTURE_INTENSITY_SIZE              = 0x8061,
+    GL_NEAREST_MIPMAP_NEAREST              = 0x2700,
+    GL_NEAREST_MIPMAP_LINEAR               = 0x2702,
+    GL_LINEAR_MIPMAP_NEAREST               = 0x2701,
+    GL_LINEAR_MIPMAP_LINEAR                = 0x2703,
+    GL_OBJECT_LINEAR                       = 0x2401,
+    GL_OBJECT_PLANE                        = 0x2501,
+    GL_EYE_LINEAR                          = 0x2400,
+    GL_EYE_PLANE                           = 0x2502,
+    GL_SPHERE_MAP                          = 0x2402,
+    GL_DECAL                               = 0x2101,
+    GL_MODULATE                            = 0x2100,
+    GL_NEAREST                             = 0x2600,
+    GL_REPEAT                              = 0x2901,
+    GL_CLAMP                               = 0x2900,
+    GL_S                                   = 0x2000,
+    GL_T                                   = 0x2001,
+    GL_R                                   = 0x2002,
+    GL_Q                                   = 0x2003,
+    GL_TEXTURE_GEN_R                       = 0x0C62,
+    GL_TEXTURE_GEN_Q                       = 0x0C63,
+
+    // Utility
+    GL_VENDOR                              = 0x1F00,
+    GL_RENDERER                            = 0x1F01,
+    GL_VERSION                             = 0x1F02,
+    GL_EXTENSIONS                          = 0x1F03,
+
+    // Errors
+    GL_NO_ERROR                            = 0x0,
+    GL_INVALID_VALUE                       = 0x0501,
+    GL_INVALID_ENUM                        = 0x0500,
+    GL_INVALID_OPERATION                   = 0x0502,
+    GL_STACK_OVERFLOW                      = 0x0503,
+    GL_STACK_UNDERFLOW                     = 0x0504,
+    GL_OUT_OF_MEMORY                       = 0x0505,
+}
+
+// glPush/PopAttrib bits
+enum : GLuint {
+    GL_CURRENT_BIT                         = 0x00000001,
+    GL_POINT_BIT                           = 0x00000002,
+    GL_LINE_BIT                            = 0x00000004,
+    GL_POLYGON_BIT                         = 0x00000008,
+    GL_POLYGON_STIPPLE_BIT                 = 0x00000010,
+    GL_PIXEL_MODE_BIT                      = 0x00000020,
+    GL_LIGHTING_BIT                        = 0x00000040,
+    GL_FOG_BIT                             = 0x00000080,
+    GL_DEPTH_BUFFER_BIT                    = 0x00000100,
+    GL_ACCUM_BUFFER_BIT                    = 0x00000200,
+    GL_STENCIL_BUFFER_BIT                  = 0x00000400,
+    GL_VIEWPORT_BIT                        = 0x00000800,
+    GL_TRANSFORM_BIT                       = 0x00001000,
+    GL_ENABLE_BIT                          = 0x00002000,
+    GL_COLOR_BUFFER_BIT                    = 0x00004000,
+    GL_HINT_BIT                            = 0x00008000,
+    GL_EVAL_BIT                            = 0x00010000,
+    GL_LIST_BIT                            = 0x00020000,
+    GL_TEXTURE_BIT                         = 0x00040000,
+    GL_SCISSOR_BIT                         = 0x00080000,
+    GL_ALL_ATTRIB_BITS                     = 0x000FFFFF,
+}
+
+// gl 1.1
+enum : GLenum {
+    GL_PROXY_TEXTURE_1D                    = 0x8063,
+    GL_PROXY_TEXTURE_2D                    = 0x8064,
+    GL_TEXTURE_PRIORITY                    = 0x8066,
+    GL_TEXTURE_RESIDENT                    = 0x8067,
+    GL_TEXTURE_BINDING_1D                  = 0x8068,
+    GL_TEXTURE_BINDING_2D                  = 0x8069,
+    GL_TEXTURE_INTERNAL_FORMAT             = 0x1003,
+    GL_ALPHA4                              = 0x803B,
+    GL_ALPHA8                              = 0x803C,
+    GL_ALPHA12                             = 0x803D,
+    GL_ALPHA16                             = 0x803E,
+    GL_LUMINANCE4                          = 0x803F,
+    GL_LUMINANCE8                          = 0x8040,
+    GL_LUMINANCE12                         = 0x8041,
+    GL_LUMINANCE16                         = 0x8042,
+    GL_LUMINANCE4_ALPHA4                   = 0x8043,
+    GL_LUMINANCE6_ALPHA2                   = 0x8044,
+    GL_LUMINANCE8_ALPHA8                   = 0x8045,
+    GL_LUMINANCE12_ALPHA4                  = 0x8046,
+    GL_LUMINANCE12_ALPHA12                 = 0x8047,
+    GL_LUMINANCE16_ALPHA16                 = 0x8048,
+    GL_INTENSITY                           = 0x8049,
+    GL_INTENSITY4                          = 0x804A,
+    GL_INTENSITY8                          = 0x804B,
+    GL_INTENSITY12                         = 0x804C,
+    GL_INTENSITY16                         = 0x804D,
+    GL_R3_G3_B2                            = 0x2A10,
+    GL_RGB4                                = 0x804F,
+    GL_RGB5                                = 0x8050,
+    GL_RGB8                                = 0x8051,
+    GL_RGB10                               = 0x8052,
+    GL_RGB12                               = 0x8053,
+    GL_RGB16                               = 0x8054,
+    GL_RGBA2                               = 0x8055,
+    GL_RGBA4                               = 0x8056,
+    GL_RGB5_A1                             = 0x8057,
+    GL_RGBA8                               = 0x8058,
+    GL_RGB10_A2                            = 0x8059,
+    GL_RGBA12                              = 0x805A,
+    GL_RGBA16                              = 0x805B,
+}
+
+enum : GLuint {
+    GL_CLIENT_PIXEL_STORE_BIT              = 0x00000001,
+    GL_CLIENT_VERTEX_ARRAY_BIT             = 0x00000002,
+    GL_ALL_CLIENT_ATTRIB_BITS              = 0xFFFFFFFF,
+    GL_CLIENT_ALL_ATTRIB_BITS              = 0xFFFFFFFF,
+}
--- a/demos/sdl.d	Fri Oct 19 07:45:35 2007 +0200
+++ b/demos/sdl.d	Fri Oct 19 15:16:11 2007 +0200
@@ -1,7 +1,6 @@
 module sdl;
 
-version(build)
-    pragma(link,"SDL");
+version(build) pragma(link,"SDL");
 
 extern(C):
 struct SDL_Rect {
@@ -43,4 +42,46 @@
     SDL_DOUBLEBUF=0x40000000,
     SDL_FULLSCREEN=0x80000000
 }
+enum {
+    SDL_GL_RED_SIZE,
+    SDL_GL_GREEN_SIZE,
+    SDL_GL_BLUE_SIZE,
+    SDL_GL_ALPHA_SIZE,
+    SDL_GL_BUFFER_SIZE,
+    SDL_GL_DOUBLEBUFFER,
+    SDL_GL_DEPTH_SIZE,
+    SDL_GL_STENCIL_SIZE,
+    SDL_GL_ACCUM_RED_SIZE,
+    SDL_GL_ACCUM_GREEN_SIZE,
+    SDL_GL_ACCUM_BLUE_SIZE,
+    SDL_GL_ACCUM_ALPHA_SIZE,
+    SDL_GL_STEREO,
+    SDL_GL_MULTISAMPLEBUFFERS,
+    SDL_GL_MULTISAMPLESAMPLES,
+    SDL_GL_ACCELERATED_VISUAL,
+    SDL_GL_SWAP_CONTROL
+}
+int SDL_GL_LoadLibrary(char*);
+void* SDL_GL_GetProcAddress(char*);
+int SDL_GL_SetAttribute(int,int);
+int SDL_GL_GetAttribute(int,int*);
+void SDL_GL_SwapBuffers();
+void SDL_GL_UpdateRects(int,SDL_Rect*);
+void SDL_GL_Lock();
+void SDL_GL_Unlock();
+enum : uint {
+    SDL_INIT_TIMER=0x00000001,
+    SDL_INIT_AUDIO=0x00000010,
+    SDL_INIT_VIDEO=0x00000020,
+    SDL_INIT_CDROM=0x00000100,
+    SDL_INIT_JOYSTICK=0x00000200,
+    SDL_INIT_NOPARACHUTE=0x00100000,
+    SDL_INIT_EVENTTHREAD=0x00200000,
+    SDL_INIT_EVERYTHING=0x0000FFFF
+}
 
+int SDL_Init(uint);
+int SDL_InitSubSystem(uint);
+int SDL_QuitSubSystem(uint);
+int SDL_WasInit(uint);
+void SDL_Quit();
--- a/dmd/expression.c	Fri Oct 19 07:45:35 2007 +0200
+++ b/dmd/expression.c	Fri Oct 19 15:16:11 2007 +0200
@@ -7412,7 +7412,8 @@
     typeCombine(sc);
     e1->checkIntegral();
     e2 = e2->checkIntegral();
-    e2 = e2->castTo(sc, Type::tshiftcnt);
+    //e2 = e2->castTo(sc, Type::tshiftcnt);
+    e2 = e2->castTo(sc, e1->type); // LLVMDC
     return this;
 }
 
@@ -7440,7 +7441,8 @@
     typeCombine(sc);
     e1->checkIntegral();
     e2 = e2->checkIntegral();
-    e2 = e2->castTo(sc, Type::tshiftcnt);
+    //e2 = e2->castTo(sc, Type::tshiftcnt);
+    e2 = e2->castTo(sc, e1->type); // LLVMDC
     return this;
 }
 
@@ -7468,7 +7470,8 @@
     typeCombine(sc);
     e1->checkIntegral();
     e2 = e2->checkIntegral();
-    e2 = e2->castTo(sc, Type::tshiftcnt);
+    //e2 = e2->castTo(sc, Type::tshiftcnt);
+    e2 = e2->castTo(sc, e1->type); // LLVMDC
     return this;
 }
 
@@ -7941,7 +7944,8 @@
 	e1 = e1->checkIntegral();
 	e2 = e2->checkIntegral();
 	e1 = e1->integralPromotions(sc);
-	e2 = e2->castTo(sc, Type::tshiftcnt);
+	//e2 = e2->castTo(sc, Type::tshiftcnt);
+    e2 = e2->castTo(sc, e1->type); // LLVMDC
 	type = e1->type;
     }
     return this;
@@ -7965,7 +7969,8 @@
 	e1 = e1->checkIntegral();
 	e2 = e2->checkIntegral();
 	e1 = e1->integralPromotions(sc);
-	e2 = e2->castTo(sc, Type::tshiftcnt);
+	//e2 = e2->castTo(sc, Type::tshiftcnt);
+    e2 = e2->castTo(sc, e1->type); // LLVMDC
 	type = e1->type;
     }
     return this;
@@ -7989,7 +7994,8 @@
 	e1 = e1->checkIntegral();
 	e2 = e2->checkIntegral();
 	e1 = e1->integralPromotions(sc);
-	e2 = e2->castTo(sc, Type::tshiftcnt);
+	//e2 = e2->castTo(sc, Type::tshiftcnt);
+    e2 = e2->castTo(sc, e1->type); // LLVMDC
 	type = e1->type;
     }
     return this;
--- a/gen/toir.c	Fri Oct 19 07:45:35 2007 +0200
+++ b/gen/toir.c	Fri Oct 19 15:16:11 2007 +0200
@@ -2250,10 +2250,14 @@
     LOG_SCOPE; \
     elem* u = e1->toElem(p); \
     elem* v = e2->toElem(p); \
-    llvm::Value* tmp = llvm::BinaryOperator::create(llvm::Instruction::Y, u->getValue(), v->getValue(), "tmp", p->scopebb()); \
-    Logger::cout() << *tmp << '|' << *u->mem << '\n'; \
+    llvm::Value* uval = u->getValue(); \
+    assert(uval); \
+    llvm::Value* vval = v->getValue(); \
+    assert(vval); \
+    llvm::Value* tmp = llvm::BinaryOperator::create(llvm::Instruction::Y, uval, vval, "tmp", p->scopebb()); \
     if (u->mem == 0) \
         LLVM_DtoGiveArgumentStorage(u); \
+    Logger::cout() << *tmp << '|' << *u->mem << '\n'; \
     new llvm::StoreInst(LLVM_DtoPointedType(u->mem, tmp), u->mem, p->scopebb()); \
     delete u; \
     delete v; \
--- a/lphobos/internal/objectimpl.d	Fri Oct 19 07:45:35 2007 +0200
+++ b/lphobos/internal/objectimpl.d	Fri Oct 19 15:16:11 2007 +0200
@@ -136,7 +136,6 @@
     //return cast(int)cast(void *)this - cast(int)cast(void *)o;
 
     assert(0, "need opCmp for class <no classinfo yet>");
-    return 0;
     //throw new Error("need opCmp for class " ~ this.classinfo.name);
     }
 
@@ -220,15 +219,15 @@
      * Returns:
      *  null if failed
      */
-    static Object factory(char[] classname)
+    /+static Object factory(char[] classname)
     {
-    /+auto ci = ClassInfo.find(classname);
+    auto ci = ClassInfo.find(classname);
     if (ci)
     {
         return ci.create();
+    }
+    return null;
     }+/
-    return null;
-    }
 }
 
 /+
--- a/lphobos/std/intrinsic.d	Fri Oct 19 07:45:35 2007 +0200
+++ b/lphobos/std/intrinsic.d	Fri Oct 19 15:16:11 2007 +0200
@@ -207,7 +207,7 @@
 	becomes byte 0.
  */
 version (LLVM)
-pragma(LLVM_internal, "intrinsic", "llvm.bswap.i32.i32")
+pragma(LLVM_internal, "intrinsic", "llvm.bswap.i32")
     uint bswap(uint val);
 else
     uint bswap(uint v);
--- a/runalltests.d	Fri Oct 19 07:45:35 2007 +0200
+++ b/runalltests.d	Fri Oct 19 15:16:11 2007 +0200
@@ -39,4 +39,3 @@
     writefln(contents.length - bad.length - badrun.length, '/', contents.length, " of the tests passed");
     return ret;
 }
-
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/bug16.d	Fri Oct 19 15:16:11 2007 +0200
@@ -0,0 +1,11 @@
+module bug16;
+
+void func(long val)
+{
+    val >>= 32;
+}
+
+void main()
+{
+    func(64L);
+}