[Java-game-lib-cvs] LWJGL/src/native/common/nv org_lwjgl_opengl_NVEvaluators.c,NONE,1.1 org_lwjgl_op

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

Modified Files:
	Makefile.am 
Added Files:
	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 
Removed Files:
	org_lwjgl_opengl_NVEvaluators.cpp org_lwjgl_opengl_NVFence.cpp 
	org_lwjgl_opengl_NVFragmentProgram.cpp 
	org_lwjgl_opengl_NVHalfFloat.cpp 
	org_lwjgl_opengl_NVOcclusionQuery.cpp 
	org_lwjgl_opengl_NVPixelDataRange.cpp 
	org_lwjgl_opengl_NVPointSprite.cpp 
	org_lwjgl_opengl_NVPrimitiveRestart.cpp 
	org_lwjgl_opengl_NVProgram.cpp 
	org_lwjgl_opengl_NVRegisterCombiners.cpp 
	org_lwjgl_opengl_NVRegisterCombiners2.cpp 
	org_lwjgl_opengl_NVVertexArrayRange.cpp 
	org_lwjgl_opengl_NVVertexProgram.cpp 
Log Message:
Converted native code from C++ (.cpp files) to C (.c files), thus avoiding an annoying dependency on the standard C++ library on Linux. We weren't using any particular C++ features anyway.




--- org_lwjgl_opengl_NVProgram.cpp DELETED ---

--- NEW FILE: org_lwjgl_opengl_NVPointSprite.c ---
/* 
 * Copyright (c) 2002-2004 LWJGL 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 'LWJGL' 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.
 */

// ----------------------------------
// IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.NVPointSprite
// ----------------------------------

#include "extgl.h"

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

static glPointParameteriNVPROC glPointParameteriNV;
static glPointParameterivNVPROC glPointParameterivNV;

/*
 * Class:	org.lwjgl.opengl.NVPointSprite
 * Method:	glPointParameteriNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVPointSprite_glPointParameteriNV
	(JNIEnv * env, jclass clazz, jint pname, jint param)
{
	glPointParameteriNV(pname, param);
	
}

/*
 * Class:	org.lwjgl.opengl.NVPointSprite
 * Method:	nglPointParameterivNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVPointSprite_nglPointParameterivNV
	(JNIEnv * env, jclass clazz, jint pname, jobject piParams, jint piParams_offset)
{
	GLint *piParams_ptr = (GLint *)(*env)->GetDirectBufferAddress(env, piParams) + piParams_offset;
	glPointParameterivNV(pname, piParams_ptr);
	
}

#ifdef __cplusplus
extern "C" {
#endif
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPointSprite_initNativeStubs(JNIEnv *env, jclass clazz) {
	JavaMethodAndExtFunction functions[] = {
		{"glPointParameteriNV", "(II)V", (void*)&Java_org_lwjgl_opengl_NVPointSprite_glPointParameteriNV, "glPointParameteriNV", (void*)&glPointParameteriNV},
		{"nglPointParameterivNV", "(ILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVPointSprite_nglPointParameterivNV, "glPointParameterivNV", (void*)&glPointParameterivNV}
	};
	int num_functions = NUMFUNCTIONS(functions);
	extgl_InitializeClass(env, clazz, num_functions, functions);
}
#ifdef __cplusplus
}
#endif


--- NEW FILE: org_lwjgl_opengl_NVProgram.c ---
/* 
 * Copyright (c) 2002-2004 LWJGL 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 'LWJGL' 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.
 */

// ----------------------------------
// IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.NVProgram
// ----------------------------------

#include "extgl.h"

typedef void (APIENTRY * glLoadProgramNVPROC) (GLenum target, GLuint id, GLsizei len, const GLubyte *program);
typedef void (APIENTRY * glBindProgramNVPROC) (GLenum target, GLuint id);
typedef void (APIENTRY * glDeleteProgramsNVPROC) (GLsizei n, const GLuint *ids);
typedef void (APIENTRY * glGenProgramsNVPROC) (GLsizei n, GLuint *ids);
typedef void (APIENTRY * glGetProgramStringNVPROC) (GLuint id, GLenum pname, GLubyte *program);
typedef GLboolean (APIENTRY * glIsProgramNVPROC) (GLuint id);
typedef GLboolean (APIENTRY * glAreProgramsResidentNVPROC) (GLsizei n, const GLuint *ids, GLboolean *residences);
typedef void (APIENTRY * glRequestResidentProgramsNVPROC) (GLsizei n, GLuint *ids);
typedef void (APIENTRY * glGetProgramivNVPROC) (GLuint id, GLenum pname, GLint *params);

static glLoadProgramNVPROC glLoadProgramNV;
static glBindProgramNVPROC glBindProgramNV;
static glDeleteProgramsNVPROC glDeleteProgramsNV;
static glGenProgramsNVPROC glGenProgramsNV;
static glGetProgramStringNVPROC glGetProgramStringNV;
static glIsProgramNVPROC glIsProgramNV;
static glAreProgramsResidentNVPROC glAreProgramsResidentNV;
static glRequestResidentProgramsNVPROC glRequestResidentProgramsNV;
static glGetProgramivNVPROC glGetProgramivNV;

