D/ldc
1
0
Fork 0
mirror of https://github.com/xomboverlord/ldc.git synced 2026-01-11 18:33:14 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Removed demos/.

Browse Source 
These were last touched before the name change to LDC. Rest in peace.
This commit is contained in:
David Nadlinger
2011-12-04 19:37:26 +01:00
parent 6559246669
commit 018c47762e
10 changed files with 0 additions and 1933 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
demos/gl.d
View File

@@ -1,6 +0,0 @@
module gl;
public {
import gltypes;
import glfuncs;
}

406
demos/glfuncs.d
View File

@@ -1,406 +0,0 @@
/*
* 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*);

665
demos/gltypes.d
View File

@@ -1,665 +0,0 @@
/*
* 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,
}

474
demos/qd.d
View File

@@ -1,474 +0,0 @@
module qd;
alias char[] string;
extern(C) {
struct SDL_Rect {
short x, y;
ushort w, h;
}
struct SDL_PixelFormat {
//SDL_Palette *palette;
void *palette;
ubyte BitsPerPixel, BytesPerPixel, Rloss, Gloss, Bloss, Aloss, Rshift, Gshift, Bshift, Ashift;
uint Rmask, Gmask, Bmask, Amask, colorkey; ubyte alpha;
}
struct SDL_Surface {
uint flags;
SDL_PixelFormat *format;
int w, h;
ushort pitch;
void *pixels;
int offset;
void *hwdata;
SDL_Rect clip_rect;
uint unused;
uint locked;
void *map;
uint format_version;
int refcount;
}
uint SDL_MapRGBA(SDL_PixelFormat *format, ubyte r, ubyte g, ubyte b, ubyte a);
void SDL_GetRGBA(uint pixel, SDL_PixelFormat *fmt, ubyte *r, ubyte *g, ubyte *b, ubyte *a);
int SDL_LockSurface(SDL_Surface *);
void SDL_UnlockSurface(SDL_Surface *);
SDL_Surface * SDL_SetVideoMode(int width, int height, int bpp, uint flags);
SDL_Surface *SDL_CreateRGBSurface(uint flags, int width, int height, int depth, uint Rmask=0, uint Gmask=0, uint Bmask=0, uint Amask=0);
int SDL_Flip(SDL_Surface *);
void SDL_UpdateRect (SDL_Surface *screen, int x, int y, uint w, uint h);
int SDL_UpperBlit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect);
alias SDL_UpperBlit SDL_BlitSurface;
int SDL_SetAlpha(SDL_Surface *surface, uint flags, ubyte alpha);
int SDL_SetColorKey(SDL_Surface *surface, uint flag, uint key);
int SDL_FillRect(SDL_Surface *dst, SDL_Rect *dstrect, uint color);
const uint SDL_SWSURFACE=0;
const uint SDL_HWSURFACE=1;
const uint SDL_DOUBLEBUF=0x40000000;
const uint SDL_FULLSCREEN=0x80000000;
const uint SDL_SRCALPHA=0x00010000;
const uint SDL_SRCCOLORKEY=0x00001000;
void SDL_Delay(uint ms);
uint SDL_GetTicks();
enum SDLKey {
Unknown = 0, First = 0,
Escape = 27,
LCtrl = 306,
}
enum SDLMod {
KMOD_NONE = 0x0000,
KMOD_LSHIFT= 0x0001, KMOD_RSHIFT= 0x0002,
KMOD_LCTRL = 0x0040, KMOD_RCTRL = 0x0080, KMOD_CTRL = 0x00C0,
KMOD_LALT = 0x0100, KMOD_RALT = 0x0200, KMOD_ALT = 0x0300,
KMOD_LMETA = 0x0400, KMOD_RMETA = 0x0800,
KMOD_NUM = 0x1000, KMOD_CAPS = 0x2000, KMOD_MODE = 0x4000,
KMOD_RESERVED = 0x8000
};
struct SDL_keysym { ubyte scancode; SDLKey sym; SDLMod mod; ushort unicode; }
enum SDL_EventType : ubyte {
NoEvent=0, Active, KeyDown, KeyUp,
MouseMotion, MouseButtonDown, MouseButtonUp,
JoyAxisMotion, JoyBallMotion, JoyHatMotion, JoyButtonDown, JoyButtonUp,
Quit, SysWMEvent
}
union SDL_Event {
SDL_EventType type;
struct Active { SDL_EventType type, gain, state; }; Active active;
struct Key { SDL_EventType type, which, state; SDL_keysym keysym; }; Key key;
struct Motion { SDL_EventType type, which, state; ushort x, y; short xrel, yrel; }; Motion motion;
struct Button { SDL_EventType type, which, button, state; ushort x, y; }; Button button;
struct Jaxis { SDL_EventType type, which, axis; short value; }; Jaxis jaxis;
struct Jball { SDL_EventType type, which, ball; short xrel, yrel; }; Jball jball;
struct Jhat { SDL_EventType type, which, hat, value; }; Jhat jhat;
struct Jbutton { SDL_EventType type, which, button, state; }; Jbutton jbutton;
struct Resize { SDL_EventType type; int w, h; }; Resize resize;
struct Expose { SDL_EventType type; }; Expose expose;
struct Quit { SDL_EventType type; }; Quit quit;
struct User { SDL_EventType type; int code; void *data1, data2; }; User user;
struct Syswm { SDL_EventType type; void *msg; }; Syswm syswm;
}
int SDL_PollEvent(SDL_Event *event);
}
SDL_Surface *display;
void putpixel32(int x, int y, ubyte[4] col) {
uint *bufp = cast(uint *)display.pixels + y*display.pitch/4 + x;
*bufp = SDL_MapRGBA(display.format, col[0], col[1], col[2], col[3]);
}
void putpixel32(int x, int y, ubyte[3] col) {
uint *bufp = cast(uint *)display.pixels + y*display.pitch/4 + x;
*bufp = SDL_MapRGBA(display.format, col[0], col[1], col[2], 0);
}
void getpixel32(int x, int y, ubyte[4] *col) {
uint *bufp = cast(uint *)display.pixels + y*display.pitch/4 + x;
SDL_GetRGBA(*bufp, display.format, &(*col)[0], &(*col)[1], &(*col)[2], &(*col)[3]);
}
align(1)
struct rgb {
ubyte[3] values;
ubyte r() { return values[0]; }
ubyte g() { return values[1]; }
ubyte b() { return values[2]; }
rgb opCat(rgb other) {
rgb res;
foreach (id, ref v; res.values) v=cast(ubyte)((values[id]+other.values[id])/2);
return res;
}
bool opEquals(rgb r) {
return values == r.values;
}
}
void putpixel(int x, int y, ubyte[4] col) {
if ( (x<0) || (y<0) || (x!<display.w) || (y!<display.h) ) return;
putpixel32(x, y, col);
}
void hline(int x, int y, int w, rgb r) {
hline(x, y, w, SDL_MapRGBA(display.format, r.values[0], r.values[1], r.values[2], 0));
}
void hline(int x, int y, int w, uint c) {
if ( (y<0) || (y!<display.h) ) return;
if (x<0) { w+=x; x=0; }
if (w<0) return;
if ( (x+w) !<display.w) w=display.w-x-1;
auto cur = cast(uint *)display.pixels + y*display.pitch/4 + x;
foreach (ref value; cur[0..w+1]) value=c;
}
const rgb White={[255, 255, 255]};
const rgb Black={[0, 0, 0]};
const rgb Red={[255, 0, 0]};
const rgb Green={[0, 255, 0]};
const rgb Blue={[0, 0, 255]};
const rgb Yellow={[255, 255, 0]};
const rgb Cyan={[0, 255, 255]};
const rgb Purple={[255, 0, 255]};
rgb color=White;
rgb back=Black;
template failfind(U, T...) {
static if (T.length)
static if (is(T[0] == U)) static assert(false, "Duplicate "~U.stringof~" found!");
else const bool failfind=failfind!(U, T[1..$]);
else
const bool failfind=true;
}
template select(U, T...) {
static if(T.length)
static if (is(U == T[0])) { static if (failfind!(U, T[1..$])) { }; const int select = 0; }
else
static if (select!(U, T[1..$]) != -1)
const int select = 1 + select!(U, T[1..$]);
else
const int select = -1;
else
const int select = -1;
}
typedef rgb back_rgb;
back_rgb Back(rgb r) { return cast(back_rgb) r; }
back_rgb Back() { return cast(back_rgb) back; }
typedef rgb box_rgb;
box_rgb Box(rgb r) { return cast(box_rgb) r; }
box_rgb Box() { return cast(box_rgb) color; }
alias Back Fill;
bool doFlip=true;
void flip() { SDL_Flip(display); }
void flip(bool target) { doFlip=target; }
scope class groupDraws {
bool wasOn;
this() { wasOn=doFlip; flip=false; }
~this() { if (wasOn) { flip=true; flip; } }
}
void execParams(T...)(T params) {
const int bcol=select!(back_rgb, T);
static if (bcol != -1) back=cast(rgb) params[bcol];
const int col=select!(rgb, T);
static if (col != -1) color=params[col];
else static if (bcol != -1) color=back;
const int boxcol=select!(box_rgb, T);
static if (boxcol != -1) color=cast(rgb) params[boxcol];
}
void tintfill(int x1, int y1, int x2, int y2, rgb color) {
SDL_LockSurface(display);
scope(exit) { SDL_UnlockSurface(display); if (doFlip) flip; }
ubyte[4] c;
for (int x=x1; x<x2; ++x) {
for (int y=y1; y<y2; ++y) {
getpixel32(x, y, &c);
c[0]=cast(ubyte)(c[0]*178+color.r*77)>>8;
c[1]=cast(ubyte)(c[1]*178+color.g*77)>>8;
c[2]=cast(ubyte)(c[2]*178+color.b*77)>>8;
putpixel32(x, y, c);
}
}
}
void pset(T...)(int x, int y, T params) {
SDL_LockSurface(display);
scope(exit) { SDL_UnlockSurface(display); if (doFlip) flip; }
execParams(params);
putpixel32(x, y, color.values);
}
rgb pget(int x, int y) {
SDL_LockSurface(display);
scope(exit) SDL_UnlockSurface(display);
ubyte[4] c;
getpixel32(x, y, &c);
rgb res; res.values[]=c[0..3]; return res;
}
void swap(T)(ref T a, ref T b) { T c=a; a=b; b=c; }
T abs(T)(T a) { return (a<0) ? -a : a; }
void bresenham(bool countUp=true, bool steep=false)(int x0, int y0, int x1, int y1) {
auto deltax = x1 - x0, deltay = y1 - y0;
static if (steep) {
auto Δerror = cast(float)deltax / cast(float)deltay;
auto var2 = x0;
const string name="y";
} else {
auto Δerror = cast(float)deltay / cast(float)deltax;
auto var2 = y0;
const string name="x";
}
auto error = 0f;
ubyte[4] col; col[0..3]=color.values;
for (auto var1 = mixin(name~'0'); var1 <= mixin(name~'1'); ++var1) {
static if (steep) putpixel(var2, var1, col);
else putpixel(var1, var2, col);
error += Δerror;
if (abs(error) >= 1f) { static if (countUp) { var2++; error -= 1f; } else { var2--; error += 1f; }}
}
}
T max(T)(T a, T b) { return a>b?a:b; }
T min(T)(T a, T b) { return a<b?a:b; }
void line(T...)(int x0, int y0, int x1, int y1, T p) {
execParams(p);
static if (select!(back_rgb, T)!=-1) {
SDL_LockSurface(display);
scope(exit) { SDL_UnlockSurface(display); if (doFlip) flip; }
auto yend=max(y0, y1);
for (int y=min(y0, y1); y<=yend; ++y) {
hline(min(x0, x1), y, max(x0, x1)-min(x0, x1), back);
}
}
static if (select!(box_rgb, T)!=-1) {
line(x0, y0, x1, y0);
line(x1, y0, x1, y1);
line(x1, y1, x0, y1);
line(x0, y1, x0, y0);
}
static if (select!(box_rgb, T)+select!(back_rgb, T)==-2) {
SDL_LockSurface(display);
scope(exit) { SDL_UnlockSurface(display); if (doFlip) flip; }
bool steep = abs(y1 - y0) > abs(x1 - x0);
void turn() { swap(x0, x1); swap(y0, y1); }
if (steep) { if (y1 < y0) turn; }
else { if (x1 < x0) turn; }
bool stepUp=steep ? (x0 < x1) : (y0 < y1);
if (steep) {
if (stepUp) bresenham!(true, true)(x0, y0, x1, y1);
else bresenham!(false, true)(x0, y0, x1, y1);
} else {
if (stepUp) bresenham!(true, false)(x0, y0, x1, y1);
else bresenham!(false, false)(x0, y0, x1, y1);
}
}
}
import ldc.intrinsics;
alias llvm_sqrt_f32 sqrt;
alias llvm_sqrt_f64 sqrt;
version(X86)
{
alias llvm_sqrt_f80 sqrt;
}
else
{
static import tango.stdc.math;
real sqrt(real x)
{
return tango.stdc.math.sqrtl(x);
}
}
template circle_bresenham_pass(bool first) {
const string xy=(first?"x":"y");
const string yx=(first?"y":"x");
const string str="
auto x="~(first?"xradius":"0")~";
auto y="~(first?"0":"yradius")~";
auto xchange=yradius*yradius*"~(first?"(1-2*xradius)":"1")~";
auto ychange=xradius*xradius*"~(first?"1":"(1-2*yradius)")~";
auto error=0;
auto stopx="~(first?"y2square*xradius":"0")~";
auto stopy="~(first?"0":"x2square*yradius")~";
while (stopx"~(first?">=":"<=")~"stopy) {
putpixel(cx+x, cy+y, col);
putpixel(cx+x, cy-y, col);
putpixel(cx-x, cy+y, col);
putpixel(cx-x, cy-y, col);
"~yx~"++;
stop"~yx~"+="~xy~"2square;
error+="~yx~"change;
"~yx~"change+="~xy~"2square;
if ((2*error+"~xy~"change)>0) {
--"~xy~";
stop"~xy~"-="~yx~"2square;
error+="~xy~"change;
"~xy~"change+="~yx~"2square;
}
}
";
}
void circle(T...)(T t) {
static assert(T.length!<3, "Circle: Needs x, y and radius");
int cx=t[0], cy=t[1], xradius=t[2];
SDL_LockSurface(display);
scope(exit) { SDL_UnlockSurface(display); if (doFlip) flip; }
execParams(t[3..$]);
auto yradius=xradius;
if (xradius!>0) return;
static if (T.length>3 && is(T[3]: int)) yradius=t[3];
static if (select!(back_rgb, T) != -1) {
auto ratio=xradius*1f/yradius;
auto back_sdl=SDL_MapRGBA(display.format, back.values[0], back.values[1], back.values[2], 0);
for (int i=0; i<=yradius; ++i) {
ushort j=cast(ushort)(sqrt(cast(real)(yradius*yradius-i*i))*ratio);
hline(cx-j, cy+i, 2*j, back_sdl);
hline(cx-j, cy-i, 2*j, back_sdl);
}
}
auto x2square=2*xradius*xradius;
auto y2square=2*yradius*yradius;
ubyte[4] col; col[0..3]=color.values;
{ mixin(circle_bresenham_pass!(true).str); }
{ mixin(circle_bresenham_pass!(false).str); }
}
float distance(float x1, float y1, float x2, float y2) {
auto x=x1-x2, y=y1-y2;
return sqrt(x*x+y*y);
}
struct floodfill_node {
int x, y;
static floodfill_node opCall(int x, int y) {
floodfill_node res;
res.x=x; res.y=y;
return res;
}
}
void paint(T...)(int x, int y, T t) {
SDL_LockSurface(display);
scope(exit) { SDL_UnlockSurface(display); if (doFlip) flip; }
execParams(t);
bool border=true;
if (select!(back_rgb, T) == -1) {
back=pget(x, y);
border=false;
}
bool check(rgb r) {
if (border) return (r != back) && (r != color);
else return r == back;
}
if (back == color) throw new Exception("Having identical backgrounds and foregrounds will severely mess up floodfill.");
alias floodfill_node node;
node[] queue;
queue ~= node(x, y);
size_t count=0;
while (count<queue.length) {
scope(exit) count++;
with (queue[count]) {
if (check(pget(x, y))) {
int w=x, e=x;
if (w<display.w) do w++; while ((w<display.w) && check(pget(w, y)));
if (e>=0) do e--; while (e>=0 && check(pget(e, y)));
//SDL_Flip(display);
for (int i=e+1; i<w; ++i) {
putpixel32(i, y, color.values);
if (y && check(pget(i, y-1)) && ((i==w-1)||!check(pget(i+1, y-1)))) queue ~= node(i, y-1);
if ((y < display.h-1) && check(pget(i, y+1)) && ((i==w-1)||!check(pget(i+1, y+1)))) queue ~= node(i, y+1);
}
}
}
}
}
struct screen {
static {
void opCall(size_t w, size_t h) {
display = SDL_SetVideoMode(w, h, 32, SDL_SWSURFACE | SDL_DOUBLEBUF);
}
int width() { return display.w; }
int height() { return display.h; }
}
}
void cls(rgb fill=Black) { line(0, 0, display.w-1, display.h-1, Fill=fill); }
void events(void delegate(int, bool) key=null, void delegate(int, int, ubyte, bool) mouse=null) {
SDL_Event evt;
while (SDL_PollEvent(&evt)) {
switch (evt.type) {
case SDL_EventType.MouseMotion:
with (evt.motion) if (mouse) mouse(x, y, 0, false);
break;
case SDL_EventType.MouseButtonDown:
with (evt.button) if (mouse) mouse(x, y, button, true);
break;
case SDL_EventType.MouseButtonUp:
with (evt.button) if (mouse) mouse(x, y, button, false);
break;
case SDL_EventType.KeyDown:
if (key) key(evt.key.keysym.sym, true);
case SDL_EventType.KeyUp:
if (key) key(evt.key.keysym.sym, false);
break;
case SDL_EventType.Quit:
throw new Exception("Quit");
break;
default: break;
}
}
}
void events(void delegate(int) key, void delegate(int, int, ubyte, bool) mouse=null) {
events((int a, bool b) {
if (b) key(a);
}, mouse);
}
void events(void delegate(int) key, void delegate(int, int) mouse) {
events(key, (int x, int y, ubyte b, bool p) { mouse(x, y); });
}
void events(void delegate(int, bool) key, void delegate(int, int) mouse) {
events(key, (int x, int y, ubyte b, bool p) { mouse(x, y); });
}
void sleep(float secs)
{
assert(secs >= 0);
uint ms = cast(uint)(secs * 1000);
SDL_Delay(ms);
}

29
demos/qd1.d
View File

@@ -1,29 +0,0 @@
module qd1;
import qd;
void main() {
screen(640, 480);
sleep(1);
cls(Red);
sleep(1);
cls(Green);
sleep(1);
cls(Blue);
sleep(1);
// pset(10, 10);
// line(0, 0, 100, 100, Box, Back(Red~Black));
// for (int i=0; i<=100; i+=10) {
// line(i, 0, 100-i, 100);
// line(0, i, 100, 100-i);
// }
// circle(100, 100, 50, 15, White~Black, Fill=White~Black);
// paint(200, 200, Red, Back=White);
// circle(100, 100, 50, 15, White);
// paint(200, 200, Black);
// pset(10, 11); pset(10, 11, Black);
// pset(10, 10);
// sleep(1);
}

124
demos/ray.cpp
View File

@@ -1,124 +0,0 @@
#include <list>
#include <iostream>
#include <limits>
#include <cmath>
#include <cstdlib>
using namespace std;
numeric_limits<double> real;
double delta = sqrt(real.epsilon()), infinity = real.infinity();
struct Vec {
double x, y, z;
Vec(double x2, double y2, double z2) : x(x2), y(y2), z(z2) {}
};
Vec operator+(const Vec &a, const Vec &b)
{ return Vec(a.x+b.x, a.y+b.y, a.z+b.z); }
Vec operator-(const Vec &a, const Vec &b)
{ return Vec(a.x-b.x, a.y-b.y, a.z-b.z); }
Vec operator*(double a, const Vec &b) { return Vec(a*b.x, a*b.y, a*b.z); }
double dot(const Vec &a, const Vec &b) { return a.x*b.x + a.y*b.y + a.z*b.z; }
Vec unitise(const Vec &a) { return (1 / sqrt(dot(a, a))) * a; }
typedef pair<double, Vec> Hit;
struct Ray {
Vec orig, dir;
Ray(const Vec &o, const Vec &d) : orig(o), dir(d) {}
};
struct Scene {
virtual ~Scene() {};
virtual void intersect(Hit &, const Ray &) const = 0;
};
struct Sphere : public Scene {
Vec center;
double radius;
Sphere(Vec c, double r) : center(c), radius(r) {}
~Sphere() {}
double ray_sphere(const Ray &ray) const {
Vec v = center - ray.orig;
double b = dot(v, ray.dir), disc = b*b - dot(v, v) + radius * radius;
if (disc < 0) return infinity;
double d = sqrt(disc), t2 = b + d;
if (t2 < 0) return infinity;
double t1 = b - d;
return (t1 > 0 ? t1 : t2);
}
void intersect(Hit &hit, const Ray &ray) const {
double lambda = ray_sphere(ray);
if (lambda >= hit.first) return;
hit = Hit(lambda, unitise(ray.orig + lambda*ray.dir - center));
}
};
typedef list<Scene *> Scenes;
struct Group : public Scene {
Sphere bound;
Scenes child;
Group(Sphere b, Scenes c) : bound(b), child(c) {}
~Group() {
for (Scenes::const_iterator it=child.begin(); it!=child.end(); ++it)
delete *it;
}
void intersect(Hit &hit, const Ray &ray) const {
double l = bound.ray_sphere(ray);
if (l < hit.first)
for (Scenes::const_iterator it=child.begin(); it!=child.end(); ++it)
(*it)->intersect(hit, ray);
}
};
Hit intersect(const Ray &ray, const Scene &s) {
Hit res = Hit(infinity, Vec(0, 0, 0));
s.intersect(res, ray);
return res;
}
double ray_trace(const Vec &light, const Ray &ray, const Scene &s) {
Hit hit = intersect(ray, s);
if (hit.first == infinity) return 0;
double g = dot(hit.second, light);
if (g >= 0) return 0.;
Vec p = ray.orig + hit.first*ray.dir + delta*hit.second;
return (intersect(Ray(p, -1. * light), s).first < infinity ? 0 : -g);
}
Scene *create(int level, const Vec &c, double r) {
Scene *s = new Sphere(c, r);
if (level == 1) return s;
Scenes child;
child.push_back(s);
double rn = 3*r/sqrt(12.);
for (int dz=-1; dz<=1; dz+=2)
for (int dx=-1; dx<=1; dx+=2)
child.push_back(create(level-1, c + rn*Vec(dx, 1, dz), r/2));
return new Group(Sphere(c, 3*r), child);
}
int main(int argc, char *argv[]) {
int level = 6, n = 512, ss = 4;
if (argc == 2) level = atoi(argv[1]);
Vec light = unitise(Vec(-1, -3, 2));
Scene *s(create(level, Vec(0, -1, 0), 1));
cout << "P5\n" << n << " " << n << "\n255\n";
for (int y=n-1; y>=0; --y)
for (int x=0; x<n; ++x) {
double g=0;
for (int dx=0; dx<ss; ++dx)
for (int dy=0; dy<ss; ++dy) {
Vec dir(unitise(Vec(x+dx*1./ss-n/2., y+dy*1./ss-n/2., n)));
g += ray_trace(light, Ray(Vec(0, 0, -4), dir), *s);
}
cout << char(int(.5 + 255. * g / (ss*ss)));
}
delete s;
return 0;
}

126
demos/ray.d
View File

@@ -1,126 +0,0 @@
import tango.stdc.stdio;
alias char[] string;
int atoi(char[] s) {
int i, fac=1;
bool neg = (s.length) && (s[0] == '-');
char[] a = neg ? s[1..$] : s;
foreach_reverse(c; a) {
i += (c-'0') * fac;
fac *= 10;
}
return !neg ? i : -i;
}
version(LDC)
{
pragma(intrinsic, "llvm.sqrt.f64")
double sqrt(double val);
}
else
{
import tango.stdc.math;
}
double delta;
static this() { delta=sqrt(real.epsilon); }
struct Vec {
double x, y, z;
Vec opAdd(ref Vec other) { return Vec(x+other.x, y+other.y, z+other.z); }
Vec opSub(ref Vec other) { return Vec(x-other.x, y-other.y, z-other.z); }
Vec opMul(double a) { return Vec(x*a, y*a, z*a); }
double dot(ref Vec other) { return x*other.x+y*other.y+z*other.z; }
Vec unitise() { return opMul(1.0/sqrt(dot(*this))); }
}
struct Pair(T, U) { T first; U second; }
typedef Pair!(double, Vec) Hit;
struct Ray { Vec orig, dir; }
class Scene {
//abstract void intersect(ref Hit, ref Ray);
void intersect(ref Hit, ref Ray) {}
}
class Sphere : Scene {
Vec center;
double radius;
//mixin This!("center, radius");
this(ref Vec c, double r)
{
center = c;
radius = r;
}
double ray_sphere(ref Ray ray) {
auto v = center - ray.orig, b = v.dot(ray.dir), disc=b*b - v.dot(v) + radius*radius;
if (disc < 0) return double.infinity;
auto d = sqrt(disc), t2 = b + d;
if (t2 < 0) return double.infinity;
auto t1 = b - d;
return (t1 > 0 ? t1 : t2);
}
void intersect(ref Hit hit, ref Ray ray) {
auto lambda = ray_sphere(ray);
if (lambda < hit.first)
hit = Hit(lambda, (ray.orig + lambda*ray.dir - center).unitise);
}
}
class Group : Scene {
Sphere bound;
Scene[] children;
//mixin This!("bound, children");
this (Sphere s, Scene[] c)
{
bound = s;
children = c;
}
void intersect(ref Hit hit, ref Ray ray) {
auto l = bound.ray_sphere(ray);
if (l < hit.first) foreach (child; children) child.intersect(hit, ray);
}
}
double ray_trace(ref Vec light, ref Ray ray, Scene s) {
auto hit=Hit(double.infinity, Vec(0, 0, 0));
s.intersect(hit, ray);
if (hit.first == double.infinity) return 0.0;
auto g = hit.second.dot(light);
if (g >= 0) return 0.0;
auto p = ray.orig + ray.dir*hit.first + hit.second*delta;
auto hit2=Hit(double.infinity, Vec(0, 0, 0));
s.intersect(hit2, Ray(p, light*-1.0));
return (hit2.first < double.infinity ? 0 : -g);
}
Scene create(int level, ref Vec c, double r) {
auto s = new Sphere(c, r);
if (level == 1) return s;
Scene[] children;
children ~= s;
double rn = 3*r/sqrt(12.0);
for (int dz=-1; dz<=1; dz+=2)
for (int dx=-1; dx<=1; dx+=2)
children~=create(level-1, c + Vec(dx, 1, dz)*rn, r/2);
return new Group(new Sphere(c, 3*r), children);
}
void main(string[] args) {
int level = (args.length==3 ? args[1].atoi() : 9),
n = (args.length==3 ? args[2].atoi() : 512), ss = 4;
auto light = Vec(-1, -3, 2).unitise();
auto s=create(level, Vec(0, -1, 0), 1);
printf("P5\n%d %d\n255\n", n,n);
for (int y=n-1; y>=0; --y)
for (int x=0; x<n; ++x) {
double g=0;
for (int d=0; d<ss*ss; ++d) {
auto dir=Vec(x+(d%ss)*1.0/ss-n/2.0, y+(d/ss)*1.0/ss-n/2.0, n).unitise();
g += ray_trace(light, Ray(Vec(0, 0, -4), dir), s);
}
printf("%c", cast(ubyte)(0.5 + 255.0 * g / (ss*ss)));
}
}

1
demos/readme.txt
View File

@@ -1 +0,0 @@
use rebuild with -dc=ldc-posix to build the demos

87
demos/sdl.d
View File

@@ -1,87 +0,0 @@
module sdl;
version(build) pragma(link,"SDL");
extern(C):
struct SDL_Rect {
short x, y;
ushort w, h;
}
struct SDL_PixelFormat {
//SDL_Palette *palette;
void *palette;
ubyte BitsPerPixel, BytesPerPixel, Rloss, Gloss, Bloss, Aloss, Rshift, Gshift, Bshift, Ashift;
uint Rmask, Gmask, Bmask, Amask, colorkey; ubyte alpha;
}
struct SDL_Surface {
uint flags;
SDL_PixelFormat *format;
int w, h;
ushort pitch;
void *pixels;
int offset;
void *hwdata;
SDL_Rect clip_rect;
uint unused;
uint locked;
void *map;
uint format_version;
int refcount;
}
uint SDL_MapRGBA(SDL_PixelFormat *format, ubyte r, ubyte g, ubyte b, ubyte a);
void SDL_GetRGBA(uint pixel, SDL_PixelFormat *fmt, ubyte *r, ubyte *g, ubyte *b, ubyte *a);
int SDL_LockSurface(SDL_Surface *);
void SDL_UnlockSurface(SDL_Surface *);
SDL_Surface * SDL_SetVideoMode(int width, int height, int bpp, uint flags);
int SDL_Flip(SDL_Surface *);
void SDL_Delay(uint);
int SDL_FillRect(SDL_Surface*,SDL_Rect*,uint);
enum : uint {
SDL_SWSURFACE=0,
SDL_HWSURFACE=1,
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();

15
demos/sdldemo1.d
View File

@@ -1,15 +0,0 @@
module sdldemo1;
import sdl;
void main()
{
auto disp = SDL_SetVideoMode(640,480,0,SDL_HWSURFACE|SDL_DOUBLEBUF);
auto r = SDL_Rect(0,190,100,100);
auto c = SDL_MapRGBA(disp.format,255,100,0,255);
while (r.x < disp.w-100) {
SDL_FillRect(disp, null, 0);
SDL_FillRect(disp, &r, c);
SDL_Flip(disp);
r.x++;
}
}