[Java-game-lib-cvs] LWJGL/src/native/generated org_lwjgl_openal_AL10.c,NONE,1.1 org_lwjgl_opengl_ARBBufferObject.c,NONE,1.1 org_lwjgl_opengl_ARBColorBufferFloat.c,NONE,1.1 org_lwjgl_opengl_ARBDrawBuffers.c,NONE,1.1 org_lwjgl_opengl_ARBImaging.c,NONE,1.1 org_lwjgl_opengl_ARBMatrixPalette.c,NONE,1.1 org_lwjgl_opengl_ARBMultisample.c,NONE,1.1 org_lwjgl_opengl_ARBMultitexture.c,NONE,1.1 org_lwjgl_opengl_ARBOcclusionQuery.c,NONE,1.1 org_lwjgl_opengl_ARBPointParameters.c,NONE,1.1 org_lwjgl_opengl_ARBProgram.c,NONE,1.1 org_lwjgl_opengl_ARBShaderObjects.c,NONE,1.1 org_lwjgl_opengl_ARBTextureCompression.c,NONE,1.1 org_lwjgl_opengl_ARBTransposeMatrix.c,NONE,1.1 org_lwjgl_opengl_ARBVertexBlend.c,NONE,1.1 org_lwjgl_opengl_ARBVertexProgram.c,NONE,1.1 org_lwjgl_opengl_ARBVertexShader.c,NONE,1.1 org_lwjgl_opengl_ARBWindowPos.c,NONE,1.1 org_lwjgl_opengl_ATIDrawBuffers.c,NONE,1.1 org_lwjgl_opengl_ATIElementArray.c,NONE,1.1 org_lwjgl_opengl_ATIEnvmapBumpmap.c,NONE,1.1 org_lwjgl_opengl_ATIFragmentShader.c,NONE,1.1 org_lwjgl_opengl_ATIMapObjectBuffer.c,NONE,1.1 org_lwjgl_opengl_ATIPnTriangles.c,NONE,1.1 org_lwjgl_opengl_ATISeparateStencil.c,NONE,1.1 org_lwjgl_opengl_ATIVertexArrayObject.c,NONE,1.1 org_lwjgl_opengl_ATIVertexAttribArrayObject.c,NONE,1.1 org_lwjgl_opengl_ATIVertexStreams.c,NONE,1.1 org_lwjgl_opengl_EXTBlendEquationSeparate.c,NONE,1.1 org_lwjgl_opengl_EXTBlendFuncSeparate.c,NONE,1.1 org_lwjgl_opengl_EXTCompiledVertexArray.c,NONE,1.1 org_lwjgl_opengl_EXTDepthBoundsTest.c,NONE,1.1 org_lwjgl_opengl_EXTDrawRangeElements.c,NONE,1.1 org_lwjgl_opengl_EXTFogCoord.c,NONE,1.1 org_lwjgl_opengl_EXTFramebufferObject.c,NONE,1.1 org_lwjgl_opengl_EXTMultiDrawArrays.c,NONE,1.1 org_lwjgl_opengl_EXTPalettedTexture.c,NONE,1.1 org_lwjgl_opengl_EXTPointParameters.c,NONE,1.1 org_lwjgl_opengl_EXTSecondaryColor.c,NONE,1.1 org_lwjgl_opengl_EXTStencilClearTag.c,NONE,1.1 org_lwjgl_opengl_EXTStencilTwoSide.c,NONE,1.1 org_lwjgl_opengl_EXTVertexShader.c,NONE,1.1 org_lwjgl_opengl_EXTVertexWeighting.c,NONE,1.1 org_lwjgl_opengl_GL11.c,NONE,1.1 org_lwjgl_opengl_GL12.c,NONE,1.1 org_lwjgl_opengl_GL13.c,NONE,1.1 org_lwjgl_opengl_GL14.c,NONE,1.1 org_lwjgl_opengl_GL15.c,NONE,1.1 org_lwjgl_opengl_GL20.c,NONE,1.1 org_lwjgl_opengl_NVEvaluators.c,NONE,1.1 org_lwjgl_opengl_NVFence.c,NONE,1.1 org_lwjgl_opengl_NVFragmentProgram.c,NONE,1.1 org_lwjgl_opengl_NVHalfFloat.c,NONE,1.1 org_lwjgl_opengl_NVOcclusionQuery.c,NONE,1.1 org_lwjgl_opengl_NVPixelDataRange.c,NONE,1.1 org_lwjgl_opengl_NVPointSprite.c,NONE,1.1 org_lwjgl_opengl_NVPrimitiveRestart.c,NONE,1.1 org_lwjgl_opengl_NVProgram.c,NONE,1.1 org_lwjgl_opengl_NVRegisterCombiners.c,NONE,1.1 org_lwjgl_opengl_NVRegisterCombiners2.c,NONE,1.1 org_lwjgl_opengl_NVVertexArrayRange.c,NONE,1.1 org_lwjgl_opengl_NVVertexProgram.c,NONE,1.1

[Elias N. <eli...@us...>]

Update of /cvsroot/java-game-lib/LWJGL/src/native/generated
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24912/src/native/generated

Added Files:
	org_lwjgl_openal_AL10.c org_lwjgl_opengl_ARBBufferObject.c 
	org_lwjgl_opengl_ARBColorBufferFloat.c 
	org_lwjgl_opengl_ARBDrawBuffers.c 
	org_lwjgl_opengl_ARBImaging.c 
	org_lwjgl_opengl_ARBMatrixPalette.c 
	org_lwjgl_opengl_ARBMultisample.c 
	org_lwjgl_opengl_ARBMultitexture.c 
	org_lwjgl_opengl_ARBOcclusionQuery.c 
	org_lwjgl_opengl_ARBPointParameters.c 
	org_lwjgl_opengl_ARBProgram.c 
	org_lwjgl_opengl_ARBShaderObjects.c 
	org_lwjgl_opengl_ARBTextureCompression.c 
	org_lwjgl_opengl_ARBTransposeMatrix.c 
	org_lwjgl_opengl_ARBVertexBlend.c 
	org_lwjgl_opengl_ARBVertexProgram.c 
	org_lwjgl_opengl_ARBVertexShader.c 
	org_lwjgl_opengl_ARBWindowPos.c 
	org_lwjgl_opengl_ATIDrawBuffers.c 
	org_lwjgl_opengl_ATIElementArray.c 
	org_lwjgl_opengl_ATIEnvmapBumpmap.c 
	org_lwjgl_opengl_ATIFragmentShader.c 
	org_lwjgl_opengl_ATIMapObjectBuffer.c 
	org_lwjgl_opengl_ATIPnTriangles.c 
	org_lwjgl_opengl_ATISeparateStencil.c 
	org_lwjgl_opengl_ATIVertexArrayObject.c 
	org_lwjgl_opengl_ATIVertexAttribArrayObject.c 
	org_lwjgl_opengl_ATIVertexStreams.c 
	org_lwjgl_opengl_EXTBlendEquationSeparate.c 
	org_lwjgl_opengl_EXTBlendFuncSeparate.c 
	org_lwjgl_opengl_EXTCompiledVertexArray.c 
	org_lwjgl_opengl_EXTDepthBoundsTest.c 
	org_lwjgl_opengl_EXTDrawRangeElements.c 
	org_lwjgl_opengl_EXTFogCoord.c 
	org_lwjgl_opengl_EXTFramebufferObject.c 
	org_lwjgl_opengl_EXTMultiDrawArrays.c 
	org_lwjgl_opengl_EXTPalettedTexture.c 
	org_lwjgl_opengl_EXTPointParameters.c 
	org_lwjgl_opengl_EXTSecondaryColor.c 
	org_lwjgl_opengl_EXTStencilClearTag.c 
	org_lwjgl_opengl_EXTStencilTwoSide.c 
	org_lwjgl_opengl_EXTVertexShader.c 
	org_lwjgl_opengl_EXTVertexWeighting.c org_lwjgl_opengl_GL11.c 
	org_lwjgl_opengl_GL12.c org_lwjgl_opengl_GL13.c 
	org_lwjgl_opengl_GL14.c org_lwjgl_opengl_GL15.c 
	org_lwjgl_opengl_GL20.c org_lwjgl_opengl_NVEvaluators.c 
	org_lwjgl_opengl_NVFence.c 
	org_lwjgl_opengl_NVFragmentProgram.c 
	org_lwjgl_opengl_NVHalfFloat.c 
	org_lwjgl_opengl_NVOcclusionQuery.c 
	org_lwjgl_opengl_NVPixelDataRange.c 
	org_lwjgl_opengl_NVPointSprite.c 
	org_lwjgl_opengl_NVPrimitiveRestart.c 
	org_lwjgl_opengl_NVProgram.c 
	org_lwjgl_opengl_NVRegisterCombiners.c 
	org_lwjgl_opengl_NVRegisterCombiners2.c 
	org_lwjgl_opengl_NVVertexArrayRange.c 
	org_lwjgl_opengl_NVVertexProgram.c 