/*
 * Class:	org.lwjgl.opengl.NVProgram
 * Method:	nglLoadProgramNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVProgram_nglLoadProgramNV
	(JNIEnv * env, jclass clazz, jint target, jint programID, jint length, jobject string, jint stringOffset)
{
	const GLubyte *string_ptr = (const GLubyte *)(*env)->GetDirectBufferAddress(env, string) + stringOffset;
	glLoadProgramNV(target, programID, length, string_ptr);
}

/*
 * Class:	org.lwjgl.opengl.NVProgram
 * Method:	glBindProgramNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVProgram_glBindProgramNV
	(JNIEnv * env, jclass clazz, jint target, jint programID)
{
	glBindProgramNV(target, programID);
}

/*
 * Class:	org.lwjgl.opengl.NVProgram
 * Method:	nglDeleteProgramsNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVProgram_nglDeleteProgramsNV
	(JNIEnv * env, jclass clazz, jint n, jobject programs, jint programsOffset)
{
	GLuint *programs_ptr = (GLuint *)(*env)->GetDirectBufferAddress(env, programs) + programsOffset;
	glDeleteProgramsNV(n, programs_ptr);
}

/*
 * Class:	org.lwjgl.opengl.NVProgram
 * Method:	nglGenProgramsNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVProgram_nglGenProgramsNV
	(JNIEnv * env, jclass clazz, jint n, jobject programs, jint programsOffset)
{
	GLuint *programs_ptr = (GLuint *)(*env)->GetDirectBufferAddress(env, programs) + programsOffset;
	glGenProgramsNV(n, programs_ptr);
}

/*
 * Class:	org.lwjgl.opengl.NVProgram
 * Method:	nglGetProgramivNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVProgram_nglGetProgramivNV
	(JNIEnv * env, jclass clazz, jint programID, jint parameterName, jobject params, jint paramsOffset)
{
	GLint *params_ptr = (GLint *)(*env)->GetDirectBufferAddress(env, params) + paramsOffset;
	glGetProgramivNV(programID, parameterName, params_ptr);
}

/*
 * Class:	org.lwjgl.opengl.NVProgram
 * Method:	nglGetProgramStringNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVProgram_nglGetProgramStringNV
	(JNIEnv * env, jclass clazz, jint programID, jint parameterName, jobject paramString, jint paramStringOffset)
{
	GLubyte *paramString_ptr = (GLubyte *)(*env)->GetDirectBufferAddress(env, paramString) + paramStringOffset;
	glGetProgramStringNV(programID, parameterName, paramString_ptr);
}

/*
 * Class:	org.lwjgl.opengl.NVProgram
 * Method:	glIsProgramNV
 */
static jboolean JNICALL Java_org_lwjgl_opengl_NVProgram_glIsProgramNV
	(JNIEnv * env, jclass clazz, jint programID)
{
	GLboolean result = glIsProgramNV(programID);
	
	return result;
}

/*
 * Class:	org.lwjgl.opengl.NVProgram
 * Method:	nglAreProgramsResidentNV
 */
static jboolean JNICALL Java_org_lwjgl_opengl_NVProgram_nglAreProgramsResidentNV
	(JNIEnv * env, jclass clazz, jint n, jobject programIDs, jint programIDsOffset, jobject programResidences, jint programResidencesOffset)
{
	GLuint *programIDs_ptr = (GLuint *)(*env)->GetDirectBufferAddress(env, programIDs) + programIDsOffset;
	GLubyte *programResidences_ptr = (GLubyte *)(*env)->GetDirectBufferAddress(env, programResidences) + programResidencesOffset;
	GLboolean result = glAreProgramsResidentNV(n, programIDs_ptr, programResidences_ptr);
	
	return result;
}

/*
 * Class:	org.lwjgl.opengl.NVProgram
 * Method:	nglRequestResidentProgramsNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVProgram_nglRequestResidentProgramsNV
	(JNIEnv * env, jclass clazz, jint n, jobject programIDs, jint programIDsOffset)
{
	GLuint *programIDs_ptr = (GLuint *)(*env)->GetDirectBufferAddress(env, programIDs) + programIDsOffset;
	glRequestResidentProgramsNV(n, programIDs_ptr);
}

#ifdef __cplusplus
extern "C" {
#endif
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVProgram_initNativeStubs(JNIEnv *env, jclass clazz) {
	JavaMethodAndExtFunction functions[] = {
		{"nglLoadProgramNV", "(IIILjava/nio/Buffer;I)V", (void*)&Java_org_lwjgl_opengl_NVProgram_nglLoadProgramNV, "glLoadProgramNV", (void*)&glLoadProgramNV},
		{"glBindProgramNV", "(II)V", (void*)&Java_org_lwjgl_opengl_NVProgram_glBindProgramNV, "glBindProgramNV", (void*)&glBindProgramNV},
		{"nglDeleteProgramsNV", "(ILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVProgram_nglDeleteProgramsNV, "glDeleteProgramsNV", (void*)&glDeleteProgramsNV},
		{"nglGenProgramsNV", "(ILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVProgram_nglGenProgramsNV, "glGenProgramsNV", (void*)&glGenProgramsNV},
		{"nglGetProgramivNV", "(IILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVProgram_nglGetProgramivNV, "glGetProgramivNV", (void*)&glGetProgramivNV},
		{"nglGetProgramStringNV", "(IILjava/nio/Buffer;I)V", (void*)&Java_org_lwjgl_opengl_NVProgram_nglGetProgramStringNV, "glGetProgramStringNV", (void*)&glGetProgramStringNV},
		{"glIsProgramNV", "(I)Z", (void*)&Java_org_lwjgl_opengl_NVProgram_glIsProgramNV, "glIsProgramNV", (void*)&glIsProgramNV},
		{"nglAreProgramsResidentNV", "(ILjava/nio/IntBuffer;ILjava/nio/ByteBuffer;I)Z", (void*)&Java_org_lwjgl_opengl_NVProgram_nglAreProgramsResidentNV, "glAreProgramsResidentNV", (void*)&glAreProgramsResidentNV},
		{"nglRequestResidentProgramsNV", "(ILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVProgram_nglRequestResidentProgramsNV, "glRequestResidentProgramsNV", (void*)&glRequestResidentProgramsNV}
	};
	int num_functions = NUMFUNCTIONS(functions);
	extgl_InitializeClass(env, clazz, num_functions, functions);
}
#ifdef __cplusplus
}
#endif


--- org_lwjgl_opengl_NVPointSprite.cpp DELETED ---

--- NEW FILE: org_lwjgl_opengl_NVEvaluators.c ---
/* 
 * Copyright (c) 2002-2004 LWJGL 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 'LWJGL' 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.
 */

// ----------------------------------
// IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.NVEvaluators
// ----------------------------------

#include "extgl.h"

typedef void (APIENTRY * glMapControlPointsNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid *points);
typedef void (APIENTRY * glMapParameterivNVPROC) (GLenum target, GLenum pname, const GLint *params);
typedef void (APIENTRY * glMapParameterfvNVPROC) (GLenum target, GLenum pname, const GLfloat *params);
typedef void (APIENTRY * glGetMapControlPointsNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid *points);
typedef void (APIENTRY * glGetMapParameterivNVPROC) (GLenum target, GLenum pname, GLint *params);
typedef void (APIENTRY * glGetMapParameterfvNVPROC) (GLenum target, GLenum pname, GLfloat *params);
typedef void (APIENTRY * glGetMapAttribParameterivNVPROC) (GLenum target, GLuint index, GLenum pname, GLint *params);
typedef void (APIENTRY * glGetMapAttribParameterfvNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat *params);
typedef void (APIENTRY * glEvalMapsNVPROC) (GLenum target, GLenum mode);

