/* * Copyright (c) 2002 Light Weight Java Game Library Project * 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 name of 'Light Weight Java Game Library' 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. */ /** * $Id$ * * Core OpenGL functions. * * @author cix_foo * @version $Revision$ */ #include "org_lwjgl_opengl_GL11.h" #include "checkGLerror.h" #include "extgl.h" typedef void (APIENTRY * glAccumPROC) (GLenum op, GLfloat value); typedef void (APIENTRY * glAlphaFuncPROC) (GLenum func, GLclampf ref); typedef GLboolean (APIENTRY * glAreTexturesResidentPROC) (GLsizei n, const GLuint *textures, GLboolean *residences); typedef void (APIENTRY * glArrayElementPROC) (GLint i); typedef void (APIENTRY * glBeginPROC) (GLenum mode); typedef void (APIENTRY * glBindTexturePROC) (GLenum target, GLuint texture); typedef void (APIENTRY * glBitmapPROC) (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap); typedef void (APIENTRY * glBlendFuncPROC) (GLenum sfactor, GLenum dfactor); typedef void (APIENTRY * glCallListPROC) (GLuint list); typedef void (APIENTRY * glCallListsPROC) (GLsizei n, GLenum type, const GLvoid *lists); typedef void (APIENTRY * glClearPROC) (GLbitfield mask); typedef void (APIENTRY * glClearAccumPROC) (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); typedef void (APIENTRY * glClearColorPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); typedef void (APIENTRY * glClearDepthPROC) (GLclampd depth); typedef void (APIENTRY * glClearIndexPROC) (GLfloat c); typedef void (APIENTRY * glClearStencilPROC) (GLint s); typedef void (APIENTRY * glClipPlanePROC) (GLenum plane, const GLdouble *equation); typedef void (APIENTRY * glColor3bPROC) (GLbyte red, GLbyte green, GLbyte blue); typedef void (APIENTRY * glColor3bvPROC) (const GLbyte *v); typedef void (APIENTRY * glColor3dPROC) (GLdouble red, GLdouble green, GLdouble blue); typedef void (APIENTRY * glColor3dvPROC) (const GLdouble *v); typedef void (APIENTRY * glColor3fPROC) (GLfloat red, GLfloat green, GLfloat blue); typedef void (APIENTRY * glColor3fvPROC) (const GLfloat *v); typedef void (APIENTRY * glColor3iPROC) (GLint red, GLint green, GLint blue); typedef void (APIENTRY * glColor3ivPROC) (const GLint *v); typedef void (APIENTRY * glColor3sPROC) (GLshort red, GLshort green, GLshort blue); typedef void (APIENTRY * glColor3svPROC) (const GLshort *v); typedef void (APIENTRY * glColor3ubPROC) (GLubyte red, GLubyte green, GLubyte blue); typedef void (APIENTRY * glColor3ubvPROC) (const GLubyte *v); typedef void (APIENTRY * glColor3uiPROC) (GLuint red, GLuint green, GLuint blue); typedef void (APIENTRY * glColor3uivPROC) (const GLuint *v); typedef void (APIENTRY * glColor3usPROC) (GLushort red, GLushort green, GLushort blue); typedef void (APIENTRY * glColor3usvPROC) (const GLushort *v); typedef void (APIENTRY * glColor4bPROC) (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); typedef void (APIENTRY * glColor4bvPROC) (const GLbyte *v); typedef void (APIENTRY * glColor4dPROC) (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); typedef void (APIENTRY * glColor4dvPROC) (const GLdouble *v); typedef void (APIENTRY * glColor4fPROC) (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); typedef void (APIENTRY * glColor4fvPROC) (const GLfloat *v); typedef void (APIENTRY * glColor4iPROC) (GLint red, GLint green, GLint blue, GLint alpha); typedef void (APIENTRY * glColor4ivPROC) (const GLint *v); typedef void (APIENTRY * glColor4sPROC) (GLshort red, GLshort green, GLshort blue, GLshort alpha); typedef void (APIENTRY * glColor4svPROC) (const GLshort *v); typedef void (APIENTRY * glColor4ubPROC) (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); typedef void (APIENTRY * glColor4ubvPROC) (const GLubyte *v); typedef void (APIENTRY * glColor4uiPROC) (GLuint red, GLuint green, GLuint blue, GLuint alpha); typedef void (APIENTRY * glColor4uivPROC) (const GLuint *v); typedef void (APIENTRY * glColor4usPROC) (GLushort red, GLushort green, GLushort blue, GLushort alpha); typedef void (APIENTRY * glColor4usvPROC) (const GLushort *v); typedef void (APIENTRY * glColorMaskPROC) (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); typedef void (APIENTRY * glColorMaterialPROC) (GLenum face, GLenum mode); typedef void (APIENTRY * glColorPointerPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRY * glCopyPixelsPROC) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); typedef void (APIENTRY * glCopyTexImage1DPROC) (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); typedef void (APIENTRY * glCopyTexImage2DPROC) (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); typedef void (APIENTRY * glCopyTexSubImage1DPROC) (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); typedef void (APIENTRY * glCopyTexSubImage2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (APIENTRY * glCullFacePROC) (GLenum mode); typedef void (APIENTRY * glDeleteListsPROC) (GLuint list, GLsizei range); typedef void (APIENTRY * glDeleteTexturesPROC) (GLsizei n, const GLuint *textures); typedef void (APIENTRY * glDepthFuncPROC) (GLenum func); typedef void (APIENTRY * glDepthMaskPROC) (GLboolean flag); typedef void (APIENTRY * glDepthRangePROC) (GLclampd zNear, GLclampd zFar); typedef void (APIENTRY * glDisablePROC) (GLenum cap); typedef void (APIENTRY * glDisableClientStatePROC) (GLenum array); typedef void (APIENTRY * glDrawArraysPROC) (GLenum mode, GLint first, GLsizei count); typedef void (APIENTRY * glDrawBufferPROC) (GLenum mode); typedef void (APIENTRY * glDrawElementsPROC) (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices); typedef void (APIENTRY * glDrawPixelsPROC) (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); typedef void (APIENTRY * glEdgeFlagPROC) (GLboolean flag); typedef void (APIENTRY * glEdgeFlagPointerPROC) (GLsizei stride, const GLvoid *pointer); typedef void (APIENTRY * glEdgeFlagvPROC) (const GLboolean *flag); typedef void (APIENTRY * glEnablePROC) (GLenum cap); typedef void (APIENTRY * glEnableClientStatePROC) (GLenum array); typedef void (APIENTRY * glEndPROC) (void); typedef void (APIENTRY * glEndListPROC) (void); typedef void (APIENTRY * glEvalCoord1dPROC) (GLdouble u); typedef void (APIENTRY * glEvalCoord1dvPROC) (const GLdouble *u); typedef void (APIENTRY * glEvalCoord1fPROC) (GLfloat u); typedef void (APIENTRY * glEvalCoord1fvPROC) (const GLfloat *u); typedef void (APIENTRY * glEvalCoord2dPROC) (GLdouble u, GLdouble v); typedef void (APIENTRY * glEvalCoord2dvPROC) (const GLdouble *u); typedef void (APIENTRY * glEvalCoord2fPROC) (GLfloat u, GLfloat v); typedef void (APIENTRY * glEvalCoord2fvPROC) (const GLfloat *u); typedef void (APIENTRY * glEvalMesh1PROC) (GLenum mode, GLint i1, GLint i2); typedef void (APIENTRY * glEvalMesh2PROC) (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); typedef void (APIENTRY * glEvalPoint1PROC) (GLint i); typedef void (APIENTRY * glEvalPoint2PROC) (GLint i, GLint j); typedef void (APIENTRY * glFeedbackBufferPROC) (GLsizei size, GLenum type, GLfloat *buffer); typedef void (APIENTRY * glFinishPROC) (void); typedef void (APIENTRY * glFlushPROC) (void); typedef void (APIENTRY * glFogfPROC) (GLenum pname, GLfloat param); typedef void (APIENTRY * glFogfvPROC) (GLenum pname, const GLfloat *params); typedef void (APIENTRY * glFogiPROC) (GLenum pname, GLint param); typedef void (APIENTRY * glFogivPROC) (GLenum pname, const GLint *params); typedef void (APIENTRY * glFrontFacePROC) (GLenum mode); typedef void (APIENTRY * glFrustumPROC) (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); typedef GLuint (APIENTRY * glGenListsPROC) (GLsizei range); typedef void (APIENTRY * glGenTexturesPROC) (GLsizei n, GLuint *textures); typedef void (APIENTRY * glGetBooleanvPROC) (GLenum pname, GLboolean *params); typedef void (APIENTRY * glGetClipPlanePROC) (GLenum plane, GLdouble *equation); typedef void (APIENTRY * glGetDoublevPROC) (GLenum pname, GLdouble *params); //typedef GLenum (APIENTRY * glGetErrorPROC) (void); typedef void (APIENTRY * glGetFloatvPROC) (GLenum pname, GLfloat *params); typedef void (APIENTRY * glGetIntegervPROC) (GLenum pname, GLint *params); typedef void (APIENTRY * glGetLightfvPROC) (GLenum light, GLenum pname, GLfloat *params); typedef void (APIENTRY * glGetLightivPROC) (GLenum light, GLenum pname, GLint *params); typedef void (APIENTRY * glGetMapdvPROC) (GLenum target, GLenum query, GLdouble *v); typedef void (APIENTRY * glGetMapfvPROC) (GLenum target, GLenum query, GLfloat *v); typedef void (APIENTRY * glGetMapivPROC) (GLenum target, GLenum query, GLint *v); typedef void (APIENTRY * glGetMaterialfvPROC) (GLenum face, GLenum pname, GLfloat *params); typedef void (APIENTRY * glGetMaterialivPROC) (GLenum face, GLenum pname, GLint *params); typedef void (APIENTRY * glGetPixelMapfvPROC) (GLenum map, GLfloat *values); typedef void (APIENTRY * glGetPixelMapuivPROC) (GLenum map, GLuint *values); typedef void (APIENTRY * glGetPixelMapusvPROC) (GLenum map, GLushort *values); typedef void (APIENTRY * glGetPointervPROC) (GLenum pname, GLvoid* *params); typedef void (APIENTRY * glGetPolygonStipplePROC) (GLubyte *mask); //typedef const GLubyte * (APIENTRY * glGetStringPROC) (GLenum name); typedef void (APIENTRY * glGetTexEnvfvPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRY * glGetTexEnvivPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRY * glGetTexGendvPROC) (GLenum coord, GLenum pname, GLdouble *params); typedef void (APIENTRY * glGetTexGenfvPROC) (GLenum coord, GLenum pname, GLfloat *params); typedef void (APIENTRY * glGetTexGenivPROC) (GLenum coord, GLenum pname, GLint *params); typedef void (APIENTRY * glGetTexImagePROC) (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels); typedef void (APIENTRY * glGetTexLevelParameterfvPROC) (GLenum target, GLint level, GLenum pname, GLfloat *params); typedef void (APIENTRY * glGetTexLevelParameterivPROC) (GLenum target, GLint level, GLenum pname, GLint *params); typedef void (APIENTRY * glGetTexParameterfvPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRY * glGetTexParameterivPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRY * glHintPROC) (GLenum target, GLenum mode); typedef void (APIENTRY * glIndexMaskPROC) (GLuint mask); typedef void (APIENTRY * glIndexPointerPROC) (GLenum type, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRY * glIndexdPROC) (GLdouble c); typedef void (APIENTRY * glIndexdvPROC) (const GLdouble *c); typedef void (APIENTRY * glIndexfPROC) (GLfloat c); typedef void (APIENTRY * glIndexfvPROC) (const GLfloat *c); typedef void (APIENTRY * glIndexiPROC) (GLint c); typedef void (APIENTRY * glIndexivPROC) (const GLint *c); typedef void (APIENTRY * glIndexsPROC) (GLshort c); typedef void (APIENTRY * glIndexsvPROC) (const GLshort *c); typedef void (APIENTRY * glIndexubPROC) (GLubyte c); typedef void (APIENTRY * glIndexubvPROC) (const GLubyte *c); typedef void (APIENTRY * glInitNamesPROC) (void); typedef void (APIENTRY * glInterleavedArraysPROC) (GLenum format, GLsizei stride, const GLvoid *pointer); typedef GLboolean (APIENTRY * glIsEnabledPROC) (GLenum cap); typedef GLboolean (APIENTRY * glIsListPROC) (GLuint list); typedef GLboolean (APIENTRY * glIsTexturePROC) (GLuint texture); typedef void (APIENTRY * glLightModelfPROC) (GLenum pname, GLfloat param); typedef void (APIENTRY * glLightModelfvPROC) (GLenum pname, const GLfloat *params); typedef void (APIENTRY * glLightModeliPROC) (GLenum pname, GLint param); typedef void (APIENTRY * glLightModelivPROC) (GLenum pname, const GLint *params); typedef void (APIENTRY * glLightfPROC) (GLenum light, GLenum pname, GLfloat param); typedef void (APIENTRY * glLightfvPROC) (GLenum light, GLenum pname, const GLfloat *params); typedef void (APIENTRY * glLightiPROC) (GLenum light, GLenum pname, GLint param); typedef void (APIENTRY * glLightivPROC) (GLenum light, GLenum pname, const GLint *params); typedef void (APIENTRY * glLineStipplePROC) (GLint factor, GLushort pattern); typedef void (APIENTRY * glLineWidthPROC) (GLfloat width); typedef void (APIENTRY * glListBasePROC) (GLuint base); typedef void (APIENTRY * glLoadIdentityPROC) (void); typedef void (APIENTRY * glLoadMatrixdPROC) (const GLdouble *m); typedef void (APIENTRY * glLoadMatrixfPROC) (const GLfloat *m); typedef void (APIENTRY * glLoadNamePROC) (GLuint name); typedef void (APIENTRY * glLogicOpPROC) (GLenum opcode); typedef void (APIENTRY * glMap1dPROC) (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points); typedef void (APIENTRY * glMap1fPROC) (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points); typedef void (APIENTRY * glMap2dPROC) (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points); typedef void (APIENTRY * glMap2fPROC) (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points); typedef void (APIENTRY * glMapGrid1dPROC) (GLint un, GLdouble u1, GLdouble u2); typedef void (APIENTRY * glMapGrid1fPROC) (GLint un, GLfloat u1, GLfloat u2); typedef void (APIENTRY * glMapGrid2dPROC) (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); typedef void (APIENTRY * glMapGrid2fPROC) (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); typedef void (APIENTRY * glMaterialfPROC) (GLenum face, GLenum pname, GLfloat param); typedef void (APIENTRY * glMaterialfvPROC) (GLenum face, GLenum pname, const GLfloat *params); typedef void (APIENTRY * glMaterialiPROC) (GLenum face, GLenum pname, GLint param); typedef void (APIENTRY * glMaterialivPROC) (GLenum face, GLenum pname, const GLint *params); typedef void (APIENTRY * glMatrixModePROC) (GLenum mode); typedef void (APIENTRY * glMultMatrixdPROC) (const GLdouble *m); typedef void (APIENTRY * glMultMatrixfPROC) (const GLfloat *m); typedef void (APIENTRY * glNewListPROC) (GLuint list, GLenum mode); typedef void (APIENTRY * glNormal3bPROC) (GLbyte nx, GLbyte ny, GLbyte nz); typedef void (APIENTRY * glNormal3bvPROC) (const GLbyte *v); typedef void (APIENTRY * glNormal3dPROC) (GLdouble nx, GLdouble ny, GLdouble nz); typedef void (APIENTRY * glNormal3dvPROC) (const GLdouble *v); typedef void (APIENTRY * glNormal3fPROC) (GLfloat nx, GLfloat ny, GLfloat nz); typedef void (APIENTRY * glNormal3fvPROC) (const GLfloat *v); typedef void (APIENTRY * glNormal3iPROC) (GLint nx, GLint ny, GLint nz); typedef void (APIENTRY * glNormal3ivPROC) (const GLint *v); typedef void (APIENTRY * glNormal3sPROC) (GLshort nx, GLshort ny, GLshort nz); typedef void (APIENTRY * glNormal3svPROC) (const GLshort *v); typedef void (APIENTRY * glNormalPointerPROC) (GLenum type, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRY * glOrthoPROC) (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); typedef void (APIENTRY * glPassThroughPROC) (GLfloat token); typedef void (APIENTRY * glPixelMapfvPROC) (GLenum map, GLsizei mapsize, const GLfloat *values); typedef void (APIENTRY * glPixelMapuivPROC) (GLenum map, GLsizei mapsize, const GLuint *values); typedef void (APIENTRY * glPixelMapusvPROC) (GLenum map, GLsizei mapsize, const GLushort *values); typedef void (APIENTRY * glPixelStorefPROC) (GLenum pname, GLfloat param); typedef void (APIENTRY * glPixelStoreiPROC) (GLenum pname, GLint param); typedef void (APIENTRY * glPixelTransferfPROC) (GLenum pname, GLfloat param); typedef void (APIENTRY * glPixelTransferiPROC) (GLenum pname, GLint param); typedef void (APIENTRY * glPixelZoomPROC) (GLfloat xfactor, GLfloat yfactor); typedef void (APIENTRY * glPointSizePROC) (GLfloat size); typedef void (APIENTRY * glPolygonModePROC) (GLenum face, GLenum mode); typedef void (APIENTRY * glPolygonOffsetPROC) (GLfloat factor, GLfloat units); typedef void (APIENTRY * glPolygonStipplePROC) (const GLubyte *mask); typedef void (APIENTRY * glPopAttribPROC) (void); typedef void (APIENTRY * glPopClientAttribPROC) (void); typedef void (APIENTRY * glPopMatrixPROC) (void); typedef void (APIENTRY * glPopNamePROC) (void); typedef void (APIENTRY * glPrioritizeTexturesPROC) (GLsizei n, const GLuint *textures, const GLclampf *priorities); typedef void (APIENTRY * glPushAttribPROC) (GLbitfield mask); typedef void (APIENTRY * glPushClientAttribPROC) (GLbitfield mask); typedef void (APIENTRY * glPushMatrixPROC) (void); typedef void (APIENTRY * glPushNamePROC) (GLuint name); typedef void (APIENTRY * glRasterPos2dPROC) (GLdouble x, GLdouble y); typedef void (APIENTRY * glRasterPos2dvPROC) (const GLdouble *v); typedef void (APIENTRY * glRasterPos2fPROC) (GLfloat x, GLfloat y); typedef void (APIENTRY * glRasterPos2fvPROC) (const GLfloat *v); typedef void (APIENTRY * glRasterPos2iPROC) (GLint x, GLint y); typedef void (APIENTRY * glRasterPos2ivPROC) (const GLint *v); typedef void (APIENTRY * glRasterPos2sPROC) (GLshort x, GLshort y); typedef void (APIENTRY * glRasterPos2svPROC) (const GLshort *v); typedef void (APIENTRY * glRasterPos3dPROC) (GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRY * glRasterPos3dvPROC) (const GLdouble *v); typedef void (APIENTRY * glRasterPos3fPROC) (GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRY * glRasterPos3fvPROC) (const GLfloat *v); typedef void (APIENTRY * glRasterPos3iPROC) (GLint x, GLint y, GLint z); typedef void (APIENTRY * glRasterPos3ivPROC) (const GLint *v); typedef void (APIENTRY * glRasterPos3sPROC) (GLshort x, GLshort y, GLshort z); typedef void (APIENTRY * glRasterPos3svPROC) (const GLshort *v); typedef void (APIENTRY * glRasterPos4dPROC) (GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRY * glRasterPos4dvPROC) (const GLdouble *v); typedef void (APIENTRY * glRasterPos4fPROC) (GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRY * glRasterPos4fvPROC) (const GLfloat *v); typedef void (APIENTRY * glRasterPos4iPROC) (GLint x, GLint y, GLint z, GLint w); typedef void (APIENTRY * glRasterPos4ivPROC) (const GLint *v); typedef void (APIENTRY * glRasterPos4sPROC) (GLshort x, GLshort y, GLshort z, GLshort w); typedef void (APIENTRY * glRasterPos4svPROC) (const GLshort *v); typedef void (APIENTRY * glReadBufferPROC) (GLenum mode); typedef void (APIENTRY * glReadPixelsPROC) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels); typedef void (APIENTRY * glRectdPROC) (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); typedef void (APIENTRY * glRectdvPROC) (const GLdouble *v1, const GLdouble *v2); typedef void (APIENTRY * glRectfPROC) (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); typedef void (APIENTRY * glRectfvPROC) (const GLfloat *v1, const GLfloat *v2); typedef void (APIENTRY * glRectiPROC) (GLint x1, GLint y1, GLint x2, GLint y2); typedef void (APIENTRY * glRectivPROC) (const GLint *v1, const GLint *v2); typedef void (APIENTRY * glRectsPROC) (GLshort x1, GLshort y1, GLshort x2, GLshort y2); typedef void (APIENTRY * glRectsvPROC) (const GLshort *v1, const GLshort *v2); typedef GLint (APIENTRY * glRenderModePROC) (GLenum mode); typedef void (APIENTRY * glRotatedPROC) (GLdouble angle, GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRY * glRotatefPROC) (GLfloat angle, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRY * glScaledPROC) (GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRY * glScalefPROC) (GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRY * glScissorPROC) (GLint x, GLint y, GLsizei width, GLsizei height); typedef void (APIENTRY * glSelectBufferPROC) (GLsizei size, GLuint *buffer); typedef void (APIENTRY * glShadeModelPROC) (GLenum mode); typedef void (APIENTRY * glStencilFuncPROC) (GLenum func, GLint ref, GLuint mask); typedef void (APIENTRY * glStencilMaskPROC) (GLuint mask); typedef void (APIENTRY * glStencilOpPROC) (GLenum fail, GLenum zfail, GLenum zpass); typedef void (APIENTRY * glTexCoord1dPROC) (GLdouble s); typedef void (APIENTRY * glTexCoord1dvPROC) (const GLdouble *v); typedef void (APIENTRY * glTexCoord1fPROC) (GLfloat s); typedef void (APIENTRY * glTexCoord1fvPROC) (const GLfloat *v); typedef void (APIENTRY * glTexCoord1iPROC) (GLint s); typedef void (APIENTRY * glTexCoord1ivPROC) (const GLint *v); typedef void (APIENTRY * glTexCoord1sPROC) (GLshort s); typedef void (APIENTRY * glTexCoord1svPROC) (const GLshort *v); typedef void (APIENTRY * glTexCoord2dPROC) (GLdouble s, GLdouble t); typedef void (APIENTRY * glTexCoord2dvPROC) (const GLdouble *v); typedef void (APIENTRY * glTexCoord2fPROC) (GLfloat s, GLfloat t); typedef void (APIENTRY * glTexCoord2fvPROC) (const GLfloat *v); typedef void (APIENTRY * glTexCoord2iPROC) (GLint s, GLint t); typedef void (APIENTRY * glTexCoord2ivPROC) (const GLint *v); typedef void (APIENTRY * glTexCoord2sPROC) (GLshort s, GLshort t); typedef void (APIENTRY * glTexCoord2svPROC) (const GLshort *v); typedef void (APIENTRY * glTexCoord3dPROC) (GLdouble s, GLdouble t, GLdouble r); typedef void (APIENTRY * glTexCoord3dvPROC) (const GLdouble *v); typedef void (APIENTRY * glTexCoord3fPROC) (GLfloat s, GLfloat t, GLfloat r); typedef void (APIENTRY * glTexCoord3fvPROC) (const GLfloat *v); typedef void (APIENTRY * glTexCoord3iPROC) (GLint s, GLint t, GLint r); typedef void (APIENTRY * glTexCoord3ivPROC) (const GLint *v); typedef void (APIENTRY * glTexCoord3sPROC) (GLshort s, GLshort t, GLshort r); typedef void (APIENTRY * glTexCoord3svPROC) (const GLshort *v); typedef void (APIENTRY * glTexCoord4dPROC) (GLdouble s, GLdouble t, GLdouble r, GLdouble q); typedef void (APIENTRY * glTexCoord4dvPROC) (const GLdouble *v); typedef void (APIENTRY * glTexCoord4fPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat q); typedef void (APIENTRY * glTexCoord4fvPROC) (const GLfloat *v); typedef void (APIENTRY * glTexCoord4iPROC) (GLint s, GLint t, GLint r, GLint q); typedef void (APIENTRY * glTexCoord4ivPROC) (const GLint *v); typedef void (APIENTRY * glTexCoord4sPROC) (GLshort s, GLshort t, GLshort r, GLshort q); typedef void (APIENTRY * glTexCoord4svPROC) (const GLshort *v); typedef void (APIENTRY * glTexCoordPointerPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRY * glTexEnvfPROC) (GLenum target, GLenum pname, GLfloat param); typedef void (APIENTRY * glTexEnvfvPROC) (GLenum target, GLenum pname, const GLfloat *params); typedef void (APIENTRY * glTexEnviPROC) (GLenum target, GLenum pname, GLint param); typedef void (APIENTRY * glTexEnvivPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (APIENTRY * glTexGendPROC) (GLenum coord, GLenum pname, GLdouble param); typedef void (APIENTRY * glTexGendvPROC) (GLenum coord, GLenum pname, const GLdouble *params); typedef void (APIENTRY * glTexGenfPROC) (GLenum coord, GLenum pname, GLfloat param); typedef void (APIENTRY * glTexGenfvPROC) (GLenum coord, GLenum pname, const GLfloat *params); typedef void (APIENTRY * glTexGeniPROC) (GLenum coord, GLenum pname, GLint param); typedef void (APIENTRY * glTexGenivPROC) (GLenum coord, GLenum pname, const GLint *params); typedef void (APIENTRY * glTexImage1DPROC) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels); typedef void (APIENTRY * glTexImage2DPROC) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels); typedef void (APIENTRY * glTexParameterfPROC) (GLenum target, GLenum pname, GLfloat param); typedef void (APIENTRY * glTexParameterfvPROC) (GLenum target, GLenum pname, const GLfloat *params); typedef void (APIENTRY * glTexParameteriPROC) (GLenum target, GLenum pname, GLint param); typedef void (APIENTRY * glTexParameterivPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (APIENTRY * glTexSubImage1DPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels); typedef void (APIENTRY * glTexSubImage2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); typedef void (APIENTRY * glTranslatedPROC) (GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRY * glTranslatefPROC) (GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRY * glVertex2dPROC) (GLdouble x, GLdouble y); typedef void (APIENTRY * glVertex2dvPROC) (const GLdouble *v); typedef void (APIENTRY * glVertex2fPROC) (GLfloat x, GLfloat y); typedef void (APIENTRY * glVertex2fvPROC) (const GLfloat *v); typedef void (APIENTRY * glVertex2iPROC) (GLint x, GLint y); typedef void (APIENTRY * glVertex2ivPROC) (const GLint *v); typedef void (APIENTRY * glVertex2sPROC) (GLshort x, GLshort y); typedef void (APIENTRY * glVertex2svPROC) (const GLshort *v); typedef void (APIENTRY * glVertex3dPROC) (GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRY * glVertex3dvPROC) (const GLdouble *v); typedef void (APIENTRY * glVertex3fPROC) (GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRY * glVertex3fvPROC) (const GLfloat *v); typedef void (APIENTRY * glVertex3iPROC) (GLint x, GLint y, GLint z); typedef void (APIENTRY * glVertex3ivPROC) (const GLint *v); typedef void (APIENTRY * glVertex3sPROC) (GLshort x, GLshort y, GLshort z); typedef void (APIENTRY * glVertex3svPROC) (const GLshort *v); typedef void (APIENTRY * glVertex4dPROC) (GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRY * glVertex4dvPROC) (const GLdouble *v); typedef void (APIENTRY * glVertex4fPROC) (GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRY * glVertex4fvPROC) (const GLfloat *v); typedef void (APIENTRY * glVertex4iPROC) (GLint x, GLint y, GLint z, GLint w); typedef void (APIENTRY * glVertex4ivPROC) (const GLint *v); typedef void (APIENTRY * glVertex4sPROC) (GLshort x, GLshort y, GLshort z, GLshort w); typedef void (APIENTRY * glVertex4svPROC) (const GLshort *v); typedef void (APIENTRY * glVertexPointerPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRY * glViewportPROC) (GLint x, GLint y, GLsizei width, GLsizei height); static glAccumPROC glAccum; static glAlphaFuncPROC glAlphaFunc; static glAreTexturesResidentPROC glAreTexturesResident; static glArrayElementPROC glArrayElement; static glBeginPROC glBegin; static glBindTexturePROC glBindTexture; static glBitmapPROC glBitmap; static glBlendFuncPROC glBlendFunc; static glCallListPROC glCallList; static glCallListsPROC glCallLists; static glClearPROC glClear; static glClearAccumPROC glClearAccum; static glClearColorPROC glClearColor; static glClearDepthPROC glClearDepth; static glClearIndexPROC glClearIndex; static glClearStencilPROC glClearStencil; static glClipPlanePROC glClipPlane; static glColor3bPROC glColor3b; static glColor3bvPROC glColor3bv; static glColor3dPROC glColor3d; static glColor3dvPROC glColor3dv; static glColor3fPROC glColor3f; static glColor3fvPROC glColor3fv; static glColor3iPROC glColor3i; static glColor3ivPROC glColor3iv; static glColor3sPROC glColor3s; static glColor3svPROC glColor3sv; static glColor3ubPROC glColor3ub; static glColor3ubvPROC glColor3ubv; static glColor3uiPROC glColor3ui; static glColor3uivPROC glColor3uiv; static glColor3usPROC glColor3us; static glColor3usvPROC glColor3usv; static glColor4bPROC glColor4b; static glColor4bvPROC glColor4bv; static glColor4dPROC glColor4d; static glColor4dvPROC glColor4dv; static glColor4fPROC glColor4f; static glColor4fvPROC glColor4fv; static glColor4iPROC glColor4i; static glColor4ivPROC glColor4iv; static glColor4sPROC glColor4s; static glColor4svPROC glColor4sv; static glColor4ubPROC glColor4ub; static glColor4ubvPROC glColor4ubv; static glColor4uiPROC glColor4ui; static glColor4uivPROC glColor4uiv; static glColor4usPROC glColor4us; static glColor4usvPROC glColor4usv; static glColorMaskPROC glColorMask; static glColorMaterialPROC glColorMaterial; static glColorPointerPROC glColorPointer; static glCopyPixelsPROC glCopyPixels; static glCopyTexImage1DPROC glCopyTexImage1D; static glCopyTexImage2DPROC glCopyTexImage2D; static glCopyTexSubImage1DPROC glCopyTexSubImage1D; static glCopyTexSubImage2DPROC glCopyTexSubImage2D; static glCullFacePROC glCullFace; static glDeleteListsPROC glDeleteLists; static glDeleteTexturesPROC glDeleteTextures; static glDepthFuncPROC glDepthFunc; static glDepthMaskPROC glDepthMask; static glDepthRangePROC glDepthRange; static glDisablePROC glDisable; static glDisableClientStatePROC glDisableClientState; static glDrawArraysPROC glDrawArrays; static glDrawBufferPROC glDrawBuffer; static glDrawElementsPROC glDrawElements; static glDrawPixelsPROC glDrawPixels; static glEdgeFlagPROC glEdgeFlag; static glEdgeFlagPointerPROC glEdgeFlagPointer; static glEdgeFlagvPROC glEdgeFlagv; static glEnablePROC glEnable; static glEnableClientStatePROC glEnableClientState; static glEndPROC glEnd; static glEndListPROC glEndList; static glEvalCoord1dPROC glEvalCoord1d; static glEvalCoord1dvPROC glEvalCoord1dv; static glEvalCoord1fPROC glEvalCoord1f; static glEvalCoord1fvPROC glEvalCoord1fv; static glEvalCoord2dPROC glEvalCoord2d; static glEvalCoord2dvPROC glEvalCoord2dv; static glEvalCoord2fPROC glEvalCoord2f; static glEvalCoord2fvPROC glEvalCoord2fv; static glEvalMesh1PROC glEvalMesh1; static glEvalMesh2PROC glEvalMesh2; static glEvalPoint1PROC glEvalPoint1; static glEvalPoint2PROC glEvalPoint2; static glFeedbackBufferPROC glFeedbackBuffer; static glFinishPROC glFinish; static glFlushPROC glFlush; static glFogfPROC glFogf; static glFogfvPROC glFogfv; static glFogiPROC glFogi; static glFogivPROC glFogiv; static glFrontFacePROC glFrontFace; static glFrustumPROC glFrustum; static glGenListsPROC glGenLists; static glGenTexturesPROC glGenTextures; static glGetBooleanvPROC glGetBooleanv; static glGetClipPlanePROC glGetClipPlane; static glGetDoublevPROC glGetDoublev; glGetErrorPROC glGetError; static glGetFloatvPROC glGetFloatv; static glGetIntegervPROC glGetIntegerv; static glGetLightfvPROC glGetLightfv; static glGetLightivPROC glGetLightiv; static glGetMapdvPROC glGetMapdv; static glGetMapfvPROC glGetMapfv; static glGetMapivPROC glGetMapiv; static glGetMaterialfvPROC glGetMaterialfv; static glGetMaterialivPROC glGetMaterialiv; static glGetPixelMapfvPROC glGetPixelMapfv; static glGetPixelMapuivPROC glGetPixelMapuiv; static glGetPixelMapusvPROC glGetPixelMapusv; static glGetPointervPROC glGetPointerv; static glGetPolygonStipplePROC glGetPolygonStipple; glGetStringPROC glGetString; static glGetTexEnvfvPROC glGetTexEnvfv; static glGetTexEnvivPROC glGetTexEnviv; static glGetTexGendvPROC glGetTexGendv; static glGetTexGenfvPROC glGetTexGenfv; static glGetTexGenivPROC glGetTexGeniv; static glGetTexImagePROC glGetTexImage; static glGetTexLevelParameterfvPROC glGetTexLevelParameterfv; static glGetTexLevelParameterivPROC glGetTexLevelParameteriv; static glGetTexParameterfvPROC glGetTexParameterfv; static glGetTexParameterivPROC glGetTexParameteriv; static glHintPROC glHint; static glIndexMaskPROC glIndexMask; static glIndexPointerPROC glIndexPointer; static glIndexdPROC glIndexd; static glIndexdvPROC glIndexdv; static glIndexfPROC glIndexf; static glIndexfvPROC glIndexfv; static glIndexiPROC glIndexi; static glIndexivPROC glIndexiv; static glIndexsPROC glIndexs; static glIndexsvPROC glIndexsv; static glIndexubPROC glIndexub; static glIndexubvPROC glIndexubv; static glInitNamesPROC glInitNames; static glInterleavedArraysPROC glInterleavedArrays; static glIsEnabledPROC glIsEnabled; static glIsListPROC glIsList; static glIsTexturePROC glIsTexture; static glLightModelfPROC glLightModelf; static glLightModelfvPROC glLightModelfv; static glLightModeliPROC glLightModeli; static glLightModelivPROC glLightModeliv; static glLightfPROC glLightf; static glLightfvPROC glLightfv; static glLightiPROC glLighti; static glLightivPROC glLightiv; static glLineStipplePROC glLineStipple; static glLineWidthPROC glLineWidth; static glListBasePROC glListBase; static glLoadIdentityPROC glLoadIdentity; static glLoadMatrixdPROC glLoadMatrixd; static glLoadMatrixfPROC glLoadMatrixf; static glLoadNamePROC glLoadName; static glLogicOpPROC glLogicOp; static glMap1dPROC glMap1d; static glMap1fPROC glMap1f; static glMap2dPROC glMap2d; static glMap2fPROC glMap2f; static glMapGrid1dPROC glMapGrid1d; static glMapGrid1fPROC glMapGrid1f; static glMapGrid2dPROC glMapGrid2d; static glMapGrid2fPROC glMapGrid2f; static glMaterialfPROC glMaterialf; static glMaterialfvPROC glMaterialfv; static glMaterialiPROC glMateriali; static glMaterialivPROC glMaterialiv; static glMatrixModePROC glMatrixMode; static glMultMatrixdPROC glMultMatrixd; static glMultMatrixfPROC glMultMatrixf; static glNewListPROC glNewList; static glNormal3bPROC glNormal3b; static glNormal3bvPROC glNormal3bv; static glNormal3dPROC glNormal3d; static glNormal3dvPROC glNormal3dv; static glNormal3fPROC glNormal3f; static glNormal3fvPROC glNormal3fv; static glNormal3iPROC glNormal3i; static glNormal3ivPROC glNormal3iv; static glNormal3sPROC glNormal3s; static glNormal3svPROC glNormal3sv; static glNormalPointerPROC glNormalPointer; static glOrthoPROC glOrtho; static glPassThroughPROC glPassThrough; static glPixelMapfvPROC glPixelMapfv; static glPixelMapuivPROC glPixelMapuiv; static glPixelMapusvPROC glPixelMapusv; static glPixelStorefPROC glPixelStoref; static glPixelStoreiPROC glPixelStorei; static glPixelTransferfPROC glPixelTransferf; static glPixelTransferiPROC glPixelTransferi; static glPixelZoomPROC glPixelZoom; static glPointSizePROC glPointSize; static glPolygonModePROC glPolygonMode; static glPolygonOffsetPROC glPolygonOffset; static glPolygonStipplePROC glPolygonStipple; static glPopAttribPROC glPopAttrib; static glPopClientAttribPROC glPopClientAttrib; static glPopMatrixPROC glPopMatrix; static glPopNamePROC glPopName; static glPrioritizeTexturesPROC glPrioritizeTextures; static glPushAttribPROC glPushAttrib; static glPushClientAttribPROC glPushClientAttrib; static glPushMatrixPROC glPushMatrix; static glPushNamePROC glPushName; static glRasterPos2dPROC glRasterPos2d; static glRasterPos2dvPROC glRasterPos2dv; static glRasterPos2fPROC glRasterPos2f; static glRasterPos2fvPROC glRasterPos2fv; static glRasterPos2iPROC glRasterPos2i; static glRasterPos2ivPROC glRasterPos2iv; static glRasterPos2sPROC glRasterPos2s; static glRasterPos2svPROC glRasterPos2sv; static glRasterPos3dPROC glRasterPos3d; static glRasterPos3dvPROC glRasterPos3dv; static glRasterPos3fPROC glRasterPos3f; static glRasterPos3fvPROC glRasterPos3fv; static glRasterPos3iPROC glRasterPos3i; static glRasterPos3ivPROC glRasterPos3iv; static glRasterPos3sPROC glRasterPos3s; static glRasterPos3svPROC glRasterPos3sv; static glRasterPos4dPROC glRasterPos4d; static glRasterPos4dvPROC glRasterPos4dv; static glRasterPos4fPROC glRasterPos4f; static glRasterPos4fvPROC glRasterPos4fv; static glRasterPos4iPROC glRasterPos4i; static glRasterPos4ivPROC glRasterPos4iv; static glRasterPos4sPROC glRasterPos4s; static glRasterPos4svPROC glRasterPos4sv; static glReadBufferPROC glReadBuffer; static glReadPixelsPROC glReadPixels; static glRectdPROC glRectd; static glRectdvPROC glRectdv; static glRectfPROC glRectf; static glRectfvPROC glRectfv; static glRectiPROC glRecti; static glRectivPROC glRectiv; static glRectsPROC glRects; static glRectsvPROC glRectsv; static glRenderModePROC glRenderMode; static glRotatedPROC glRotated; static glRotatefPROC glRotatef; static glScaledPROC glScaled; static glScalefPROC glScalef; static glScissorPROC glScissor; static glSelectBufferPROC glSelectBuffer; static glShadeModelPROC glShadeModel; static glStencilFuncPROC glStencilFunc; static glStencilMaskPROC glStencilMask; static glStencilOpPROC glStencilOp; static glTexCoord1dPROC glTexCoord1d; static glTexCoord1dvPROC glTexCoord1dv; static glTexCoord1fPROC glTexCoord1f; static glTexCoord1fvPROC glTexCoord1fv; static glTexCoord1iPROC glTexCoord1i; static glTexCoord1ivPROC glTexCoord1iv; static glTexCoord1sPROC glTexCoord1s; static glTexCoord1svPROC glTexCoord1sv; static glTexCoord2dPROC glTexCoord2d; static glTexCoord2dvPROC glTexCoord2dv; static glTexCoord2fPROC glTexCoord2f; static glTexCoord2fvPROC glTexCoord2fv; static glTexCoord2iPROC glTexCoord2i; static glTexCoord2ivPROC glTexCoord2iv; static glTexCoord2sPROC glTexCoord2s; static glTexCoord2svPROC glTexCoord2sv; static glTexCoord3dPROC glTexCoord3d; static glTexCoord3dvPROC glTexCoord3dv; static glTexCoord3fPROC glTexCoord3f; static glTexCoord3fvPROC glTexCoord3fv; static glTexCoord3iPROC glTexCoord3i; static glTexCoord3ivPROC glTexCoord3iv; static glTexCoord3sPROC glTexCoord3s; static glTexCoord3svPROC glTexCoord3sv; static glTexCoord4dPROC glTexCoord4d; static glTexCoord4dvPROC glTexCoord4dv; static glTexCoord4fPROC glTexCoord4f; static glTexCoord4fvPROC glTexCoord4fv; static glTexCoord4iPROC glTexCoord4i; static glTexCoord4ivPROC glTexCoord4iv; static glTexCoord4sPROC glTexCoord4s; static glTexCoord4svPROC glTexCoord4sv; static glTexCoordPointerPROC glTexCoordPointer; static glTexEnvfPROC glTexEnvf; static glTexEnvfvPROC glTexEnvfv; static glTexEnviPROC glTexEnvi; static glTexEnvivPROC glTexEnviv; static glTexGendPROC glTexGend; static glTexGendvPROC glTexGendv; static glTexGenfPROC glTexGenf; static glTexGenfvPROC glTexGenfv; static glTexGeniPROC glTexGeni; static glTexGenivPROC glTexGeniv; static glTexImage1DPROC glTexImage1D; static glTexImage2DPROC glTexImage2D; static glTexParameterfPROC glTexParameterf; static glTexParameterfvPROC glTexParameterfv; static glTexParameteriPROC glTexParameteri; static glTexParameterivPROC glTexParameteriv; static glTexSubImage1DPROC glTexSubImage1D; static glTexSubImage2DPROC glTexSubImage2D; static glTranslatedPROC glTranslated; static glTranslatefPROC glTranslatef; static glVertex2dPROC glVertex2d; static glVertex2dvPROC glVertex2dv; static glVertex2fPROC glVertex2f; static glVertex2fvPROC glVertex2fv; static glVertex2iPROC glVertex2i; static glVertex2ivPROC glVertex2iv; static glVertex2sPROC glVertex2s; static glVertex2svPROC glVertex2sv; static glVertex3dPROC glVertex3d; static glVertex3dvPROC glVertex3dv; static glVertex3fPROC glVertex3f; static glVertex3fvPROC glVertex3fv; static glVertex3iPROC glVertex3i; static glVertex3ivPROC glVertex3iv; static glVertex3sPROC glVertex3s; static glVertex3svPROC glVertex3sv; static glVertex4dPROC glVertex4d; static glVertex4dvPROC glVertex4dv; static glVertex4fPROC glVertex4f; static glVertex4fvPROC glVertex4fv; static glVertex4iPROC glVertex4i; static glVertex4ivPROC glVertex4iv; static glVertex4sPROC glVertex4s; static glVertex4svPROC glVertex4sv; static glVertexPointerPROC glVertexPointer; static glViewportPROC glViewport; void extgl_InitOpenGL1_1(void) { glAccum = (glAccumPROC) extgl_GetProcAddress("glAccum"); glAlphaFunc = (glAlphaFuncPROC) extgl_GetProcAddress("glAlphaFunc"); glAreTexturesResident = (glAreTexturesResidentPROC) extgl_GetProcAddress("glAreTexturesResident"); glArrayElement = (glArrayElementPROC) extgl_GetProcAddress("glArrayElement"); glBegin = (glBeginPROC) extgl_GetProcAddress("glBegin"); glBindTexture = (glBindTexturePROC) extgl_GetProcAddress("glBindTexture"); glBitmap = (glBitmapPROC) extgl_GetProcAddress("glBitmap"); glBlendFunc = (glBlendFuncPROC) extgl_GetProcAddress("glBlendFunc"); glCallList = (glCallListPROC) extgl_GetProcAddress("glCallList"); glCallLists = (glCallListsPROC) extgl_GetProcAddress("glCallLists"); glClear = (glClearPROC) extgl_GetProcAddress("glClear"); glClearAccum = (glClearAccumPROC) extgl_GetProcAddress("glClearAccum"); glClearColor = (glClearColorPROC) extgl_GetProcAddress("glClearColor"); glClearDepth = (glClearDepthPROC) extgl_GetProcAddress("glClearDepth"); glClearIndex = (glClearIndexPROC) extgl_GetProcAddress("glClearIndex"); glClearStencil = (glClearStencilPROC) extgl_GetProcAddress("glClearStencil"); glClipPlane = (glClipPlanePROC) extgl_GetProcAddress("glClipPlane"); glColor3b = (glColor3bPROC) extgl_GetProcAddress("glColor3b"); glColor3bv = (glColor3bvPROC) extgl_GetProcAddress("glColor3bv"); glColor3d = (glColor3dPROC) extgl_GetProcAddress("glColor3d"); glColor3dv = (glColor3dvPROC) extgl_GetProcAddress("glColor3dv"); glColor3f = (glColor3fPROC) extgl_GetProcAddress("glColor3f"); glColor3fv = (glColor3fvPROC) extgl_GetProcAddress("glColor3fv"); glColor3i = (glColor3iPROC) extgl_GetProcAddress("glColor3i"); glColor3iv = (glColor3ivPROC) extgl_GetProcAddress("glColor3iv"); glColor3s = (glColor3sPROC) extgl_GetProcAddress("glColor3s"); glColor3sv = (glColor3svPROC) extgl_GetProcAddress("glColor3sv"); glColor3ub = (glColor3ubPROC) extgl_GetProcAddress("glColor3ub"); glColor3ubv = (glColor3ubvPROC) extgl_GetProcAddress("glColor3ubv"); glColor3ui = (glColor3uiPROC) extgl_GetProcAddress("glColor3ui"); glColor3uiv = (glColor3uivPROC) extgl_GetProcAddress("glColor3uiv"); glColor3us = (glColor3usPROC) extgl_GetProcAddress("glColor3us"); glColor3usv = (glColor3usvPROC) extgl_GetProcAddress("glColor3usv"); glColor4b = (glColor4bPROC) extgl_GetProcAddress("glColor4b"); glColor4bv = (glColor4bvPROC) extgl_GetProcAddress("glColor4bv"); glColor4d = (glColor4dPROC) extgl_GetProcAddress("glColor4d"); glColor4dv = (glColor4dvPROC) extgl_GetProcAddress("glColor4dv"); glColor4f = (glColor4fPROC) extgl_GetProcAddress("glColor4f"); glColor4fv = (glColor4fvPROC) extgl_GetProcAddress("glColor4fv"); glColor4i = (glColor4iPROC) extgl_GetProcAddress("glColor4i"); glColor4iv = (glColor4ivPROC) extgl_GetProcAddress("glColor4iv"); glColor4s = (glColor4sPROC) extgl_GetProcAddress("glColor4s"); glColor4sv = (glColor4svPROC) extgl_GetProcAddress("glColor4sv"); glColor4ub = (glColor4ubPROC) extgl_GetProcAddress("glColor4ub"); glColor4ubv = (glColor4ubvPROC) extgl_GetProcAddress("glColor4ubv"); glColor4ui = (glColor4uiPROC) extgl_GetProcAddress("glColor4ui"); glColor4uiv = (glColor4uivPROC) extgl_GetProcAddress("glColor4uiv"); glColor4us = (glColor4usPROC) extgl_GetProcAddress("glColor4us"); glColor4usv = (glColor4usvPROC) extgl_GetProcAddress("glColor4usv"); glColorMask = (glColorMaskPROC) extgl_GetProcAddress("glColorMask"); glColorMaterial = (glColorMaterialPROC) extgl_GetProcAddress("glColorMaterial"); glColorPointer = (glColorPointerPROC) extgl_GetProcAddress("glColorPointer"); glCopyPixels = (glCopyPixelsPROC) extgl_GetProcAddress("glCopyPixels"); glCopyTexImage1D = (glCopyTexImage1DPROC) extgl_GetProcAddress("glCopyTexImage1D"); glCopyTexImage2D = (glCopyTexImage2DPROC) extgl_GetProcAddress("glCopyTexImage2D"); glCopyTexSubImage1D = (glCopyTexSubImage1DPROC) extgl_GetProcAddress("glCopyTexSubImage1D"); glCopyTexSubImage2D = (glCopyTexSubImage2DPROC) extgl_GetProcAddress("glCopyTexSubImage2D"); glCullFace = (glCullFacePROC) extgl_GetProcAddress("glCullFace"); glDeleteLists = (glDeleteListsPROC) extgl_GetProcAddress("glDeleteLists"); glDeleteTextures = (glDeleteTexturesPROC) extgl_GetProcAddress("glDeleteTextures"); glDepthFunc = (glDepthFuncPROC) extgl_GetProcAddress("glDepthFunc"); glDepthMask = (glDepthMaskPROC) extgl_GetProcAddress("glDepthMask"); glDepthRange = (glDepthRangePROC) extgl_GetProcAddress("glDepthRange"); glDisable = (glDisablePROC) extgl_GetProcAddress("glDisable"); glDisableClientState = (glDisableClientStatePROC) extgl_GetProcAddress("glDisableClientState"); glDrawArrays = (glDrawArraysPROC) extgl_GetProcAddress("glDrawArrays"); glDrawBuffer = (glDrawBufferPROC) extgl_GetProcAddress("glDrawBuffer"); glDrawElements = (glDrawElementsPROC) extgl_GetProcAddress("glDrawElements"); glDrawPixels = (glDrawPixelsPROC) extgl_GetProcAddress("glDrawPixels"); glEdgeFlag = (glEdgeFlagPROC) extgl_GetProcAddress("glEdgeFlag"); glEdgeFlagPointer = (glEdgeFlagPointerPROC) extgl_GetProcAddress("glEdgeFlagPointer"); glEdgeFlagv = (glEdgeFlagvPROC) extgl_GetProcAddress("glEdgeFlagv"); glEnable = (glEnablePROC) extgl_GetProcAddress("glEnable"); glEnableClientState = (glEnableClientStatePROC) extgl_GetProcAddress("glEnableClientState"); glEnd = (glEndPROC) extgl_GetProcAddress("glEnd"); glEndList = (glEndListPROC) extgl_GetProcAddress("glEndList"); glEvalCoord1d = (glEvalCoord1dPROC) extgl_GetProcAddress("glEvalCoord1d"); glEvalCoord1dv = (glEvalCoord1dvPROC) extgl_GetProcAddress("glEvalCoord1dv"); glEvalCoord1f = (glEvalCoord1fPROC) extgl_GetProcAddress("glEvalCoord1f"); glEvalCoord1fv = (glEvalCoord1fvPROC) extgl_GetProcAddress("glEvalCoord1fv"); glEvalCoord2d = (glEvalCoord2dPROC) extgl_GetProcAddress("glEvalCoord2d"); glEvalCoord2dv = (glEvalCoord2dvPROC) extgl_GetProcAddress("glEvalCoord2dv"); glEvalCoord2f = (glEvalCoord2fPROC) extgl_GetProcAddress("glEvalCoord2f"); glEvalCoord2fv = (glEvalCoord2fvPROC) extgl_GetProcAddress("glEvalCoord2fv"); glEvalMesh1 = (glEvalMesh1PROC) extgl_GetProcAddress("glEvalMesh1"); glEvalMesh2 = (glEvalMesh2PROC) extgl_GetProcAddress("glEvalMesh2"); glEvalPoint1 = (glEvalPoint1PROC) extgl_GetProcAddress("glEvalPoint1"); glEvalPoint2 = (glEvalPoint2PROC) extgl_GetProcAddress("glEvalPoint2"); glFeedbackBuffer = (glFeedbackBufferPROC) extgl_GetProcAddress("glFeedbackBuffer"); glFinish = (glFinishPROC) extgl_GetProcAddress("glFinish"); glFlush = (glFlushPROC) extgl_GetProcAddress("glFlush"); glFogf = (glFogfPROC) extgl_GetProcAddress("glFogf"); glFogfv = (glFogfvPROC) extgl_GetProcAddress("glFogfv"); glFogi = (glFogiPROC) extgl_GetProcAddress("glFogi"); glFogiv = (glFogivPROC) extgl_GetProcAddress("glFogiv"); glFrontFace = (glFrontFacePROC) extgl_GetProcAddress("glFrontFace"); glFrustum = (glFrustumPROC) extgl_GetProcAddress("glFrustum"); glGenLists = (glGenListsPROC) extgl_GetProcAddress("glGenLists"); glGenTextures = (glGenTexturesPROC) extgl_GetProcAddress("glGenTextures"); glGetBooleanv = (glGetBooleanvPROC) extgl_GetProcAddress("glGetBooleanv"); glGetClipPlane = (glGetClipPlanePROC) extgl_GetProcAddress("glGetClipPlane"); glGetDoublev = (glGetDoublevPROC) extgl_GetProcAddress("glGetDoublev"); glGetError = (glGetErrorPROC) extgl_GetProcAddress("glGetError"); glGetFloatv = (glGetFloatvPROC) extgl_GetProcAddress("glGetFloatv"); glGetIntegerv = (glGetIntegervPROC) extgl_GetProcAddress("glGetIntegerv"); glGetLightfv = (glGetLightfvPROC) extgl_GetProcAddress("glGetLightfv"); glGetLightiv = (glGetLightivPROC) extgl_GetProcAddress("glGetLightiv"); glGetMapdv = (glGetMapdvPROC) extgl_GetProcAddress("glGetMapdv"); glGetMapfv = (glGetMapfvPROC) extgl_GetProcAddress("glGetMapfv"); glGetMapiv = (glGetMapivPROC) extgl_GetProcAddress("glGetMapiv"); glGetMaterialfv = (glGetMaterialfvPROC) extgl_GetProcAddress("glGetMaterialfv"); glGetMaterialiv = (glGetMaterialivPROC) extgl_GetProcAddress("glGetMaterialiv"); glGetPixelMapfv = (glGetPixelMapfvPROC) extgl_GetProcAddress("glGetPixelMapfv"); glGetPixelMapuiv = (glGetPixelMapuivPROC) extgl_GetProcAddress("glGetPixelMapuiv"); glGetPixelMapusv = (glGetPixelMapusvPROC) extgl_GetProcAddress("glGetPixelMapusv"); glGetPointerv = (glGetPointervPROC) extgl_GetProcAddress("glGetPointerv"); glGetPolygonStipple = (glGetPolygonStipplePROC) extgl_GetProcAddress("glGetPolygonStipple"); glGetString = (glGetStringPROC) extgl_GetProcAddress("glGetString"); glGetTexEnvfv = (glGetTexEnvfvPROC) extgl_GetProcAddress("glGetTexEnvfv"); glGetTexEnviv = (glGetTexEnvivPROC) extgl_GetProcAddress("glGetTexEnviv"); glGetTexGendv = (glGetTexGendvPROC) extgl_GetProcAddress("glGetTexGendv"); glGetTexGenfv = (glGetTexGenfvPROC) extgl_GetProcAddress("glGetTexGenfv"); glGetTexGeniv = (glGetTexGenivPROC) extgl_GetProcAddress("glGetTexGeniv"); glGetTexImage = (glGetTexImagePROC) extgl_GetProcAddress("glGetTexImage"); glGetTexLevelParameterfv = (glGetTexLevelParameterfvPROC) extgl_GetProcAddress("glGetTexLevelParameterfv"); glGetTexLevelParameteriv = (glGetTexLevelParameterivPROC) extgl_GetProcAddress("glGetTexLevelParameteriv"); glGetTexParameterfv = (glGetTexParameterfvPROC) extgl_GetProcAddress("glGetTexParameterfv"); glGetTexParameteriv = (glGetTexParameterivPROC) extgl_GetProcAddress("glGetTexParameteriv"); glHint = (glHintPROC) extgl_GetProcAddress("glHint"); glIndexMask = (glIndexMaskPROC) extgl_GetProcAddress("glIndexMask"); glIndexPointer = (glIndexPointerPROC) extgl_GetProcAddress("glIndexPointer"); glIndexd = (glIndexdPROC) extgl_GetProcAddress("glIndexd"); glIndexdv = (glIndexdvPROC) extgl_GetProcAddress("glIndexdv"); glIndexf = (glIndexfPROC) extgl_GetProcAddress("glIndexf"); glIndexfv = (glIndexfvPROC) extgl_GetProcAddress("glIndexfv"); glIndexi = (glIndexiPROC) extgl_GetProcAddress("glIndexi"); glIndexiv = (glIndexivPROC) extgl_GetProcAddress("glIndexiv"); glIndexs = (glIndexsPROC) extgl_GetProcAddress("glIndexs"); glIndexsv = (glIndexsvPROC) extgl_GetProcAddress("glIndexsv"); glIndexub = (glIndexubPROC) extgl_GetProcAddress("glIndexub"); glIndexubv = (glIndexubvPROC) extgl_GetProcAddress("glIndexubv"); glInitNames = (glInitNamesPROC) extgl_GetProcAddress("glInitNames"); glInterleavedArrays = (glInterleavedArraysPROC) extgl_GetProcAddress("glInterleavedArrays"); glIsEnabled = (glIsEnabledPROC) extgl_GetProcAddress("glIsEnabled"); glIsList = (glIsListPROC) extgl_GetProcAddress("glIsList"); glIsTexture = (glIsTexturePROC) extgl_GetProcAddress("glIsTexture"); glLightModelf = (glLightModelfPROC) extgl_GetProcAddress("glLightModelf"); glLightModelfv = (glLightModelfvPROC) extgl_GetProcAddress("glLightModelfv"); glLightModeli = (glLightModeliPROC) extgl_GetProcAddress("glLightModeli"); glLightModeliv = (glLightModelivPROC) extgl_GetProcAddress("glLightModeliv"); glLightf = (glLightfPROC) extgl_GetProcAddress("glLightf"); glLightfv = (glLightfvPROC) extgl_GetProcAddress("glLightfv"); glLighti = (glLightiPROC) extgl_GetProcAddress("glLighti"); glLightiv = (glLightivPROC) extgl_GetProcAddress("glLightiv"); glLineStipple = (glLineStipplePROC) extgl_GetProcAddress("glLineStipple"); glLineWidth = (glLineWidthPROC) extgl_GetProcAddress("glLineWidth"); glListBase = (glListBasePROC) extgl_GetProcAddress("glListBase"); glLoadIdentity = (glLoadIdentityPROC) extgl_GetProcAddress("glLoadIdentity"); glLoadMatrixd = (glLoadMatrixdPROC) extgl_GetProcAddress("glLoadMatrixd"); glLoadMatrixf = (glLoadMatrixfPROC) extgl_GetProcAddress("glLoadMatrixf"); glLoadName = (glLoadNamePROC) extgl_GetProcAddress("glLoadName"); glLogicOp = (glLogicOpPROC) extgl_GetProcAddress("glLogicOp"); glMap1d = (glMap1dPROC) extgl_GetProcAddress("glMap1d"); glMap1f = (glMap1fPROC) extgl_GetProcAddress("glMap1f"); glMap2d = (glMap2dPROC) extgl_GetProcAddress("glMap2d"); glMap2f = (glMap2fPROC) extgl_GetProcAddress("glMap2f"); glMapGrid1d = (glMapGrid1dPROC) extgl_GetProcAddress("glMapGrid1d"); glMapGrid1f = (glMapGrid1fPROC) extgl_GetProcAddress("glMapGrid1f"); glMapGrid2d = (glMapGrid2dPROC) extgl_GetProcAddress("glMapGrid2d"); glMapGrid2f = (glMapGrid2fPROC) extgl_GetProcAddress("glMapGrid2f"); glMaterialf = (glMaterialfPROC) extgl_GetProcAddress("glMaterialf"); glMaterialfv = (glMaterialfvPROC) extgl_GetProcAddress("glMaterialfv"); glMateriali = (glMaterialiPROC) extgl_GetProcAddress("glMateriali"); glMaterialiv = (glMaterialivPROC) extgl_GetProcAddress("glMaterialiv"); glMatrixMode = (glMatrixModePROC) extgl_GetProcAddress("glMatrixMode"); glMultMatrixd = (glMultMatrixdPROC) extgl_GetProcAddress("glMultMatrixd"); glMultMatrixf = (glMultMatrixfPROC) extgl_GetProcAddress("glMultMatrixf"); glNewList = (glNewListPROC) extgl_GetProcAddress("glNewList"); glNormal3b = (glNormal3bPROC) extgl_GetProcAddress("glNormal3b"); glNormal3bv = (glNormal3bvPROC) extgl_GetProcAddress("glNormal3bv"); glNormal3d = (glNormal3dPROC) extgl_GetProcAddress("glNormal3d"); glNormal3dv = (glNormal3dvPROC) extgl_GetProcAddress("glNormal3dv"); glNormal3f = (glNormal3fPROC) extgl_GetProcAddress("glNormal3f"); glNormal3fv = (glNormal3fvPROC) extgl_GetProcAddress("glNormal3fv"); glNormal3i = (glNormal3iPROC) extgl_GetProcAddress("glNormal3i"); glNormal3iv = (glNormal3ivPROC) extgl_GetProcAddress("glNormal3iv"); glNormal3s = (glNormal3sPROC) extgl_GetProcAddress("glNormal3s"); glNormal3sv = (glNormal3svPROC) extgl_GetProcAddress("glNormal3sv"); glNormalPointer = (glNormalPointerPROC) extgl_GetProcAddress("glNormalPointer"); glOrtho = (glOrthoPROC) extgl_GetProcAddress("glOrtho"); glPassThrough = (glPassThroughPROC) extgl_GetProcAddress("glPassThrough"); glPixelMapfv = (glPixelMapfvPROC) extgl_GetProcAddress("glPixelMapfv"); glPixelMapuiv = (glPixelMapuivPROC) extgl_GetProcAddress("glPixelMapuiv"); glPixelMapusv = (glPixelMapusvPROC) extgl_GetProcAddress("glPixelMapusv"); glPixelStoref = (glPixelStorefPROC) extgl_GetProcAddress("glPixelStoref"); glPixelStorei = (glPixelStoreiPROC) extgl_GetProcAddress("glPixelStorei"); glPixelTransferf = (glPixelTransferfPROC) extgl_GetProcAddress("glPixelTransferf"); glPixelTransferi = (glPixelTransferiPROC) extgl_GetProcAddress("glPixelTransferi"); glPixelZoom = (glPixelZoomPROC) extgl_GetProcAddress("glPixelZoom"); glPointSize = (glPointSizePROC) extgl_GetProcAddress("glPointSize"); glPolygonMode = (glPolygonModePROC) extgl_GetProcAddress("glPolygonMode"); glPolygonOffset = (glPolygonOffsetPROC) extgl_GetProcAddress("glPolygonOffset"); glPolygonStipple = (glPolygonStipplePROC) extgl_GetProcAddress("glPolygonStipple"); glPopAttrib = (glPopAttribPROC) extgl_GetProcAddress("glPopAttrib"); glPopClientAttrib = (glPopClientAttribPROC) extgl_GetProcAddress("glPopClientAttrib"); glPopMatrix = (glPopMatrixPROC) extgl_GetProcAddress("glPopMatrix"); glPopName = (glPopNamePROC) extgl_GetProcAddress("glPopName"); glPrioritizeTextures = (glPrioritizeTexturesPROC) extgl_GetProcAddress("glPrioritizeTextures"); glPushAttrib = (glPushAttribPROC) extgl_GetProcAddress("glPushAttrib"); glPushClientAttrib = (glPushClientAttribPROC) extgl_GetProcAddress("glPushClientAttrib"); glPushMatrix = (glPushMatrixPROC) extgl_GetProcAddress("glPushMatrix"); glPushName = (glPushNamePROC) extgl_GetProcAddress("glPushName"); glRasterPos2d = (glRasterPos2dPROC) extgl_GetProcAddress("glRasterPos2d"); glRasterPos2dv = (glRasterPos2dvPROC) extgl_GetProcAddress("glRasterPos2dv"); glRasterPos2f = (glRasterPos2fPROC) extgl_GetProcAddress("glRasterPos2f"); glRasterPos2fv = (glRasterPos2fvPROC) extgl_GetProcAddress("glRasterPos2fv"); glRasterPos2i = (glRasterPos2iPROC) extgl_GetProcAddress("glRasterPos2i"); glRasterPos2iv = (glRasterPos2ivPROC) extgl_GetProcAddress("glRasterPos2iv"); glRasterPos2s = (glRasterPos2sPROC) extgl_GetProcAddress("glRasterPos2s"); glRasterPos2sv = (glRasterPos2svPROC) extgl_GetProcAddress("glRasterPos2sv"); glRasterPos3d = (glRasterPos3dPROC) extgl_GetProcAddress("glRasterPos3d"); glRasterPos3dv = (glRasterPos3dvPROC) extgl_GetProcAddress("glRasterPos3dv"); glRasterPos3f = (glRasterPos3fPROC) extgl_GetProcAddress("glRasterPos3f"); glRasterPos3fv = (glRasterPos3fvPROC) extgl_GetProcAddress("glRasterPos3fv"); glRasterPos3i = (glRasterPos3iPROC) extgl_GetProcAddress("glRasterPos3i"); glRasterPos3iv = (glRasterPos3ivPROC) extgl_GetProcAddress("glRasterPos3iv"); glRasterPos3s = (glRasterPos3sPROC) extgl_GetProcAddress("glRasterPos3s"); glRasterPos3sv = (glRasterPos3svPROC) extgl_GetProcAddress("glRasterPos3sv"); glRasterPos4d = (glRasterPos4dPROC) extgl_GetProcAddress("glRasterPos4d"); glRasterPos4dv = (glRasterPos4dvPROC) extgl_GetProcAddress("glRasterPos4dv"); glRasterPos4f = (glRasterPos4fPROC) extgl_GetProcAddress("glRasterPos4f"); glRasterPos4fv = (glRasterPos4fvPROC) extgl_GetProcAddress("glRasterPos4fv"); glRasterPos4i = (glRasterPos4iPROC) extgl_GetProcAddress("glRasterPos4i"); glRasterPos4iv = (glRasterPos4ivPROC) extgl_GetProcAddress("glRasterPos4iv"); glRasterPos4s = (glRasterPos4sPROC) extgl_GetProcAddress("glRasterPos4s"); glRasterPos4sv = (glRasterPos4svPROC) extgl_GetProcAddress("glRasterPos4sv"); glReadBuffer = (glReadBufferPROC) extgl_GetProcAddress("glReadBuffer"); glReadPixels = (glReadPixelsPROC) extgl_GetProcAddress("glReadPixels"); glRectd = (glRectdPROC) extgl_GetProcAddress("glRectd"); glRectdv = (glRectdvPROC) extgl_GetProcAddress("glRectdv"); glRectf = (glRectfPROC) extgl_GetProcAddress("glRectf"); glRectfv = (glRectfvPROC) extgl_GetProcAddress("glRectfv"); glRecti = (glRectiPROC) extgl_GetProcAddress("glRecti"); glRectiv = (glRectivPROC) extgl_GetProcAddress("glRectiv"); glRects = (glRectsPROC) extgl_GetProcAddress("glRects"); glRectsv = (glRectsvPROC) extgl_GetProcAddress("glRectsv"); glRenderMode = (glRenderModePROC) extgl_GetProcAddress("glRenderMode"); glRotated = (glRotatedPROC) extgl_GetProcAddress("glRotated"); glRotatef = (glRotatefPROC) extgl_GetProcAddress("glRotatef"); glScaled = (glScaledPROC) extgl_GetProcAddress("glScaled"); glScalef = (glScalefPROC) extgl_GetProcAddress("glScalef"); glScissor = (glScissorPROC) extgl_GetProcAddress("glScissor"); glSelectBuffer = (glSelectBufferPROC) extgl_GetProcAddress("glSelectBuffer"); glShadeModel = (glShadeModelPROC) extgl_GetProcAddress("glShadeModel"); glStencilFunc = (glStencilFuncPROC) extgl_GetProcAddress("glStencilFunc"); glStencilMask = (glStencilMaskPROC) extgl_GetProcAddress("glStencilMask"); glStencilOp = (glStencilOpPROC) extgl_GetProcAddress("glStencilOp"); glTexCoord1d = (glTexCoord1dPROC) extgl_GetProcAddress("glTexCoord1d"); glTexCoord1dv = (glTexCoord1dvPROC) extgl_GetProcAddress("glTexCoord1dv"); glTexCoord1f = (glTexCoord1fPROC) extgl_GetProcAddress("glTexCoord1f"); glTexCoord1fv = (glTexCoord1fvPROC) extgl_GetProcAddress("glTexCoord1fv"); glTexCoord1i = (glTexCoord1iPROC) extgl_GetProcAddress("glTexCoord1i"); glTexCoord1iv = (glTexCoord1ivPROC) extgl_GetProcAddress("glTexCoord1iv"); glTexCoord1s = (glTexCoord1sPROC) extgl_GetProcAddress("glTexCoord1s"); glTexCoord1sv = (glTexCoord1svPROC) extgl_GetProcAddress("glTexCoord1sv"); glTexCoord2d = (glTexCoord2dPROC) extgl_GetProcAddress("glTexCoord2d"); glTexCoord2dv = (glTexCoord2dvPROC) extgl_GetProcAddress("glTexCoord2dv"); glTexCoord2f = (glTexCoord2fPROC) extgl_GetProcAddress("glTexCoord2f"); glTexCoord2fv = (glTexCoord2fvPROC) extgl_GetProcAddress("glTexCoord2fv"); glTexCoord2i = (glTexCoord2iPROC) extgl_GetProcAddress("glTexCoord2i"); glTexCoord2iv = (glTexCoord2ivPROC) extgl_GetProcAddress("glTexCoord2iv"); glTexCoord2s = (glTexCoord2sPROC) extgl_GetProcAddress("glTexCoord2s"); glTexCoord2sv = (glTexCoord2svPROC) extgl_GetProcAddress("glTexCoord2sv"); glTexCoord3d = (glTexCoord3dPROC) extgl_GetProcAddress("glTexCoord3d"); glTexCoord3dv = (glTexCoord3dvPROC) extgl_GetProcAddress("glTexCoord3dv"); glTexCoord3f = (glTexCoord3fPROC) extgl_GetProcAddress("glTexCoord3f"); glTexCoord3fv = (glTexCoord3fvPROC) extgl_GetProcAddress("glTexCoord3fv"); glTexCoord3i = (glTexCoord3iPROC) extgl_GetProcAddress("glTexCoord3i"); glTexCoord3iv = (glTexCoord3ivPROC) extgl_GetProcAddress("glTexCoord3iv"); glTexCoord3s = (glTexCoord3sPROC) extgl_GetProcAddress("glTexCoord3s"); glTexCoord3sv = (glTexCoord3svPROC) extgl_GetProcAddress("glTexCoord3sv"); glTexCoord4d = (glTexCoord4dPROC) extgl_GetProcAddress("glTexCoord4d"); glTexCoord4dv = (glTexCoord4dvPROC) extgl_GetProcAddress("glTexCoord4dv"); glTexCoord4f = (glTexCoord4fPROC) extgl_GetProcAddress("glTexCoord4f"); glTexCoord4fv = (glTexCoord4fvPROC) extgl_GetProcAddress("glTexCoord4fv"); glTexCoord4i = (glTexCoord4iPROC) extgl_GetProcAddress("glTexCoord4i"); glTexCoord4iv = (glTexCoord4ivPROC) extgl_GetProcAddress("glTexCoord4iv"); glTexCoord4s = (glTexCoord4sPROC) extgl_GetProcAddress("glTexCoord4s"); glTexCoord4sv = (glTexCoord4svPROC) extgl_GetProcAddress("glTexCoord4sv"); glTexCoordPointer = (glTexCoordPointerPROC) extgl_GetProcAddress("glTexCoordPointer"); glTexEnvf = (glTexEnvfPROC) extgl_GetProcAddress("glTexEnvf"); glTexEnvfv = (glTexEnvfvPROC) extgl_GetProcAddress("glTexEnvfv"); glTexEnvi = (glTexEnviPROC) extgl_GetProcAddress("glTexEnvi"); glTexEnviv = (glTexEnvivPROC) extgl_GetProcAddress("glTexEnviv"); glTexGend = (glTexGendPROC) extgl_GetProcAddress("glTexGend"); glTexGendv = (glTexGendvPROC) extgl_GetProcAddress("glTexGendv"); glTexGenf = (glTexGenfPROC) extgl_GetProcAddress("glTexGenf"); glTexGenfv = (glTexGenfvPROC) extgl_GetProcAddress("glTexGenfv"); glTexGeni = (glTexGeniPROC) extgl_GetProcAddress("glTexGeni"); glTexGeniv = (glTexGenivPROC) extgl_GetProcAddress("glTexGeniv"); glTexImage1D = (glTexImage1DPROC) extgl_GetProcAddress("glTexImage1D"); glTexImage2D = (glTexImage2DPROC) extgl_GetProcAddress("glTexImage2D"); glTexParameterf = (glTexParameterfPROC) extgl_GetProcAddress("glTexParameterf"); glTexParameterfv = (glTexParameterfvPROC) extgl_GetProcAddress("glTexParameterfv"); glTexParameteri = (glTexParameteriPROC) extgl_GetProcAddress("glTexParameteri"); glTexParameteriv = (glTexParameterivPROC) extgl_GetProcAddress("glTexParameteriv"); glTexSubImage1D = (glTexSubImage1DPROC) extgl_GetProcAddress("glTexSubImage1D"); glTexSubImage2D = (glTexSubImage2DPROC) extgl_GetProcAddress("glTexSubImage2D"); glTranslated = (glTranslatedPROC) extgl_GetProcAddress("glTranslated"); glTranslatef = (glTranslatefPROC) extgl_GetProcAddress("glTranslatef"); glVertex2d = (glVertex2dPROC) extgl_GetProcAddress("glVertex2d"); glVertex2dv = (glVertex2dvPROC) extgl_GetProcAddress("glVertex2dv"); glVertex2f = (glVertex2fPROC) extgl_GetProcAddress("glVertex2f"); glVertex2fv = (glVertex2fvPROC) extgl_GetProcAddress("glVertex2fv"); glVertex2i = (glVertex2iPROC) extgl_GetProcAddress("glVertex2i"); glVertex2iv = (glVertex2ivPROC) extgl_GetProcAddress("glVertex2iv"); glVertex2s = (glVertex2sPROC) extgl_GetProcAddress("glVertex2s"); glVertex2sv = (glVertex2svPROC) extgl_GetProcAddress("glVertex2sv"); glVertex3d = (glVertex3dPROC) extgl_GetProcAddress("glVertex3d"); glVertex3dv = (glVertex3dvPROC) extgl_GetProcAddress("glVertex3dv"); glVertex3f = (glVertex3fPROC) extgl_GetProcAddress("glVertex3f"); glVertex3fv = (glVertex3fvPROC) extgl_GetProcAddress("glVertex3fv"); glVertex3i = (glVertex3iPROC) extgl_GetProcAddress("glVertex3i"); glVertex3iv = (glVertex3ivPROC) extgl_GetProcAddress("glVertex3iv"); glVertex3s = (glVertex3sPROC) extgl_GetProcAddress("glVertex3s"); glVertex3sv = (glVertex3svPROC) extgl_GetProcAddress("glVertex3sv"); glVertex4d = (glVertex4dPROC) extgl_GetProcAddress("glVertex4d"); glVertex4dv = (glVertex4dvPROC) extgl_GetProcAddress("glVertex4dv"); glVertex4f = (glVertex4fPROC) extgl_GetProcAddress("glVertex4f"); glVertex4fv = (glVertex4fvPROC) extgl_GetProcAddress("glVertex4fv"); glVertex4i = (glVertex4iPROC) extgl_GetProcAddress("glVertex4i"); glVertex4iv = (glVertex4ivPROC) extgl_GetProcAddress("glVertex4iv"); glVertex4s = (glVertex4sPROC) extgl_GetProcAddress("glVertex4s"); glVertex4sv = (glVertex4svPROC) extgl_GetProcAddress("glVertex4sv"); glVertexPointer = (glVertexPointerPROC) extgl_GetProcAddress("glVertexPointer"); glViewport = (glViewportPROC) extgl_GetProcAddress("glViewport"); } /* * Class: org_lwjgl_opengl_GL11 * Method: glAccum */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glAccum(JNIEnv * env, jclass clazz, jint p0, jfloat p1) { glAccum((GLint) p0, (GLfloat) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glAlphaFunc */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glAlphaFunc(JNIEnv * env, jclass clazz, jint p0, jfloat p1) { glAlphaFunc((GLint) p0, (GLfloat) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glClearColor */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glClearColor(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1, jfloat p2, jfloat p3) { glClearColor((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glClearAccum */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glClearAccum(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1, jfloat p2, jfloat p3) { glClearAccum((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glClear */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glClear(JNIEnv * env, jclass clazz, jint p0) { glClear((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glCallLists */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglCallLists(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject lists_buffer, jint lists_offset) { GLbyte *lists = (GLbyte *)env->GetDirectBufferAddress(lists_buffer); glCallLists((GLint) p0, (GLint) p1, (const void *)(lists + lists_offset)); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glCallList */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glCallList(JNIEnv * env, jclass clazz, jint p0) { glCallList((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glBlendFunc */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glBlendFunc(JNIEnv * env, jclass clazz, jint p0, jint p1) { glBlendFunc((GLint) p0, (GLint) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glBitmap */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglBitmap(JNIEnv * env, jclass clazz, jint p0, jint p1, jfloat p2, jfloat p3, jfloat p4, jfloat p5, jobject image_buffer, jint image_offset) { const GLubyte *image = (const GLubyte *)env->GetDirectBufferAddress(image_buffer); glBitmap((GLint) p0, (GLint) p1, (GLfloat) p2, (GLfloat) p3, (GLfloat) p4, (GLfloat) p5, image + image_offset); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glBindTexture */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glBindTexture(JNIEnv * env, jclass clazz, jint p0, jint p1) { glBindTexture((GLint) p0, (GLint) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glBegin */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glBegin(JNIEnv * env, jclass clazz, jint p0) { glBegin((GLint) p0); } /* * Class: org_lwjgl_opengl_GL11 * Method: glEnd */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glEnd(JNIEnv * env, jclass clazz) { glEnd(); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glArrayElement */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glArrayElement(JNIEnv * env, jclass clazz, jint p0) { glArrayElement((GLint) p0); } /* * Class: org_lwjgl_opengl_GL11 * Method: glClearDepth */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glClearDepth(JNIEnv * env, jclass clazz, jdouble p0) { glClearDepth((GLdouble) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glDeleteLists */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glDeleteLists(JNIEnv * env, jclass clazz, jint p0, jint p1) { glDeleteLists((GLuint) p0, (GLint) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glDeleteTextures */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglDeleteTextures(JNIEnv * env, jclass clazz, jint p0, jobject buffer, jint offset) { const GLuint *address = (const GLuint *)(offset + (const GLbyte *)env->GetDirectBufferAddress(buffer)); glDeleteTextures((GLint) p0, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glCullFace */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glCullFace(JNIEnv * env, jclass clazz, jint p0) { glCullFace((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glCopyTexSubImage2D */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glCopyTexSubImage2D(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7) { glCopyTexSubImage2D((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (GLint) p7); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glCopyTexSubImage1D */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glCopyTexSubImage1D(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5) { glCopyTexSubImage1D((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glCopyTexImage2D */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glCopyTexImage2D(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7) { glCopyTexImage2D((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (GLint) p7); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glCopyTexImage1D */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glCopyTexImage1D(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6) { glCopyTexImage1D((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glCopyPixels */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glCopyPixels(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jint p4) { glCopyPixels((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: nglColorPointer */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglColorPointer(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jobject buffer, jint buffer_offset) { const GLbyte *address = (const GLbyte *)env->GetDirectBufferAddress(buffer); glColorPointer((GLint) p0, (GLint) p1, (GLint) p2, (const void *) (address + buffer_offset)); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: nglColorPointerVBO */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglColorPointerVBO(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint buffer_offset) { glColorPointer((GLint) p0, (GLint) p1, (GLint) p2, offsetToPointer(buffer_offset)); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glColorMaterial */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glColorMaterial(JNIEnv * env, jclass clazz, jint p0, jint p1) { glColorMaterial((GLint) p0, (GLint) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glColorMask */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glColorMask(JNIEnv * env, jclass clazz, jboolean p0, jboolean p1, jboolean p2, jboolean p3) { glColorMask((GLboolean) p0, (GLboolean) p1, (GLboolean) p2, (GLboolean) p3); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glColor3b */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glColor3b(JNIEnv * env, jclass clazz, jbyte p0, jbyte p1, jbyte p2) { glColor3b((GLbyte) p0, (GLbyte) p1, (GLbyte) p2); } /* * Class: org_lwjgl_opengl_GL11 * Method: glColor3f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glColor3f(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1, jfloat p2) { glColor3f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2); } /* * Class: org_lwjgl_opengl_GL11 * Method: glColor3ub */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glColor3ub(JNIEnv * env, jclass clazz, jbyte p0, jbyte p1, jbyte p2) { glColor3ub((GLbyte) p0, (GLbyte) p1, (GLbyte) p2); } /* * Class: org_lwjgl_opengl_GL11 * Method: glColor4b */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glColor4b(JNIEnv * env, jclass clazz, jbyte p0, jbyte p1, jbyte p2, jbyte p3) { glColor4b((GLbyte) p0, (GLbyte) p1, (GLbyte) p2, (GLbyte) p3); } /* * Class: org_lwjgl_opengl_GL11 * Method: glColor4f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glColor4f(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1, jfloat p2, jfloat p3) { glColor4f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); } /* * Class: org_lwjgl_opengl_GL11 * Method: glColor4ub */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glColor4ub(JNIEnv * env, jclass clazz, jbyte p0, jbyte p1, jbyte p2, jbyte p3) { glColor4ub((GLbyte) p0, (GLbyte) p1, (GLbyte) p2, (GLbyte) p3); } /* * Class: org_lwjgl_opengl_GL11 * Method: glClipPlane */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglClipPlane(JNIEnv * env, jclass clazz, jint p0, jobject buffer, jint offset) { const GLdouble *address = offset + (const GLdouble *)env->GetDirectBufferAddress(buffer); glClipPlane((GLint) p0, address + offset); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glClearStencil */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glClearStencil(JNIEnv * env, jclass clazz, jint p0) { glClearStencil((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glClearIndex */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glClearIndex(JNIEnv * env, jclass clazz, jfloat p0) { glClearIndex((GLfloat) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glEvalPoint1 */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glEvalPoint1(JNIEnv * env, jclass clazz, jint p0) { glEvalPoint1((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glEvalPoint2 */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glEvalPoint2(JNIEnv * env, jclass clazz, jint p0, jint p1) { glEvalPoint2((GLint) p0, (GLint) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glEvalMesh1 */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glEvalMesh1(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2) { glEvalMesh1((GLint) p0, (GLint) p1, (GLint) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glEvalMesh2 */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glEvalMesh2(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jint p4) { glEvalMesh2((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glEvalCoord1f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glEvalCoord1f(JNIEnv * env, jclass clazz, jfloat p0) { glEvalCoord1f((GLfloat) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glEvalCoord2f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glEvalCoord2f(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1) { glEvalCoord2f((GLfloat) p0, (GLfloat) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glEnableClientState */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glEnableClientState(JNIEnv * env, jclass clazz, jint p0) { glEnableClientState((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glDisableClientState */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glDisableClientState(JNIEnv * env, jclass clazz, jint p0) { glDisableClientState((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glEnable */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glEnable(JNIEnv * env, jclass clazz, jint p0) { glEnable((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glDisable */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glDisable(JNIEnv * env, jclass clazz, jint p0) { glDisable((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: nglEdgeFlagPointer */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglEdgeFlagPointer(JNIEnv * env, jclass clazz, jint p0, jobject buffer, jint offset) { const GLbyte *address = offset + (const GLbyte *)env->GetDirectBufferAddress(buffer); glEdgeFlagPointer((GLint) p0, (const void *)address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: nglEdgeFlagPointerVBO */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglEdgeFlagPointerVBO(JNIEnv * env, jclass clazz, jint p0, jint buffer_offset) { glEdgeFlagPointer((GLint) p0, offsetToPointer(buffer_offset)); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glEdgeFlag */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glEdgeFlag(JNIEnv * env, jclass clazz, jboolean p0) { glEdgeFlag((GLboolean) p0); } /* * Class: org_lwjgl_opengl_GL11 * Method: glDrawPixels */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglDrawPixels(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jobject buffer, jint offset) { const GLbyte *address = (const GLbyte *)env->GetDirectBufferAddress(buffer); glDrawPixels((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (const void *)(address + offset)); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: nglDrawElements */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglDrawElements(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jobject buffer, jint offset) { const GLbyte *address = (const GLbyte *)env->GetDirectBufferAddress(buffer); glDrawElements((GLint) p0, (GLint) p1, (GLint) p2, (const void *)(address + offset)); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: nglDrawElementsVBO */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglDrawElementsVBO(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint buffer_offset) { glDrawElements((GLint) p0, (GLint) p1, (GLint) p2, offsetToPointer(buffer_offset)); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glDrawBuffer */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glDrawBuffer(JNIEnv * env, jclass clazz, jint p0) { glDrawBuffer((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glDrawArrays */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glDrawArrays(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2) { glDrawArrays((GLint) p0, (GLint) p1, (GLint) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glDepthRange */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glDepthRange(JNIEnv * env, jclass clazz, jdouble p0, jdouble p1) { glDepthRange((GLdouble) p0, (GLdouble) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glDepthMask */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glDepthMask(JNIEnv * env, jclass clazz, jboolean p0) { glDepthMask((GLboolean) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glDepthFunc */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glDepthFunc(JNIEnv * env, jclass clazz, jint p0) { glDepthFunc((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glFeedbackBuffer */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglFeedbackBuffer(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { GLfloat *address = offset + (GLfloat *)env->GetDirectBufferAddress(buffer); glFeedbackBuffer((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetPixelMapfv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetPixelMapfv(JNIEnv * env, jclass clazz, jint p0, jobject buffer, jint offset) { GLfloat *address = offset + (GLfloat *)env->GetDirectBufferAddress(buffer); glGetPixelMapfv((GLint) p0, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetPixelMapuiv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetPixelMapuiv(JNIEnv * env, jclass clazz, jint p0, jobject buffer, jint offset) { GLuint *address = offset + (GLuint *)env->GetDirectBufferAddress(buffer); glGetPixelMapuiv((GLint) p0, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetPixelMapusv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetPixelMapusv(JNIEnv * env, jclass clazz, jint p0, jobject buffer, jint offset) { GLushort *address = (GLushort *)env->GetDirectBufferAddress(buffer); glGetPixelMapusv((GLint) p0, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetMaterialfv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetMaterialfv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { GLfloat *address = offset + (GLfloat *)env->GetDirectBufferAddress(buffer); glGetMaterialfv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetMaterialiv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetMaterialiv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { GLint *address = offset + (GLint *)env->GetDirectBufferAddress(buffer); glGetMaterialiv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetMapfv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetMapfv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { GLfloat *address = offset + (GLfloat *)env->GetDirectBufferAddress(buffer); glGetMapfv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetMapiv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetMapiv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { GLint *address = offset + (GLint *)env->GetDirectBufferAddress(buffer); glGetMapiv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetLightfv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetLightfv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { GLfloat *address = offset + (GLfloat *)env->GetDirectBufferAddress(buffer); glGetLightfv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetLightiv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetLightiv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { GLint *address = offset + (GLint *)env->GetDirectBufferAddress(buffer); glGetLightiv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetError */ JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL11_glGetError(JNIEnv * env, jclass clazz) { jint ret = (jint) glGetError(); CHECK_GL_ERROR return ret; } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetClipPlane */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetClipPlane(JNIEnv * env, jclass clazz, jint p0, jobject buffer, jint offset) { GLdouble *address = offset + (GLdouble *)env->GetDirectBufferAddress(buffer); glGetClipPlane((GLint) p0, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetBooleanv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetBooleanv(JNIEnv * env, jclass clazz, jint p0, jobject buffer, jint offset) { GLubyte *address = offset + (GLubyte *)env->GetDirectBufferAddress(buffer); glGetBooleanv((GLint) p0, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetDoublev */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetDoublev(JNIEnv * env, jclass clazz, jint p0, jobject buffer, jint offset) { GLdouble *address = offset + (GLdouble *)env->GetDirectBufferAddress(buffer); glGetDoublev((GLint) p0, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetFloatv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetFloatv(JNIEnv * env, jclass clazz, jint p0, jobject buffer, jint offset) { GLfloat *address = offset + (GLfloat *)env->GetDirectBufferAddress(buffer); glGetFloatv((GLint) p0, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetIntegerv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetIntegerv(JNIEnv * env, jclass clazz, jint p0, jobject buffer, jint offset) { GLint *address = offset + (GLint *)env->GetDirectBufferAddress(buffer); glGetIntegerv((GLint) p0, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGenTextures */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGenTextures(JNIEnv * env, jclass clazz, jint p0, jobject buffer, jint offset) { GLuint *address = offset + (GLuint *)env->GetDirectBufferAddress(buffer); glGenTextures((GLint) p0, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGenLists */ JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL11_glGenLists(JNIEnv * env, jclass clazz, jint p0) { jint ret = (jint) glGenLists((GLint) p0); CHECK_GL_ERROR return ret; } /* * Class: org_lwjgl_opengl_GL11 * Method: glFrustum */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glFrustum(JNIEnv * env, jclass clazz, jdouble p0, jdouble p1, jdouble p2, jdouble p3, jdouble p4, jdouble p5) { glFrustum((GLdouble) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3, (GLdouble) p4, (GLdouble) p5); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glFrontFace */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glFrontFace(JNIEnv * env, jclass clazz, jint p0) { glFrontFace((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glFogf */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glFogf(JNIEnv * env, jclass clazz, jint p0, jfloat p1) { glFogf((GLint) p0, (GLfloat) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glFogi */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glFogi(JNIEnv * env, jclass clazz, jint p0, jint p1) { glFogi((GLint) p0, (GLint) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glFogfv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglFogfv(JNIEnv * env, jclass clazz, jint p0, jobject buffer, jint offset) { const GLfloat *address = offset + (const GLfloat *)env->GetDirectBufferAddress(buffer); glFogfv((GLint) p0, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glFogiv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglFogiv(JNIEnv * env, jclass clazz, jint p0, jobject buffer, jint offset) { const GLint *address = offset + (const GLint *)env->GetDirectBufferAddress(buffer); glFogiv((GLint) p0, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glFlush */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glFlush(JNIEnv * env, jclass clazz) { glFlush(); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glFinish */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glFinish(JNIEnv * env, jclass clazz) { glFinish(); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetPointerv */ JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_GL11_glGetPointerv(JNIEnv * env, jclass clazz, jint p0, int size) { void *pointer; glGetPointerv((GLint) p0, &pointer); CHECK_GL_ERROR return safeNewBuffer(env, pointer, size); } /* * Class: org_lwjgl_opengl_GL11 * Method: glIsEnabled */ JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL11_glIsEnabled(JNIEnv * env, jclass clazz, jint p0) { jboolean ret = (jboolean) glIsEnabled((GLint) p0); CHECK_GL_ERROR return ret; } /* * Class: org_lwjgl_opengl_GL11 * Method: nglInterleavedArrays */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglInterleavedArrays(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { const void *address = (const void *)(offset + (GLbyte *)env->GetDirectBufferAddress(buffer)); glInterleavedArrays((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: nglInterleavedArraysVBO */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglInterleavedArraysVBO(JNIEnv * env, jclass clazz, jint p0, jint p1, jint buffer_offset) { glInterleavedArrays((GLint) p0, (GLint) p1, offsetToPointer(buffer_offset)); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glInitNames */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glInitNames(JNIEnv * env, jclass clazz) { glInitNames(); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glHint */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glHint(JNIEnv * env, jclass clazz, jint p0, jint p1) { glHint((GLint) p0, (GLint) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetTexParameterfv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetTexParameterfv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { GLfloat *address = offset + (GLfloat *)env->GetDirectBufferAddress(buffer); glGetTexParameterfv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetTexParameteriv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetTexParameteriv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { GLint *address = offset + (GLint *)env->GetDirectBufferAddress(buffer); glGetTexParameteriv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetTexLevelParameterfv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetTexLevelParameterfv(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jobject buffer, jint offset) { GLfloat *address = offset + (GLfloat *)env->GetDirectBufferAddress(buffer); glGetTexLevelParameterfv((GLint) p0, (GLint) p1, (GLint) p2, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetTexLevelParameteriv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetTexLevelParameteriv(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jobject buffer, jint offset) { GLint *address = offset + (GLint *)env->GetDirectBufferAddress(buffer); glGetTexLevelParameteriv((GLint) p0, (GLint) p1, (GLint) p2, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetTexImage */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetTexImage(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jobject buffer, jint offset) { void *address = (void *)(offset + (GLbyte *)env->GetDirectBufferAddress(buffer)); glGetTexImage((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetTexGenfv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetTexGenfv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { GLfloat *address = offset + (GLfloat *)env->GetDirectBufferAddress(buffer); glGetTexGenfv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetTexEnvfv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetTexEnvfv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { GLfloat *address = offset + (GLfloat *)env->GetDirectBufferAddress(buffer); glGetTexEnvfv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetTexEnviv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetTexEnviv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { GLint *address = offset + (GLint *)env->GetDirectBufferAddress(buffer); glGetTexEnviv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetString */ JNIEXPORT jstring JNICALL Java_org_lwjgl_opengl_GL11_glGetString(JNIEnv * env, jclass clazz, jint p0) { const GLubyte * string = glGetString((GLenum) p0); return env->NewStringUTF((const char *) string); } /* * Class: org_lwjgl_opengl_GL11 * Method: glGetPolygonStipple */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglGetPolygonStipple(JNIEnv * env, jclass clazz, jobject buffer, jint offset) { GLubyte *address = offset + (GLubyte *)env->GetDirectBufferAddress(buffer); glGetPolygonStipple(address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glIsList */ JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL11_glIsList(JNIEnv * env, jclass clazz, jint p0) { jboolean ret = (jboolean) glIsList((GLint) p0); CHECK_GL_ERROR return ret; } /* * Class: org_lwjgl_opengl_GL11 * Method: glMaterialf */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glMaterialf(JNIEnv * env, jclass clazz, jint p0, jint p1, jfloat p2) { glMaterialf((GLint) p0, (GLint) p1, (GLfloat) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glMateriali */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glMateriali(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2) { glMateriali((GLint) p0, (GLint) p1, (GLint) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glMaterialfv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglMaterialfv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { const GLfloat *address = offset + (const GLfloat *)env->GetDirectBufferAddress(buffer); glMaterialfv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glMaterialiv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglMaterialiv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { const GLint *address = offset + (const GLint *)env->GetDirectBufferAddress(buffer); glMaterialiv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glMapGrid1f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glMapGrid1f(JNIEnv * env, jclass clazz, jint p0, jfloat p1, jfloat p2) { glMapGrid1f((GLint) p0, (GLfloat) p1, (GLfloat) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glMapGrid2f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glMapGrid2f(JNIEnv * env, jclass clazz, jint p0, jfloat p1, jfloat p2, jint p3, jfloat p4, jfloat p5) { glMapGrid2f((GLint) p0, (GLfloat) p1, (GLfloat) p2, (GLint) p3, (GLfloat) p4, (GLfloat) p5); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glMap2f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglMap2f(JNIEnv * env, jclass clazz, jint p0, jfloat p1, jfloat p2, jint p3, jint p4, jfloat p5, jfloat p6, jint p7, jint p8, jobject buffer, jint offset) { const GLfloat *address = offset + (const GLfloat *)env->GetDirectBufferAddress(buffer); glMap2f((GLint) p0, (GLfloat) p1, (GLfloat) p2, (GLint) p3, (GLint) p4, (GLfloat) p5, (GLfloat) p6, (GLint) p7, (GLint) p8, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glMap1f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglMap1f(JNIEnv * env, jclass clazz, jint p0, jfloat p1, jfloat p2, jint p3, jint p4, jobject buffer, jint offset) { const GLfloat *address = offset + (const GLfloat *)env->GetDirectBufferAddress(buffer); glMap1f((GLint) p0, (GLfloat) p1, (GLfloat) p2, (GLint) p3, (GLint) p4, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glLogicOp */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glLogicOp(JNIEnv * env, jclass clazz, jint p0) { glLogicOp((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glLoadName */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glLoadName(JNIEnv * env, jclass clazz, jint p0) { glLoadName((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glLoadMatrixf */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglLoadMatrixf(JNIEnv * env, jclass clazz, jobject buffer, jint offset) { const GLfloat *address = offset + (const GLfloat *)env->GetDirectBufferAddress(buffer); glLoadMatrixf(address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glLoadIdentity */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glLoadIdentity(JNIEnv * env, jclass clazz) { glLoadIdentity(); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glListBase */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glListBase(JNIEnv * env, jclass clazz, jint p0) { glListBase((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glLineWidth */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glLineWidth(JNIEnv * env, jclass clazz, jfloat p0) { glLineWidth((GLfloat) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glLineStipple */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glLineStipple(JNIEnv * env, jclass clazz, jint p0, jshort p1) { glLineStipple((GLint) p0, (GLshort) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glLightModelf */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glLightModelf(JNIEnv * env, jclass clazz, jint p0, jfloat p1) { glLightModelf((GLint) p0, (GLfloat) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glLightModeli */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glLightModeli(JNIEnv * env, jclass clazz, jint p0, jint p1) { glLightModeli((GLint) p0, (GLint) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glLightModelfv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglLightModelfv(JNIEnv * env, jclass clazz, jint p0, jobject buffer, jint offset) { const GLfloat *address = offset + (const GLfloat *)env->GetDirectBufferAddress(buffer); glLightModelfv((GLint) p0, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glLightModeliv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglLightModeliv(JNIEnv * env, jclass clazz, jint p0, jobject buffer, jint offset) { const GLint *address = offset + (const GLint *)env->GetDirectBufferAddress(buffer); glLightModeliv((GLint) p0, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glLightf */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glLightf(JNIEnv * env, jclass clazz, jint p0, jint p1, jfloat p2) { glLightf((GLint) p0, (GLint) p1, (GLfloat) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glLighti */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glLighti(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2) { glLighti((GLint) p0, (GLint) p1, (GLint) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glLightfv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglLightfv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { const GLfloat *address = offset + (const GLfloat *)env->GetDirectBufferAddress(buffer); glLightfv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glLightiv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglLightiv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { const GLint *address = offset + (const GLint *)env->GetDirectBufferAddress(buffer); glLightiv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glIsTexture */ JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_GL11_glIsTexture(JNIEnv * env, jclass clazz, jint p0) { jboolean ret = (jboolean) glIsTexture((GLint) p0); CHECK_GL_ERROR return ret; } /* * Class: org_lwjgl_opengl_GL11 * Method: glMatrixMode */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glMatrixMode(JNIEnv * env, jclass clazz, jint p0) { glMatrixMode((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPolygonStipple */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglPolygonStipple(JNIEnv * env, jclass clazz, jobject buffer, jint offset) { const GLubyte *address = offset + (const GLubyte *)env->GetDirectBufferAddress(buffer); glPolygonStipple(address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPolygonOffset */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glPolygonOffset(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1) { glPolygonOffset((GLfloat) p0, (GLfloat) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPolygonMode */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glPolygonMode(JNIEnv * env, jclass clazz, jint p0, jint p1) { glPolygonMode((GLint) p0, (GLint) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPointSize */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glPointSize(JNIEnv * env, jclass clazz, jfloat p0) { glPointSize((GLfloat) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPixelZoom */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glPixelZoom(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1) { glPixelZoom((GLfloat) p0, (GLfloat) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPixelTransferf */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glPixelTransferf(JNIEnv * env, jclass clazz, jint p0, jfloat p1) { glPixelTransferf((GLint) p0, (GLfloat) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPixelTransferi */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glPixelTransferi(JNIEnv * env, jclass clazz, jint p0, jint p1) { glPixelTransferi((GLint) p0, (GLint) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPixelStoref */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glPixelStoref(JNIEnv * env, jclass clazz, jint p0, jfloat p1) { glPixelStoref((GLint) p0, (GLfloat) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPixelStorei */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glPixelStorei(JNIEnv * env, jclass clazz, jint p0, jint p1) { glPixelStorei((GLint) p0, (GLint) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPixelMapfv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglPixelMapfv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { const GLfloat *address = offset + (const GLfloat *)env->GetDirectBufferAddress(buffer); glPixelMapfv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPixelMapuiv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglPixelMapuiv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { const GLuint *address = (const GLuint *)(offset + (const GLbyte *)env->GetDirectBufferAddress(buffer)); glPixelMapuiv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPixelMapusv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglPixelMapusv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { const GLushort *address = (const GLushort *)(offset + (const GLbyte *)env->GetDirectBufferAddress(buffer)); glPixelMapusv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPassThrough */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glPassThrough(JNIEnv * env, jclass clazz, jfloat p0) { glPassThrough((GLfloat) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glOrtho */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glOrtho(JNIEnv * env, jclass clazz, jdouble p0, jdouble p1, jdouble p2, jdouble p3, jdouble p4, jdouble p5) { glOrtho((GLdouble) p0, (GLdouble) p1, (GLdouble) p2, (GLdouble) p3, (GLdouble) p4, (GLdouble) p5); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: nglNormalPointer */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglNormalPointer(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { const void *address = (const void *)(offset + (GLbyte *)env->GetDirectBufferAddress(buffer)); glNormalPointer((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: nglNormalPointerVBO */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglNormalPointerVBO(JNIEnv * env, jclass clazz, jint p0, jint p1, jint buffer_offset) { glNormalPointer((GLint) p0, (GLint) p1, offsetToPointer(buffer_offset)); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glNormal3b */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glNormal3b(JNIEnv * env, jclass clazz, jbyte p0, jbyte p1, jbyte p2) { glNormal3b((GLbyte) p0, (GLbyte) p1, (GLbyte) p2); } /* * Class: org_lwjgl_opengl_GL11 * Method: glNormal3f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glNormal3f(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1, jfloat p2) { glNormal3f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2); } /* * Class: org_lwjgl_opengl_GL11 * Method: glNormal3i */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glNormal3i(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2) { glNormal3i((GLint) p0, (GLint) p1, (GLint) p2); } /* * Class: org_lwjgl_opengl_GL11 * Method: glNewList */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glNewList(JNIEnv * env, jclass clazz, jint p0, jint p1) { glNewList((GLint) p0, (GLint) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glEndList */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glEndList(JNIEnv * env, jclass clazz) { glEndList(); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glMultMatrixf */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglMultMatrixf(JNIEnv * env, jclass clazz, jobject buffer, jint offset) { const GLfloat *address = offset + (const GLfloat *)env->GetDirectBufferAddress(buffer); glMultMatrixf(address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glShadeModel */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glShadeModel(JNIEnv * env, jclass clazz, jint p0) { glShadeModel((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glSelectBuffer */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglSelectBuffer(JNIEnv * env, jclass clazz, jint p0, jobject buffer, jint offset) { GLuint *address = offset + (GLuint *)env->GetDirectBufferAddress(buffer); glSelectBuffer((GLint) p0, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glScissor */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glScissor(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3) { glScissor((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glScalef */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glScalef(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1, jfloat p2) { glScalef((GLfloat) p0, (GLfloat) p1, (GLfloat) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glRotatef */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glRotatef(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1, jfloat p2, jfloat p3) { glRotatef((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glRenderMode */ JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL11_glRenderMode(JNIEnv * env, jclass clazz, jint p0) { jint ret = (jint) glRenderMode((GLint) p0); CHECK_GL_ERROR return ret; } /* * Class: org_lwjgl_opengl_GL11 * Method: glRectf */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glRectf(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1, jfloat p2, jfloat p3) { glRectf((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glRecti */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glRecti(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3) { glRecti((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glReadPixels */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglReadPixels(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jobject buffer, jint offset) { void *address = (void *)(offset + (GLbyte *)env->GetDirectBufferAddress(buffer)); glReadPixels((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glReadBuffer */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glReadBuffer(JNIEnv * env, jclass clazz, jint p0) { glReadBuffer((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glRasterPos2f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glRasterPos2f(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1) { glRasterPos2f((GLfloat) p0, (GLfloat) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glRasterPos2i */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glRasterPos2i(JNIEnv * env, jclass clazz, jint p0, jint p1) { glRasterPos2i((GLint) p0, (GLint) p1); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glRasterPos3f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glRasterPos3f(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1, jfloat p2) { glRasterPos3f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glRasterPos3i */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glRasterPos3i(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2) { glRasterPos3i((GLint) p0, (GLint) p1, (GLint) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glRasterPos4f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glRasterPos4f(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1, jfloat p2, jfloat p3) { glRasterPos4f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glRasterPos4i */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glRasterPos4i(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3) { glRasterPos4i((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPushName */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glPushName(JNIEnv * env, jclass clazz, jint p0) { glPushName((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPopName */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glPopName(JNIEnv * env, jclass clazz) { glPopName(); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPushMatrix */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glPushMatrix(JNIEnv * env, jclass clazz) { glPushMatrix(); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPopMatrix */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glPopMatrix(JNIEnv * env, jclass clazz) { glPopMatrix(); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: nglPushClientAttrib */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglPushClientAttrib(JNIEnv * env, jclass clazz, jint p0) { glPushClientAttrib((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: nglPopClientAttrib */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglPopClientAttrib(JNIEnv * env, jclass clazz) { glPopClientAttrib(); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPushAttrib */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glPushAttrib(JNIEnv * env, jclass clazz, jint p0) { glPushAttrib((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glPopAttrib */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glPopAttrib(JNIEnv * env, jclass clazz) { glPopAttrib(); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glStencilFunc */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glStencilFunc(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2) { glStencilFunc((GLint) p0, (GLint) p1, (GLint) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: nglVertexPointer */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglVertexPointer(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jobject buffer, jint offset) { const void *address = (const void *)(offset + (GLbyte *)env->GetDirectBufferAddress(buffer)); glVertexPointer((GLint) p0, (GLint) p1, (GLint) p2, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: nglVertexPointerVBO */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglVertexPointerVBO(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint buffer_offset) { glVertexPointer((GLint) p0, (GLint) p1, (GLint) p2, offsetToPointer(buffer_offset)); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glVertex2f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glVertex2f(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1) { glVertex2f((GLfloat) p0, (GLfloat) p1); } /* * Class: org_lwjgl_opengl_GL11 * Method: glVertex2i */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glVertex2i(JNIEnv * env, jclass clazz, jint p0, jint p1) { glVertex2i((GLint) p0, (GLint) p1); } /* * Class: org_lwjgl_opengl_GL11 * Method: glVertex3f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glVertex3f(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1, jfloat p2) { glVertex3f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2); } /* * Class: org_lwjgl_opengl_GL11 * Method: glVertex3i */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glVertex3i(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2) { glVertex3i((GLint) p0, (GLint) p1, (GLint) p2); } /* * Class: org_lwjgl_opengl_GL11 * Method: glVertex4f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glVertex4f(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1, jfloat p2, jfloat p3) { glVertex4f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); } /* * Class: org_lwjgl_opengl_GL11 * Method: glVertex4i */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glVertex4i(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3) { glVertex4i((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); } /* * Class: org_lwjgl_opengl_GL11 * Method: glTranslatef */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glTranslatef(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1, jfloat p2) { glTranslatef((GLfloat) p0, (GLfloat) p1, (GLfloat) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glTexSubImage2D */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglTexSubImage2D(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7, jobject buffer, jint offset) { const void *address = (const void *)(offset + (GLbyte *)env->GetDirectBufferAddress(buffer)); glTexSubImage2D((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (GLint) p7, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glTexSubImage1D */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglTexSubImage1D(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jobject buffer, jint offset) { const void *address = (const void *)(offset + (GLbyte *)env->GetDirectBufferAddress(buffer)); glTexSubImage1D((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, address); CHECK_GL_ERROR } JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglTexParameterfv (JNIEnv *env, jclass clazz, jint target, jint pname, jobject param, jint param_offset) { GLfloat *address = param_offset + (GLfloat *)env->GetDirectBufferAddress(param); glTexParameterfv(target, pname, address); } JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglTexParameteriv (JNIEnv *env, jclass clazz, jint target, jint pname, jobject param, jint param_offset) { GLint *address = param_offset + (GLint *)env->GetDirectBufferAddress(param); glTexParameteriv(target, pname, address); } /* * Class: org_lwjgl_opengl_GL11 * Method: glTexParameterf */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glTexParameterf(JNIEnv * env, jclass clazz, jint p0, jint p1, jfloat p2) { glTexParameterf((GLint) p0, (GLint) p1, (GLfloat) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glTexParameteri */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glTexParameteri(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2) { glTexParameteri((GLint) p0, (GLint) p1, (GLint) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glTexImage2D */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglTexImage2D(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jint p7, jobject buffer, jint offset) { const void *address = (const void *)(offset + (GLbyte *)env->GetDirectBufferAddress(buffer)); glTexImage2D((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, (GLint) p7, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glTexImage1D */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglTexImage1D(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3, jint p4, jint p5, jint p6, jobject buffer, jint offset) { const void *address = (const void *)(offset + (GLbyte *)env->GetDirectBufferAddress(buffer)); glTexImage1D((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3, (GLint) p4, (GLint) p5, (GLint) p6, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glTexGenf */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glTexGenf(JNIEnv * env, jclass clazz, jint p0, jint p1, jfloat p2) { glTexGenf((GLint) p0, (GLint) p1, (GLfloat) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: nglTexGenfv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglTexGenfv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { const GLfloat *address = offset + (const GLfloat *)env->GetDirectBufferAddress(buffer); glTexGenfv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glTexGeni */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glTexGeni(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2) { glTexGeni((GLint) p0, (GLint) p1, (GLint) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: nglTexGeniv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglTexGeniv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { const GLint *address = offset + (const GLint *)env->GetDirectBufferAddress(buffer); glTexGeniv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glTexEnvf */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glTexEnvf(JNIEnv * env, jclass clazz, jint p0, jint p1, jfloat p2) { glTexEnvf((GLint) p0, (GLint) p1, (GLfloat) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glTexEnvi */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glTexEnvi(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2) { glTexEnvi((GLint) p0, (GLint) p1, (GLint) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glTexEnvfv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglTexEnvfv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { const GLfloat *address = offset + (const GLfloat *)env->GetDirectBufferAddress(buffer); glTexEnvfv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glTexEnviv */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglTexEnviv(JNIEnv * env, jclass clazz, jint p0, jint p1, jobject buffer, jint offset) { const GLint *address = offset + (const GLint *)env->GetDirectBufferAddress(buffer); glTexEnviv((GLint) p0, (GLint) p1, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: nglTexCoordPointer */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglTexCoordPointer(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jobject buffer, jint offset) { const void *address = (const void *)(offset + (GLbyte *)env->GetDirectBufferAddress(buffer)); glTexCoordPointer((GLint) p0, (GLint) p1, (GLint) p2, address); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: nglTexCoordPointerVBO */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_nglTexCoordPointerVBO(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint buffer_offset) { glTexCoordPointer((GLint) p0, (GLint) p1, (GLint) p2, offsetToPointer(buffer_offset)); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glTexCoord1f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glTexCoord1f(JNIEnv * env, jclass clazz, jfloat p0) { glTexCoord1f((GLfloat) p0); } /* * Class: org_lwjgl_opengl_GL11 * Method: glTexCoord2f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glTexCoord2f(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1) { glTexCoord2f((GLfloat) p0, (GLfloat) p1); } /* * Class: org_lwjgl_opengl_GL11 * Method: glTexCoord3f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glTexCoord3f(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1, jfloat p2) { glTexCoord3f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2); } /* * Class: org_lwjgl_opengl_GL11 * Method: glTexCoord4f */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glTexCoord4f(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1, jfloat p2, jfloat p3) { glTexCoord4f((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3); } /* * Class: org_lwjgl_opengl_GL11 * Method: glStencilOp */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glStencilOp(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2) { glStencilOp((GLint) p0, (GLint) p1, (GLint) p2); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glStencilMask */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glStencilMask(JNIEnv * env, jclass clazz, jint p0) { glStencilMask((GLint) p0); CHECK_GL_ERROR } /* * Class: org_lwjgl_opengl_GL11 * Method: glViewport */ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL11_glViewport(JNIEnv * env, jclass clazz, jint p0, jint p1, jint p2, jint p3) { glViewport((GLint) p0, (GLint) p1, (GLint) p2, (GLint) p3); CHECK_GL_ERROR }