[Java-game-lib-cvs] LWJGL/src/native/common/arb org_lwjgl_opengl_ARBBufferObject.c,NONE,1.1 org_lwjg

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

Modified Files:
	Makefile.am 
Added Files:
	org_lwjgl_opengl_ARBBufferObject.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 
Removed Files:
	org_lwjgl_opengl_ARBBufferObject.cpp 
	org_lwjgl_opengl_ARBDrawBuffers.cpp 
	org_lwjgl_opengl_ARBImaging.cpp 
	org_lwjgl_opengl_ARBMatrixPalette.cpp 
	org_lwjgl_opengl_ARBMultisample.cpp 
	org_lwjgl_opengl_ARBMultitexture.cpp 
	org_lwjgl_opengl_ARBOcclusionQuery.cpp 
	org_lwjgl_opengl_ARBPointParameters.cpp 
	org_lwjgl_opengl_ARBProgram.cpp 
	org_lwjgl_opengl_ARBShaderObjects.cpp 
	org_lwjgl_opengl_ARBTextureCompression.cpp 
	org_lwjgl_opengl_ARBTransposeMatrix.cpp 
	org_lwjgl_opengl_ARBVertexBlend.cpp 
	org_lwjgl_opengl_ARBVertexProgram.cpp 
	org_lwjgl_opengl_ARBVertexShader.cpp 
	org_lwjgl_opengl_ARBWindowPos.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.




--- NEW FILE: org_lwjgl_opengl_ARBDrawBuffers.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.ARBDrawBuffers
// ----------------------------------

#include "extgl.h"


typedef void (APIENTRY * glDrawBuffersARBPROC) (GLsizei n, const GLenum *bufs);

static glDrawBuffersARBPROC glDrawBuffersARB;

/*
 * Class:	org.lwjgl.opengl.ARBDrawBuffers
 * Method:	nglDrawBuffersARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBDrawBuffers_nglDrawBuffersARB
	(JNIEnv * env, jclass clazz, jint size, jobject buffers, jint buffersOffset)
{
	GLuint *buffers_ptr = (GLuint *)(*env)->GetDirectBufferAddress(env, buffers) + buffersOffset;
	glDrawBuffersARB(size, buffers_ptr);

}

#ifdef __clplusplus
extern "C" {
#endif
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBDrawBuffers_initNativeStubs(JNIEnv *env, jclass clazz) {
	JavaMethodAndExtFunction functions[] = {
		{"nglDrawBuffersARB", "(ILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBDrawBuffers_nglDrawBuffersARB, "glDrawBuffersARB", (void*)&glDrawBuffersARB}
	};
	int num_functions = NUMFUNCTIONS(functions);
	extgl_InitializeClass(env, clazz, num_functions, functions);
}
#ifdef __cplusplus
}
#endif


--- NEW FILE: org_lwjgl_opengl_ARBMatrixPalette.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.ARBMatrixPalette
// ----------------------------------

#include "extgl.h"

typedef void (APIENTRY * glCurrentPaletteMatrixARBPROC) (GLint index);
typedef void (APIENTRY * glMatrixIndexubvARBPROC) (GLint size, GLubyte *indices);
typedef void (APIENTRY * glMatrixIndexusvARBPROC) (GLint size, GLushort *indices);
typedef void (APIENTRY * glMatrixIndexuivARBPROC) (GLint size, GLuint *indices);
typedef void (APIENTRY * glMatrixIndexPointerARBPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer);

static glCurrentPaletteMatrixARBPROC glCurrentPaletteMatrixARB;
static glMatrixIndexubvARBPROC glMatrixIndexubvARB;
static glMatrixIndexusvARBPROC glMatrixIndexusvARB;
static glMatrixIndexuivARBPROC glMatrixIndexuivARB;
static glMatrixIndexPointerARBPROC glMatrixIndexPointerARB;

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

/*
 * Class:	org.lwjgl.opengl.ARBMatrixPalette
 * Method:	nglMatrixIndexPointerARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBMatrixPalette_nglMatrixIndexPointerARB
	(JNIEnv * env, jclass clazz, jint size, jint type, jint stride, jobject pPointer, jint pPointer_offset)
{
	GLvoid *pPointer_ptr = (GLvoid *)((GLubyte *)(*env)->GetDirectBufferAddress(env, pPointer) + pPointer_offset);
	glMatrixIndexPointerARB(size, type, stride, pPointer_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBMatrixPalette
 * Method:	nglMatrixIndexPointerARBVBO
 */