static glMapControlPointsNVPROC glMapControlPointsNV;
static glMapParameterivNVPROC glMapParameterivNV;
static glMapParameterfvNVPROC glMapParameterfvNV;
static glGetMapControlPointsNVPROC glGetMapControlPointsNV;
static glGetMapParameterivNVPROC glGetMapParameterivNV;
static glGetMapParameterfvNVPROC glGetMapParameterfvNV;
static glGetMapAttribParameterivNVPROC glGetMapAttribParameterivNV;
static glGetMapAttribParameterfvNVPROC glGetMapAttribParameterfvNV;
static glEvalMapsNVPROC glEvalMapsNV;

/*
 * Class:	org.lwjgl.opengl.NVEvaluators
 * Method:	nglGetMapControlPointsNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapControlPointsNV
	(JNIEnv * env, jclass clazz, jint target, jint index, jint type, jint ustride, jint vstride, jboolean packed, jobject pPoints, jint pPoints_offset)
{
	GLvoid *pPoints_ptr = (GLvoid *)((GLubyte *)(*env)->GetDirectBufferAddress(env, pPoints) + pPoints_offset);
	glGetMapControlPointsNV(target, index, type, ustride, vstride, packed, pPoints_ptr);
}

/*
 * Class:	org.lwjgl.opengl.NVEvaluators
 * Method:	nglMapControlPointsNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglMapControlPointsNV
	(JNIEnv * env, jclass clazz, jint target, jint index, jint type, jint ustride, jint vstride, jint uorder, jint vorder, jboolean packed, jobject pPoints, jint pPoints_offset)
{
	GLvoid *pPoints_ptr = (GLvoid *)((GLubyte *)(*env)->GetDirectBufferAddress(env, pPoints) + pPoints_offset);
	glMapControlPointsNV(target, index, type, ustride, vstride, uorder, vorder, packed, pPoints_ptr);
}

/*
 * Class:	org.lwjgl.opengl.NVEvaluators
 * Method:	nglMapParameterfvNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglMapParameterfvNV
	(JNIEnv * env, jclass clazz, jint target, jint pname, jobject pfParams, jint pfParams_offset)
{
	GLfloat *pfParams_ptr = (GLfloat *)(*env)->GetDirectBufferAddress(env, pfParams) + pfParams_offset;
	glMapParameterfvNV(target, pname, pfParams_ptr);
}

/*
 * Class:	org.lwjgl.opengl.NVEvaluators
 * Method:	nglMapParameterivNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglMapParameterivNV
	(JNIEnv * env, jclass clazz, jint target, jint pname, jobject piParams, jint piParams_offset)
{
	GLint *piParams_ptr = (GLint *)(*env)->GetDirectBufferAddress(env, piParams) + piParams_offset;
	glMapParameterivNV(target, pname, piParams_ptr);
}

/*
 * Class:	org.lwjgl.opengl.NVEvaluators
 * Method:	nglGetMapParameterfvNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapParameterfvNV
	(JNIEnv * env, jclass clazz, jint target, jint pname, jobject pfParams, jint pfParams_offset)
{
	GLfloat *pfParams_ptr = (GLfloat *)(*env)->GetDirectBufferAddress(env, pfParams) + pfParams_offset;
	glGetMapParameterfvNV(target, pname, pfParams_ptr);
}

/*
 * Class:	org.lwjgl.opengl.NVEvaluators
 * Method:	nglGetMapParameterivNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapParameterivNV
	(JNIEnv * env, jclass clazz, jint target, jint pname, jobject piParams, jint piParams_offset)
{
	GLint *piParams_ptr = (GLint *)(*env)->GetDirectBufferAddress(env, piParams) + piParams_offset;
	glGetMapParameterivNV(target, pname, piParams_ptr);
}

/*
 * Class:	org.lwjgl.opengl.NVEvaluators
 * Method:	nglGetMapAttribParameterfvNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapAttribParameterfvNV
	(JNIEnv * env, jclass clazz, jint target, jint index, jint pname, jobject pfParams, jint pfParams_offset)
{
	GLfloat *pfParams_ptr = (GLfloat *)(*env)->GetDirectBufferAddress(env, pfParams) + pfParams_offset;
	glGetMapAttribParameterfvNV(target, index, pname, pfParams_ptr);
}

/*
 * Class:	org.lwjgl.opengl.NVEvaluators
 * Method:	nglGetMapAttribParameterivNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapAttribParameterivNV
	(JNIEnv * env, jclass clazz, jint target, jint index, jint pname, jobject piParams, jint piParams_offset)
{
	GLint *piParams_ptr = (GLint *)(*env)->GetDirectBufferAddress(env, piParams) + piParams_offset;
	glGetMapAttribParameterivNV(target, index, pname, piParams_ptr);
}

/*
 * Class:	org.lwjgl.opengl.NVEvaluators
 * Method:	glEvalMapsNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVEvaluators_glEvalMapsNV
	(JNIEnv * env, jclass clazz, jint target, jint mode)
{
	glEvalMapsNV(target, mode);
}

#ifdef __cplusplus
extern "C" {
#endif
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_initNativeStubs(JNIEnv *env, jclass clazz) {
	JavaMethodAndExtFunction functions[] = {
		{"nglGetMapControlPointsNV", "(IIIIIZLjava/nio/Buffer;I)V", (void*)&Java_org_lwjgl_opengl_NVEvaluators_nglGetMapControlPointsNV, "glGetMapControlPointsNV", (void*)&glGetMapControlPointsNV},
		{"nglMapControlPointsNV", "(IIIIIIIZLjava/nio/Buffer;I)V", (void*)&Java_org_lwjgl_opengl_NVEvaluators_nglMapControlPointsNV, "glMapControlPointsNV", (void*)&glMapControlPointsNV},
		{"nglMapParameterfvNV", "(IILjava/nio/FloatBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVEvaluators_nglMapParameterfvNV, "glMapParameterfvNV", (void*)&glMapParameterfvNV},
		{"nglMapParameterivNV", "(IILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVEvaluators_nglMapParameterivNV, "glMapParameterivNV", (void*)&glMapParameterivNV},
		{"nglGetMapParameterfvNV", "(IILjava/nio/FloatBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVEvaluators_nglGetMapParameterfvNV, "glGetMapParameterfvNV", (void*)&glGetMapParameterfvNV},
		{"nglGetMapParameterivNV", "(IILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVEvaluators_nglGetMapParameterivNV, "glGetMapParameterivNV", (void*)&glGetMapParameterivNV},
		{"nglGetMapAttribParameterfvNV", "(IIILjava/nio/FloatBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVEvaluators_nglGetMapAttribParameterfvNV, "glGetMapAttribParameterfvNV", (void*)&glGetMapAttribParameterfvNV},
		{"nglGetMapAttribParameterivNV", "(IIILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVEvaluators_nglGetMapAttribParameterivNV, "glGetMapAttribParameterivNV", (void*)&glGetMapAttribParameterivNV},
		{"glEvalMapsNV", "(II)V", (void*)&Java_org_lwjgl_opengl_NVEvaluators_glEvalMapsNV, "glEvalMapsNV", (void*)&glEvalMapsNV}
	};
	int num_functions = NUMFUNCTIONS(functions);
	extgl_InitializeClass(env, clazz, num_functions, functions);
}
#ifdef __cplusplus
}
#endif

--- org_lwjgl_opengl_NVPrimitiveRestart.cpp DELETED ---

--- NEW FILE: org_lwjgl_opengl_NVHalfFloat.c ---
/* 
 * Copyright (c) 2002-2004 LWJGL 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 'LWJGL' 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.
 */