Log Message:
Moved generated files to seperate directories

--- NEW FILE: org_lwjgl_opengl_ARBDrawBuffers.c ---
/* MACHINE GENERATED FILE, DO NOT EDIT */

#include <jni.h>
#include "extgl.h"

typedef void (APIENTRY *glDrawBuffersARBPROC) (GLsizei size, const GLenum * buffers);

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBDrawBuffers_nglDrawBuffersARB(JNIEnv *env, jclass clazz, jint size, jobject buffers, jint buffers_position, jlong function_pointer) {
	const GLenum *buffers_address = ((const GLenum *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position;
	glDrawBuffersARBPROC glDrawBuffersARB = (glDrawBuffersARBPROC)((intptr_t)function_pointer);
	glDrawBuffersARB(size, buffers_address);
}


--- NEW FILE: org_lwjgl_opengl_ATIElementArray.c ---
/* MACHINE GENERATED FILE, DO NOT EDIT */

#include <jni.h>
#include "extgl.h"

typedef void (APIENTRY *glElementPointerATIPROC) (GLenum type, const GLvoid * pPointer);
typedef void (APIENTRY *glDrawElementArrayATIPROC) (GLenum mode, GLsizei count);
typedef void (APIENTRY *glDrawRangeElementArrayATIPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count);

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIElementArray_nglElementPointerATI(JNIEnv *env, jclass clazz, jint type, jobject pPointer, jint pPointer_position, jlong function_pointer) {
	const GLvoid *pPointer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPointer)) + pPointer_position));
	glElementPointerATIPROC glElementPointerATI = (glElementPointerATIPROC)((intptr_t)function_pointer);
	glElementPointerATI(type, pPointer_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIElementArray_nglElementPointerATIBO(JNIEnv *env, jclass clazz, jint type, jint pPointer_buffer_offset, jlong function_pointer) {
	const GLvoid *pPointer_address = ((const GLvoid *)offsetToPointer(pPointer_buffer_offset));
	glElementPointerATIPROC glElementPointerATI = (glElementPointerATIPROC)((intptr_t)function_pointer);
	glElementPointerATI(type, pPointer_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIElementArray_nglDrawElementArrayATI(JNIEnv *env, jclass clazz, jint mode, jint count, jlong function_pointer) {
	glDrawElementArrayATIPROC glDrawElementArrayATI = (glDrawElementArrayATIPROC)((intptr_t)function_pointer);
	glDrawElementArrayATI(mode, count);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIElementArray_nglDrawRangeElementArrayATI(JNIEnv *env, jclass clazz, jint mode, jint start, jint end, jint count, jlong function_pointer) {
	glDrawRangeElementArrayATIPROC glDrawRangeElementArrayATI = (glDrawRangeElementArrayATIPROC)((intptr_t)function_pointer);
	glDrawRangeElementArrayATI(mode, start, end, count);
}


--- NEW FILE: org_lwjgl_opengl_ARBVertexProgram.c ---
/* MACHINE GENERATED FILE, DO NOT EDIT */

#include <jni.h>
#include "extgl.h"

typedef void (APIENTRY *glVertexAttrib1sARBPROC) (GLuint index, GLshort x);
typedef void (APIENTRY *glVertexAttrib1fARBPROC) (GLuint index, GLfloat x);
typedef void (APIENTRY *glVertexAttrib2sARBPROC) (GLuint index, GLshort x, GLshort y);
typedef void (APIENTRY *glVertexAttrib2fARBPROC) (GLuint index, GLfloat x, GLfloat y);
typedef void (APIENTRY *glVertexAttrib3sARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z);
typedef void (APIENTRY *glVertexAttrib3fARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z);
typedef void (APIENTRY *glVertexAttrib4sARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
typedef void (APIENTRY *glVertexAttrib4fARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (APIENTRY *glVertexAttrib4NubARBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
typedef void (APIENTRY *glVertexAttribPointerARBPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * buffer);
typedef void (APIENTRY *glEnableVertexAttribArrayARBPROC) (GLuint index);
typedef void (APIENTRY *glDisableVertexAttribArrayARBPROC) (GLuint index);
typedef void (APIENTRY *glGetVertexAttribfvARBPROC) (GLuint index, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glGetVertexAttribivARBPROC) (GLuint index, GLenum pname, GLint * params);
typedef void (APIENTRY *glGetVertexAttribPointervARBPROC) (GLuint index, GLenum pname, GLvoid ** result);

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib1sARB(JNIEnv *env, jclass clazz, jint index, jshort x, jlong function_pointer) {
	glVertexAttrib1sARBPROC glVertexAttrib1sARB = (glVertexAttrib1sARBPROC)((intptr_t)function_pointer);
	glVertexAttrib1sARB(index, x);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib1fARB(JNIEnv *env, jclass clazz, jint index, jfloat x, jlong function_pointer) {
	glVertexAttrib1fARBPROC glVertexAttrib1fARB = (glVertexAttrib1fARBPROC)((intptr_t)function_pointer);
	glVertexAttrib1fARB(index, x);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib2sARB(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jlong function_pointer) {
	glVertexAttrib2sARBPROC glVertexAttrib2sARB = (glVertexAttrib2sARBPROC)((intptr_t)function_pointer);
	glVertexAttrib2sARB(index, x, y);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib2fARB(JNIEnv *env, jclass clazz, jint index, jfloat x, jfloat y, jlong function_pointer) {
	glVertexAttrib2fARBPROC glVertexAttrib2fARB = (glVertexAttrib2fARBPROC)((intptr_t)function_pointer);
	glVertexAttrib2fARB(index, x, y);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib3sARB(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jshort z, jlong function_pointer) {
	glVertexAttrib3sARBPROC glVertexAttrib3sARB = (glVertexAttrib3sARBPROC)((intptr_t)function_pointer);
	glVertexAttrib3sARB(index, x, y, z);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib3fARB(JNIEnv *env, jclass clazz, jint index, jfloat x, jfloat y, jfloat z, jlong function_pointer) {
	glVertexAttrib3fARBPROC glVertexAttrib3fARB = (glVertexAttrib3fARBPROC)((intptr_t)function_pointer);
	glVertexAttrib3fARB(index, x, y, z);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib4sARB(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jshort z, jshort w, jlong function_pointer) {
	glVertexAttrib4sARBPROC glVertexAttrib4sARB = (glVertexAttrib4sARBPROC)((intptr_t)function_pointer);
	glVertexAttrib4sARB(index, x, y, z, w);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib4fARB(JNIEnv *env, jclass clazz, jint index, jfloat x, jfloat y, jfloat z, jfloat w, jlong function_pointer) {
	glVertexAttrib4fARBPROC glVertexAttrib4fARB = (glVertexAttrib4fARBPROC)((intptr_t)function_pointer);
	glVertexAttrib4fARB(index, x, y, z, w);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttrib4NubARB(JNIEnv *env, jclass clazz, jint index, jbyte x, jbyte y, jbyte z, jbyte w, jlong function_pointer) {
	glVertexAttrib4NubARBPROC glVertexAttrib4NubARB = (glVertexAttrib4NubARBPROC)((intptr_t)function_pointer);
	glVertexAttrib4NubARB(index, x, y, z, w);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttribPointerARB(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jboolean normalized, jint stride, jobject buffer, jint buffer_position, jlong function_pointer) {
	const GLvoid *buffer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, buffer)) + buffer_position));
	glVertexAttribPointerARBPROC glVertexAttribPointerARB = (glVertexAttribPointerARBPROC)((intptr_t)function_pointer);
	glVertexAttribPointerARB(index, size, type, normalized, stride, buffer_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttribPointerARBBO(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jboolean normalized, jint stride, jint buffer_buffer_offset, jlong function_pointer) {
	const GLvoid *buffer_address = ((const GLvoid *)offsetToPointer(buffer_buffer_offset));
	glVertexAttribPointerARBPROC glVertexAttribPointerARB = (glVertexAttribPointerARBPROC)((intptr_t)function_pointer);
	glVertexAttribPointerARB(index, size, type, normalized, stride, buffer_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglEnableVertexAttribArrayARB(JNIEnv *env, jclass clazz, jint index, jlong function_pointer) {
	glEnableVertexAttribArrayARBPROC glEnableVertexAttribArrayARB = (glEnableVertexAttribArrayARBPROC)((intptr_t)function_pointer);
	glEnableVertexAttribArrayARB(index);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglDisableVertexAttribArrayARB(JNIEnv *env, jclass clazz, jint index, jlong function_pointer) {
	glDisableVertexAttribArrayARBPROC glDisableVertexAttribArrayARB = (glDisableVertexAttribArrayARBPROC)((intptr_t)function_pointer);
	glDisableVertexAttribArrayARB(index);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglGetVertexAttribfvARB(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
	GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
	glGetVertexAttribfvARBPROC glGetVertexAttribfvARB = (glGetVertexAttribfvARBPROC)((intptr_t)function_pointer);
	glGetVertexAttribfvARB(index, pname, params_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglGetVertexAttribivARB(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
	glGetVertexAttribivARBPROC glGetVertexAttribivARB = (glGetVertexAttribivARBPROC)((intptr_t)function_pointer);
	glGetVertexAttribivARB(index, pname, params_address);
}

JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglGetVertexAttribPointervARB(JNIEnv *env, jclass clazz, jint index, jint pname, jint result_size, jlong function_pointer) {
	glGetVertexAttribPointervARBPROC glGetVertexAttribPointervARB = (glGetVertexAttribPointervARBPROC)((intptr_t)function_pointer);
	GLvoid * __result;
	glGetVertexAttribPointervARB(index, pname, &__result);
	return safeNewBuffer(env, __result, result_size);
}


--- NEW FILE: org_lwjgl_opengl_ATIVertexAttribArrayObject.c ---
/* MACHINE GENERATED FILE, DO NOT EDIT */

#include <jni.h>
#include "extgl.h"

typedef void (APIENTRY *glVertexAttribArrayObjectATIPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset);
typedef void (APIENTRY *glGetVertexAttribArrayObjectfvATIPROC) (GLuint index, GLenum pname, GLfloat * params);
typedef void (APIENTRY *glGetVertexAttribArrayObjectivATIPROC) (GLuint index, GLenum pname, GLint * params);

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexAttribArrayObject_nglVertexAttribArrayObjectATI(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jboolean normalized, jint stride, jint buffer, jint offset, jlong function_pointer) {
	glVertexAttribArrayObjectATIPROC glVertexAttribArrayObjectATI = (glVertexAttribArrayObjectATIPROC)((intptr_t)function_pointer);
	glVertexAttribArrayObjectATI(index, size, type, normalized, stride, buffer, offset);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexAttribArrayObject_nglGetVertexAttribArrayObjectfvATI(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
	GLfloat *params_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
	glGetVertexAttribArrayObjectfvATIPROC glGetVertexAttribArrayObjectfvATI = (glGetVertexAttribArrayObjectfvATIPROC)((intptr_t)function_pointer);
	glGetVertexAttribArrayObjectfvATI(index, pname, params_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ATIVertexAttribArrayObject_nglGetVertexAttribArrayObjectivATI(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) {
	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
	glGetVertexAttribArrayObjectivATIPROC glGetVertexAttribArrayObjectivATI = (glGetVertexAttribArrayObjectivATIPROC)((intptr_t)function_pointer);
	glGetVertexAttribArrayObjectivATI(index, pname, params_address);
}


--- NEW FILE: org_lwjgl_opengl_EXTVertexShader.c ---
/* MACHINE GENERATED FILE, DO NOT EDIT */

#include <jni.h>
#include "extgl.h"

typedef void (APIENTRY *glBeginVertexShaderEXTPROC) ();
typedef void (APIENTRY *glEndVertexShaderEXTPROC) ();
typedef void (APIENTRY *glBindVertexShaderEXTPROC) (GLuint id);
typedef GLuint (APIENTRY *glGenVertexShadersEXTPROC) (GLuint range);
typedef void (APIENTRY *glDeleteVertexShaderEXTPROC) (GLuint id);
typedef void (APIENTRY *glShaderOp1EXTPROC) (GLenum op, GLuint res, GLuint arg1);
typedef void (APIENTRY *glShaderOp2EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2);
typedef void (APIENTRY *glShaderOp3EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3);
typedef void (APIENTRY *glSwizzleEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
typedef void (APIENTRY *glWriteMaskEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
typedef void (APIENTRY *glInsertComponentEXTPROC) (GLuint res, GLuint src, GLuint num);
typedef void (APIENTRY *glExtractComponentEXTPROC) (GLuint res, GLuint src, GLuint num);
typedef GLuint (APIENTRY *glGenSymbolsEXTPROC) (GLenum dataType, GLenum storageType, GLenum range, GLuint components);
typedef void (APIENTRY *glSetInvariantEXTPROC) (GLuint id, GLenum type, GLvoid * pAddr);
typedef void (APIENTRY *glSetLocalConstantEXTPROC) (GLuint id, GLenum type, GLvoid * pAddr);
typedef void (APIENTRY *glVariantbvEXTPROC) (GLuint id, GLbyte * pAddr);
typedef void (APIENTRY *glVariantsvEXTPROC) (GLuint id, GLshort * pAddr);
typedef void (APIENTRY *glVariantivEXTPROC) (GLuint id, GLint * pAddr);
typedef void (APIENTRY *glVariantfvEXTPROC) (GLuint id, GLfloat * pAddr);
typedef void (APIENTRY *glVariantubvEXTPROC) (GLuint id, GLubyte * pAddr);
typedef void (APIENTRY *glVariantusvEXTPROC) (GLuint id, GLushort * pAddr);
typedef void (APIENTRY *glVariantuivEXTPROC) (GLuint id, GLuint * pAddr);
typedef void (APIENTRY *glVariantPointerEXTPROC) (GLuint id, GLenum type, GLuint stride, GLvoid * pAddr);
typedef void (APIENTRY *glEnableVariantClientStateEXTPROC) (GLuint id);
typedef void (APIENTRY *glDisableVariantClientStateEXTPROC) (GLuint id);
typedef GLuint (APIENTRY *glBindLightParameterEXTPROC) (GLenum light, GLenum value);
typedef GLuint (APIENTRY *glBindMaterialParameterEXTPROC) (GLenum face, GLenum value);
typedef GLuint (APIENTRY *glBindTexGenParameterEXTPROC) (GLenum unit, GLenum coord, GLenum value);
typedef GLuint (APIENTRY *glBindTextureUnitParameterEXTPROC) (GLenum unit, GLenum value);
typedef GLuint (APIENTRY *glBindParameterEXTPROC) (GLenum value);
typedef GLboolean (APIENTRY *glIsVariantEnabledEXTPROC) (GLuint id, GLenum cap);
typedef void (APIENTRY *glGetVariantBooleanvEXTPROC) (GLuint id, GLenum value, GLbyte * pbData);
typedef void (APIENTRY *glGetVariantIntegervEXTPROC) (GLuint id, GLenum value, GLint * pbData);
typedef void (APIENTRY *glGetVariantFloatvEXTPROC) (GLuint id, GLenum value, GLfloat * pbData);
typedef void (APIENTRY *glGetVariantPointervEXTPROC) (GLuint id, GLenum value, GLvoid ** pbData);
typedef void (APIENTRY *glGetInvariantBooleanvEXTPROC) (GLuint id, GLenum value, GLbyte * pbData);
typedef void (APIENTRY *glGetInvariantIntegervEXTPROC) (GLuint id, GLenum value, GLint * pbData);
typedef void (APIENTRY *glGetInvariantFloatvEXTPROC) (GLuint id, GLenum value, GLfloat * pbData);
typedef void (APIENTRY *glGetLocalConstantBooleanvEXTPROC) (GLuint id, GLenum value, GLbyte * pbData);
typedef void (APIENTRY *glGetLocalConstantIntegervEXTPROC) (GLuint id, GLenum value, GLint * pbData);
typedef void (APIENTRY *glGetLocalConstantFloatvEXTPROC) (GLuint id, GLenum value, GLfloat * pbData);

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglBeginVertexShaderEXT(JNIEnv *env, jclass clazz, jlong function_pointer) {
	glBeginVertexShaderEXTPROC glBeginVertexShaderEXT = (glBeginVertexShaderEXTPROC)((intptr_t)function_pointer);
	glBeginVertexShaderEXT();
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglEndVertexShaderEXT(JNIEnv *env, jclass clazz, jlong function_pointer) {
	glEndVertexShaderEXTPROC glEndVertexShaderEXT = (glEndVertexShaderEXTPROC)((intptr_t)function_pointer);
	glEndVertexShaderEXT();
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglBindVertexShaderEXT(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
	glBindVertexShaderEXTPROC glBindVertexShaderEXT = (glBindVertexShaderEXTPROC)((intptr_t)function_pointer);
	glBindVertexShaderEXT(id);
}

JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGenVertexShadersEXT(JNIEnv *env, jclass clazz, jint range, jlong function_pointer) {
	glGenVertexShadersEXTPROC glGenVertexShadersEXT = (glGenVertexShadersEXTPROC)((intptr_t)function_pointer);
	GLuint __result = glGenVertexShadersEXT(range);
	return __result;
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglDeleteVertexShaderEXT(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
	glDeleteVertexShaderEXTPROC glDeleteVertexShaderEXT = (glDeleteVertexShaderEXTPROC)((intptr_t)function_pointer);
	glDeleteVertexShaderEXT(id);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglShaderOp1EXT(JNIEnv *env, jclass clazz, jint op, jint res, jint arg1, jlong function_pointer) {
	glShaderOp1EXTPROC glShaderOp1EXT = (glShaderOp1EXTPROC)((intptr_t)function_pointer);
	glShaderOp1EXT(op, res, arg1);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglShaderOp2EXT(JNIEnv *env, jclass clazz, jint op, jint res, jint arg1, jint arg2, jlong function_pointer) {
	glShaderOp2EXTPROC glShaderOp2EXT = (glShaderOp2EXTPROC)((intptr_t)function_pointer);
	glShaderOp2EXT(op, res, arg1, arg2);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglShaderOp3EXT(JNIEnv *env, jclass clazz, jint op, jint res, jint arg1, jint arg2, jint arg3, jlong function_pointer) {
	glShaderOp3EXTPROC glShaderOp3EXT = (glShaderOp3EXTPROC)((intptr_t)function_pointer);
	glShaderOp3EXT(op, res, arg1, arg2, arg3);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglSwizzleEXT(JNIEnv *env, jclass clazz, jint res, jint in, jint outX, jint outY, jint outZ, jint outW, jlong function_pointer) {
	glSwizzleEXTPROC glSwizzleEXT = (glSwizzleEXTPROC)((intptr_t)function_pointer);
	glSwizzleEXT(res, in, outX, outY, outZ, outW);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglWriteMaskEXT(JNIEnv *env, jclass clazz, jint res, jint in, jint outX, jint outY, jint outZ, jint outW, jlong function_pointer) {
	glWriteMaskEXTPROC glWriteMaskEXT = (glWriteMaskEXTPROC)((intptr_t)function_pointer);
	glWriteMaskEXT(res, in, outX, outY, outZ, outW);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglInsertComponentEXT(JNIEnv *env, jclass clazz, jint res, jint src, jint num, jlong function_pointer) {
	glInsertComponentEXTPROC glInsertComponentEXT = (glInsertComponentEXTPROC)((intptr_t)function_pointer);
	glInsertComponentEXT(res, src, num);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglExtractComponentEXT(JNIEnv *env, jclass clazz, jint res, jint src, jint num, jlong function_pointer) {
	glExtractComponentEXTPROC glExtractComponentEXT = (glExtractComponentEXTPROC)((intptr_t)function_pointer);
	glExtractComponentEXT(res, src, num);
}

JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGenSymbolsEXT(JNIEnv *env, jclass clazz, jint dataType, jint storageType, jint range, jint components, jlong function_pointer) {
	glGenSymbolsEXTPROC glGenSymbolsEXT = (glGenSymbolsEXTPROC)((intptr_t)function_pointer);
	GLuint __result = glGenSymbolsEXT(dataType, storageType, range, components);
	return __result;
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglSetInvariantEXT(JNIEnv *env, jclass clazz, jint id, jint type, jobject pAddr, jint pAddr_position, jlong function_pointer) {
	GLvoid *pAddr_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position));
	glSetInvariantEXTPROC glSetInvariantEXT = (glSetInvariantEXTPROC)((intptr_t)function_pointer);
	glSetInvariantEXT(id, type, pAddr_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglSetLocalConstantEXT(JNIEnv *env, jclass clazz, jint id, jint type, jobject pAddr, jint pAddr_position, jlong function_pointer) {
	GLvoid *pAddr_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position));
	glSetLocalConstantEXTPROC glSetLocalConstantEXT = (glSetLocalConstantEXTPROC)((intptr_t)function_pointer);
	glSetLocalConstantEXT(id, type, pAddr_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantbvEXT(JNIEnv *env, jclass clazz, jint id, jobject pAddr, jint pAddr_position, jlong function_pointer) {
	GLbyte *pAddr_address = ((GLbyte *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position;
	glVariantbvEXTPROC glVariantbvEXT = (glVariantbvEXTPROC)((intptr_t)function_pointer);
	glVariantbvEXT(id, pAddr_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantsvEXT(JNIEnv *env, jclass clazz, jint id, jobject pAddr, jint pAddr_position, jlong function_pointer) {
	GLshort *pAddr_address = ((GLshort *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position;
	glVariantsvEXTPROC glVariantsvEXT = (glVariantsvEXTPROC)((intptr_t)function_pointer);
	glVariantsvEXT(id, pAddr_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantivEXT(JNIEnv *env, jclass clazz, jint id, jobject pAddr, jint pAddr_position, jlong function_pointer) {
	GLint *pAddr_address = ((GLint *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position;
	glVariantivEXTPROC glVariantivEXT = (glVariantivEXTPROC)((intptr_t)function_pointer);
	glVariantivEXT(id, pAddr_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantfvEXT(JNIEnv *env, jclass clazz, jint id, jobject pAddr, jint pAddr_position, jlong function_pointer) {
	GLfloat *pAddr_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position;
	glVariantfvEXTPROC glVariantfvEXT = (glVariantfvEXTPROC)((intptr_t)function_pointer);
	glVariantfvEXT(id, pAddr_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantubvEXT(JNIEnv *env, jclass clazz, jint id, jobject pAddr, jint pAddr_position, jlong function_pointer) {
	GLubyte *pAddr_address = ((GLubyte *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position;
	glVariantubvEXTPROC glVariantubvEXT = (glVariantubvEXTPROC)((intptr_t)function_pointer);
	glVariantubvEXT(id, pAddr_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantusvEXT(JNIEnv *env, jclass clazz, jint id, jobject pAddr, jint pAddr_position, jlong function_pointer) {
	GLushort *pAddr_address = ((GLushort *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position;
	glVariantusvEXTPROC glVariantusvEXT = (glVariantusvEXTPROC)((intptr_t)function_pointer);
	glVariantusvEXT(id, pAddr_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantuivEXT(JNIEnv *env, jclass clazz, jint id, jobject pAddr, jint pAddr_position, jlong function_pointer) {
	GLuint *pAddr_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position;
	glVariantuivEXTPROC glVariantuivEXT = (glVariantuivEXTPROC)((intptr_t)function_pointer);
	glVariantuivEXT(id, pAddr_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantPointerEXT(JNIEnv *env, jclass clazz, jint id, jint type, jint stride, jobject pAddr, jint pAddr_position, jlong function_pointer) {
	GLvoid *pAddr_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pAddr)) + pAddr_position));
	glVariantPointerEXTPROC glVariantPointerEXT = (glVariantPointerEXTPROC)((intptr_t)function_pointer);
	glVariantPointerEXT(id, type, stride, pAddr_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglVariantPointerEXTBO(JNIEnv *env, jclass clazz, jint id, jint type, jint stride, jint pAddr_buffer_offset, jlong function_pointer) {
	GLvoid *pAddr_address = ((GLvoid *)offsetToPointer(pAddr_buffer_offset));
	glVariantPointerEXTPROC glVariantPointerEXT = (glVariantPointerEXTPROC)((intptr_t)function_pointer);
	glVariantPointerEXT(id, type, stride, pAddr_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglEnableVariantClientStateEXT(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
	glEnableVariantClientStateEXTPROC glEnableVariantClientStateEXT = (glEnableVariantClientStateEXTPROC)((intptr_t)function_pointer);
	glEnableVariantClientStateEXT(id);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglDisableVariantClientStateEXT(JNIEnv *env, jclass clazz, jint id, jlong function_pointer) {
	glDisableVariantClientStateEXTPROC glDisableVariantClientStateEXT = (glDisableVariantClientStateEXTPROC)((intptr_t)function_pointer);
	glDisableVariantClientStateEXT(id);
}

JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglBindLightParameterEXT(JNIEnv *env, jclass clazz, jint light, jint value, jlong function_pointer) {
	glBindLightParameterEXTPROC glBindLightParameterEXT = (glBindLightParameterEXTPROC)((intptr_t)function_pointer);
	GLuint __result = glBindLightParameterEXT(light, value);
	return __result;
}

JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglBindMaterialParameterEXT(JNIEnv *env, jclass clazz, jint face, jint value, jlong function_pointer) {
	glBindMaterialParameterEXTPROC glBindMaterialParameterEXT = (glBindMaterialParameterEXTPROC)((intptr_t)function_pointer);
	GLuint __result = glBindMaterialParameterEXT(face, value);
	return __result;
}

JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglBindTexGenParameterEXT(JNIEnv *env, jclass clazz, jint unit, jint coord, jint value, jlong function_pointer) {
	glBindTexGenParameterEXTPROC glBindTexGenParameterEXT = (glBindTexGenParameterEXTPROC)((intptr_t)function_pointer);
	GLuint __result = glBindTexGenParameterEXT(unit, coord, value);
	return __result;
}

JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglBindTextureUnitParameterEXT(JNIEnv *env, jclass clazz, jint unit, jint value, jlong function_pointer) {
	glBindTextureUnitParameterEXTPROC glBindTextureUnitParameterEXT = (glBindTextureUnitParameterEXTPROC)((intptr_t)function_pointer);
	GLuint __result = glBindTextureUnitParameterEXT(unit, value);
	return __result;
}

JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglBindParameterEXT(JNIEnv *env, jclass clazz, jint value, jlong function_pointer) {
	glBindParameterEXTPROC glBindParameterEXT = (glBindParameterEXTPROC)((intptr_t)function_pointer);
	GLuint __result = glBindParameterEXT(value);
	return __result;
}

JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglIsVariantEnabledEXT(JNIEnv *env, jclass clazz, jint id, jint cap, jlong function_pointer) {
	glIsVariantEnabledEXTPROC glIsVariantEnabledEXT = (glIsVariantEnabledEXTPROC)((intptr_t)function_pointer);
	GLboolean __result = glIsVariantEnabledEXT(id, cap);
	return __result;
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetVariantBooleanvEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
	GLbyte *pbData_address = ((GLbyte *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
	glGetVariantBooleanvEXTPROC glGetVariantBooleanvEXT = (glGetVariantBooleanvEXTPROC)((intptr_t)function_pointer);
	glGetVariantBooleanvEXT(id, value, pbData_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetVariantIntegervEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
	GLint *pbData_address = ((GLint *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
	glGetVariantIntegervEXTPROC glGetVariantIntegervEXT = (glGetVariantIntegervEXTPROC)((intptr_t)function_pointer);
	glGetVariantIntegervEXT(id, value, pbData_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetVariantFloatvEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
	GLfloat *pbData_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
	glGetVariantFloatvEXTPROC glGetVariantFloatvEXT = (glGetVariantFloatvEXTPROC)((intptr_t)function_pointer);
	glGetVariantFloatvEXT(id, value, pbData_address);
}

JNIEXPORT jobject JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetVariantPointervEXT(JNIEnv *env, jclass clazz, jint id, jint value, jint result_size, jlong function_pointer) {
	glGetVariantPointervEXTPROC glGetVariantPointervEXT = (glGetVariantPointervEXTPROC)((intptr_t)function_pointer);
	GLvoid * __result;
	glGetVariantPointervEXT(id, value, &__result);
	return safeNewBuffer(env, __result, result_size);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetInvariantBooleanvEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
	GLbyte *pbData_address = ((GLbyte *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
	glGetInvariantBooleanvEXTPROC glGetInvariantBooleanvEXT = (glGetInvariantBooleanvEXTPROC)((intptr_t)function_pointer);
	glGetInvariantBooleanvEXT(id, value, pbData_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetInvariantIntegervEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
	GLint *pbData_address = ((GLint *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
	glGetInvariantIntegervEXTPROC glGetInvariantIntegervEXT = (glGetInvariantIntegervEXTPROC)((intptr_t)function_pointer);
	glGetInvariantIntegervEXT(id, value, pbData_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetInvariantFloatvEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
	GLfloat *pbData_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
	glGetInvariantFloatvEXTPROC glGetInvariantFloatvEXT = (glGetInvariantFloatvEXTPROC)((intptr_t)function_pointer);
	glGetInvariantFloatvEXT(id, value, pbData_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetLocalConstantBooleanvEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
	GLbyte *pbData_address = ((GLbyte *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
	glGetLocalConstantBooleanvEXTPROC glGetLocalConstantBooleanvEXT = (glGetLocalConstantBooleanvEXTPROC)((intptr_t)function_pointer);
	glGetLocalConstantBooleanvEXT(id, value, pbData_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetLocalConstantIntegervEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
	GLint *pbData_address = ((GLint *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
	glGetLocalConstantIntegervEXTPROC glGetLocalConstantIntegervEXT = (glGetLocalConstantIntegervEXTPROC)((intptr_t)function_pointer);
	glGetLocalConstantIntegervEXT(id, value, pbData_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTVertexShader_nglGetLocalConstantFloatvEXT(JNIEnv *env, jclass clazz, jint id, jint value, jobject pbData, jint pbData_position, jlong function_pointer) {
	GLfloat *pbData_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, pbData)) + pbData_position;
	glGetLocalConstantFloatvEXTPROC glGetLocalConstantFloatvEXT = (glGetLocalConstantFloatvEXTPROC)((intptr_t)function_pointer);
	glGetLocalConstantFloatvEXT(id, value, pbData_address);
}


--- NEW FILE: org_lwjgl_opengl_NVPointSprite.c ---
/* MACHINE GENERATED FILE, DO NOT EDIT */

#include <jni.h>
#include "extgl.h"

typedef void (APIENTRY *glPointParameteriNVPROC) (GLenum pname, GLint param);
typedef void (APIENTRY *glPointParameterivNVPROC) (GLenum pname, const GLint * params);

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPointSprite_nglPointParameteriNV(JNIEnv *env, jclass clazz, jint pname, jint param, jlong function_pointer) {
	glPointParameteriNVPROC glPointParameteriNV = (glPointParameteriNVPROC)((intptr_t)function_pointer);
	glPointParameteriNV(pname, param);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPointSprite_nglPointParameterivNV(JNIEnv *env, jclass clazz, jint pname, jobject params, jint params_position, jlong function_pointer) {
	const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
	glPointParameterivNVPROC glPointParameterivNV = (glPointParameterivNVPROC)((intptr_t)function_pointer);
	glPointParameterivNV(pname, params_address);
}


--- NEW FILE: org_lwjgl_opengl_NVProgram.c ---
/* MACHINE GENERATED FILE, DO NOT EDIT */

#include <jni.h>
#include "extgl.h"

typedef void (APIENTRY *glLoadProgramNVPROC) (GLenum target, GLuint programID, GLsizei length, const GLvoid * string);
typedef void (APIENTRY *glBindProgramNVPROC) (GLenum target, GLuint programID);
typedef void (APIENTRY *glDeleteProgramsNVPROC) (GLsizei n, const GLuint * programs);
typedef void (APIENTRY *glGenProgramsNVPROC) (GLsizei n, GLuint * programs);
typedef void (APIENTRY *glGetProgramivNVPROC) (GLuint programID, GLenum parameterName, GLint * params);
typedef void (APIENTRY *glGetProgramStringNVPROC) (GLuint programID, GLenum parameterName, GLvoid * paramString);
typedef GLboolean (APIENTRY *glIsProgramNVPROC) (GLuint programID);
typedef GLboolean (APIENTRY *glAreProgramsResidentNVPROC) (GLsizei n, const GLuint * programIDs, GLboolean * programResidences);
typedef void (APIENTRY *glRequestResidentProgramsNVPROC) (GLsizei n, GLuint * programIDs);

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglLoadProgramNV(JNIEnv *env, jclass clazz, jint target, jint programID, jint length, jobject string, jint string_position, jlong function_pointer) {
	const GLvoid *string_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, string)) + string_position));
	glLoadProgramNVPROC glLoadProgramNV = (glLoadProgramNVPROC)((intptr_t)function_pointer);
	glLoadProgramNV(target, programID, length, string_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglBindProgramNV(JNIEnv *env, jclass clazz, jint target, jint programID, jlong function_pointer) {
	glBindProgramNVPROC glBindProgramNV = (glBindProgramNVPROC)((intptr_t)function_pointer);
	glBindProgramNV(target, programID);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglDeleteProgramsNV(JNIEnv *env, jclass clazz, jint n, jobject programs, jint programs_position, jlong function_pointer) {
	const GLuint *programs_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, programs)) + programs_position;
	glDeleteProgramsNVPROC glDeleteProgramsNV = (glDeleteProgramsNVPROC)((intptr_t)function_pointer);
	glDeleteProgramsNV(n, programs_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglGenProgramsNV(JNIEnv *env, jclass clazz, jint n, jobject programs, jint programs_position, jlong function_pointer) {
	GLuint *programs_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, programs)) + programs_position;
	glGenProgramsNVPROC glGenProgramsNV = (glGenProgramsNVPROC)((intptr_t)function_pointer);
	glGenProgramsNV(n, programs_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglGetProgramivNV(JNIEnv *env, jclass clazz, jint programID, jint parameterName, jobject params, jint params_position, jlong function_pointer) {
	GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
	glGetProgramivNVPROC glGetProgramivNV = (glGetProgramivNVPROC)((intptr_t)function_pointer);
	glGetProgramivNV(programID, parameterName, params_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglGetProgramStringNV(JNIEnv *env, jclass clazz, jint programID, jint parameterName, jobject paramString, jint paramString_position, jlong function_pointer) {
	GLvoid *paramString_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, paramString)) + paramString_position));
	glGetProgramStringNVPROC glGetProgramStringNV = (glGetProgramStringNVPROC)((intptr_t)function_pointer);
	glGetProgramStringNV(programID, parameterName, paramString_address);
}

JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVProgram_nglIsProgramNV(JNIEnv *env, jclass clazz, jint programID, jlong function_pointer) {
	glIsProgramNVPROC glIsProgramNV = (glIsProgramNVPROC)((intptr_t)function_pointer);
	GLboolean __result = glIsProgramNV(programID);
	return __result;
}

JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVProgram_nglAreProgramsResidentNV(JNIEnv *env, jclass clazz, jint n, jobject programIDs, jint programIDs_position, jobject programResidences, jint programResidences_position, jlong function_pointer) {
	const GLuint *programIDs_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, programIDs)) + programIDs_position;
	GLboolean *programResidences_address = ((GLboolean *)(*env)->GetDirectBufferAddress(env, programResidences)) + programResidences_position;
	glAreProgramsResidentNVPROC glAreProgramsResidentNV = (glAreProgramsResidentNVPROC)((intptr_t)function_pointer);
	GLboolean __result = glAreProgramsResidentNV(n, programIDs_address, programResidences_address);
	return __result;
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_nglRequestResidentProgramsNV(JNIEnv *env, jclass clazz, jint n, jobject programIDs, jint programIDs_position, jlong function_pointer) {
	GLuint *programIDs_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, programIDs)) + programIDs_position;
	glRequestResidentProgramsNVPROC glRequestResidentProgramsNV = (glRequestResidentProgramsNVPROC)((intptr_t)function_pointer);
	glRequestResidentProgramsNV(n, programIDs_address);
}


--- NEW FILE: org_lwjgl_opengl_ARBVertexBlend.c ---
/* MACHINE GENERATED FILE, DO NOT EDIT */

#include <jni.h>
#include "extgl.h"

typedef void (APIENTRY *glWeightbvARBPROC) (GLint size, GLbyte * pWeights);
typedef void (APIENTRY *glWeightsvARBPROC) (GLint size, GLshort * pWeights);
typedef void (APIENTRY *glWeightivARBPROC) (GLint size, GLint * pWeights);
typedef void (APIENTRY *glWeightfvARBPROC) (GLint size, GLfloat * pWeights);
typedef void (APIENTRY *glWeightubvARBPROC) (GLint size, GLubyte * pWeights);
typedef void (APIENTRY *glWeightusvARBPROC) (GLint size, GLushort * pWeights);
typedef void (APIENTRY *glWeightuivARBPROC) (GLint size, GLuint * pWeights);
typedef void (APIENTRY *glWeightPointerARBPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid * pPointer);
typedef void (APIENTRY *glVertexBlendARBPROC) (GLint count);

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightbvARB(JNIEnv *env, jclass clazz, jint size, jobject pWeights, jint pWeights_position, jlong function_pointer) {
	GLbyte *pWeights_address = ((GLbyte *)(*env)->GetDirectBufferAddress(env, pWeights)) + pWeights_position;
	glWeightbvARBPROC glWeightbvARB = (glWeightbvARBPROC)((intptr_t)function_pointer);
	glWeightbvARB(size, pWeights_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightsvARB(JNIEnv *env, jclass clazz, jint size, jobject pWeights, jint pWeights_position, jlong function_pointer) {
	GLshort *pWeights_address = ((GLshort *)(*env)->GetDirectBufferAddress(env, pWeights)) + pWeights_position;
	glWeightsvARBPROC glWeightsvARB = (glWeightsvARBPROC)((intptr_t)function_pointer);
	glWeightsvARB(size, pWeights_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightivARB(JNIEnv *env, jclass clazz, jint size, jobject pWeights, jint pWeights_position, jlong function_pointer) {
	GLint *pWeights_address = ((GLint *)(*env)->GetDirectBufferAddress(env, pWeights)) + pWeights_position;
	glWeightivARBPROC glWeightivARB = (glWeightivARBPROC)((intptr_t)function_pointer);
	glWeightivARB(size, pWeights_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightfvARB(JNIEnv *env, jclass clazz, jint size, jobject pWeights, jint pWeights_position, jlong function_pointer) {
	GLfloat *pWeights_address = ((GLfloat *)(*env)->GetDirectBufferAddress(env, pWeights)) + pWeights_position;
	glWeightfvARBPROC glWeightfvARB = (glWeightfvARBPROC)((intptr_t)function_pointer);
	glWeightfvARB(size, pWeights_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightubvARB(JNIEnv *env, jclass clazz, jint size, jobject pWeights, jint pWeights_position, jlong function_pointer) {
	GLubyte *pWeights_address = ((GLubyte *)(*env)->GetDirectBufferAddress(env, pWeights)) + pWeights_position;
	glWeightubvARBPROC glWeightubvARB = (glWeightubvARBPROC)((intptr_t)function_pointer);
	glWeightubvARB(size, pWeights_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightusvARB(JNIEnv *env, jclass clazz, jint size, jobject pWeights, jint pWeights_position, jlong function_pointer) {
	GLushort *pWeights_address = ((GLushort *)(*env)->GetDirectBufferAddress(env, pWeights)) + pWeights_position;
	glWeightusvARBPROC glWeightusvARB = (glWeightusvARBPROC)((intptr_t)function_pointer);
	glWeightusvARB(size, pWeights_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightuivARB(JNIEnv *env, jclass clazz, jint size, jobject pWeights, jint pWeights_position, jlong function_pointer) {
	GLuint *pWeights_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, pWeights)) + pWeights_position;
	glWeightuivARBPROC glWeightuivARB = (glWeightuivARBPROC)((intptr_t)function_pointer);
	glWeightuivARB(size, pWeights_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightPointerARB(JNIEnv *env, jclass clazz, jint size, jint type, jint stride, jobject pPointer, jint pPointer_position, jlong function_pointer) {
	const GLvoid *pPointer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, pPointer)) + pPointer_position));
	glWeightPointerARBPROC glWeightPointerARB = (glWeightPointerARBPROC)((intptr_t)function_pointer);
	glWeightPointerARB(size, type, stride, pPointer_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightPointerARBBO(JNIEnv *env, jclass clazz, jint size, jint type, jint stride, jint pPointer_buffer_offset, jlong function_pointer) {
	const GLvoid *pPointer_address = ((const GLvoid *)offsetToPointer(pPointer_buffer_offset));
	glWeightPointerARBPROC glWeightPointerARB = (glWeightPointerARBPROC)((intptr_t)function_pointer);
	glWeightPointerARB(size, type, stride, pPointer_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglVertexBlendARB(JNIEnv *env, jclass clazz, jint count, jlong function_pointer) {
	glVertexBlendARBPROC glVertexBlendARB = (glVertexBlendARBPROC)((intptr_t)function_pointer);
	glVertexBlendARB(count);
}


--- NEW FILE: org_lwjgl_opengl_ARBVertexShader.c ---
/* MACHINE GENERATED FILE, DO NOT EDIT */

#include <jni.h>
#include "extgl.h"

typedef void (APIENTRY *glBindAttribLocationARBPROC) (GLhandleARB programObj, GLuint index, const GLcharARB * name);
typedef void (APIENTRY *glGetActiveAttribARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name);
typedef GLint (APIENTRY *glGetAttribLocationARBPROC) (GLhandleARB programObj, const GLcharARB * name);

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglBindAttribLocationARB(JNIEnv *env, jclass clazz, jint programObj, jint index, jobject name, jint name_position, jlong function_pointer) {
	const GLcharARB *name_address = ((const GLcharARB *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
	glBindAttribLocationARBPROC glBindAttribLocationARB = (glBindAttribLocationARBPROC)((intptr_t)function_pointer);
	glBindAttribLocationARB(programObj, index, name_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglGetActiveAttribARB(JNIEnv *env, jclass clazz, jint programObj, jint index, jint maxLength, jobject length, jint length_position, jobject size, jint size_position, jobject type, jint type_position, jobject name, jint name_position, jlong function_pointer) {
	GLsizei *length_address = ((GLsizei *)safeGetBufferAddress(env, length)) + length_position;
	GLint *size_address = ((GLint *)(*env)->GetDirectBufferAddress(env, size)) + size_position;
	GLenum *type_address = ((GLenum *)(*env)->GetDirectBufferAddress(env, type)) + type_position;
	GLcharARB *name_address = ((GLcharARB *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
	glGetActiveAttribARBPROC glGetActiveAttribARB = (glGetActiveAttribARBPROC)((intptr_t)function_pointer);
	glGetActiveAttribARB(programObj, index, maxLength, length_address, size_address, type_address, name_address);
}

JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglGetAttribLocationARB(JNIEnv *env, jclass clazz, jint programObj, jobject name, jint name_position, jlong function_pointer) {
	const GLcharARB *name_address = ((const GLcharARB *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
	glGetAttribLocationARBPROC glGetAttribLocationARB = (glGetAttribLocationARBPROC)((intptr_t)function_pointer);
	GLint __result = glGetAttribLocationARB(programObj, name_address);
	return __result;
}


--- NEW FILE: org_lwjgl_opengl_NVHalfFloat.c ---
/* MACHINE GENERATED FILE, DO NOT EDIT */

#include <jni.h>
#include "extgl.h"

typedef void (APIENTRY *glVertex2hNVPROC) (GLhalf x, GLhalf y);
typedef void (APIENTRY *glVertex3hNVPROC) (GLhalf x, GLhalf y, GLhalf z);
typedef void (APIENTRY *glVertex4hNVPROC) (GLhalf x, GLhalf y, GLhalf z, GLhalf w);
typedef void (APIENTRY *glNormal3hNVPROC) (GLhalf nx, GLhalf ny, GLhalf nz);
typedef void (APIENTRY *glColor3hNVPROC) (GLhalf red, GLhalf green, GLhalf blue);
typedef void (APIENTRY *glColor4hNVPROC) (GLhalf red, GLhalf green, GLhalf blue, GLhalf alpha);
typedef void (APIENTRY *glTexCoord1hNVPROC) (GLhalf s);
typedef void (APIENTRY *glTexCoord2hNVPROC) (GLhalf s, GLhalf t);
typedef void (APIENTRY *glTexCoord3hNVPROC) (GLhalf s, GLhalf t, GLhalf r);
typedef void (APIENTRY *glTexCoord4hNVPROC) (GLhalf s, GLhalf t, GLhalf r, GLhalf q);
typedef void (APIENTRY *glMultiTexCoord1hNVPROC) (GLenum target, GLhalf s);
typedef void (APIENTRY *glMultiTexCoord2hNVPROC) (GLenum target, GLhalf s, GLhalf t);
typedef void (APIENTRY *glMultiTexCoord3hNVPROC) (GLenum target, GLhalf s, GLhalf t, GLhalf r);
typedef void (APIENTRY *glMultiTexCoord4hNVPROC) (GLenum target, GLhalf s, GLhalf t, GLhalf r, GLhalf q);
typedef void (APIENTRY *glFogCoordhNVPROC) (GLhalf fog);
typedef void (APIENTRY *glSecondaryColor3hNVPROC) (GLhalf red, GLhalf green, GLhalf blue);
typedef void (APIENTRY *glVertexAttrib1hNVPROC) (GLuint index, GLhalf x);
typedef void (APIENTRY *glVertexAttrib2hNVPROC) (GLuint index, GLhalf x, GLhalf y);
typedef void (APIENTRY *glVertexAttrib3hNVPROC) (GLuint index, GLhalf x, GLhalf y, GLhalf z);
typedef void (APIENTRY *glVertexAttrib4hNVPROC) (GLuint index, GLhalf x, GLhalf y, GLhalf z, GLhalf w);
typedef void (APIENTRY *glVertexAttribs1hvNVPROC) (GLuint index, GLsizei n, const GLhalf * attribs);
typedef void (APIENTRY *glVertexAttribs2hvNVPROC) (GLuint index, GLsizei n, const GLhalf * attribs);
typedef void (APIENTRY *glVertexAttribs3hvNVPROC) (GLuint index, GLsizei n, const GLhalf * attribs);
typedef void (APIENTRY *glVertexAttribs4hvNVPROC) (GLuint index, GLsizei n, const GLhalf * attribs);

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertex2hNV(JNIEnv *env, jclass clazz, jshort x, jshort y, jlong function_pointer) {
	glVertex2hNVPROC glVertex2hNV = (glVertex2hNVPROC)((intptr_t)function_pointer);
	glVertex2hNV(x, y);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertex3hNV(JNIEnv *env, jclass clazz, jshort x, jshort y, jshort z, jlong function_pointer) {
	glVertex3hNVPROC glVertex3hNV = (glVertex3hNVPROC)((intptr_t)function_pointer);
	glVertex3hNV(x, y, z);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertex4hNV(JNIEnv *env, jclass clazz, jshort x, jshort y, jshort z, jshort w, jlong function_pointer) {
	glVertex4hNVPROC glVertex4hNV = (glVertex4hNVPROC)((intptr_t)function_pointer);
	glVertex4hNV(x, y, z, w);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglNormal3hNV(JNIEnv *env, jclass clazz, jshort nx, jshort ny, jshort nz, jlong function_pointer) {
	glNormal3hNVPROC glNormal3hNV = (glNormal3hNVPROC)((intptr_t)function_pointer);
	glNormal3hNV(nx, ny, nz);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglColor3hNV(JNIEnv *env, jclass clazz, jshort red, jshort green, jshort blue, jlong function_pointer) {
	glColor3hNVPROC glColor3hNV = (glColor3hNVPROC)((intptr_t)function_pointer);
	glColor3hNV(red, green, blue);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglColor4hNV(JNIEnv *env, jclass clazz, jshort red, jshort green, jshort blue, jshort alpha, jlong function_pointer) {
	glColor4hNVPROC glColor4hNV = (glColor4hNVPROC)((intptr_t)function_pointer);
	glColor4hNV(red, green, blue, alpha);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglTexCoord1hNV(JNIEnv *env, jclass clazz, jshort s, jlong function_pointer) {
	glTexCoord1hNVPROC glTexCoord1hNV = (glTexCoord1hNVPROC)((intptr_t)function_pointer);
	glTexCoord1hNV(s);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglTexCoord2hNV(JNIEnv *env, jclass clazz, jshort s, jshort t, jlong function_pointer) {
	glTexCoord2hNVPROC glTexCoord2hNV = (glTexCoord2hNVPROC)((intptr_t)function_pointer);
	glTexCoord2hNV(s, t);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglTexCoord3hNV(JNIEnv *env, jclass clazz, jshort s, jshort t, jshort r, jlong function_pointer) {
	glTexCoord3hNVPROC glTexCoord3hNV = (glTexCoord3hNVPROC)((intptr_t)function_pointer);
	glTexCoord3hNV(s, t, r);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglTexCoord4hNV(JNIEnv *env, jclass clazz, jshort s, jshort t, jshort r, jshort q, jlong function_pointer) {
	glTexCoord4hNVPROC glTexCoord4hNV = (glTexCoord4hNVPROC)((intptr_t)function_pointer);
	glTexCoord4hNV(s, t, r, q);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglMultiTexCoord1hNV(JNIEnv *env, jclass clazz, jint target, jshort s, jlong function_pointer) {
	glMultiTexCoord1hNVPROC glMultiTexCoord1hNV = (glMultiTexCoord1hNVPROC)((intptr_t)function_pointer);
	glMultiTexCoord1hNV(target, s);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglMultiTexCoord2hNV(JNIEnv *env, jclass clazz, jint target, jshort s, jshort t, jlong function_pointer) {
	glMultiTexCoord2hNVPROC glMultiTexCoord2hNV = (glMultiTexCoord2hNVPROC)((intptr_t)function_pointer);
	glMultiTexCoord2hNV(target, s, t);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglMultiTexCoord3hNV(JNIEnv *env, jclass clazz, jint target, jshort s, jshort t, jshort r, jlong function_pointer) {
	glMultiTexCoord3hNVPROC glMultiTexCoord3hNV = (glMultiTexCoord3hNVPROC)((intptr_t)function_pointer);
	glMultiTexCoord3hNV(target, s, t, r);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglMultiTexCoord4hNV(JNIEnv *env, jclass clazz, jint target, jshort s, jshort t, jshort r, jshort q, jlong function_pointer) {
	glMultiTexCoord4hNVPROC glMultiTexCoord4hNV = (glMultiTexCoord4hNVPROC)((intptr_t)function_pointer);
	glMultiTexCoord4hNV(target, s, t, r, q);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglFogCoordhNV(JNIEnv *env, jclass clazz, jshort fog, jlong function_pointer) {
	glFogCoordhNVPROC glFogCoordhNV = (glFogCoordhNVPROC)((intptr_t)function_pointer);
	glFogCoordhNV(fog);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglSecondaryColor3hNV(JNIEnv *env, jclass clazz, jshort red, jshort green, jshort blue, jlong function_pointer) {
	glSecondaryColor3hNVPROC glSecondaryColor3hNV = (glSecondaryColor3hNVPROC)((intptr_t)function_pointer);
	glSecondaryColor3hNV(red, green, blue);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttrib1hNV(JNIEnv *env, jclass clazz, jint index, jshort x, jlong function_pointer) {
	glVertexAttrib1hNVPROC glVertexAttrib1hNV = (glVertexAttrib1hNVPROC)((intptr_t)function_pointer);
	glVertexAttrib1hNV(index, x);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttrib2hNV(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jlong function_pointer) {
	glVertexAttrib2hNVPROC glVertexAttrib2hNV = (glVertexAttrib2hNVPROC)((intptr_t)function_pointer);
	glVertexAttrib2hNV(index, x, y);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttrib3hNV(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jshort z, jlong function_pointer) {
	glVertexAttrib3hNVPROC glVertexAttrib3hNV = (glVertexAttrib3hNVPROC)((intptr_t)function_pointer);
	glVertexAttrib3hNV(index, x, y, z);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttrib4hNV(JNIEnv *env, jclass clazz, jint index, jshort x, jshort y, jshort z, jshort w, jlong function_pointer) {
	glVertexAttrib4hNVPROC glVertexAttrib4hNV = (glVertexAttrib4hNVPROC)((intptr_t)function_pointer);
	glVertexAttrib4hNV(index, x, y, z, w);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs1hvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject attribs, jint attribs_position, jlong function_pointer) {
	const GLhalf *attribs_address = ((const GLhalf *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position;
	glVertexAttribs1hvNVPROC glVertexAttribs1hvNV = (glVertexAttribs1hvNVPROC)((intptr_t)function_pointer);
	glVertexAttribs1hvNV(index, n, attribs_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs2hvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject attribs, jint attribs_position, jlong function_pointer) {
	const GLhalf *attribs_address = ((const GLhalf *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position;
	glVertexAttribs2hvNVPROC glVertexAttribs2hvNV = (glVertexAttribs2hvNVPROC)((intptr_t)function_pointer);
	glVertexAttribs2hvNV(index, n, attribs_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs3hvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject attribs, jint attribs_position, jlong function_pointer) {
	const GLhalf *attribs_address = ((const GLhalf *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position;
	glVertexAttribs3hvNVPROC glVertexAttribs3hvNV = (glVertexAttribs3hvNVPROC)((intptr_t)function_pointer);
	glVertexAttribs3hvNV(index, n, attribs_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs4hvNV(JNIEnv *env, jclass clazz, jint index, jint n, jobject attribs, jint attribs_position, jlong function_pointer) {
	const GLhalf *attribs_address = ((const GLhalf *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position;
	glVertexAttribs4hvNVPROC glVertexAttribs4hvNV = (glVertexAttribs4hvNVPROC)((intptr_t)function_pointer);
	glVertexAttribs4hvNV(index, n, attribs_address);
}


--- NEW FILE: org_lwjgl_opengl_NVPixelDataRange.c ---
/* MACHINE GENERATED FILE, DO NOT EDIT */

#include <jni.h>
#include "extgl.h"

typedef void (APIENTRY *glPixelDataRangeNVPROC) (GLenum target, GLsizei length, GLvoid * data);
typedef void (APIENTRY *glFlushPixelDataRangeNVPROC) (GLenum target);

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPixelDataRange_nglPixelDataRangeNV(JNIEnv *env, jclass clazz, jint target, jint length, jobject data, jint data_position, jlong function_pointer) {
	GLvoid *data_address = ((GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, data)) + data_position));
	glPixelDataRangeNVPROC glPixelDataRangeNV = (glPixelDataRangeNVPROC)((intptr_t)function_pointer);
	glPixelDataRangeNV(target, length, data_address);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPixelDataRange_nglFlushPixelDataRangeNV(JNIEnv *env, jclass clazz, jint target, jlong function_pointer) {
	glFlushPixelDataRangeNVPROC glFlushPixelDataRangeNV = (glFlushPixelDataRangeNVPROC)((intptr_t)function_pointer);
	glFlushPixelDataRangeNV(target);
}


--- NEW FILE: org_lwjgl_opengl_EXTSecondaryColor.c ---
/* MACHINE GENERATED FILE, DO NOT EDIT */

#include <jni.h>
#include "extgl.h"

typedef void (APIENTRY *glSecondaryColor3bEXTPROC) (GLbyte red, GLbyte green, GLbyte blue);
typedef void (APIENTRY *glSecondaryColor3fEXTPROC) (GLfloat red, GLfloat green, GLfloat blue);
typedef void (APIENTRY *glSecondaryColor3ubEXTPROC) (GLubyte red, GLubyte green, GLubyte blue);
typedef void (APIENTRY *glSecondaryColorPointerEXTPROC) (GLint size, GLenum type, GLsizei stride, GLvoid * pPointer);

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTSecondaryColor_nglSecondaryColor3bEXT(JNIEnv *env, jclass clazz, jbyte red, jbyte green, jbyte blue, jlong function_pointer) {
	glSecondaryColor3bEXTPROC glSecondaryColor3bEXT = (glSecondaryColor3bEXTPROC)((intptr_t)function_pointer);
	glSecondaryColor3bEXT(red, green, blue);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTSecondaryColor_nglSecondaryColor3fEXT(JNIEnv *env, jclass clazz, jfloat red, jfloat green, jfloat blue, jlong function_pointer) {
	glSecondaryColor3fEXTPROC glSecondaryColor3fEXT = (glSecondaryColor3fEXTPROC)((intptr_t)function_pointer);
	glSecondaryColor3fEXT(red, green, blue);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTSecondaryColor_nglSecondaryColor3ubEXT(JNIEnv *env, jclass clazz, jbyte red, jbyte green, jbyte blue, jlong function_pointer) {
	glSecondaryColor3ubEXTPROC glSecondaryColor3ubEXT = (glSecondaryColor3ubEXTPROC)((intptr_t)function_pointer);
	glSecondaryColor3ubEXT(red, green, blue);
}

JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTSecondaryColor_nglSecondaryC...
 
[truncated message content]