Menu
▾
▴
[Java-game-lib-cvs] LWJGL/src/native/common/nv org_lwjgl_opengl_NVEvaluators.cpp,1.1,1.2 org_lwjgl_opengl_NVFence.cpp,1.1,1.2 org_lwjgl_opengl_NVFragmentProgram.cpp,1.1,1.2 org_lwjgl_opengl_NVHalfFloat.cpp,1.2,1.3 org_lwjgl_opengl_NVOcclusionQuery.cpp,1.1,1.2 org_lwjgl_opengl_NVPixelDataRange.cpp,1.1,1.2 org_lwjgl_opengl_NVPointSprite.cpp,1.1,1.2 org_lwjgl_opengl_NVPrimitiveRestart.cpp,1.1,1.2 org_lwjgl_opengl_NVProgram.cpp,1.1,1.2 org_lwjgl_opengl_NVRegisterCombiners.cpp,1.1,1.2 org_lwjgl_opengl_NVRegisterCombiners2.cpp,1.1,1.2 org_lwjgl_opengl_NVVertexArrayRange.cpp,1.1,1.2 org_lwjgl_opengl_NVVertexProgram.cpp,1.1,1.2 org_lwjgl_opengl_NVEvaluators.h,1.1,NONE org_lwjgl_opengl_NVFence.h,1.1,NONE org_lwjgl_opengl_NVFragmentProgram.h,1.1,NONE org_lwjgl_opengl_NVHalfFloat.h,1.2,NONE org_lwjgl_opengl_NVOcclusionQuery.h,1.1,NONE org_lwjgl_opengl_NVPixelDataRange.h,1.1,NONE org_lwjgl_opengl_NVPointSprite.h,1.1,NONE org_lwjgl_opengl_NVPrimitiveRestart.h,1.1,NONE org_lwjgl_opengl_NVProgram.h,1.1,NONE org_lwjgl_opengl_NVRegisterCombiners.h,1.1,NONE org_lwjgl_opengl_NVRegisterCombiners2.h,1.1,NONE org_lwjgl_opengl_NVVertexArrayRange.h,1.1,NONE org_lwjgl_opengl_NVVertexProgram.h,1.1,NONE
Update of /cvsroot/java-game-lib/LWJGL/src/native/common/nv In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv31365/src/native/common/nv Modified 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 Removed Files: org_lwjgl_opengl_NVEvaluators.h org_lwjgl_opengl_NVFence.h org_lwjgl_opengl_NVFragmentProgram.h org_lwjgl_opengl_NVHalfFloat.h org_lwjgl_opengl_NVOcclusionQuery.h org_lwjgl_opengl_NVPixelDataRange.h org_lwjgl_opengl_NVPointSprite.h org_lwjgl_opengl_NVPrimitiveRestart.h org_lwjgl_opengl_NVProgram.h org_lwjgl_opengl_NVRegisterCombiners.h org_lwjgl_opengl_NVRegisterCombiners2.h org_lwjgl_opengl_NVVertexArrayRange.h org_lwjgl_opengl_NVVertexProgram.h Log Message: Replaced CHECK_EXISTS with one time check at symbol load time Index: org_lwjgl_opengl_NVEvaluators.cpp =================================================================== RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/nv/org_lwjgl_opengl_NVEvaluators.cpp,v retrieving revision 1.1 retrieving revision 1.2 diff -u -d -r1.1 -r1.2 --- org_lwjgl_opengl_NVEvaluators.cpp 8 Feb 2004 20:28:48 -0000 1.1 +++ org_lwjgl_opengl_NVEvaluators.cpp 7 Mar 2004 15:18:46 -0000 1.2 @@ -34,7 +34,6 @@ // IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.NVEvaluators // ---------------------------------- -#include "org_lwjgl_opengl_NVEvaluators.h" #include "extgl.h" #include "checkGLerror.h" @@ -58,30 +57,13 @@ static glGetMapAttribParameterfvNVPROC glGetMapAttribParameterfvNV; static glEvalMapsNVPROC glEvalMapsNV; -void extgl_InitNVEvaluators(JNIEnv *env, jobject ext_set) -{ - if (!extgl_Extensions.GL_NV_evaluators) - return; - glMapControlPointsNV = (glMapControlPointsNVPROC) extgl_GetProcAddress("glMapControlPointsNV"); - glMapParameterivNV = (glMapParameterivNVPROC) extgl_GetProcAddress("glMapParameterivNV"); - glMapParameterfvNV = (glMapParameterfvNVPROC) extgl_GetProcAddress("glMapParameterfvNV"); - glGetMapControlPointsNV = (glGetMapControlPointsNVPROC) extgl_GetProcAddress("glGetMapControlPointsNV"); - glGetMapParameterivNV = (glGetMapParameterivNVPROC) extgl_GetProcAddress("glGetMapParameterivNV"); - glGetMapParameterfvNV = (glGetMapParameterfvNVPROC) extgl_GetProcAddress("glGetMapParameterfvNV"); - glGetMapAttribParameterivNV = (glGetMapAttribParameterivNVPROC) extgl_GetProcAddress("glGetMapAttribParameterivNV"); - glGetMapAttribParameterfvNV = (glGetMapAttribParameterfvNVPROC) extgl_GetProcAddress("glGetMapAttribParameterfvNV"); - glEvalMapsNV = (glEvalMapsNVPROC) extgl_GetProcAddress("glEvalMapsNV"); - EXTGL_SANITY_CHECK(env, ext_set, GL_NV_evaluators) -} - /* * Class: org.lwjgl.opengl.NVEvaluators * Method: nglGetMapControlPointsNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapControlPointsNV +static JNIEXPORT 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) { - CHECK_EXISTS(glGetMapControlPointsNV) GLvoid *pPoints_ptr = (GLvoid *)((GLubyte *)env->GetDirectBufferAddress(pPoints) + pPoints_offset); glGetMapControlPointsNV(target, index, type, ustride, vstride, packed, pPoints_ptr); CHECK_GL_ERROR @@ -91,10 +73,9 @@ * Class: org.lwjgl.opengl.NVEvaluators * Method: nglMapControlPointsNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglMapControlPointsNV +static JNIEXPORT 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) { - CHECK_EXISTS(glMapControlPointsNV) GLvoid *pPoints_ptr = (GLvoid *)((GLubyte *)env->GetDirectBufferAddress(pPoints) + pPoints_offset); glMapControlPointsNV(target, index, type, ustride, vstride, uorder, vorder, packed, pPoints_ptr); CHECK_GL_ERROR @@ -104,10 +85,9 @@ * Class: org.lwjgl.opengl.NVEvaluators * Method: nglMapParameterfvNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglMapParameterfvNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglMapParameterfvNV (JNIEnv * env, jclass clazz, jint target, jint pname, jobject pfParams, jint pfParams_offset) { - CHECK_EXISTS(glMapParameterfvNV) GLfloat *pfParams_ptr = (GLfloat *)env->GetDirectBufferAddress(pfParams) + pfParams_offset; glMapParameterfvNV(target, pname, pfParams_ptr); CHECK_GL_ERROR @@ -117,10 +97,9 @@ * Class: org.lwjgl.opengl.NVEvaluators * Method: nglMapParameterivNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglMapParameterivNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglMapParameterivNV (JNIEnv * env, jclass clazz, jint target, jint pname, jobject piParams, jint piParams_offset) { - CHECK_EXISTS(glMapParameterivNV) GLint *piParams_ptr = (GLint *)env->GetDirectBufferAddress(piParams) + piParams_offset; glMapParameterivNV(target, pname, piParams_ptr); CHECK_GL_ERROR @@ -130,10 +109,9 @@ * Class: org.lwjgl.opengl.NVEvaluators * Method: nglGetMapParameterfvNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapParameterfvNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapParameterfvNV (JNIEnv * env, jclass clazz, jint target, jint pname, jobject pfParams, jint pfParams_offset) { - CHECK_EXISTS(glGetMapParameterfvNV) GLfloat *pfParams_ptr = (GLfloat *)env->GetDirectBufferAddress(pfParams) + pfParams_offset; glGetMapParameterfvNV(target, pname, pfParams_ptr); CHECK_GL_ERROR @@ -143,10 +121,9 @@ * Class: org.lwjgl.opengl.NVEvaluators * Method: nglGetMapParameterivNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapParameterivNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapParameterivNV (JNIEnv * env, jclass clazz, jint target, jint pname, jobject piParams, jint piParams_offset) { - CHECK_EXISTS(glGetMapParameterivNV) GLint *piParams_ptr = (GLint *)env->GetDirectBufferAddress(piParams) + piParams_offset; glGetMapParameterivNV(target, pname, piParams_ptr); CHECK_GL_ERROR @@ -156,10 +133,9 @@ * Class: org.lwjgl.opengl.NVEvaluators * Method: nglGetMapAttribParameterfvNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapAttribParameterfvNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapAttribParameterfvNV (JNIEnv * env, jclass clazz, jint target, jint index, jint pname, jobject pfParams, jint pfParams_offset) { - CHECK_EXISTS(glGetMapAttribParameterfvNV) GLfloat *pfParams_ptr = (GLfloat *)env->GetDirectBufferAddress(pfParams) + pfParams_offset; glGetMapAttribParameterfvNV(target, index, pname, pfParams_ptr); CHECK_GL_ERROR @@ -169,10 +145,9 @@ * Class: org.lwjgl.opengl.NVEvaluators * Method: nglGetMapAttribParameterivNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapAttribParameterivNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_nglGetMapAttribParameterivNV (JNIEnv * env, jclass clazz, jint target, jint index, jint pname, jobject piParams, jint piParams_offset) { - CHECK_EXISTS(glGetMapAttribParameterivNV) GLint *piParams_ptr = (GLint *)env->GetDirectBufferAddress(piParams) + piParams_offset; glGetMapAttribParameterivNV(target, index, pname, piParams_ptr); CHECK_GL_ERROR @@ -182,10 +157,28 @@ * Class: org.lwjgl.opengl.NVEvaluators * Method: glEvalMapsNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_glEvalMapsNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVEvaluators_glEvalMapsNV (JNIEnv * env, jclass clazz, jint target, jint mode) { - CHECK_EXISTS(glEvalMapsNV) glEvalMapsNV(target, mode); CHECK_GL_ERROR } + +void extgl_InitNVEvaluators(JNIEnv *env, jobject ext_set) +{ + JavaMethodAndGLFunction 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); + jclass clazz = extgl_ResetClass(env, "org/lwjgl/opengl/NVEvaluators"); + if (extgl_Extensions.GL_NV_evaluators) + extgl_InitializeClass(env, clazz, ext_set, "GL_NV_evaluators", num_functions, functions); +} Index: org_lwjgl_opengl_NVFence.cpp =================================================================== RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/nv/org_lwjgl_opengl_NVFence.cpp,v retrieving revision 1.1 retrieving revision 1.2 diff -u -d -r1.1 -r1.2 --- org_lwjgl_opengl_NVFence.cpp 8 Feb 2004 20:28:48 -0000 1.1 +++ org_lwjgl_opengl_NVFence.cpp 7 Mar 2004 15:18:46 -0000 1.2 @@ -34,7 +34,6 @@ // IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.NVFence // ---------------------------------- -#include "org_lwjgl_opengl_NVFence.h" #include "extgl.h" #include "checkGLerror.h" @@ -54,28 +53,13 @@ static glIsFenceNVPROC glIsFenceNV; static glGetFenceivNVPROC glGetFenceivNV; -void extgl_InitNVFence(JNIEnv *env, jobject ext_set) -{ - if (!extgl_Extensions.GL_NV_fence) - return; - glGenFencesNV = (glGenFencesNVPROC) extgl_GetProcAddress("glGenFencesNV"); - glDeleteFencesNV = (glDeleteFencesNVPROC) extgl_GetProcAddress("glDeleteFencesNV"); - glSetFenceNV = (glSetFenceNVPROC) extgl_GetProcAddress("glSetFenceNV"); - glTestFenceNV = (glTestFenceNVPROC) extgl_GetProcAddress("glTestFenceNV"); - glFinishFenceNV = (glFinishFenceNVPROC) extgl_GetProcAddress("glFinishFenceNV"); - glIsFenceNV = (glIsFenceNVPROC) extgl_GetProcAddress("glIsFenceNV"); - glGetFenceivNV = (glGetFenceivNVPROC) extgl_GetProcAddress("glGetFenceivNV"); - EXTGL_SANITY_CHECK(env, ext_set, GL_NV_fence) -} - /* * Class: org.lwjgl.opengl.NVFence * Method: nglGenFencesNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglGenFencesNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglGenFencesNV (JNIEnv * env, jclass clazz, jint n, jobject piFences, jint piFences_offset) { - CHECK_EXISTS(glGenFencesNV) GLuint *piFences_ptr = (GLuint *)env->GetDirectBufferAddress(piFences) + piFences_offset; glGenFencesNV(n, piFences_ptr); CHECK_GL_ERROR @@ -85,10 +69,9 @@ * Class: org.lwjgl.opengl.NVFence * Method: nglDeleteFencesNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglDeleteFencesNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglDeleteFencesNV (JNIEnv * env, jclass clazz, jint n, jobject piFences, jint piFences_offset) { - CHECK_EXISTS(glDeleteFencesNV) GLuint *piFences_ptr = (GLuint *)env->GetDirectBufferAddress(piFences) + piFences_offset; glDeleteFencesNV(n, piFences_ptr); CHECK_GL_ERROR @@ -98,10 +81,9 @@ * Class: org.lwjgl.opengl.NVFence * Method: glSetFenceNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_glSetFenceNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_glSetFenceNV (JNIEnv * env, jclass clazz, jint fence, jint condition) { - CHECK_EXISTS(glSetFenceNV) glSetFenceNV(fence, condition); CHECK_GL_ERROR } @@ -110,10 +92,9 @@ * Class: org.lwjgl.opengl.NVFence * Method: glTestFenceNV */ -JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVFence_glTestFenceNV +static JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVFence_glTestFenceNV (JNIEnv * env, jclass clazz, jint fence) { - CHECK_EXISTS(glTestFenceNV) GLboolean result = glTestFenceNV(fence); CHECK_GL_ERROR return result; @@ -123,10 +104,9 @@ * Class: org.lwjgl.opengl.NVFence * Method: glFinishFenceNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_glFinishFenceNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_glFinishFenceNV (JNIEnv * env, jclass clazz, jint fence) { - CHECK_EXISTS(glFinishFenceNV) glFinishFenceNV(fence); CHECK_GL_ERROR } @@ -135,10 +115,9 @@ * Class: org.lwjgl.opengl.NVFence * Method: glIsFenceNV */ -JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVFence_glIsFenceNV +static JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVFence_glIsFenceNV (JNIEnv * env, jclass clazz, jint fence) { - CHECK_EXISTS(glIsFenceNV) GLboolean result = glIsFenceNV(fence); CHECK_GL_ERROR return result; @@ -148,11 +127,27 @@ * Class: org.lwjgl.opengl.NVFence * Method: nglGetFenceivNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglGetFenceivNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFence_nglGetFenceivNV (JNIEnv * env, jclass clazz, jint fence, jint pname, jobject piParams, jint piParams_offset) { - CHECK_EXISTS(glGetFenceivNV) GLint *piParams_ptr = (GLint *)env->GetDirectBufferAddress(piParams) + piParams_offset; glGetFenceivNV(fence, pname, piParams_ptr); CHECK_GL_ERROR } + +void extgl_InitNVFence(JNIEnv *env, jobject ext_set) +{ + JavaMethodAndGLFunction functions[] = { + {"nglGenFencesNV", "(ILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVFence_nglGenFencesNV, "glGenFencesNV", (void**)&glGenFencesNV}, + {"nglDeleteFencesNV", "(ILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVFence_nglDeleteFencesNV, "glDeleteFencesNV", (void**)&glDeleteFencesNV}, + {"glSetFenceNV", "(II)V", (void*)&Java_org_lwjgl_opengl_NVFence_glSetFenceNV, "glSetFenceNV", (void**)&glSetFenceNV}, + {"glTestFenceNV", "(I)Z", (void*)&Java_org_lwjgl_opengl_NVFence_glTestFenceNV, "glTestFenceNV", (void**)&glTestFenceNV}, + {"glFinishFenceNV", "(I)V", (void*)&Java_org_lwjgl_opengl_NVFence_glFinishFenceNV, "glFinishFenceNV", (void**)&glFinishFenceNV}, + {"glIsFenceNV", "(I)Z", (void*)&Java_org_lwjgl_opengl_NVFence_glIsFenceNV, "glIsFenceNV", (void**)&glIsFenceNV}, + {"nglGetFenceivNV", "(IILjava/nio/IntBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVFence_nglGetFenceivNV, "glGetFenceivNV", (void**)&glGetFenceivNV} + }; + int num_functions = NUMFUNCTIONS(functions); + jclass clazz = extgl_ResetClass(env, "org/lwjgl/opengl/NVFence"); + if (extgl_Extensions.GL_NV_fence) + extgl_InitializeClass(env, clazz, ext_set, "GL_NV_fence", num_functions, functions); +} Index: org_lwjgl_opengl_NVFragmentProgram.cpp =================================================================== RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/nv/org_lwjgl_opengl_NVFragmentProgram.cpp,v retrieving revision 1.1 retrieving revision 1.2 diff -u -d -r1.1 -r1.2 --- org_lwjgl_opengl_NVFragmentProgram.cpp 8 Feb 2004 20:28:48 -0000 1.1 +++ org_lwjgl_opengl_NVFragmentProgram.cpp 7 Mar 2004 15:18:46 -0000 1.2 @@ -34,45 +34,26 @@ // IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.NVFragmentProgram // ---------------------------------- -#include "org_lwjgl_opengl_NVFragmentProgram.h" #include "extgl.h" #include "checkGLerror.h" typedef void (APIENTRY * glProgramNamedParameter4fNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w); -typedef void (APIENTRY * glProgramNamedParameter4fvNVPROC) (GLuint id, GLsizei len, const GLubyte *name, const GLfloat v[]); typedef void (APIENTRY * glProgramLocalParameter4fARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); -typedef void (APIENTRY * glProgramLocalParameter4fvARBPROC) (GLenum target, GLuint index, const GLfloat *params); typedef void (APIENTRY * glGetProgramNamedParameterfvNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat *params); typedef void (APIENTRY * glGetProgramLocalParameterfvARBPROC) (GLenum target, GLuint index, GLfloat *params); static glProgramNamedParameter4fNVPROC glProgramNamedParameter4fNV; -static glProgramNamedParameter4fvNVPROC glProgramNamedParameter4fvNV; static glProgramLocalParameter4fARBPROC glProgramLocalParameter4fARB; -static glProgramLocalParameter4fvARBPROC glProgramLocalParameter4fvARB; static glGetProgramNamedParameterfvNVPROC glGetProgramNamedParameterfvNV; static glGetProgramLocalParameterfvARBPROC glGetProgramLocalParameterfvARB; -void extgl_InitNVFragmentProgram(JNIEnv *env, jobject ext_set) -{ - if (!extgl_Extensions.GL_NV_fragment_program) - return; - glProgramNamedParameter4fNV = (glProgramNamedParameter4fNVPROC) extgl_GetProcAddress("glProgramNamedParameter4fNV"); - glProgramNamedParameter4fvNV = (glProgramNamedParameter4fvNVPROC) extgl_GetProcAddress("glProgramNamedParameter4fvNV"); - glGetProgramNamedParameterfvNV = (glGetProgramNamedParameterfvNVPROC) extgl_GetProcAddress("glGetProgramNamedParameterfvNV"); - glProgramLocalParameter4fARB = (glProgramLocalParameter4fARBPROC) extgl_GetProcAddress("glProgramLocalParameter4fARB"); - glProgramLocalParameter4fvARB = (glProgramLocalParameter4fvARBPROC) extgl_GetProcAddress("glProgramLocalParameter4fvARB"); - glGetProgramLocalParameterfvARB = (glGetProgramLocalParameterfvARBPROC) extgl_GetProcAddress("glGetProgramLocalParameterfvARB"); - EXTGL_SANITY_CHECK(env, ext_set, GL_NV_fragment_program) -} - /* * Class: org.lwjgl.opengl.NVFragmentProgram * Method: nglProgramNamedParameter4fNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFragmentProgram_nglProgramNamedParameter4fNV +static JNIEXPORT 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) { - CHECK_EXISTS(glProgramNamedParameter4fNV) GLubyte *name_ptr = (GLubyte *)env->GetDirectBufferAddress(name) + nameOffset; glProgramNamedParameter4fNV(id, length, name_ptr, x, y, z, w); CHECK_GL_ERROR @@ -82,10 +63,9 @@ * Class: org.lwjgl.opengl.NVFragmentProgram * Method: nglGetProgramNamedParameterfvNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFragmentProgram_nglGetProgramNamedParameterfvNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFragmentProgram_nglGetProgramNamedParameterfvNV (JNIEnv * env, jclass clazz, jint id, jint length, jobject name, jint nameOffset, jobject params, jint paramsOffset) { - CHECK_EXISTS(glGetProgramNamedParameterfvNV) GLubyte *name_ptr = (GLubyte *)env->GetDirectBufferAddress(name) + nameOffset; GLfloat *params_ptr = (GLfloat *)env->GetDirectBufferAddress(params) + paramsOffset; glGetProgramNamedParameterfvNV(id, length, name_ptr, params_ptr); @@ -96,10 +76,9 @@ * Class: org.lwjgl.opengl.NVFragmentProgram * Method: glProgramLocalParameter4fNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFragmentProgram_glProgramLocalParameter4fARB +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFragmentProgram_glProgramLocalParameter4fARB (JNIEnv * env, jclass clazz, jint target, jint index, jfloat x, jfloat y, jfloat z, jfloat w) { - CHECK_EXISTS(glProgramLocalParameter4fARB) glProgramLocalParameter4fARB(target, index, x, y, z, w); CHECK_GL_ERROR } @@ -108,11 +87,24 @@ * Class: org.lwjgl.opengl.NVFragmentProgram * Method: nglGetProgramLocalParameterfvNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFragmentProgram_nglGetProgramLocalParameterfvARB +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFragmentProgram_nglGetProgramLocalParameterfvARB (JNIEnv * env, jclass clazz, jint target, jint index, jobject params, jint params_offset) { - CHECK_EXISTS(glGetProgramLocalParameterfvARB) GLfloat *params_ptr = (GLfloat *)env->GetDirectBufferAddress(params) + params_offset; glGetProgramLocalParameterfvARB(target, index, params_ptr); CHECK_GL_ERROR } + +void extgl_InitNVFragmentProgram(JNIEnv *env, jobject ext_set) +{ + JavaMethodAndGLFunction 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}, + {"glProgramLocalParameter4fARB", "(IIFFFF)V", (void*)&Java_org_lwjgl_opengl_NVFragmentProgram_glProgramLocalParameter4fARB, "glProgramLocalParameter4fARB", (void**)&glProgramLocalParameter4fARB}, + {"nglGetProgramLocalParameterfvARB", "(IILjava/nio/FloatBuffer;I)V", (void*)&Java_org_lwjgl_opengl_NVFragmentProgram_nglGetProgramLocalParameterfvARB, "glGetProgramLocalParameterfvARB", (void**)&glGetProgramLocalParameterfvARB} + }; + int num_functions = NUMFUNCTIONS(functions); + jclass clazz = extgl_ResetClass(env, "org/lwjgl/opengl/NVFragmentProgram"); + if (extgl_Extensions.GL_NV_fragment_program) + extgl_InitializeClass(env, clazz, ext_set, "GL_NV_fragment_program", num_functions, functions); +} Index: org_lwjgl_opengl_NVHalfFloat.cpp =================================================================== RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/nv/org_lwjgl_opengl_NVHalfFloat.cpp,v retrieving revision 1.2 retrieving revision 1.3 diff -u -d -r1.2 -r1.3 --- org_lwjgl_opengl_NVHalfFloat.cpp 29 Feb 2004 23:27:13 -0000 1.2 +++ org_lwjgl_opengl_NVHalfFloat.cpp 7 Mar 2004 15:18:46 -0000 1.3 @@ -34,163 +34,68 @@ // IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.NVHalfFloat // ---------------------------------- -#include "org_lwjgl_opengl_NVHalfFloat.h" #include "extgl.h" #include "checkGLerror.h" typedef unsigned short GLhalf; typedef void (APIENTRY * glVertex2hNVPROC) (GLhalf x, GLhalf y); -typedef void (APIENTRY * glVertex2hvNVPROC) (const GLhalf *v); typedef void (APIENTRY * glVertex3hNVPROC) (GLhalf x, GLhalf y, GLhalf z); -typedef void (APIENTRY * glVertex3hvNVPROC) (const GLhalf *v); typedef void (APIENTRY * glVertex4hNVPROC) (GLhalf x, GLhalf y, GLhalf z, GLhalf w); -typedef void (APIENTRY * glVertex4hvNVPROC) (const GLhalf *v); typedef void (APIENTRY * glNormal3hNVPROC) (GLhalf nx, GLhalf ny, GLhalf nz); -typedef void (APIENTRY * glNormal3hvNVPROC) (const GLhalf *v); typedef void (APIENTRY * glColor3hNVPROC) (GLhalf red, GLhalf green, GLhalf blue); -typedef void (APIENTRY * glColor3hvNVPROC) (const GLhalf *v); typedef void (APIENTRY * glColor4hNVPROC) (GLhalf red, GLhalf green, GLhalf blue, GLhalf alpha); -typedef void (APIENTRY * glColor4hvNVPROC) (const GLhalf *v); typedef void (APIENTRY * glTexCoord1hNVPROC) (GLhalf s); -typedef void (APIENTRY * glTexCoord1hvNVPROC) (const GLhalf *v); typedef void (APIENTRY * glTexCoord2hNVPROC) (GLhalf s, GLhalf t); -typedef void (APIENTRY * glTexCoord2hvNVPROC) (const GLhalf *v); typedef void (APIENTRY * glTexCoord3hNVPROC) (GLhalf s, GLhalf t, GLhalf r); -typedef void (APIENTRY * glTexCoord3hvNVPROC) (const GLhalf *v); typedef void (APIENTRY * glTexCoord4hNVPROC) (GLhalf s, GLhalf t, GLhalf r, GLhalf q); -typedef void (APIENTRY * glTexCoord4hvNVPROC) (const GLhalf *v); typedef void (APIENTRY * glMultiTexCoord1hNVPROC) (GLenum target, GLhalf s); -typedef void (APIENTRY * glMultiTexCoord1hvNVPROC) (GLenum target, const GLhalf *v); typedef void (APIENTRY * glMultiTexCoord2hNVPROC) (GLenum target, GLhalf s, GLhalf t); -typedef void (APIENTRY * glMultiTexCoord2hvNVPROC) (GLenum target, const GLhalf *v); typedef void (APIENTRY * glMultiTexCoord3hNVPROC) (GLenum target, GLhalf s, GLhalf t, GLhalf r); -typedef void (APIENTRY * glMultiTexCoord3hvNVPROC) (GLenum target, const GLhalf *v); typedef void (APIENTRY * glMultiTexCoord4hNVPROC) (GLenum target, GLhalf s, GLhalf t, GLhalf r, GLhalf q); -typedef void (APIENTRY * glMultiTexCoord4hvNVPROC) (GLenum target, const GLhalf *v); typedef void (APIENTRY * glFogCoordhNVPROC) (GLhalf fog); -typedef void (APIENTRY * glFogCoordhvNVPROC) (const GLhalf *fog); typedef void (APIENTRY * glSecondaryColor3hNVPROC) (GLhalf red, GLhalf green, GLhalf blue); -typedef void (APIENTRY * glSecondaryColor3hvNVPROC) (const GLhalf *v); typedef void (APIENTRY * glVertexAttrib1hNVPROC) (GLuint index, GLhalf x); -typedef void (APIENTRY * glVertexAttrib1hvNVPROC) (GLuint index, const GLhalf *v); typedef void (APIENTRY * glVertexAttrib2hNVPROC) (GLuint index, GLhalf x, GLhalf y); -typedef void (APIENTRY * glVertexAttrib2hvNVPROC) (GLuint index, const GLhalf *v); typedef void (APIENTRY * glVertexAttrib3hNVPROC) (GLuint index, GLhalf x, GLhalf y, GLhalf z); -typedef void (APIENTRY * glVertexAttrib3hvNVPROC) (GLuint index, const GLhalf *v); typedef void (APIENTRY * glVertexAttrib4hNVPROC) (GLuint index, GLhalf x, GLhalf y, GLhalf z, GLhalf w); -typedef void (APIENTRY * glVertexAttrib4hvNVPROC) (GLuint index, const GLhalf *v); 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 glVertex2hvNVPROC glVertex2hvNV; static glVertex3hNVPROC glVertex3hNV; -static glVertex3hvNVPROC glVertex3hvNV; static glVertex4hNVPROC glVertex4hNV; -static glVertex4hvNVPROC glVertex4hvNV; static glNormal3hNVPROC glNormal3hNV; -static glNormal3hvNVPROC glNormal3hvNV; static glColor3hNVPROC glColor3hNV; -static glColor3hvNVPROC glColor3hvNV; static glColor4hNVPROC glColor4hNV; -static glColor4hvNVPROC glColor4hvNV; static glTexCoord1hNVPROC glTexCoord1hNV; -static glTexCoord1hvNVPROC glTexCoord1hvNV; static glTexCoord2hNVPROC glTexCoord2hNV; -static glTexCoord2hvNVPROC glTexCoord2hvNV; static glTexCoord3hNVPROC glTexCoord3hNV; -static glTexCoord3hvNVPROC glTexCoord3hvNV; static glTexCoord4hNVPROC glTexCoord4hNV; -static glTexCoord4hvNVPROC glTexCoord4hvNV; static glMultiTexCoord1hNVPROC glMultiTexCoord1hNV; -static glMultiTexCoord1hvNVPROC glMultiTexCoord1hvNV; static glMultiTexCoord2hNVPROC glMultiTexCoord2hNV; -static glMultiTexCoord2hvNVPROC glMultiTexCoord2hvNV; static glMultiTexCoord3hNVPROC glMultiTexCoord3hNV; -static glMultiTexCoord3hvNVPROC glMultiTexCoord3hvNV; static glMultiTexCoord4hNVPROC glMultiTexCoord4hNV; -static glMultiTexCoord4hvNVPROC glMultiTexCoord4hvNV; static glFogCoordhNVPROC glFogCoordhNV; -static glFogCoordhvNVPROC glFogCoordhvNV; static glSecondaryColor3hNVPROC glSecondaryColor3hNV; -static glSecondaryColor3hvNVPROC glSecondaryColor3hvNV; static glVertexAttrib1hNVPROC glVertexAttrib1hNV; -static glVertexAttrib1hvNVPROC glVertexAttrib1hvNV; static glVertexAttrib2hNVPROC glVertexAttrib2hNV; -static glVertexAttrib2hvNVPROC glVertexAttrib2hvNV; static glVertexAttrib3hNVPROC glVertexAttrib3hNV; -static glVertexAttrib3hvNVPROC glVertexAttrib3hvNV; static glVertexAttrib4hNVPROC glVertexAttrib4hNV; -static glVertexAttrib4hvNVPROC glVertexAttrib4hvNV; static glVertexAttribs1hvNVPROC glVertexAttribs1hvNV; static glVertexAttribs2hvNVPROC glVertexAttribs2hvNV; static glVertexAttribs3hvNVPROC glVertexAttribs3hvNV; static glVertexAttribs4hvNVPROC glVertexAttribs4hvNV; -void extgl_InitNVHalfFloat(JNIEnv *env, jobject ext_set) -{ - if (!extgl_Extensions.GL_NV_half_float) - return; - - glVertex2hNV = (glVertex2hNVPROC) extgl_GetProcAddress("glVertex2hNV"); - glVertex2hvNV = (glVertex2hvNVPROC) extgl_GetProcAddress("glVertex2hvNV"); - glVertex3hNV = (glVertex3hNVPROC) extgl_GetProcAddress("glVertex3hNV"); - glVertex3hvNV = (glVertex3hvNVPROC) extgl_GetProcAddress("glVertex3hvNV"); - glVertex4hNV = (glVertex4hNVPROC) extgl_GetProcAddress("glVertex4hNV"); - glVertex4hvNV = (glVertex4hvNVPROC) extgl_GetProcAddress("glVertex4hvNV"); - glNormal3hNV = (glNormal3hNVPROC) extgl_GetProcAddress("glNormal3hNV"); - glNormal3hvNV = (glNormal3hvNVPROC) extgl_GetProcAddress("glNormal3hvNV"); - glColor3hNV = (glColor3hNVPROC) extgl_GetProcAddress("glColor3hNV"); - glColor3hvNV = (glColor3hvNVPROC) extgl_GetProcAddress("glColor3hvNV"); - glColor4hNV = (glColor4hNVPROC) extgl_GetProcAddress("glColor4hNV"); - glColor4hvNV = (glColor4hvNVPROC) extgl_GetProcAddress("glColor4hvNV"); - glTexCoord1hNV = (glTexCoord1hNVPROC) extgl_GetProcAddress("glTexCoord1hNV"); - glTexCoord1hvNV = (glTexCoord1hvNVPROC) extgl_GetProcAddress("glTexCoord1hvNV"); - glTexCoord2hNV = (glTexCoord2hNVPROC) extgl_GetProcAddress("glTexCoord2hNV"); - glTexCoord2hvNV = (glTexCoord2hvNVPROC) extgl_GetProcAddress("glTexCoord2hvNV"); - glTexCoord3hNV = (glTexCoord3hNVPROC) extgl_GetProcAddress("glTexCoord3hNV"); - glTexCoord3hvNV = (glTexCoord3hvNVPROC) extgl_GetProcAddress("glTexCoord3hvNV"); - glTexCoord4hNV = (glTexCoord4hNVPROC) extgl_GetProcAddress("glTexCoord4hNV"); - glTexCoord4hvNV = (glTexCoord4hvNVPROC) extgl_GetProcAddress("glTexCoord4hvNV"); - glMultiTexCoord1hNV = (glMultiTexCoord1hNVPROC) extgl_GetProcAddress("glMultiTexCoord1hNV"); - glMultiTexCoord1hvNV = (glMultiTexCoord1hvNVPROC) extgl_GetProcAddress("glMultiTexCoord1hvNV"); - glMultiTexCoord2hNV = (glMultiTexCoord2hNVPROC) extgl_GetProcAddress("glMultiTexCoord2hNV"); - glMultiTexCoord2hvNV = (glMultiTexCoord2hvNVPROC) extgl_GetProcAddress("glMultiTexCoord2hvNV"); - glMultiTexCoord3hNV = (glMultiTexCoord3hNVPROC) extgl_GetProcAddress("glMultiTexCoord3hNV"); - glMultiTexCoord3hvNV = (glMultiTexCoord3hvNVPROC) extgl_GetProcAddress("glMultiTexCoord3hvNV"); - glMultiTexCoord4hNV = (glMultiTexCoord4hNVPROC) extgl_GetProcAddress("glMultiTexCoord4hNV"); - glMultiTexCoord4hvNV = (glMultiTexCoord4hvNVPROC) extgl_GetProcAddress("glMultiTexCoord4hvNV"); - glFogCoordhNV = (glFogCoordhNVPROC) extgl_GetProcAddress("glFogCoordhNV"); - glFogCoordhvNV = (glFogCoordhvNVPROC) extgl_GetProcAddress("glFogCoordhvNV"); - glSecondaryColor3hNV = (glSecondaryColor3hNVPROC) extgl_GetProcAddress("glSecondaryColor3hNV"); - glSecondaryColor3hvNV = (glSecondaryColor3hvNVPROC) extgl_GetProcAddress("glSecondaryColor3hvNV"); - glVertexAttrib1hNV = (glVertexAttrib1hNVPROC) extgl_GetProcAddress("glVertexAttrib1hNV"); - glVertexAttrib1hvNV = (glVertexAttrib1hvNVPROC) extgl_GetProcAddress("glVertexAttrib1hvNV"); - glVertexAttrib2hNV = (glVertexAttrib2hNVPROC) extgl_GetProcAddress("glVertexAttrib2hNV"); - glVertexAttrib2hvNV = (glVertexAttrib2hvNVPROC) extgl_GetProcAddress("glVertexAttrib2hvNV"); - glVertexAttrib3hNV = (glVertexAttrib3hNVPROC) extgl_GetProcAddress("glVertexAttrib3hNV"); - glVertexAttrib3hvNV = (glVertexAttrib3hvNVPROC) extgl_GetProcAddress("glVertexAttrib3hvNV"); - glVertexAttrib4hNV = (glVertexAttrib4hNVPROC) extgl_GetProcAddress("glVertexAttrib4hNV"); - glVertexAttrib4hvNV = (glVertexAttrib4hvNVPROC) extgl_GetProcAddress("glVertexAttrib4hvNV"); - glVertexAttribs1hvNV = (glVertexAttribs1hvNVPROC) extgl_GetProcAddress("glVertexAttribs1hvNV"); - glVertexAttribs2hvNV = (glVertexAttribs2hvNVPROC) extgl_GetProcAddress("glVertexAttribs2hvNV"); - glVertexAttribs3hvNV = (glVertexAttribs3hvNVPROC) extgl_GetProcAddress("glVertexAttribs3hvNV"); - glVertexAttribs4hvNV = (glVertexAttribs4hvNVPROC) extgl_GetProcAddress("glVertexAttribs4hvNV"); - - EXTGL_SANITY_CHECK(env, ext_set, GL_NV_half_float) -} - /* * Class: org.lwjgl.opengl.NVHalfFloat * Method: glVertex2hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertex2hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertex2hNV (JNIEnv * env, jclass clazz, jshort x, jshort y) { - CHECK_EXISTS(glVertex2hNV) glVertex2hNV(x, y); CHECK_GL_ERROR } @@ -199,10 +104,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glVertex3hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertex3hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertex3hNV (JNIEnv * env, jclass clazz, jshort x, jshort y, jshort z) { - CHECK_EXISTS(glVertex3hNV) glVertex3hNV(x, y, z); CHECK_GL_ERROR } @@ -211,10 +115,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glVertex4hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertex4hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertex4hNV (JNIEnv * env, jclass clazz, jshort x, jshort y, jshort z, jshort w) { - CHECK_EXISTS(glVertex4hNV) glVertex4hNV(x, y, z, w); CHECK_GL_ERROR } @@ -223,10 +126,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glNormal3hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glNormal3hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glNormal3hNV (JNIEnv * env, jclass clazz, jshort nx, jshort ny, jshort nz) { - CHECK_EXISTS(glNormal3hNV) glNormal3hNV(nx, ny, nz); CHECK_GL_ERROR } @@ -235,10 +137,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glColor3hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glColor3hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glColor3hNV (JNIEnv * env, jclass clazz, jshort red, jshort green, jshort blue) { - CHECK_EXISTS(glColor3hNV) glColor3hNV(red, green, blue); CHECK_GL_ERROR } @@ -247,10 +148,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glColor4hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glColor4hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glColor4hNV (JNIEnv * env, jclass clazz, jshort red, jshort green, jshort blue, jshort alpha) { - CHECK_EXISTS(glColor4hNV) glColor4hNV(red, green, blue, alpha); CHECK_GL_ERROR } @@ -259,10 +159,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glTexCoord1hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glTexCoord1hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glTexCoord1hNV (JNIEnv * env, jclass clazz, jshort s) { - CHECK_EXISTS(glTexCoord1hNV) glTexCoord1hNV(s); CHECK_GL_ERROR } @@ -271,10 +170,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glTexCoord2hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glTexCoord2hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glTexCoord2hNV (JNIEnv * env, jclass clazz, jshort s, jshort t) { - CHECK_EXISTS(glTexCoord2hNV) glTexCoord2hNV(s, t); CHECK_GL_ERROR } @@ -283,10 +181,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glTexCoord3hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glTexCoord3hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glTexCoord3hNV (JNIEnv * env, jclass clazz, jshort s, jshort t, jshort r) { - CHECK_EXISTS(glTexCoord3hNV) glTexCoord3hNV(s, t, r); CHECK_GL_ERROR } @@ -295,10 +192,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glTexCoord4hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glTexCoord4hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glTexCoord4hNV (JNIEnv * env, jclass clazz, jshort s, jshort t, jshort r, jshort q) { - CHECK_EXISTS(glTexCoord4hNV) glTexCoord4hNV(s, t, r, q); CHECK_GL_ERROR } @@ -307,10 +203,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glMultiTexCoord1hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glMultiTexCoord1hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glMultiTexCoord1hNV (JNIEnv * env, jclass clazz, jint target, jshort s) { - CHECK_EXISTS(glMultiTexCoord1hNV) glMultiTexCoord1hNV(target, s); CHECK_GL_ERROR } @@ -319,10 +214,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glMultiTexCoord2hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glMultiTexCoord2hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glMultiTexCoord2hNV (JNIEnv * env, jclass clazz, jint target, jshort s, jshort t) { - CHECK_EXISTS(glMultiTexCoord2hNV) glMultiTexCoord2hNV(target, s, t); CHECK_GL_ERROR } @@ -331,10 +225,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glMultiTexCoord3hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glMultiTexCoord3hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glMultiTexCoord3hNV (JNIEnv * env, jclass clazz, jint target, jshort s, jshort t, jshort r) { - CHECK_EXISTS(glMultiTexCoord3hNV) glMultiTexCoord3hNV(target, s, t, r); CHECK_GL_ERROR } @@ -343,10 +236,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glMultiTexCoord4hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glMultiTexCoord4hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glMultiTexCoord4hNV (JNIEnv * env, jclass clazz, jint target, jshort s, jshort t, jshort r, jshort q) { - CHECK_EXISTS(glMultiTexCoord4hNV) glMultiTexCoord4hNV(target, s, t, r, q); CHECK_GL_ERROR } @@ -355,10 +247,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glFogCoordhNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glFogCoordhNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glFogCoordhNV (JNIEnv * env, jclass clazz, jshort fog) { - CHECK_EXISTS(glFogCoordhNV) glFogCoordhNV(fog); CHECK_GL_ERROR } @@ -367,10 +258,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glSecondaryColor3hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glSecondaryColor3hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glSecondaryColor3hNV (JNIEnv * env, jclass clazz, jshort red, jshort green, jshort blue) { - CHECK_EXISTS(glSecondaryColor3hNV) glSecondaryColor3hNV(red, green, blue); CHECK_GL_ERROR } @@ -379,10 +269,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glVertexAttrib1hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertexAttrib1hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertexAttrib1hNV (JNIEnv * env, jclass clazz, jint index, jshort x) { - CHECK_EXISTS(glVertexAttrib1hNV) glVertexAttrib1hNV(index, x); CHECK_GL_ERROR } @@ -391,10 +280,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glVertexAttrib2hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertexAttrib2hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertexAttrib2hNV (JNIEnv * env, jclass clazz, jint index, jshort x, jshort y) { - CHECK_EXISTS(glVertexAttrib2hNV) glVertexAttrib2hNV(index, x, y); CHECK_GL_ERROR } @@ -403,10 +291,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glVertexAttrib3hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertexAttrib3hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertexAttrib3hNV (JNIEnv * env, jclass clazz, jint index, jshort x, jshort y, jshort z) { - CHECK_EXISTS(glVertexAttrib3hNV) glVertexAttrib3hNV(index, x, y, z); CHECK_GL_ERROR } @@ -415,10 +302,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: glVertexAttrib4hNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertexAttrib4hNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_glVertexAttrib4hNV (JNIEnv * env, jclass clazz, jint index, jshort x, jshort y, jshort z, jshort w) { - CHECK_EXISTS(glVertexAttrib4hNV) glVertexAttrib4hNV(index, x, y, z, w); CHECK_GL_ERROR } @@ -427,10 +313,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: nglVertexAttribs1hvNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs1hvNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs1hvNV (JNIEnv * env, jclass clazz, jint index, jint n, jobject attribs, jint attribsOffset) { - CHECK_EXISTS(glVertexAttribs1hvNV) GLushort *attribs_ptr = (GLushort *)env->GetDirectBufferAddress(attribs) + attribsOffset; glVertexAttribs1hvNV(index, n, attribs_ptr); CHECK_GL_ERROR @@ -440,10 +325,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: nglVertexAttribs2hvNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs2hvNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs2hvNV (JNIEnv * env, jclass clazz, jint index, jint n, jobject attribs, jint attribsOffset) { - CHECK_EXISTS(glVertexAttribs2hvNV) GLushort *attribs_ptr = (GLushort *)env->GetDirectBufferAddress(attribs) + attribsOffset; glVertexAttribs2hvNV(index, n, attribs_ptr); CHECK_GL_ERROR @@ -453,10 +337,9 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: nglVertexAttribs3hvNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs3hvNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs3hvNV (JNIEnv * env, jclass clazz, jint index, jint n, jobject attribs, jint attribsOffset) { - CHECK_EXISTS(glVertexAttribs3hvNV) GLushort *attribs_ptr = (GLushort *)env->GetDirectBufferAddress(attribs) + attribsOffset; glVertexAttribs3hvNV(index, n, attribs_ptr); CHECK_GL_ERROR @@ -466,11 +349,44 @@ * Class: org.lwjgl.opengl.NVHalfFloat * Method: nglVertexAttribs4hvNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs4hvNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVHalfFloat_nglVertexAttribs4hvNV (JNIEnv * env, jclass clazz, jint index, jint n, jobject attribs, jint attribsOffset) { - CHECK_EXISTS(glVertexAttribs4hvNV) GLushort *attribs_ptr = (GLushort *)env->GetDirectBufferAddress(attribs) + attribsOffset; glVertexAttribs4hvNV(index, n, attribs_ptr); CHECK_GL_ERROR } + +void extgl_InitNVHalfFloat(JNIEnv *env, jobject ext_set) +{ + JavaMethodAndGLFunction 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); + jclass clazz = extgl_ResetClass(env, "org/lwjgl/opengl/NVHalfFloat"); + if (extgl_Extensions.GL_NV_half_float) + extgl_InitializeClass(env, clazz, ext_set, "GL_NV_half_float", num_functions, functions); +} Index: org_lwjgl_opengl_NVOcclusionQuery.cpp =================================================================== RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/nv/org_lwjgl_opengl_NVOcclusionQuery.cpp,v retrieving revision 1.1 retrieving revision 1.2 diff -u -d -r1.1 -r1.2 --- org_lwjgl_opengl_NVOcclusionQuery.cpp 8 Feb 2004 20:28:48 -0000 1.1 +++ org_lwjgl_opengl_NVOcclusionQuery.cpp 7 Mar 2004 15:18:46 -0000 1.2 @@ -34,7 +34,6 @@ // IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.NVOcclusionQuery // ---------------------------------- -#include "org_lwjgl_opengl_NVOcclusionQuery.h" #include "extgl.h" #include "checkGLerror.h" @@ -54,28 +53,13 @@ static glGetOcclusionQueryivNVPROC glGetOcclusionQueryivNV; static glGetOcclusionQueryuivNVPROC glGetOcclusionQueryuivNV; -void extgl_InitNVOcclusionQuery(JNIEnv *env, jobject ext_set) -{ - if (!extgl_Extensions.GL_NV_occlusion_query) - return; - glGenOcclusionQueriesNV = (glGenOcclusionQueriesNVPROC) extgl_GetProcAddress("glGenOcclusionQueriesNV"); - glDeleteOcclusionQueriesNV = (glDeleteOcclusionQueriesNVPROC) extgl_GetProcAddress("glDeleteOcclusionQueriesNV"); - glIsOcclusionQueryNV = (glIsOcclusionQueryNVPROC) extgl_GetProcAddress("glIsOcclusionQueryNV"); - glBeginOcclusionQueryNV = (glBeginOcclusionQueryNVPROC) extgl_GetProcAddress("glBeginOcclusionQueryNV"); - glEndOcclusionQueryNV = (glEndOcclusionQueryNVPROC) extgl_GetProcAddress("glEndOcclusionQueryNV"); - glGetOcclusionQueryivNV = (glGetOcclusionQueryivNVPROC) extgl_GetProcAddress("glGetOcclusionQueryivNV"); - glGetOcclusionQueryuivNV = (glGetOcclusionQueryuivNVPROC) extgl_GetProcAddress("glGetOcclusionQueryuivNV"); - EXTGL_SANITY_CHECK(env, ext_set, GL_NV_occlusion_query) -} - /* * Class: org.lwjgl.opengl.NVOcclusionQuery * Method: nglGenOcclusionQueriesNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglGenOcclusionQueriesNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglGenOcclusionQueriesNV (JNIEnv * env, jclass clazz, jint n, jobject piIDs, jint piIDs_offset) { - CHECK_EXISTS(glGenOcclusionQueriesNV) GLuint *piIDs_ptr = (GLuint *)env->GetDirectBufferAddress(piIDs) + piIDs_offset; glGenOcclusionQueriesNV(n, piIDs_ptr); CHECK_GL_ERROR @@ -85,10 +69,9 @@ * Class: org.lwjgl.opengl.NVOcclusionQuery * Method: nglDeleteOcclusionQueriesNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglDeleteOcclusionQueriesNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglDeleteOcclusionQueriesNV (JNIEnv * env, jclass clazz, jint n, jobject piIDs, jint piIDs_offset) { - CHECK_EXISTS(glDeleteOcclusionQueriesNV) GLuint *piIDs_ptr = (GLuint *)env->GetDirectBufferAddress(piIDs) + piIDs_offset; glDeleteOcclusionQueriesNV(n, piIDs_ptr); CHECK_GL_ERROR @@ -98,10 +81,9 @@ * Class: org.lwjgl.opengl.NVOcclusionQuery * Method: glIsOcclusionQueryNV */ -JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_glIsOcclusionQueryNV +static JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_glIsOcclusionQueryNV (JNIEnv * env, jclass clazz, jint id) { - CHECK_EXISTS(glIsOcclusionQueryNV) GLboolean result = glIsOcclusionQueryNV(id); CHECK_GL_ERROR return result; @@ -111,10 +93,9 @@ * Class: org.lwjgl.opengl.NVOcclusionQuery * Method: glBeginOcclusionQueryNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_glBeginOcclusionQueryNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_glBeginOcclusionQueryNV (JNIEnv * env, jclass clazz, jint id) { - CHECK_EXISTS(glBeginOcclusionQueryNV) glBeginOcclusionQueryNV(id); CHECK_GL_ERROR } @@ -123,10 +104,9 @@ * Class: org.lwjgl.opengl.NVOcclusionQuery * Method: glEndOcclusionQueryNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_glEndOcclusionQueryNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_glEndOcclusionQueryNV (JNIEnv * env, jclass clazz) { - CHECK_EXISTS(glEndOcclusionQueryNV) glEndOcclusionQueryNV(); CHECK_GL_ERROR } @@ -135,10 +115,9 @@ * Class: org.lwjgl.opengl.NVOcclusionQuery * Method: nglGetOcclusionQueryivNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglGetOcclusionQueryivNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglGetOcclusionQueryivNV (JNIEnv * env, jclass clazz, jint id, jint pname, jobject piParams, jint piParams_offset) { - CHECK_EXISTS(glGetOcclusionQueryivNV) GLint *piParams_ptr = (GLint *)env->GetDirectBufferAddress(piParams) + piParams_offset; glGetOcclusionQueryivNV(id, pname, piParams_ptr); CHECK_GL_ERROR @@ -148,11 +127,27 @@ * Class: org.lwjgl.opengl.NVOcclusionQuery * Method: nglGetOcclusionQueryuivNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglGetOcclusionQueryuivNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVOcclusionQuery_nglGetOcclusionQueryuivNV (JNIEnv * env, jclass clazz, jint id, jint pname, jobject piParams, jint piParams_offset) { - CHECK_EXISTS(glGetOcclusionQueryuivNV) GLuint *piParams_ptr = (GLuint *)env->GetDirectBufferAddress(piParams) + piParams_offset; glGetOcclusionQueryuivNV(id, pname, piParams_ptr); CHECK_GL_ERROR } + +void extgl_InitNVOcclusionQuery(JNIEnv *env, jobject ext_set) +{ + JavaMethodAndGLFunction 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); + jclass clazz = extgl_ResetClass(env, "org/lwjgl/opengl/NVOcclusionQuery"); + if (extgl_Extensions.GL_NV_occlusion_query) + extgl_InitializeClass(env, clazz, ext_set, "GL_NV_occlusion_query", num_functions, functions); +} Index: org_lwjgl_opengl_NVPixelDataRange.cpp =================================================================== RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/nv/org_lwjgl_opengl_NVPixelDataRange.cpp,v retrieving revision 1.1 retrieving revision 1.2 diff -u -d -r1.1 -r1.2 --- org_lwjgl_opengl_NVPixelDataRange.cpp 8 Feb 2004 20:28:49 -0000 1.1 +++ org_lwjgl_opengl_NVPixelDataRange.cpp 7 Mar 2004 15:18:46 -0000 1.2 @@ -34,7 +34,6 @@ // IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.NVPixelDataRange // ---------------------------------- -#include "org_lwjgl_opengl_NVPixelDataRange.h" #include "extgl.h" #include "checkGLerror.h" @@ -44,25 +43,13 @@ static glPixelDataRangeNVPROC glPixelDataRangeNV; static glFlushPixelDataRangeNVPROC glFlushPixelDataRangeNV; -void extgl_InitNVPixelDataRange(JNIEnv *env, jobject ext_set) -{ - if (!extgl_Extensions.GL_NV_pixel_data_range) - return; - - glPixelDataRangeNV = (glPixelDataRangeNVPROC) extgl_GetProcAddress("glPixelDataRangeNV"); - glFlushPixelDataRangeNV = (glFlushPixelDataRangeNVPROC) extgl_GetProcAddress("glFlushPixelDataRangeNV"); - - EXTGL_SANITY_CHECK(env, ext_set, GL_NV_pixel_data_range) -} - /* * Class: org.lwjgl.opengl.NVPixelDataRange * Method: nglPixelDataRangeNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPixelDataRange_nglPixelDataRangeNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPixelDataRange_nglPixelDataRangeNV (JNIEnv * env, jclass clazz, jint target, jint length, jobject data, jint dataOffset) { - CHECK_EXISTS(glPixelDataRangeNV) GLvoid *data_ptr = (GLvoid *)((GLubyte *)env->GetDirectBufferAddress(data) + dataOffset); glPixelDataRangeNV(target, length, data_ptr); CHECK_GL_ERROR @@ -72,10 +59,21 @@ * Class: org.lwjgl.opengl.NVPixelDataRange * Method: glFlushPixelDataRangeNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPixelDataRange_glFlushPixelDataRangeNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPixelDataRange_glFlushPixelDataRangeNV (JNIEnv * env, jclass clazz, jint target) { - CHECK_EXISTS(glFlushPixelDataRangeNV) glFlushPixelDataRangeNV(target); CHECK_GL_ERROR } + +void extgl_InitNVPixelDataRange(JNIEnv *env, jobject ext_set) +{ + JavaMethodAndGLFunction functions[] = { + {"nglPixelDataRangeNV", "(IILjava/nio/Buffer;I)V", (void*)&Java_org_lwjgl_opengl_NVPixelDataRange_nglPixelDataRangeNV, "glPixelDataRangeNV", (void**)&glPixelDataRangeNV}, + {"glFlushPixelDataRangeNV", "(I)V", (void*)&Java_org_lwjgl_opengl_NVPixelDataRange_glFlushPixelDataRangeNV, "glFlushPixelDataRangeNV", (void**)&glFlushPixelDataRangeNV} + }; + int num_functions = NUMFUNCTIONS(functions); + jclass clazz = extgl_ResetClass(env, "org/lwjgl/opengl/NVPixelDataRange"); + if (extgl_Extensions.GL_NV_pixel_data_range) + extgl_InitializeClass(env, clazz, ext_set, "GL_NV_pixel_data_range", num_functions, functions); +} Index: org_lwjgl_opengl_NVPointSprite.cpp =================================================================== RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/nv/org_lwjgl_opengl_NVPointSprite.cpp,v retrieving revision 1.1 retrieving revision 1.2 diff -u -d -r1.1 -r1.2 --- org_lwjgl_opengl_NVPointSprite.cpp 8 Feb 2004 20:28:48 -0000 1.1 +++ org_lwjgl_opengl_NVPointSprite.cpp 7 Mar 2004 15:18:46 -0000 1.2 @@ -34,7 +34,6 @@ // IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.NVPointSprite // ---------------------------------- -#include "org_lwjgl_opengl_NVPointSprite.h" #include "extgl.h" #include "checkGLerror.h" @@ -44,23 +43,13 @@ static glPointParameteriNVPROC glPointParameteriNV; static glPointParameterivNVPROC glPointParameterivNV; -void extgl_InitNVPointSprite(JNIEnv *env, jobject ext_set) -{ - if (!extgl_Extensions.GL_NV_point_sprite) - return; - glPointParameteriNV = (glPointParameteriNVPROC) extgl_GetProcAddress("glPointParameteriNV"); - glPointParameterivNV = (glPointParameterivNVPROC) extgl_GetProcAddress("glPointParameterivNV"); - EXTGL_SANITY_CHECK(env, ext_set, GL_NV_point_sprite) -} - /* * Class: org.lwjgl.opengl.NVPointSprite * Method: glPointParameteriNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPointSprite_glPointParameteriNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPointSprite_glPointParameteriNV (JNIEnv * env, jclass clazz, jint pname, jint param) { - CHECK_EXISTS(glPointParameteriNV) glPointParameteriNV(pname, param); CHECK_GL_ERROR } @@ -69,11 +58,22 @@ * Class: org.lwjgl.opengl.NVPointSprite * Method: nglPointParameterivNV */ -JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPointSprite_nglPointParameterivNV +static JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVPointSprite_nglPointParameterivNV (JNIEnv * env, jclass clazz, jint pname, jobject piParams, jint piParams_offset) { - CHECK_EXISTS(glPointParameterivNV) GLint *piParams_ptr = (GLint *)env->GetDirectBufferAddress(piParams) + piParams_offset; glPointParameterivNV(pname, piParams_ptr); CHECK_GL_ERROR } + +void extgl_InitNVPointSprite(JNIEnv *env, jobject ext_set) +{ + JavaMethodAndGLFunction 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); + jclass clazz = extgl_ResetClass(env, "org/lwjgl/opengl/NVPointSprite"); + if (extgl_Extensions.GL_NV_point_sprite) + extgl_InitializeClass(env, clazz, ext_set, "GL_NV_point_sprite", num_functions, functions); +} Index: org_lwjgl_opengl_NVPrimitiveRestart.cpp =================================================================== RCS file: /cvsroot/java-game-lib/LWJGL/src/native/common/nv/org_lwjgl_opengl_NVPrimitiveRestart.cpp,v retrieving revision 1.1 retrieving revision 1.2 diff -u -d -r1.1 -r1.2 --- org_lwjgl_opengl_NVPrimitiveRestart.cpp 8 Feb 2004 20:28:48 -0000 1.1 +++ org_lwjgl_opengl_NVPrimitiveRestart.cpp 7 Mar 2004 15:18:47 -0000 1.2 @@ -34,7 +34,6 @@ // IMPLEMENTATION OF NATIVE METHODS FOR CLASS: org.lwjgl.opengl.NVPrimitiveRestart // ---------------------------------- -#include "org_lwjgl_opengl_NVPrimitiveRestart.h" #include "extgl.h" #include "checkGLerror.h" @@ -44,25 +43,13 @@ static glPrimitiveRestartNVPROC glPrimitiveRestartNV; static glPrimitiveRestartIndexNVPROC glPrimitiveRestartIndexNV; -void extgl_InitNVPrimitiveRestart(JNIEnv *env, jobject ext_set) -{ - if (!extgl_Extensions.GL_NV_primitive_restart) - return; - - glPrimitiveRestartNV = (glPrimitiveRestartNVPR... [truncated message content] |
