Mercurial > projects > ldc
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; - } + }+/ } /+
--- 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);