static void JNICALL Java_org_lwjgl_opengl_ARBMatrixPalette_nglMatrixIndexPointerARBVBO
	(JNIEnv * env, jclass clazz, jint size, jint type, jint stride, jint buffer_offset)
{
	glMatrixIndexPointerARB(size, type, stride, (GLvoid *)buffer_offset);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBMatrixPalette
 * Method:	nglMatrixIndexubvARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBMatrixPalette_nglMatrixIndexubvARB
	(JNIEnv * env, jclass clazz, jint size, jobject pIndices, jint pIndices_offset)
{
	GLubyte *pIndices_ptr = (GLubyte *)(*env)->GetDirectBufferAddress(env, pIndices) + pIndices_offset;
	glMatrixIndexubvARB(size, pIndices_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBMatrixPalette
 * Method:	nglMatrixIndexuivARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBMatrixPalette_nglMatrixIndexuivARB
	(JNIEnv * env, jclass clazz, jint size, jobject piIndices, jint piIndices_offset)
{
	GLuint *piIndices_ptr = (GLuint *)(*env)->GetDirectBufferAddress(env, piIndices) + piIndices_offset;
	glMatrixIndexuivARB(size, piIndices_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBMatrixPalette
 * Method:	nglMatrixIndexusvARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBMatrixPalette_nglMatrixIndexusvARB
	(JNIEnv * env, jclass clazz, jint size, jobject psIndices, jint psIndices_offset)
{
	GLushort *psIndices_ptr = (GLushort *)(*env)->GetDirectBufferAddress(env, psIndices) + psIndices_offset;
	glMatrixIndexusvARB(size, psIndices_ptr);
	
}

#ifdef _cplusplus
extern "C" {
#endif
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMatrixPalette_initNativeStubs(JNIEnv *env, jclass clazz) {
	JavaMethodAndExtFunction functions[] = {
		{"glCurrentPaletteMatrixARB", "(I)V", (void*)&Java_org_lwjgl_opengl_ARBMatrixPalette_glCurrentPaletteMatrixARB, "glCurrentPaletteMatrixARB", (void*)&glCurrentPaletteMatrixARB},
		{"nglMatrixIndexPointerARB", "(IIILjava/nio/Buffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBMatrixPalette_nglMatrixIndexPointerARB, "glMatrixIndexPointerARB", (void*)&glMatrixIndexPointerARB},
		{"nglMatrixIndexPointerARBVBO", "(IIII)V", (void*)&Java_org_lwjgl_opengl_ARBMatrixPalette_nglMatrixIndexPointerARBVBO, NULL, NULL},
		{"nglMatrixIndexubvARB", "(ILjava/nio/ByteBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBMatrixPalette_nglMatrixIndexubvARB, "glMatrixIndexubvARB", (void*)&glMatrixIndexubvARB},
		{"nglMatrixIndexuivARB", "(ILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBMatrixPalette_nglMatrixIndexuivARB, "glMatrixIndexuivARB", (void*)&glMatrixIndexuivARB},
		{"nglMatrixIndexusvARB", "(ILjava/nio/ShortBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBMatrixPalette_nglMatrixIndexusvARB, "glMatrixIndexusvARB", (void*)&glMatrixIndexusvARB}
	};
	int num_functions = NUMFUNCTIONS(functions);
	extgl_InitializeClass(env, clazz, num_functions, functions);
}
#ifdef __cplusplus
}
#endif


--- NEW FILE: org_lwjgl_opengl_ARBVertexProgram.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.ARBVertexProgram
// ----------------------------------

#include "extgl.h"
#include "common_tools.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 * glVertexAttrib1svARBPROC) (GLuint index, const GLshort *v);
typedef void (APIENTRY * glVertexAttrib1fvARBPROC) (GLuint index, const GLfloat *v);
typedef void (APIENTRY * glVertexAttrib2svARBPROC) (GLuint index, const GLshort *v);
typedef void (APIENTRY * glVertexAttrib2fvARBPROC) (GLuint index, const GLfloat *v);
typedef void (APIENTRY * glVertexAttrib2dvARBPROC) (GLuint index, const GLdouble *v);
typedef void (APIENTRY * glVertexAttrib3svARBPROC) (GLuint index, const GLshort *v);
typedef void (APIENTRY * glVertexAttrib3fvARBPROC) (GLuint index, const GLfloat *v);
typedef void (APIENTRY * glVertexAttrib3dvARBPROC) (GLuint index, const GLdouble *v);
typedef void (APIENTRY * glVertexAttrib4bvARBPROC) (GLuint index, const GLbyte *v);
typedef void (APIENTRY * glVertexAttrib4svARBPROC) (GLuint index, const GLshort *v);
typedef void (APIENTRY * glVertexAttrib4ivARBPROC) (GLuint index, const GLint *v);
typedef void (APIENTRY * glVertexAttrib4ubvARBPROC) (GLuint index, const GLubyte *v);
typedef void (APIENTRY * glVertexAttrib4usvARBPROC) (GLuint index, const GLushort *v);
typedef void (APIENTRY * glVertexAttrib4uivARBPROC) (GLuint index, const GLuint *v);
typedef void (APIENTRY * glVertexAttrib4fvARBPROC) (GLuint index, const GLfloat *v);
typedef void (APIENTRY * glVertexAttrib4dvARBPROC) (GLuint index, const GLdouble *v);
typedef void (APIENTRY * glVertexAttrib4NbvARBPROC) (GLuint index, const GLbyte *v);
typedef void (APIENTRY * glVertexAttrib4NsvARBPROC) (GLuint index, const GLshort *v);
typedef void (APIENTRY * glVertexAttrib4NivARBPROC) (GLuint index, const GLint *v);
typedef void (APIENTRY * glVertexAttrib4NubvARBPROC) (GLuint index, const GLubyte *v);
typedef void (APIENTRY * glVertexAttrib4NusvARBPROC) (GLuint index, const GLushort *v);
typedef void (APIENTRY * glVertexAttrib4NuivARBPROC) (GLuint index, const GLuint *v);
typedef void (APIENTRY * glVertexAttribPointerARBPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
typedef void (APIENTRY * glEnableVertexAttribArrayARBPROC) (GLuint index);
typedef void (APIENTRY * glDisableVertexAttribArrayARBPROC) (GLuint index);
typedef void (APIENTRY * glGetVertexAttribdvARBPROC) (GLuint index, GLenum pname, GLdouble *params);
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 **pointer);

static glVertexAttrib1sARBPROC glVertexAttrib1sARB;
static glVertexAttrib1fARBPROC glVertexAttrib1fARB;
static glVertexAttrib2sARBPROC glVertexAttrib2sARB;
static glVertexAttrib2fARBPROC glVertexAttrib2fARB;
static glVertexAttrib3sARBPROC glVertexAttrib3sARB;
static glVertexAttrib3fARBPROC glVertexAttrib3fARB;
static glVertexAttrib4sARBPROC glVertexAttrib4sARB;
static glVertexAttrib4fARBPROC glVertexAttrib4fARB;
static glVertexAttrib4NubARBPROC glVertexAttrib4NubARB;
static glVertexAttribPointerARBPROC glVertexAttribPointerARB;
static glEnableVertexAttribArrayARBPROC glEnableVertexAttribArrayARB;
static glDisableVertexAttribArrayARBPROC glDisableVertexAttribArrayARB;
static glGetVertexAttribfvARBPROC glGetVertexAttribfvARB;
static glGetVertexAttribivARBPROC glGetVertexAttribivARB;
static glGetVertexAttribPointervARBPROC glGetVertexAttribPointervARB;

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

/*
 * Class:	org.lwjgl.opengl.ARBVertexProgram
 * Method:	glVertexAttrib1fARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_glVertexAttrib1fARB
	(JNIEnv * env, jclass clazz, jint index, jfloat x)
{
	glVertexAttrib1fARB(index, x);
	
}

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

/*
 * Class:	org.lwjgl.opengl.ARBVertexProgram
 * Method:	glVertexAttrib2fARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_glVertexAttrib2fARB
	(JNIEnv * env, jclass clazz, jint index, jfloat x, jfloat y)
{
	glVertexAttrib2fARB(index, x, y);
	
}

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

/*
 * Class:	org.lwjgl.opengl.ARBVertexProgram
 * Method:	glVertexAttrib3fARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_glVertexAttrib3fARB
	(JNIEnv * env, jclass clazz, jint index, jfloat x, jfloat y, jfloat z)
{
	glVertexAttrib3fARB(index, x, y, z);
	
}

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

/*
 * Class:	org.lwjgl.opengl.ARBVertexProgram
 * Method:	glVertexAttrib4fARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_glVertexAttrib4fARB
	(JNIEnv * env, jclass clazz, jint index, jfloat x, jfloat y, jfloat z, jfloat w)
{
	glVertexAttrib4fARB(index, x, y, z, w);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBVertexProgram
 * Method:	glVertexAttrib4NubARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_glVertexAttrib4NubARB
	(JNIEnv * env, jclass clazz, jint index, jbyte x, jbyte y, jbyte z, jbyte w)
{
	glVertexAttrib4NubARB(index, x, y, z, w);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBVertexProgram
 * Method:	nglVertexAttribPointerARB
 */
static 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 bufferOffset)
{
	GLvoid *buffer_ptr = (GLvoid *)((GLubyte *)(*env)->GetDirectBufferAddress(env, buffer) + bufferOffset);
	glVertexAttribPointerARB(index, size, type, normalized, stride, buffer_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBVertexProgram
 * Method:	nglVertexAttribPointerARBVBO
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttribPointerARBVBO
	(JNIEnv * env, jclass clazz, jint index, jint size, jint type, jboolean normalized, jint stride, jint bufferOffset)
{
	glVertexAttribPointerARB(index, size, type, normalized, stride, (GLvoid *)bufferOffset);
	
}

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

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

/*
 * Class:	org.lwjgl.opengl.ARBVertexProgram
 * Method:	nglGetVertexAttribfvARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglGetVertexAttribfvARB
	(JNIEnv * env, jclass clazz, jint index, jint pname, jobject params, jint paramsOffset)
{
	GLfloat *params_ptr = (GLfloat *)(*env)->GetDirectBufferAddress(env, params) + paramsOffset;
	glGetVertexAttribfvARB(index, pname, params_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBVertexProgram
 * Method:	nglGetVertexAttribivARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglGetVertexAttribivARB
	(JNIEnv * env, jclass clazz, jint index, jint pname, jobject params, jint paramsOffset)
{
	GLint *params_ptr = (GLint *)(*env)->GetDirectBufferAddress(env, params) + paramsOffset;
	glGetVertexAttribivARB(index, pname, params_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBVertexProgram
 * Method:	glGetVertexAttribPointerARB
 */
static jobject JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_glGetVertexAttribPointerARB
	(JNIEnv * env, jclass clazz, jint index, jint pname, jint size)
{
        void *address;
        glGetVertexAttribPointervARB((GLuint)index, (GLuint)pname, &address);
        
        return safeNewBuffer(env, address, size);
}

#ifdef __cplusplus
extern "C" {
#endif
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_initNativeStubs(JNIEnv *env, jclass clazz) {
	JavaMethodAndExtFunction functions[] = {
		{"glVertexAttrib1sARB", "(IS)V", (void*)&Java_org_lwjgl_opengl_ARBVertexProgram_glVertexAttrib1sARB, "glVertexAttrib1sARB", (void*)&glVertexAttrib1sARB},
		{"glVertexAttrib1fARB", "(IF)V", (void*)&Java_org_lwjgl_opengl_ARBVertexProgram_glVertexAttrib1fARB, "glVertexAttrib1fARB", (void*)&glVertexAttrib1fARB},
		{"glVertexAttrib2sARB", "(ISS)V", (void*)&Java_org_lwjgl_opengl_ARBVertexProgram_glVertexAttrib2sARB, "glVertexAttrib2sARB", (void*)&glVertexAttrib2sARB},
		{"glVertexAttrib2fARB", "(IFF)V", (void*)&Java_org_lwjgl_opengl_ARBVertexProgram_glVertexAttrib2fARB, "glVertexAttrib2fARB", (void*)&glVertexAttrib2fARB},
		{"glVertexAttrib3sARB", "(ISSS)V", (void*)&Java_org_lwjgl_opengl_ARBVertexProgram_glVertexAttrib3sARB, "glVertexAttrib3sARB", (void*)&glVertexAttrib3sARB},
		{"glVertexAttrib3fARB", "(IFFF)V", (void*)&Java_org_lwjgl_opengl_ARBVertexProgram_glVertexAttrib3fARB, "glVertexAttrib3fARB", (void*)&glVertexAttrib3fARB},
		{"glVertexAttrib4sARB", "(ISSSS)V", (void*)&Java_org_lwjgl_opengl_ARBVertexProgram_glVertexAttrib4sARB, "glVertexAttrib4sARB", (void*)&glVertexAttrib4sARB},
		{"glVertexAttrib4fARB", "(IFFFF)V", (void*)&Java_org_lwjgl_opengl_ARBVertexProgram_glVertexAttrib4fARB, "glVertexAttrib4fARB", (void*)&glVertexAttrib4fARB},
		{"glVertexAttrib4NubARB", "(IBBBB)V", (void*)&Java_org_lwjgl_opengl_ARBVertexProgram_glVertexAttrib4NubARB, "glVertexAttrib4NubARB", (void*)&glVertexAttrib4NubARB},
		{"nglVertexAttribPointerARB", "(IIIZILjava/nio/Buffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttribPointerARB, "glVertexAttribPointerARB", (void*)&glVertexAttribPointerARB},
		{"nglVertexAttribPointerARBVBO", "(IIIZII)V", (void*)&Java_org_lwjgl_opengl_ARBVertexProgram_nglVertexAttribPointerARBVBO, NULL, NULL},
		{"glEnableVertexAttribArrayARB", "(I)V", (void*)&Java_org_lwjgl_opengl_ARBVertexProgram_glEnableVertexAttribArrayARB, "glEnableVertexAttribArrayARB", (void*)&glEnableVertexAttribArrayARB},
		{"glDisableVertexAttribArrayARB", "(I)V", (void*)&Java_org_lwjgl_opengl_ARBVertexProgram_glDisableVertexAttribArrayARB, "glDisableVertexAttribArrayARB", (void*)&glDisableVertexAttribArrayARB},
		{"nglGetVertexAttribfvARB", "(IILjava/nio/FloatBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBVertexProgram_nglGetVertexAttribfvARB, "glGetVertexAttribfvARB", (void*)&glGetVertexAttribfvARB},
		{"nglGetVertexAttribivARB", "(IILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBVertexProgram_nglGetVertexAttribivARB, "glGetVertexAttribivARB", (void*)&glGetVertexAttribivARB},
		{"glGetVertexAttribPointerARB", "(III)Ljava/nio/ByteBuffer;", (void*)&Java_org_lwjgl_opengl_ARBVertexProgram_glGetVertexAttribPointerARB, "glGetVertexAttribPointervARB", (void*)&glGetVertexAttribPointervARB}
	};
	int num_functions = NUMFUNCTIONS(functions);
	extgl_InitializeClass(env, clazz, num_functions, functions);
}
#ifdef __cplusplus
}
#endif


--- NEW FILE: org_lwjgl_opengl_ARBMultisample.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.ARBMultisample
// ----------------------------------

#include "extgl.h"

typedef void (APIENTRY * glSampleCoverageARBPROC) (GLclampf value, GLboolean invert);

static glSampleCoverageARBPROC glSampleCoverageARB;

/*
 * Class:	org.lwjgl.opengl.ARBMultisample
 * Method:	glSampleCoverageARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBMultisample_glSampleCoverageARB
	(JNIEnv * env, jclass clazz, jfloat value, jboolean invert)
{
	glSampleCoverageARB(value, invert);
	
}

#ifdef __cplusplus
extern "C" {
#endif
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBMultisample_initNativeStubs(JNIEnv *env, jclass clazz) {
	JavaMethodAndExtFunction functions[] = {
		{"glSampleCoverageARB", "(FZ)V", (void*)&Java_org_lwjgl_opengl_ARBMultisample_glSampleCoverageARB, "glSampleCoverageARB", (void*)&glSampleCoverageARB}
	};
	int num_functions = NUMFUNCTIONS(functions);
	extgl_InitializeClass(env, clazz, num_functions, functions);
}
#ifdef __cplusplus
}
#endif


--- NEW FILE: org_lwjgl_opengl_ARBOcclusionQuery.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.ARBOcclusionQuery
// ----------------------------------

#include "extgl.h"

typedef void (APIENTRY * glGenQueriesARBPROC) (GLsizei n, GLuint *ids);
typedef void (APIENTRY * glDeleteQueriesARBPROC) (GLsizei n, const GLuint *ids);
typedef GLboolean (APIENTRY * glIsQueryARBPROC) (GLuint id);
typedef void (APIENTRY * glBeginQueryARBPROC) (GLenum target, GLuint id);
typedef void (APIENTRY * glEndQueryARBPROC) (GLenum target);
typedef void (APIENTRY * glGetQueryivARBPROC) (GLenum target, GLenum pname, GLint *params);
typedef void (APIENTRY * glGetQueryObjectivARBPROC) (GLuint id, GLenum pname, GLint *params);
typedef void (APIENTRY * glGetQueryObjectuivARBPROC) (GLuint id, GLenum pname, GLuint *params);

static glGenQueriesARBPROC glGenQueriesARB;
static glDeleteQueriesARBPROC glDeleteQueriesARB;
static glIsQueryARBPROC glIsQueryARB;
static glBeginQueryARBPROC glBeginQueryARB;
static glEndQueryARBPROC glEndQueryARB;
static glGetQueryivARBPROC glGetQueryivARB;
static glGetQueryObjectivARBPROC glGetQueryObjectivARB;
static glGetQueryObjectuivARBPROC glGetQueryObjectuivARB;

/*
 * Class:	org.lwjgl.opengl.ARBOcclusionQuery
 * Method:	nglGenQueriesARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_nglGenQueriesARB
	(JNIEnv * env, jclass clazz, jint n, jobject ids, jint idsOffset)
{
	GLuint *ids_ptr = (GLuint *)(*env)->GetDirectBufferAddress(env, ids) + idsOffset;
	glGenQueriesARB(n, ids_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBOcclusionQuery
 * Method:	nglDeleteQueriesARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_nglDeleteQueriesARB
	(JNIEnv * env, jclass clazz, jint n, jobject ids, jint idsOffset)
{
	GLuint *ids_ptr = (GLuint *)(*env)->GetDirectBufferAddress(env, ids) + idsOffset;
	glDeleteQueriesARB(n, ids_ptr);
	
}

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

/*
 * Class:	org.lwjgl.opengl.ARBOcclusionQuery
 * Method:	glBeginQueryARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_glBeginQueryARB
	(JNIEnv * env, jclass clazz, jint target, jint id)
{
	glBeginQueryARB(target, id);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBOcclusionQuery
 * Method:	glEndQueryARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_glEndQueryARB
	(JNIEnv * env, jclass clazz, jint target)
{
	glEndQueryARB(target);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBOcclusionQuery
 * Method:	nglGetQueryivARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_nglGetQueryivARB
	(JNIEnv * env, jclass clazz, jint target, jint pname, jobject params, jint paramsOffset)
{
	GLint *params_ptr = (GLint *)(*env)->GetDirectBufferAddress(env, params) + paramsOffset;
	glGetQueryivARB(target, pname, params_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBOcclusionQuery
 * Method:	nglGetQueryObjectivARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_nglGetQueryObjectivARB
	(JNIEnv * env, jclass clazz, jint id, jint pname, jobject params, jint paramsOffset)
{
	GLint *params_ptr = (GLint *)(*env)->GetDirectBufferAddress(env, params) + paramsOffset;
	glGetQueryObjectivARB(id, pname, params_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBOcclusionQuery
 * Method:	nglGetQueryObjectuivARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_nglGetQueryObjectuivARB
	(JNIEnv * env, jclass clazz, jint id, jint pname, jobject params, jint paramsOffset)
{
	GLuint *params_ptr = (GLuint *)(*env)->GetDirectBufferAddress(env, params) + paramsOffset;
	glGetQueryObjectuivARB(id, pname, params_ptr);
	
}

#ifdef __cplusplus
extern "C" {
#endif
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_initNativeStubs(JNIEnv *env, jclass clazz) {
	JavaMethodAndExtFunction functions[] = {
		{"nglGenQueriesARB", "(ILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBOcclusionQuery_nglGenQueriesARB, "glGenQueriesARB", (void*)&glGenQueriesARB},
		{"nglDeleteQueriesARB", "(ILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBOcclusionQuery_nglDeleteQueriesARB, "glDeleteQueriesARB", (void*)&glDeleteQueriesARB},
		{"glIsQueryARB", "(I)Z", (void*)&Java_org_lwjgl_opengl_ARBOcclusionQuery_glIsQueryARB, "glIsQueryARB", (void*)&glIsQueryARB},
		{"glBeginQueryARB", "(II)V", (void*)&Java_org_lwjgl_opengl_ARBOcclusionQuery_glBeginQueryARB, "glBeginQueryARB", (void*)&glBeginQueryARB},
		{"glEndQueryARB", "(I)V", (void*)&Java_org_lwjgl_opengl_ARBOcclusionQuery_glEndQueryARB, "glEndQueryARB", (void*)&glEndQueryARB},
		{"nglGetQueryivARB", "(IILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBOcclusionQuery_nglGetQueryivARB, "glGetQueryivARB", (void*)&glGetQueryivARB},
		{"nglGetQueryObjectivARB", "(IILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBOcclusionQuery_nglGetQueryObjectivARB, "glGetQueryObjectivARB", (void*)&glGetQueryObjectivARB},
		{"nglGetQueryObjectuivARB", "(IILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBOcclusionQuery_nglGetQueryObjectuivARB, "glGetQueryObjectuivARB", (void*)&glGetQueryObjectuivARB}
	};
	int num_functions = NUMFUNCTIONS(functions);
	extgl_InitializeClass(env, clazz, num_functions, functions);
}
#ifdef __cplusplus
}
#endif


--- org_lwjgl_opengl_ARBWindowPos.cpp DELETED ---

--- org_lwjgl_opengl_ARBMatrixPalette.cpp DELETED ---

--- NEW FILE: org_lwjgl_opengl_ARBVertexBlend.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.ARBVertexBlend
// ----------------------------------

#include "extgl.h"

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

static glWeightbvARBPROC glWeightbvARB;
static glWeightsvARBPROC glWeightsvARB;
static glWeightivARBPROC glWeightivARB;
static glWeightfvARBPROC glWeightfvARB;
static glWeightubvARBPROC glWeightubvARB;
static glWeightusvARBPROC glWeightusvARB;
static glWeightuivARBPROC glWeightuivARB;
static glWeightPointerARBPROC glWeightPointerARB;
static glVertexBlendARBPROC glVertexBlendARB;

/*
 * Class:	org.lwjgl.opengl.ARBVertexBlend
 * Method:	nglWeightbvARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightbvARB
	(JNIEnv * env, jclass clazz, jint size, jobject pWeights, jint pWeights_offset)
{
	GLbyte *pWeights_ptr = (GLbyte *)(*env)->GetDirectBufferAddress(env, pWeights) + pWeights_offset;
	glWeightbvARB(size, pWeights_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBVertexBlend
 * Method:	nglWeightfvARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightfvARB
	(JNIEnv * env, jclass clazz, jint size, jobject pfWeights, jint pfWeights_offset)
{
	GLfloat *pfWeights_ptr = (GLfloat *)(*env)->GetDirectBufferAddress(env, pfWeights) + pfWeights_offset;
	glWeightfvARB(size, pfWeights_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBVertexBlend
 * Method:	nglWeightivARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightivARB
	(JNIEnv * env, jclass clazz, jint size, jobject piWeights, jint piWeights_offset)
{
	GLint *piWeights_ptr = (GLint *)(*env)->GetDirectBufferAddress(env, piWeights) + piWeights_offset;
	glWeightivARB(size, piWeights_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBVertexBlend
 * Method:	nglWeightsvARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightsvARB
	(JNIEnv * env, jclass clazz, jint size, jobject psWeights, jint psWeights_offset)
{
	GLshort *psWeights_ptr = (GLshort *)(*env)->GetDirectBufferAddress(env, psWeights) + psWeights_offset;
	glWeightsvARB(size, psWeights_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBVertexBlend
 * Method:	nglWeightubvARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightubvARB
	(JNIEnv * env, jclass clazz, jint size, jobject pWeights, jint pWeights_offset)
{
	GLubyte *pWeights_ptr = (GLubyte *)(*env)->GetDirectBufferAddress(env, pWeights) + pWeights_offset;
	glWeightubvARB(size, pWeights_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBVertexBlend
 * Method:	nglWeightuivARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightuivARB
	(JNIEnv * env, jclass clazz, jint size, jobject piWeights, jint piWeights_offset)
{
	GLuint *piWeights_ptr = (GLuint *)(*env)->GetDirectBufferAddress(env, piWeights) + piWeights_offset;
	glWeightuivARB(size, piWeights_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBVertexBlend
 * Method:	nglWeightusvARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightusvARB
	(JNIEnv * env, jclass clazz, jint size, jobject psWeights, jint psWeights_offset)
{
	GLushort *psWeights_ptr = (GLushort *)(*env)->GetDirectBufferAddress(env, psWeights) + psWeights_offset;
	glWeightusvARB(size, psWeights_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBVertexBlend
 * Method:	nglWeightPointerARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightPointerARB
	(JNIEnv * env, jclass clazz, jint size, jint type, jint stride, jobject pPointer, jint pPointer_offset)
{
	GLvoid *pPointer_ptr = (GLvoid *)((GLubyte *)(*env)->GetDirectBufferAddress(env, pPointer) + pPointer_offset);
	glWeightPointerARB(size, type, stride, pPointer_ptr);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBVertexBlend
 * Method:	nglWeightPointerARBVBO
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightPointerARBVBO
	(JNIEnv * env, jclass clazz, jint size, jint type, jint stride, jint buffer_offset)
{
	glWeightPointerARB(size, type, stride, (GLvoid *)buffer_offset);
	
}

/*
 * Class:	org.lwjgl.opengl.ARBVertexBlend
 * Method:	glVertexBlendARB
 */
static void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_glVertexBlendARB
	(JNIEnv * env, jclass clazz, jint count)
{
	glVertexBlendARB(count);
	
}

#ifdef __cplusplus
extern "C" {
#endif
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexBlend_initNativeStubs(JNIEnv *env, jclass clazz) {
	JavaMethodAndExtFunction functions[] = {
		{"nglWeightbvARB", "(ILjava/nio/ByteBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightbvARB, "glWeightbvARB", (void*)&glWeightbvARB},
		{"nglWeightfvARB", "(ILjava/nio/FloatBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightfvARB, "glWeightfvARB", (void*)&glWeightfvARB},
		{"nglWeightivARB", "(ILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightivARB, "glWeightivARB", (void*)&glWeightivARB},
		{"nglWeightsvARB", "(ILjava/nio/ShortBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightsvARB, "glWeightsvARB", (void*)&glWeightsvARB},
		{"nglWeightubvARB", "(ILjava/nio/ByteBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightubvARB, "glWeightubvARB", (void*)&glWeightubvARB},
		{"nglWeightuivARB", "(ILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightuivARB, "glWeightuivARB", (void*)&glWeightuivARB},
		{"nglWeightusvARB", "(ILjava/nio/ShortBuffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightusvARB, "glWeightusvARB", (void*)&glWeightusvARB},
		{"nglWeightPointerARB", "(IIILjava/nio/Buffer;I)V", (void*)&Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightPointerARB, "glWeightPointerARB", (void*)&glWeightPointerARB},
		{"nglWeightPointerARBVBO", "(IIII)V", (void*)&Java_org_lwjgl_opengl_ARBVertexBlend_nglWeightPointerARBVBO, NULL, NULL},
		{"glVertexBlendARB", "(I)V", (void*)&Java_org_lwjgl_opengl_ARBVertexBlend_glVertexBlendARB, "glVertexBlendARB", (void*)&glVertexBlendARB}
	};
	int num_functions = NUMFUNCTIONS(functions);
	extgl_InitializeClass(env, clazz, num_functions, functions);
}
#ifdef __cplusplus
}
#endif


--- NEW FILE: org_lwjgl_opengl_ARBImaging.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.
 */
 
/**
 * $Id: org_lwjgl_opengl_ARBImaging.c,v 1.1 2004/09/10 08:13:51 elias_naur Exp $
 *
 * Core OpenGL functions.
 *
 * @author cix_foo <ci...@us...>
 * @version $Revision: 1.1 $
 */

#include "extgl.h"

typedef void (APIENTRY * glBlendColorPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );
typedef void (APIENTRY * glBlendEquationPROC) (GLenum mode );
typedef void (APIENTRY * glColorTablePROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table );
typedef void (APIENTRY * glColorTableParameterfvPROC) (GLenum target, GLenum pname, const GLfloat *params);
typedef void (APIENTRY * glColorTableParameterivPROC) (GLenum target, GLenum pname, const GLint *params);
typedef void (APIENTRY * glCopyColorTablePROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width );
typedef void (APIENTRY * glGetColorTablePROC) (GLenum target, GLenum format, GLenum type, GLvoid *table );
typedef void (APIENTRY * glGetColorTableParameterfvPROC) (GLenum target, GLenum pname, GLfloat *params );
typedef void (APIENTRY * glGetColorTableParameterivPROC) (GLenum target, GLenum pname, GLint *params );
typedef void (APIENTRY * glColorSubTablePROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data );
typedef void (APIENTRY * glCopyColorSubTablePROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width );
typedef void (APIENTRY * glConvolutionFilter1DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image );
typedef void (APIENTRY * glConvolutionFilter2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image );
typedef void (APIENTRY * glConvolutionParameterfPROC) (GLenum target, GLenum pname, GLfloat params );
typedef void (APIENTRY * glConvolutionParameterfvPROC) (GLenum target, GLenum pname, const GLfloat *params );
typedef void (APIENTRY * glConvolutionParameteriPROC) (GLenum target, GLenum pname, GLint params );
typedef void (APIENTRY * glConvolutionParameterivPROC) (GLenum target, GLenum pname, const GLint *params );
typedef void (APIENTRY * glCopyConvolutionFilter1DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width );
typedef void (APIENTRY * glCopyConvolutionFilter2DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
typedef void (APIENTRY * glGetConvolutionFilterPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image );
typedef void (APIENTRY * glGetConvolutionParameterfvPROC) (GLenum target, GLenum pname, GLfloat *params );
typedef void (APIENTRY * glGetConvolutionParameterivPROC) (GLenum target, GLenum pname, GLint *params );
typedef void (APIENTRY * glSeparableFilter2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column );
typedef void (APIENTRY * glGetHistogramPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values );
typedef void (APIENTRY * glGetHistogramParameterfvPROC) (GLenum target, GLenum pname, GLfloat *params );
typedef void (APIENTRY * glGetHistogramParameterivPROC) (GLenum target, GLenum pname, GLint *params );
typedef void (APIENTRY * glGetMinmaxPROC) (GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values );
typedef void (APIENTRY * glGetMinmaxParameterfvPROC) (GLenum target, GLenum pname, GLfloat *params );
typedef void (APIENTRY * glGetMinmaxParameterivPROC) (GLenum target, GLenum pname, GLint *params );
typedef void (APIENTRY * glHistogramPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink );
typedef void (APIENTRY * glResetHistogramPROC) (GLenum target );
typedef void (APIENTRY * glMinmaxPROC) (GLenum target, GLenum internalformat, GLboolean sink );
typedef void (APIENTRY * glResetMinmaxPROC) (GLenum target );
typedef void (APIENTRY * glGetSeparableFilterPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span );

static glBlendColorPROC glBlendColor;
static glBlendEquationPROC glBlendEquation;
static glColorTablePROC glColorTable;
static glColorTableParameterfvPROC glColorTableParameterfv;
static glColorTableParameterivPROC glColorTableParameteriv;
static glCopyColorTablePROC glCopyColorTable;
static glGetColorTablePROC glGetColorTable;
static glGetColorTableParameterfvPROC glGetColorTableParameterfv;
static glGetColorTableParameterivPROC glGetColorTableParameteriv;
static glColorSubTablePROC glColorSubTable;
static glCopyColorSubTablePROC glCopyColorSubTable;
static glConvolutionFilter1DPROC glConvolutionFilter1D;
static glConvolutionFilter2DPROC glConvolutionFilter2D;
static glConvolutionParameterfPROC glConvolutionParameterf;
static glConvolutionParameterfvPROC glConvolutionParameterfv;
static glConvolutionParameteriPROC glConvolutionParameteri;
static glConvolutionParameterivPROC glConvolutionParameteriv;
static glCopyConvolutionFilter1DPROC glCopyConvolutionFilter1D;
static glCopyConvolutionFilter2DPROC glCopyConvolutionFilter2D;
static glGetConvolutionFilterPROC glGetConvolutionFilter;
static glGetConvolutionParameterfvPROC glGetConvolutionParameterfv;
static glGetConvolutionParameterivPROC glGetConvolutionParameteriv;
static glGetSeparableFilterPROC glGetSeparableFilter;
static glSeparableFilter2DPROC glSeparableFilter2D;
static glGetHistogramPROC glGetHistogram;
static glGetHistogramParameterfvPROC glGetHistogramParameterfv;
static glGetHistogramParameterivPROC glGetHistogramParameteriv;
static glGetMinmaxPROC glGetMinmax;
static glGetMinmaxParameterfvPROC glGetMinmaxParameterfv;
static glGetMinmaxParameterivPROC glGetMinmaxParameteriv;
static glHistogramPROC glHistogram;
static glMinmaxPROC glMinmax;
static glResetHistogramPROC glResetHistogram;
static glResetMinmaxPROC glResetMinmax;

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glColorTable
 * Signature: (IIIIII)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglColorTable
  (JNIEnv * env, jclass clazz, jint target, jint internalFormat, jint width, jint format, jint type, jobject buffer, jint offset)
{
	const void *address = (const void *)(offset + (const GLbyte *)(*env)->GetDirectBufferAddress(env, buffer));
	glColorTable(target, internalFormat, width, format, type, address);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glColorSubTable
 * Signature: (IIIIII)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglColorSubTable
  (JNIEnv * env, jclass clazz, jint target, jint start, jint count, jint format, jint type, jobject buffer, jint offset)
{
	const void *address = (const void *)(offset + (const GLbyte *)(*env)->GetDirectBufferAddress(env, buffer));
	glColorSubTable(target, start, count, format, type, address);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glGetColorTable
 * Signature: (IIII)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetColorTable
  (JNIEnv * env, jclass clazz, jint target, jint format, jint type, jobject buffer, jint offset)
{
	void *address = (void *)(offset + (GLbyte *)(*env)->GetDirectBufferAddress(env, buffer));
	glGetColorTable(target, format, type, address);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glGetColorTableParameteriv
 * Signature: (III)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetColorTableParameteriv
  (JNIEnv * env, jclass clazz, jint target, jint pname, jobject buffer, jint offset)
{
	GLint *address = offset + (GLint *)(*env)->GetDirectBufferAddress(env, buffer);
	glGetColorTableParameteriv(target, pname, address);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glGetColorTableParameterfv
 * Signature: (III)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetColorTableParameterfv
  (JNIEnv * env, jclass clazz, jint target, jint pname, jobject buffer, jint offset)
{
	GLfloat *address = offset + (GLfloat *)(*env)->GetDirectBufferAddress(env, buffer);
	glGetColorTableParameterfv(target, pname, address);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glColorTableParameteriv
 * Signature: (III)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglColorTableParameteriv
  (JNIEnv *env, jclass clazz, jint target, jint pname, jobject buffer, jint offset)
{
	const GLint *address = offset + (const GLint *)(*env)->GetDirectBufferAddress(env, buffer);
	glColorTableParameteriv(target, pname, address);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glColorTableParameterfv
 * Signature: (III)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglColorTableParameterfv
  (JNIEnv *env, jclass clazz, jint target, jint pname, jobject buffer, jint offset)
{
	const GLfloat *address = offset + (const GLfloat *)(*env)->GetDirectBufferAddress(env, buffer);
	glColorTableParameterfv(target, pname, address);
	
}


/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glCopyColorSubTable
 * Signature: (IIIII)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_glCopyColorSubTable
  (JNIEnv *env, jclass clazz, jint target, jint start, jint x, jint y, jint width)
{
	glCopyColorSubTable(target, start, x, y, width);
	
}


/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glCopyColorTable
 * Signature: (IIIII)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_glCopyColorTable
  (JNIEnv *env, jclass clazz, jint target, jint internalformat, jint x, jint y, jint width)
{
	glCopyColorTable(target, internalformat, x, y, width);
	
}


/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glBlendEquation
 * Signature: (I)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_glBlendEquation
  (JNIEnv *env, jclass clazz, jint mode)
{
	glBlendEquation(mode);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glBlendColor
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_glBlendColor(JNIEnv * env, jclass clazz, jfloat p0, jfloat p1, jfloat p2, jfloat p3)
{
	glBlendColor((GLfloat) p0, (GLfloat) p1, (GLfloat) p2, (GLfloat) p3);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glHistogram
 * Signature: (IIIZ)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_glHistogram
  (JNIEnv *env, jclass clazz, jint target, jint width, jint internalformat, jboolean sink)
{
	glHistogram(target, width, internalformat, sink);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glResetHistogram
 * Signature: (I)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_glResetHistogram
  (JNIEnv *env, jclass clazz, jint target)
{
	glResetHistogram(target);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glGetHistogram
 * Signature: (IZIII)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetHistogram
  (JNIEnv *env, jclass clazz, jint target, jboolean reset, jint format, jint type, jobject buffer, jint offset)
{
	void *address = (void *)(offset + (GLbyte *)(*env)->GetDirectBufferAddress(env, buffer));
	glGetHistogram(target, reset, format, type, address);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glGetHistogramParameterfv
 * Signature: (III)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetHistogramParameterfv
  (JNIEnv *env, jclass clazz, jint target, jint pname, jobject buffer, jint offset)
{
	GLfloat *address = offset + (GLfloat *)(*env)->GetDirectBufferAddress(env, buffer);
	glGetHistogramParameterfv(target, pname, address);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glGetHistogramParameteriv
 * Signature: (III)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetHistogramParameteriv
  (JNIEnv *env, jclass clazz, jint target, jint pname, jobject buffer, jint offset)
{
	GLint *address = offset + (GLint *)(*env)->GetDirectBufferAddress(env, buffer);
	glGetHistogramParameteriv(target, pname, address);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glMinmax
 * Signature: (IIZ)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_glMinmax
  (JNIEnv *env, jclass clazz, jint target, jint internalformat, jboolean sink)
{
	glMinmax(target, internalformat, sink);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glResetMinmax
 * Signature: (I)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_glResetMinmax
  (JNIEnv *env, jclass clazz, jint target)
{
	glResetMinmax(target);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glGetMinmax
 * Signature: (IZIII)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetMinmax
  (JNIEnv *env, jclass clazz, jint target, jboolean reset, jint format, jint type, jobject buffer, jint offset)
{
	void *address = (void *)(offset + (GLbyte *)(*env)->GetDirectBufferAddress(env, buffer));
	glGetMinmax(target, reset, format, type, address);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glGetMinmaxParameterfv
 * Signature: (III)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetMinmaxParameterfv
  (JNIEnv *env, jclass clazz, jint target, jint pname, jobject buffer, jint offset)
{
	GLfloat *address = offset + (GLfloat *)(*env)->GetDirectBufferAddress(env, buffer);
	glGetMinmaxParameterfv(target, pname, address);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glGetMinmaxParameteriv
 * Signature: (III)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglGetMinmaxParameteriv
  (JNIEnv *env, jclass clazz, jint target, jint pname, jobject buffer, jint offset)
{
	GLint *address = offset + (GLint *)(*env)->GetDirectBufferAddress(env, buffer);
	glGetMinmaxParameteriv(target, pname, address);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glConvolutionFilter1D
 * Signature: (IIIIII)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglConvolutionFilter1D
  (JNIEnv *env, jclass clazz, jint target, jint internalformat, jint width, jint format, jint type, jobject buffer, jint offset)
{
	const void *address = (const void *)(offset + (const GLbyte *)(*env)->GetDirectBufferAddress(env, buffer));
	glConvolutionFilter1D(target, internalformat, width, format, type, address);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glConvolutionFilter2D
 * Signature: (IIIIIII)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglConvolutionFilter2D
  (JNIEnv *env, jclass clazz, jint target, jint internalformat, jint width, jint height, jint format, jint type, jobject buffer, jint offset)
{
	const void *address = (const void *)(offset + (const GLbyte *)(*env)->GetDirectBufferAddress(env, buffer));
	glConvolutionFilter2D(target, internalformat, width, height, format, type, address);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glConvolutionParameterf
 * Signature: (IIF)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_glConvolutionParameterf
  (JNIEnv *env, jclass clazz, jint target, jint pname, jfloat params)
{
	glConvolutionParameterf(target, pname, params);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glConvolutionParameterfv
 * Signature: (III)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_nglConvolutionParameterfv
  (JNIEnv *env, jclass clazz, jint target, jint pname, jobject buffer, jint offset)
{
	const GLfloat *address = offset + (const GLfloat *)(*env)->GetDirectBufferAddress(env, buffer);
	glConvolutionParameterfv(target, pname, address);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glConvolutionParameteri
 * Signature: (III)V
 */
static void JNICALL Java_org_lwjgl_opengl_ARBImaging_glConvolutionParameteri
  (JNIEnv *env, jclass clazz, jint target, jint pname, jint params)
{
	glConvolutionParameteri(target, pname, params);
	
}

/*
 * Class:     org_lwjgl_opengl_ARBImaging
 * Method:    glConvolutionParameteriv
 * Signature: (II...
 
[truncated message content]