// ----------------------------------
// IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.NVHalfFloat
// ----------------------------------

#include "extgl.h"

typedef unsigned short GLhalf;

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 *v);
typedef void (APIENTRY * glVertexAttribs2hvNVPROC) (GLuint index, GLsizei n, const GLhalf *v);
typedef void (APIENTRY * glVertexAttribs3hvNVPROC) (GLuint index, GLsizei n, const GLhalf *v);
typedef void (APIENTRY * glVertexAttribs4hvNVPROC) (GLuint index, GLsizei n, const GLhalf *v);

static glVertex2hNVPROC glVertex2hNV;
static glVertex3hNVPROC glVertex3hNV;
static glVertex4hNVPROC glVertex4hNV;
static glNormal3hNVPROC glNormal3hNV;
static glColor3hNVPROC glColor3hNV;
static glColor4hNVPROC glColor4hNV;
static glTexCoord1hNVPROC glTexCoord1hNV;
static glTexCoord2hNVPROC glTexCoord2hNV;
static glTexCoord3hNVPROC glTexCoord3hNV;
static glTexCoord4hNVPROC glTexCoord4hNV;
static glMultiTexCoord1hNVPROC glMultiTexCoord1hNV;
static glMultiTexCoord2hNVPROC glMultiTexCoord2hNV;
static glMultiTexCoord3hNVPROC glMultiTexCoord3hNV;
static glMultiTexCoord4hNVPROC glMultiTexCoord4hNV;
static glFogCoordhNVPROC glFogCoordhNV;
static glSecondaryColor3hNVPROC glSecondaryColor3hNV;
static glVertexAttrib1hNVPROC glVertexAttrib1hNV;
static glVertexAttrib2hNVPROC glVertexAttrib2hNV;
static glVertexAttrib3hNVPROC glVertexAttrib3hNV;
static glVertexAttrib4hNVPROC glVertexAttrib4hNV;
static glVertexAttribs1hvNVPROC glVertexAttribs1hvNV;
static glVertexAttribs2hvNVPROC glVertexAttribs2hvNV;
static glVertexAttribs3hvNVPROC glVertexAttribs3hvNV;
static glVertexAttribs4hvNVPROC glVertexAttribs4hvNV;

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glVertex2hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertex2hNV
	(JNIEnv * env, jclass clazz, jshort x, jshort y)
{
	glVertex2hNV(x, y);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glVertex3hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertex3hNV
	(JNIEnv * env, jclass clazz, jshort x, jshort y, jshort z)
{
	glVertex3hNV(x, y, z);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glVertex4hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertex4hNV
	(JNIEnv * env, jclass clazz, jshort x, jshort y, jshort z, jshort w)
{
	glVertex4hNV(x, y, z, w);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glNormal3hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glNormal3hNV
	(JNIEnv * env, jclass clazz, jshort nx, jshort ny, jshort nz)
{
	glNormal3hNV(nx, ny, nz);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glColor3hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glColor3hNV
	(JNIEnv * env, jclass clazz, jshort red, jshort green, jshort blue)
{
	glColor3hNV(red, green, blue);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glColor4hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glColor4hNV
	(JNIEnv * env, jclass clazz, jshort red, jshort green, jshort blue, jshort alpha)
{
	glColor4hNV(red, green, blue, alpha);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glTexCoord1hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glTexCoord1hNV
	(JNIEnv * env, jclass clazz, jshort s)
{
	glTexCoord1hNV(s);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glTexCoord2hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glTexCoord2hNV
	(JNIEnv * env, jclass clazz, jshort s, jshort t)
{
	glTexCoord2hNV(s, t);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glTexCoord3hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glTexCoord3hNV
	(JNIEnv * env, jclass clazz, jshort s, jshort t, jshort r)
{
	glTexCoord3hNV(s, t, r);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glTexCoord4hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glTexCoord4hNV
	(JNIEnv * env, jclass clazz, jshort s, jshort t, jshort r, jshort q)
{
	glTexCoord4hNV(s, t, r, q);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glMultiTexCoord1hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glMultiTexCoord1hNV
	(JNIEnv * env, jclass clazz, jint target, jshort s)
{
	glMultiTexCoord1hNV(target, s);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glMultiTexCoord2hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glMultiTexCoord2hNV
	(JNIEnv * env, jclass clazz, jint target, jshort s, jshort t)
{
	glMultiTexCoord2hNV(target, s, t);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glMultiTexCoord3hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glMultiTexCoord3hNV
	(JNIEnv * env, jclass clazz, jint target, jshort s, jshort t, jshort r)
{
	glMultiTexCoord3hNV(target, s, t, r);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glMultiTexCoord4hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glMultiTexCoord4hNV
	(JNIEnv * env, jclass clazz, jint target, jshort s, jshort t, jshort r, jshort q)
{
	glMultiTexCoord4hNV(target, s, t, r, q);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glFogCoordhNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glFogCoordhNV
	(JNIEnv * env, jclass clazz, jshort fog)
{
	glFogCoordhNV(fog);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glSecondaryColor3hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glSecondaryColor3hNV
	(JNIEnv * env, jclass clazz, jshort red, jshort green, jshort blue)
{
	glSecondaryColor3hNV(red, green, blue);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glVertexAttrib1hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertexAttrib1hNV
	(JNIEnv * env, jclass clazz, jint index, jshort x)
{
	glVertexAttrib1hNV(index, x);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glVertexAttrib2hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertexAttrib2hNV
	(JNIEnv * env, jclass clazz, jint index, jshort x, jshort y)
{
	glVertexAttrib2hNV(index, x, y);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glVertexAttrib3hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertexAttrib3hNV
	(JNIEnv * env, jclass clazz, jint index, jshort x, jshort y, jshort z)
{
	glVertexAttrib3hNV(index, x, y, z);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	glVertexAttrib4hNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertexAttrib4hNV
	(JNIEnv * env, jclass clazz, jint index, jshort x, jshort y, jshort z, jshort w)
{
	glVertexAttrib4hNV(index, x, y, z, w);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	nglVertexAttribs1hvNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs1hvNV
	(JNIEnv * env, jclass clazz, jint index, jint n, jobject attribs, jint attribsOffset)
{
	GLushort *attribs_ptr = (GLushort *)(*env)->GetDirectBufferAddress(env, attribs) + attribsOffset;
	glVertexAttribs1hvNV(index, n, attribs_ptr);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	nglVertexAttribs2hvNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs2hvNV
	(JNIEnv * env, jclass clazz, jint index, jint n, jobject attribs, jint attribsOffset)
{
	GLushort *attribs_ptr = (GLushort *)(*env)->GetDirectBufferAddress(env, attribs) + attribsOffset;
	glVertexAttribs2hvNV(index, n, attribs_ptr);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	nglVertexAttribs3hvNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs3hvNV
	(JNIEnv * env, jclass clazz, jint index, jint n, jobject attribs, jint attribsOffset)
{
	GLushort *attribs_ptr = (GLushort *)(*env)->GetDirectBufferAddress(env, attribs) + attribsOffset;
	glVertexAttribs3hvNV(index, n, attribs_ptr);
}

/*
 * Class:	org.lwjgl.opengl.NVHalfFloat
 * Method:	nglVertexAttribs4hvNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs4hvNV
	(JNIEnv * env, jclass clazz, jint index, jint n, jobject attribs, jint attribsOffset)
{
	GLushort *attribs_ptr = (GLushort *)(*env)->GetDirectBufferAddress(env, attribs) + attribsOffset;
	glVertexAttribs4hvNV(index, n, attribs_ptr);
}

#ifdef __cplusplus
extern "C" {
#endif
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_initNativeStubs(JNIEnv *env, jclass clazz) {
	JavaMethodAndExtFunction functions[] = {
		{"glVertex2hNV", "(SS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glVertex2hNV, "glVertex2hNV", (void*)&glVertex2hNV},
		{"glVertex3hNV", "(SSS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glVertex3hNV, "glVertex3hNV", (void*)&glVertex3hNV},
		{"glVertex4hNV", "(SSSS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glVertex4hNV, "glVertex4hNV", (void*)&glVertex4hNV},
		{"glNormal3hNV", "(SSS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glNormal3hNV, "glNormal3hNV", (void*)&glNormal3hNV},
		{"glColor3hNV", "(SSS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glColor3hNV, "glColor3hNV", (void*)&glColor3hNV},
		{"glColor4hNV", "(SSSS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glColor4hNV, "glColor4hNV", (void*)&glColor4hNV},
		{"glTexCoord1hNV", "(S)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glTexCoord1hNV, "glTexCoord1hNV", (void*)&glTexCoord1hNV},
		{"glTexCoord2hNV", "(SS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glTexCoord2hNV, "glTexCoord2hNV", (void*)&glTexCoord2hNV},
		{"glTexCoord3hNV", "(SSS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glTexCoord3hNV, "glTexCoord3hNV", (void*)&glTexCoord3hNV},
		{"glTexCoord4hNV", "(SSSS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glTexCoord4hNV, "glTexCoord4hNV", (void*)&glTexCoord4hNV},
		{"glMultiTexCoord1hNV", "(IS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glMultiTexCoord1hNV, "glMultiTexCoord1hNV", (void*)&glMultiTexCoord1hNV},
		{"glMultiTexCoord2hNV", "(ISS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glMultiTexCoord2hNV, "glMultiTexCoord2hNV", (void*)&glMultiTexCoord2hNV},
		{"glMultiTexCoord3hNV", "(ISSS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glMultiTexCoord3hNV, "glMultiTexCoord3hNV", (void*)&glMultiTexCoord3hNV},
		{"glMultiTexCoord4hNV", "(ISSSS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glMultiTexCoord4hNV, "glMultiTexCoord4hNV", (void*)&glMultiTexCoord4hNV},
		{"glFogCoordhNV", "(S)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glFogCoordhNV, "glFogCoordhNV", (void*)&glFogCoordhNV},
		{"glSecondaryColor3hNV", "(SSS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glSecondaryColor3hNV, "glSecondaryColor3hNV", (void*)&glSecondaryColor3hNV},
		{"glVertexAttrib1hNV", "(IS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glVertexAttrib1hNV, "glVertexAttrib1hNV", (void*)&glVertexAttrib1hNV},
		{"glVertexAttrib2hNV", "(ISS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glVertexAttrib2hNV, "glVertexAttrib2hNV", (void*)&glVertexAttrib2hNV},
		{"glVertexAttrib3hNV", "(ISSS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glVertexAttrib3hNV, "glVertexAttrib3hNV", (void*)&glVertexAttrib3hNV},
		{"glVertexAttrib4hNV", "(ISSSS)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_glVertexAttrib4hNV, "glVertexAttrib4hNV", (void*)&glVertexAttrib4hNV},
		{"nglVertexAttribs1hvNV", "(IILjava/nio/ShortBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs1hvNV, "glVertexAttribs1hvNV", (void*)&glVertexAttribs1hvNV},
		{"nglVertexAttribs2hvNV", "(IILjava/nio/ShortBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs2hvNV, "glVertexAttribs2hvNV", (void*)&glVertexAttribs2hvNV},
		{"nglVertexAttribs3hvNV", "(IILjava/nio/ShortBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs3hvNV, "glVertexAttribs3hvNV", (void*)&glVertexAttribs3hvNV},
		{"nglVertexAttribs4hvNV", "(IILjava/nio/ShortBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs4hvNV, "glVertexAttribs4hvNV", (void*)&glVertexAttribs4hvNV}
	};
	int num_functions = NUMFUNCTIONS(functions);
	extgl_InitializeClass(env, clazz, num_functions, functions);
}
#ifdef __cplusplus
}
#endif


--- NEW FILE: org_lwjgl_opengl_NVFragmentProgram.c ---
/* 
 * Copyright (c) 2002-2004 LWJGL 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 'LWJGL' 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.
 */

// ----------------------------------
// IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.NVFragmentProgram
// ----------------------------------

#include "extgl.h"

typedef void (APIENTRY * glProgramNamedParameter4fNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (APIENTRY * glGetProgramNamedParameterfvNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat *params);

static glProgramNamedParameter4fNVPROC glProgramNamedParameter4fNV;
static glGetProgramNamedParameterfvNVPROC glGetProgramNamedParameterfvNV;

/*
 * Class:	org.lwjgl.opengl.NVFragmentProgram
 * Method:	nglProgramNamedParameter4fNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVFragmentProgram_nglProgramNamedParameter4fNV
	(JNIEnv * env, jclass clazz, jint id, jint length, jobject name, jint nameOffset, jfloat x, jfloat y, jfloat z, jfloat w)
{
	GLubyte *name_ptr = (GLubyte *)(*env)->GetDirectBufferAddress(env, name) + nameOffset;
	glProgramNamedParameter4fNV(id, length, name_ptr, x, y, z, w);
}

/*
 * Class:	org.lwjgl.opengl.NVFragmentProgram
 * Method:	nglGetProgramNamedParameterfvNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVFragmentProgram_nglGetProgramNamedParameterfvNV
	(JNIEnv * env, jclass clazz, jint id, jint length, jobject name, jint nameOffset, jobject params, jint paramsOffset)
{
	GLubyte *name_ptr = (GLubyte *)(*env)->GetDirectBufferAddress(env, name) + nameOffset;
	GLfloat *params_ptr = (GLfloat *)(*env)->GetDirectBufferAddress(env, params) + paramsOffset;
	glGetProgramNamedParameterfvNV(id, length, name_ptr, params_ptr);
}

#ifdef __cplusplus
extern "C" {
#endif
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFragmentProgram_initNativeStubs(JNIEnv *env, jclass clazz) {
	JavaMethodAndExtFunction functions[] = {
		{"nglProgramNamedParameter4fNV", "(IILjava/nio/ByteBuffer;IFFFF)V", (void*)&Java_org_lwjgl_opengl_NVFragmentProgram_nglProgramNamedParameter4fNV, "glProgramNamedParameter4fNV", (void*)&glProgramNamedParameter4fNV},
		{"nglGetProgramNamedParameterfvNV", "(IILjava/nio/ByteBuffer;ILjava/nio/FloatBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVFragmentProgram_nglGetProgramNamedParameterfvNV, "glGetProgramNamedParameterfvNV", (void*)&glGetProgramNamedParameterfvNV},
	};
	int num_functions = NUMFUNCTIONS(functions);
	extgl_InitializeClass(env, clazz, num_functions, functions);
}
#ifdef __cplusplus
}
#endif

--- org_lwjgl_opengl_NVRegisterCombiners.cpp DELETED ---

--- NEW FILE: org_lwjgl_opengl_NVOcclusionQuery.c ---
/* 
 * Copyright (c) 2002-2004 LWJGL 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 'LWJGL' 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.
 */

// ----------------------------------
// IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.NVOcclusionQuery
// ----------------------------------

#include "extgl.h"

typedef void (APIENTRY * glGenOcclusionQueriesNVPROC) (GLsizei n, GLuint *ids);
typedef void (APIENTRY * glDeleteOcclusionQueriesNVPROC) (GLsizei n, const GLuint *ids);
typedef GLboolean (APIENTRY * glIsOcclusionQueryNVPROC) (GLuint id);
typedef void (APIENTRY * glBeginOcclusionQueryNVPROC) (GLuint id);
typedef void (APIENTRY * glEndOcclusionQueryNVPROC) (void);
typedef void (APIENTRY * glGetOcclusionQueryivNVPROC) (GLuint id, GLenum pname, GLint *params);
typedef void (APIENTRY * glGetOcclusionQueryuivNVPROC) (GLuint id, GLenum pname, GLuint *params);

static glGenOcclusionQueriesNVPROC glGenOcclusionQueriesNV;
static glDeleteOcclusionQueriesNVPROC glDeleteOcclusionQueriesNV;
static glIsOcclusionQueryNVPROC glIsOcclusionQueryNV;
static glBeginOcclusionQueryNVPROC glBeginOcclusionQueryNV;
static glEndOcclusionQueryNVPROC glEndOcclusionQueryNV;
static glGetOcclusionQueryivNVPROC glGetOcclusionQueryivNV;
static glGetOcclusionQueryuivNVPROC glGetOcclusionQueryuivNV;

/*
 * Class:	org.lwjgl.opengl.NVOcclusionQuery
 * Method:	nglGenOcclusionQueriesNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglGenOcclusionQueriesNV
	(JNIEnv * env, jclass clazz, jint n, jobject piIDs, jint piIDs_offset)
{
	GLuint *piIDs_ptr = (GLuint *)(*env)->GetDirectBufferAddress(env, piIDs) + piIDs_offset;
	glGenOcclusionQueriesNV(n, piIDs_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.NVOcclusionQuery
 * Method:	nglDeleteOcclusionQueriesNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglDeleteOcclusionQueriesNV
	(JNIEnv * env, jclass clazz, jint n, jobject piIDs, jint piIDs_offset)
{
	GLuint *piIDs_ptr = (GLuint *)(*env)->GetDirectBufferAddress(env, piIDs) + piIDs_offset;
	glDeleteOcclusionQueriesNV(n, piIDs_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.NVOcclusionQuery
 * Method:	glIsOcclusionQueryNV
 */
static jboolean JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_glIsOcclusionQueryNV
	(JNIEnv * env, jclass clazz, jint id)
{
	GLboolean result = glIsOcclusionQueryNV(id);
	
	return result;
}

/*
 * Class:	org.lwjgl.opengl.NVOcclusionQuery
 * Method:	glBeginOcclusionQueryNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_glBeginOcclusionQueryNV
	(JNIEnv * env, jclass clazz, jint id)
{
	glBeginOcclusionQueryNV(id);
	
}

/*
 * Class:	org.lwjgl.opengl.NVOcclusionQuery
 * Method:	glEndOcclusionQueryNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_glEndOcclusionQueryNV
	(JNIEnv * env, jclass clazz)
{
	glEndOcclusionQueryNV();
	
}

/*
 * Class:	org.lwjgl.opengl.NVOcclusionQuery
 * Method:	nglGetOcclusionQueryivNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglGetOcclusionQueryivNV
	(JNIEnv * env, jclass clazz, jint id, jint pname, jobject piParams, jint piParams_offset)
{
	GLint *piParams_ptr = (GLint *)(*env)->GetDirectBufferAddress(env, piParams) + piParams_offset;
	glGetOcclusionQueryivNV(id, pname, piParams_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.NVOcclusionQuery
 * Method:	nglGetOcclusionQueryuivNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglGetOcclusionQueryuivNV
	(JNIEnv * env, jclass clazz, jint id, jint pname, jobject piParams, jint piParams_offset)
{
	GLuint *piParams_ptr = (GLuint *)(*env)->GetDirectBufferAddress(env, piParams) + piParams_offset;
	glGetOcclusionQueryuivNV(id, pname, piParams_ptr);
	
}

#ifdef __cplusplus
extern "C" {
#endif
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_initNativeStubs(JNIEnv *env, jclass clazz) {
	JavaMethodAndExtFunction functions[] = {
		{"nglGenOcclusionQueriesNV", "(ILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVOcclusionQuery_nglGenOcclusionQueriesNV, "glGenOcclusionQueriesNV", (void*)&glGenOcclusionQueriesNV},
		{"nglDeleteOcclusionQueriesNV", "(ILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVOcclusionQuery_nglDeleteOcclusionQueriesNV, "glDeleteOcclusionQueriesNV", (void*)&glDeleteOcclusionQueriesNV},
		{"glIsOcclusionQueryNV", "(I)Z", (void*)&Java_org_lwjgl_opengl_NVOcclusionQuery_glIsOcclusionQueryNV, "glIsOcclusionQueryNV", (void*)&glIsOcclusionQueryNV},
		{"glBeginOcclusionQueryNV", "(I)V", (void*)&Java_org_lwjgl_opengl_NVOcclusionQuery_glBeginOcclusionQueryNV, "glBeginOcclusionQueryNV", (void*)&glBeginOcclusionQueryNV},
		{"glEndOcclusionQueryNV", "()V", (void*)&Java_org_lwjgl_opengl_NVOcclusionQuery_glEndOcclusionQueryNV, "glEndOcclusionQueryNV", (void*)&glEndOcclusionQueryNV},
		{"nglGetOcclusionQueryivNV", "(IILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVOcclusionQuery_nglGetOcclusionQueryivNV, "glGetOcclusionQueryivNV", (void*)&glGetOcclusionQueryivNV},
		{"nglGetOcclusionQueryuivNV", "(IILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVOcclusionQuery_nglGetOcclusionQueryuivNV, "glGetOcclusionQueryuivNV", (void*)&glGetOcclusionQueryuivNV}
	};
	int num_functions = NUMFUNCTIONS(functions);
	extgl_InitializeClass(env, clazz, num_functions, functions);
}
#ifdef __cplusplus
}
#endif


--- org_lwjgl_opengl_NVVertexArrayRange.cpp DELETED ---

--- org_lwjgl_opengl_NVFragmentProgram.cpp DELETED ---

--- org_lwjgl_opengl_NVFence.cpp DELETED ---

--- org_lwjgl_opengl_NVHalfFloat.cpp DELETED ---

--- NEW FILE: org_lwjgl_opengl_NVVertexArrayRange.c ---
/* 
 * Copyright (c) 2002-2004 LWJGL 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 'LWJGL' 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.
 */

// ----------------------------------
// IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.NVVertexArrayRange
// ----------------------------------

#include "extgl.h"
#include "common_tools.h"

typedef void (APIENTRY * glFlushVertexArrayRangeNVPROC) (void);
typedef void (APIENTRY * glVertexArrayRangeNVPROC) (GLsizei size, const GLvoid *pointer);

static glFlushVertexArrayRangeNVPROC glFlushVertexArrayRangeNV;
static glVertexArrayRangeNVPROC glVertexArrayRangeNV;

#ifdef _WIN32

typedef void * (APIENTRY * wglAllocateMemoryNVPROC) (GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority);
typedef void (APIENTRY * wglFreeMemoryNVPROC) (void *pointer);

static wglAllocateMemoryNVPROC wglAllocateMemoryNV;
static wglFreeMemoryNVPROC wglFreeMemoryNV;

#endif /* WIN32 */

#ifdef _X11

typedef void * (APIENTRY * glXAllocateMemoryNVPROC) (GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority);
typedef void (APIENTRY * glXFreeMemoryNVPROC) (void *pointer);

static glXAllocateMemoryNVPROC glXAllocateMemoryNV;
static glXFreeMemoryNVPROC glXFreeMemoryNV;

#endif /* X11 */

/*
 * Class:	org.lwjgl.opengl.NVVertexArrayRange
 * Method:	nglVertexArrayRangeNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVVertexArrayRange_nglVertexArrayRangeNV
	(JNIEnv * env, jclass clazz, jint size, jobject pPointer, jint pPointer_offset)
{
	GLvoid *pPointer_ptr = (GLvoid *)((GLubyte *)(*env)->GetDirectBufferAddress(env, pPointer) + pPointer_offset);
	glVertexArrayRangeNV(size, pPointer_ptr);
}

/*
 * Class:	org.lwjgl.opengl.NVVertexArrayRange
 * Method:	glFlushVertexArrayRangeNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVVertexArrayRange_glFlushVertexArrayRangeNV
	(JNIEnv * env, jclass clazz)
{
	glFlushVertexArrayRangeNV();
}

#ifdef _X11
static jobject JNICALL Java_org_lwjgl_opengl_NVVertexArrayRange_glXAllocateMemoryNV
	(JNIEnv * env, jclass clazz, jint size, jfloat readFrequency, jfloat writeFrequency, jfloat priority)
{
	void *mem_address = glXAllocateMemoryNV((GLint) size, (GLfloat)readFrequency, (GLfloat)writeFrequency, (GLfloat)priority);
	return safeNewBuffer(env, mem_address, size);
}

static void JNICALL Java_org_lwjgl_opengl_NVVertexArrayRange_glXFreeMemoryNV
	(JNIEnv * env, jclass clazz, jobject pointer)
{
        void *address = (void *)(*env)->GetDirectBufferAddress(env, pointer);
        glXFreeMemoryNV(address);
}
#endif

#ifdef _WIN32
static jobject JNICALL Java_org_lwjgl_opengl_NVVertexArrayRange_wglAllocateMemoryNV
	(JNIEnv * env, jclass clazz, jint size, jfloat readFrequency, jfloat writeFrequency, jfloat priority)
{
        void *mem_address = wglAllocateMemoryNV((GLint)size, (GLfloat)readFrequency, (GLfloat)writeFrequency, (GLfloat)priority);
        return safeNewBuffer(env, mem_address, size);
}

static void JNICALL Java_org_lwjgl_opengl_NVVertexArrayRange_wglFreeMemoryNV
	(JNIEnv * env, jclass clazz, jobject pointer)
{
        void *address = (void *)(*env)->GetDirectBufferAddress(env, pointer);
        wglFreeMemoryNV(address);
}
#endif

#ifdef __cplusplus
extern "C" {
#endif
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVVertexArrayRange_initNativeStubs(JNIEnv *env, jclass clazz) {
	JavaMethodAndExtFunction functions[] = {
		{"nglVertexArrayRangeNV", "(ILjava/nio/Buffer;I)V", (void*)&Java_org_lwjgl_opengl_NVVertexArrayRange_nglVertexArrayRangeNV, "glVertexArrayRangeNV", (void*)&glVertexArrayRangeNV},
		{"glFlushVertexArrayRangeNV", "()V", (void*)&Java_org_lwjgl_opengl_NVVertexArrayRange_glFlushVertexArrayRangeNV, "glFlushVertexArrayRangeNV", (void*)&glFlushVertexArrayRangeNV},
#ifdef _X11
		{"glXAllocateMemoryNV", "(IFFF)Ljava/nio/ByteBuffer;", (void*)&Java_org_lwjgl_opengl_NVVertexArrayRange_glXAllocateMemoryNV, "glXAllocateMemoryNV", (void*)&glXAllocateMemoryNV},
		{"glXFreeMemoryNV", "(Ljava/nio/ByteBuffer;)V", (void*)&Java_org_lwjgl_opengl_NVVertexArrayRange_glXFreeMemoryNV, "glXFreeMemoryNV", (void*)&glXFreeMemoryNV},
#endif
#ifdef _WIN32
		{"wglAllocateMemoryNV", "(IFFF)Ljava/nio/ByteBuffer;", (void*)&Java_org_lwjgl_opengl_NVVertexArrayRange_wglAllocateMemoryNV, "wglAllocateMemoryNV", (void*)&wglAllocateMemoryNV},
		{"wglFreeMemoryNV", "(Ljava/nio/ByteBuffer;)V", (void*)&Java_org_lwjgl_opengl_NVVertexArrayRange_wglFreeMemoryNV, "wglFreeMemoryNV", (void*)&wglFreeMemoryNV}
#endif
	};
	int num_functions = NUMFUNCTIONS(functions);
	extgl_InitializeClass(env, clazz, num_functions, functions);
}
#ifdef __cplusplus
}
#endif


--- org_lwjgl_opengl_NVRegisterCombiners2.cpp DELETED ---

--- NEW FILE: org_lwjgl_opengl_NVPrimitiveRestart.c ---
/* 
 * Copyright (c) 2002-2004 LWJGL 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 'LWJGL' 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.
 */

// ----------------------------------
// IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.NVPrimitiveRestart
// ----------------------------------

#include "extgl.h"

typedef void (APIENTRY * glPrimitiveRestartNVPROC) (GLvoid);
typedef void (APIENTRY * glPrimitiveRestartIndexNVPROC) (GLuint index);

static glPrimitiveRestartNVPROC glPrimitiveRestartNV;
static glPrimitiveRestartIndexNVPROC glPrimitiveRestartIndexNV;

/*
 * Class:	org.lwjgl.opengl.NVPrimitiveRestart
 * Method:	glPrimitiveRestartNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVPrimitiveRestart_glPrimitiveRestartNV
	(JNIEnv * env, jclass clazz)
{
	glPrimitiveRestartNV();
}

/*
 * Class:	org.lwjgl.opengl.NVPrimitiveRestart
 * Method:	glPrimitiveRestartIndexNV
 */
static void JNICALL Java_org_lwjgl_opengl_NVPrimitiveRestart_glPrimitiveRestartIndexNV
	(JNIEnv * env, jclass clazz, jint index)
{
	glPrimitiveRestartIndexNV(index);
}

#ifdef __cplusplus
extern "C" {
#endif
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPrimitiveRestart_initNativeStubs(JNIEnv *env, jclass clazz) {
	JavaMethodAndExtFunction functions[] = {
		{"glPrimitiveRestartNV", "()V", (void*)&Java_org_lwjgl_opengl_NVPrimitiveRestart_glPrimitiveRestartNV, "glPrimitiveRestartNV", (void*)&glPrimitiveRestartNV},
		{"glPrimitiveRestartIndexNV", "(I)V", (void*)&Java_org_lwjgl_opengl_NVPrimitiveRestart_glPrimitiveRestartIndexNV, "glPrimitiveRestartIndexNV", (void*)&glPrimitiveRestartIndexNV}
	};
	int num_functions = NUMFUNCTIONS(functions);
	extgl_InitializeClass(env, clazz, num_functions, functions);
}
#ifdef __cplusplus
}
#endif


--- NEW FILE: org_lwjgl_opengl_NVFence.c ---
/* 
 * Copyright (c) 2002-2004 LWJGL 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 'LWJGL' 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.
 */

// ----------------------------------
// IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.NVFence
// ----------------------------------

#include "extgl.h"

typedef void (APIENTRY * glGenFencesNVPROC) (GLsizei n, GLuint *fences);
typedef void (APIENTRY * glDeleteFencesNVPROC) (GLsizei n, const GLuint *fences);
typedef void (APIENTRY * glSetFenceNVPROC) (GLuint fence, GLenum condition);
typedef GLboolean (APIENTRY * glTestFenceNVPROC) (GLuint fence);
typedef void (APIENTRY * glFinishFenceNVPROC) (GLuint fence);
typedef GLboolean (APIENTRY * glIsFenceNVPROC) (GLuint fence);
typedef void (APIENTRY * glGetFenceivNVPROC) (GLuint fence, GLenum pname, GLint *params);

static glGenFencesNVPROC glGenFencesNV;
static glDeleteFencesNVPROC glDeleteFencesNV;
static glSetFenceNVPROC glSetFenceNV;
static glTestFenceNVPROC glTestFenceNV;
static glFinishFenceNVPROC glFinishFenceNV;
static glIsFenceNVPROC glIsFenceNV;
static glGetFenceivNVPROC glGetFenceivNV;

/*
 * Class:	...
 
[truncated message content]