aboutsummaryrefslogtreecommitdiffstats
path: root/CNativeCode
diff options
context:
space:
mode:
authorSven Gothel <[email protected]>2001-11-06 08:20:20 +0000
committerSven Gothel <[email protected]>2001-11-06 08:20:20 +0000
commit603d6cac0aee219f4d24270e3669712f5b5f0900 (patch)
tree198adc2f79fd7904ab99fa6435e5d16f51502847 /CNativeCode
parent29a4ca7a93fc2547466a732441b8374a5c99019b (diff)
java.nio, mesa-4.0 (gl1.3)rel-2-8-0-8-prerelease
Diffstat (limited to 'CNativeCode')
-rw-r--r--CNativeCode/OpenGLU_JauJNI14_funcs.c4480
-rw-r--r--CNativeCode/OpenGLU_funcs14.c.skel29
-rw-r--r--CNativeCode/OpenGL_JauJNI14_funcs.c51456
-rw-r--r--CNativeCode/OpenGL_funcs14.c.skel44
4 files changed, 56009 insertions, 0 deletions
diff --git a/CNativeCode/OpenGLU_JauJNI14_funcs.c b/CNativeCode/OpenGLU_JauJNI14_funcs.c
new file mode 100644
index 0000000..a82a3a1
--- /dev/null
+++ b/CNativeCode/OpenGLU_JauJNI14_funcs.c
@@ -0,0 +1,4480 @@
+/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!!
+
+ DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!!
+*/
+
+
+/*
+ * Leo Chan -- 1995
+ *
+ * This C file takes care of all the native implementation for the
+ * OpenGL utility commands
+ * ---------------
+ *
+ * Sven Goethel
+ *
+ * September 1997
+ */
+
+
+/*--------------------------------------------------------------------------
+ * here on in is just regular apple pie C
+ */
+
+#include "OpenGL_misc.h"
+
+#include "gl4java_GLUFunc14JauJNI.h"
+
+#include "GLCallbackHelperJNI.h"
+#include "GLUCallbackJNI.h"
+#include "jnitools.h"
+
+/**
+ * herein lies the native JAVA methods for the OpenGL functions.
+ */
+
+static const char _glu_n_a_string[] = "GLU-String not avaiable !";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFunc14JauJNI_gluErrorString ( JNIEnv *env, jobject obj,
+ jint errorCode )
+{
+ const char *tmpString=0;
+
+ if ( disp__gluErrorString == NULL )
+ return (*env)->NewStringUTF(env, _glu_n_a_string);
+
+ tmpString = disp__gluErrorString ( /* jint */ errorCode );
+ if(tmpString==NULL)
+ tmpString=_glu_n_a_string;
+
+ return (*env)->NewStringUTF(env, tmpString);
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFunc14JauJNI_gluGetString ( JNIEnv *env, jobject obj,
+ jint name )
+{
+ const char *tmpString=0;
+
+ if ( disp__gluGetString == NULL )
+ return (*env)->NewStringUTF(env, _glu_n_a_string);
+
+ tmpString = disp__gluGetString ( /* jint */ name);
+ if(tmpString==NULL)
+ tmpString=_glu_n_a_string;
+
+ return (*env)->NewStringUTF(env, tmpString);
+}
+
+static const char * _glu_lib_vendor_="Jausoft - Sven Goethel Software Development";
+static const char * _glu_lib_version_="2.8.0.8";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFunc14JauJNI_getNativeVendor ( JNIEnv *env, jobject obj )
+{
+ return (*env)->NewStringUTF(env, _glu_lib_vendor_);
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFunc14JauJNI_getNativeVersion ( JNIEnv *env, jobject obj )
+{
+ return (*env)->NewStringUTF(env, _glu_lib_version_);
+}
+
+static void _AddCallbackNode(JNIEnv *env,
+ jlong qnt_obj, jint which,
+ jobject methodClassInstance,
+ jstring methodName,
+ jstring signature,
+ jint arrayLen1,
+ jint arrayLen2,
+ jint arrayLen3,
+ jint arrayLen4,
+ jint arrayLen5)
+{
+ char * strMethodName = jnitoolsGetJavaString(env, methodName);
+ char * strSignature = jnitoolsGetJavaString(env, signature);
+ jlong glx=0;
+
+ glx = GetCurrentGLContext();
+
+ AddCallbackNode(env, methodClassInstance, strMethodName, strSignature,
+ arrayLen1, arrayLen2, arrayLen3,
+ arrayLen4, arrayLen5,
+ (void *)((PointerHolder)qnt_obj), which, glx);
+ free(strMethodName);
+ free(strSignature);
+}
+
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFunc14JauJNI_gluQuadricCallback( JNIEnv *env, jobject obj,
+ jlong qobj, jint which,
+ jobject methodClassInstance,
+ jstring methodName,
+ jstring signature)
+{
+ if ( disp__gluQuadricCallback == NULL ) return;
+
+ switch(which)
+ {
+ case GLU_ERROR:
+ disp__gluQuadricCallback((void *)((PointerHolder)qobj),
+ which, cbf_GLU_ERROR );
+ break;
+ default:
+ jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+ return;
+ }
+ _AddCallbackNode(env,
+ qobj, which, methodClassInstance, methodName,
+ signature,
+ 0, 0, 0, 0, 0);
+}
+
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFunc14JauJNI_gluNurbsCallback( JNIEnv *env, jobject obj,
+ jlong nobj, jint which,
+ jobject methodClassInstance,
+ jstring methodName,
+ jstring signature)
+{
+ if ( disp__gluNurbsCallback == NULL ) return;
+
+ switch(which)
+ {
+ case GLU_ERROR:
+ disp__gluNurbsCallback((void *)((PointerHolder)nobj), which,
+ cbf_GLU_ERROR );
+ break;
+ default:
+ jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+ return;
+ }
+ _AddCallbackNode(env,
+ nobj, which, methodClassInstance, methodName,
+ signature,
+ 0, 0, 0, 0, 0);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFunc14JauJNI_gluTessCallback( JNIEnv *env, jobject obj,
+ jlong tobj, jint which,
+ jobject methodClassInstance,
+ jstring methodName,
+ jstring signature,
+ jint arrayLen1,
+ jint arrayLen2,
+ jint arrayLen3,
+ jint arrayLen4,
+ jint arrayLen5)
+{
+ if ( disp__gluTessCallback == NULL ) return;
+
+ switch(which)
+ {
+ case GLU_TESS_BEGIN:
+ disp__gluTessCallback((GLUtesselator *)((PointerHolder)tobj),
+ which,
+ cbf_GLU_TESS_BEGIN );
+ break;
+ case GLU_TESS_BEGIN_DATA:
+ disp__gluTessCallback((GLUtesselator *)((PointerHolder)tobj),
+ which,
+ cbf_GLU_TESS_BEGIN_DATA );
+ break;
+ case GLU_TESS_EDGE_FLAG:
+ disp__gluTessCallback((GLUtesselator *)((PointerHolder)tobj),
+ which,
+ cbf_GLU_TESS_EDGE_FLAG );
+ break;
+ case GLU_TESS_EDGE_FLAG_DATA:
+ disp__gluTessCallback((GLUtesselator *)((PointerHolder)tobj),
+ which,
+ cbf_GLU_TESS_EDGE_FLAG_DATA );
+ break;
+ case GLU_TESS_VERTEX:
+ disp__gluTessCallback((GLUtesselator *)((PointerHolder)tobj),
+ which,
+ cbf_GLU_TESS_VERTEX );
+ break;
+ case GLU_TESS_VERTEX_DATA:
+ disp__gluTessCallback((GLUtesselator *)((PointerHolder)tobj),
+ which,
+ cbf_GLU_TESS_VERTEX_DATA );
+ break;
+ case GLU_TESS_END:
+ disp__gluTessCallback((GLUtesselator *)((PointerHolder)tobj),
+ which,
+ cbf_GLU_TESS_END );
+ break;
+ case GLU_TESS_END_DATA:
+ disp__gluTessCallback((GLUtesselator *)((PointerHolder)tobj),
+ which,
+ cbf_GLU_TESS_END_DATA );
+ break;
+ case GLU_TESS_ERROR:
+ disp__gluTessCallback((GLUtesselator *)((PointerHolder)tobj),
+ which,
+ cbf_GLU_TESS_ERROR );
+ break;
+ case GLU_TESS_ERROR_DATA:
+ disp__gluTessCallback((GLUtesselator *)((PointerHolder)tobj),
+ which,
+ cbf_GLU_TESS_ERROR_DATA );
+ break;
+ case GLU_TESS_COMBINE:
+ disp__gluTessCallback((GLUtesselator *)((PointerHolder)tobj),
+ which,
+ cbf_GLU_TESS_COMBINE );
+ break;
+ case GLU_TESS_COMBINE_DATA:
+ disp__gluTessCallback((GLUtesselator *)((PointerHolder)tobj),
+ which,
+ cbf_GLU_TESS_COMBINE_DATA );
+ break;
+ default:
+ jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+ return;
+ }
+ _AddCallbackNode(env,
+ tobj, which, methodClassInstance, methodName,
+ signature,
+ arrayLen1, arrayLen2, arrayLen3,
+ arrayLen4, arrayLen5);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFunc14JauJNI_gluDeleteQuadric( JNIEnv *env, jobject obj,
+ jlong qobj )
+{
+ if ( disp__gluDeleteQuadric == NULL ) return;
+
+ disp__gluDeleteQuadric((void *)((PointerHolder)qobj));
+ RemoveCallbackNodes((void *)((PointerHolder)qobj));
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFunc14JauJNI_gluDeleteNurbsRenderer( JNIEnv *env, jobject obj,
+ jlong nobj )
+{
+ if ( disp__gluDeleteNurbsRenderer == NULL ) return;
+
+ disp__gluDeleteNurbsRenderer((void *)((PointerHolder)nobj));
+ RemoveCallbackNodes((void *)((PointerHolder)nobj));
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFunc14JauJNI_gluDeleteTess( JNIEnv *env, jobject obj,
+ jlong tobj )
+{
+ if ( disp__gluDeleteTess == NULL ) return;
+
+ disp__gluDeleteTess((GLUtesselator *)((PointerHolder)tobj));
+ RemoveCallbackNodes((void *)((PointerHolder)tobj));
+}
+
+JNIEXPORT jlong JNICALL
+Java_gl4java_GLUFunc14JauJNI_gluNewQuadric( JNIEnv *env, jobject obj)
+{
+ if ( disp__gluNewQuadric == NULL ) return 0;
+
+ return (jlong)((PointerHolder)disp__gluNewQuadric());
+}
+
+JNIEXPORT jlong JNICALL
+Java_gl4java_GLUFunc14JauJNI_gluNewNurbsRenderer( JNIEnv *env, jobject obj)
+{
+ if ( disp__gluNewNurbsRenderer == NULL ) return 0;
+
+ return (jlong)((PointerHolder)disp__gluNewNurbsRenderer());
+}
+
+JNIEXPORT jlong JNICALL
+Java_gl4java_GLUFunc14JauJNI_gluNewTess( JNIEnv *env, jobject obj)
+{
+ if ( disp__gluNewTess == NULL ) return 0;
+
+ return (jlong)((PointerHolder)disp__gluNewTess());
+}
+
+/**
+ * C2J Parser Version 3.0
+ * Jausoft - Sven Goethel Software Development
+ * Reading from file: glu-proto-auto.orig.h . . .
+ * Destination-Class: gl4java_GLUFunc14JauJNI !
+ */
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluBeginCurve ( GLUnurbs * nurb ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBeginCurve (
+ JNIEnv *env, jobject obj,
+ jlong nurb)
+ {
+
+ if ( disp__gluBeginCurve == NULL ) return;
+
+ disp__gluBeginCurve (
+ (GLUnurbs *) (PointerHolder) nurb
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluBeginPolygon ( GLUtesselator * tess ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBeginPolygon (
+ JNIEnv *env, jobject obj,
+ jlong tess)
+ {
+
+ if ( disp__gluBeginPolygon == NULL ) return;
+
+ disp__gluBeginPolygon (
+ (GLUtesselator *) (PointerHolder) tess
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluBeginSurface ( GLUnurbs * nurb ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBeginSurface (
+ JNIEnv *env, jobject obj,
+ jlong nurb)
+ {
+
+ if ( disp__gluBeginSurface == NULL ) return;
+
+ disp__gluBeginSurface (
+ (GLUnurbs *) (PointerHolder) nurb
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluBeginTrim ( GLUnurbs * nurb ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBeginTrim (
+ JNIEnv *env, jobject obj,
+ jlong nurb)
+ {
+
+ if ( disp__gluBeginTrim == NULL ) return;
+
+ disp__gluBeginTrim (
+ (GLUnurbs *) (PointerHolder) nurb
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLint gluBuild1DMipmapLevels ( GLenum target , GLint internalFormat , GLsizei width , GLenum format , GLenum type , GLint level , GLint base , GLint max , const void * data ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild1DMipmapLevels__IIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jbyteArray data)
+ {
+ jint ret;
+
+ jbyte *ptr8 = NULL;
+
+ if ( disp__gluBuild1DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild1DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild1DMipmapLevels__IIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jshortArray data)
+ {
+ jint ret;
+
+ jshort *ptr8 = NULL;
+
+ if ( disp__gluBuild1DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild1DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild1DMipmapLevels__IIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jintArray data)
+ {
+ jint ret;
+
+ jint *ptr8 = NULL;
+
+ if ( disp__gluBuild1DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild1DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild1DMipmapLevels__IIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jfloatArray data)
+ {
+ jint ret;
+
+ jfloat *ptr8 = NULL;
+
+ if ( disp__gluBuild1DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild1DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild1DMipmapLevels__IIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jdoubleArray data)
+ {
+ jint ret;
+
+ jdouble *ptr8 = NULL;
+
+ if ( disp__gluBuild1DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild1DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild1DMipmapLevels__IIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jbooleanArray data)
+ {
+ jint ret;
+
+ jboolean *ptr8 = NULL;
+
+ if ( disp__gluBuild1DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild1DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild1DMipmapLevels__IIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jlongArray data)
+ {
+ jint ret;
+
+ jlong *ptr8 = NULL;
+
+ if ( disp__gluBuild1DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild1DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild1DMipmapLevels__IIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jobject data)
+ {
+ jint ret;
+
+ void *ptr8 = NULL;
+
+ if ( disp__gluBuild1DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr8 = (*env)->GetDirectBufferAddress(env, data);
+ if (ptr8 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 8 was not a direct buffer");
+ return 0;
+ }
+ }
+ ret = (jint) disp__gluBuild1DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr8
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLint gluBuild1DMipmaps ( GLenum target , GLint internalFormat , GLsizei width , GLenum format , GLenum type , const void * data ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild1DMipmaps__IIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint format,
+ jint type,
+ jbyteArray data)
+ {
+ jint ret;
+
+ jbyte *ptr5 = NULL;
+
+ if ( disp__gluBuild1DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild1DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild1DMipmaps__IIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint format,
+ jint type,
+ jshortArray data)
+ {
+ jint ret;
+
+ jshort *ptr5 = NULL;
+
+ if ( disp__gluBuild1DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild1DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild1DMipmaps__IIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint format,
+ jint type,
+ jintArray data)
+ {
+ jint ret;
+
+ jint *ptr5 = NULL;
+
+ if ( disp__gluBuild1DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild1DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild1DMipmaps__IIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint format,
+ jint type,
+ jfloatArray data)
+ {
+ jint ret;
+
+ jfloat *ptr5 = NULL;
+
+ if ( disp__gluBuild1DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild1DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild1DMipmaps__IIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint format,
+ jint type,
+ jdoubleArray data)
+ {
+ jint ret;
+
+ jdouble *ptr5 = NULL;
+
+ if ( disp__gluBuild1DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild1DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild1DMipmaps__IIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint format,
+ jint type,
+ jbooleanArray data)
+ {
+ jint ret;
+
+ jboolean *ptr5 = NULL;
+
+ if ( disp__gluBuild1DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild1DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild1DMipmaps__IIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint format,
+ jint type,
+ jlongArray data)
+ {
+ jint ret;
+
+ jlong *ptr5 = NULL;
+
+ if ( disp__gluBuild1DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild1DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild1DMipmaps__IIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint format,
+ jint type,
+ jobject data)
+ {
+ jint ret;
+
+ void *ptr5 = NULL;
+
+ if ( disp__gluBuild1DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr5 = (*env)->GetDirectBufferAddress(env, data);
+ if (ptr5 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 5 was not a direct buffer");
+ return 0;
+ }
+ }
+ ret = (jint) disp__gluBuild1DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr5
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLint gluBuild2DMipmapLevels ( GLenum target , GLint internalFormat , GLsizei width , GLsizei height , GLenum format , GLenum type , GLint level , GLint base , GLint max , const void * data ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jbyteArray data)
+ {
+ jint ret;
+
+ jbyte *ptr9 = NULL;
+
+ if ( disp__gluBuild2DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr9 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild2DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr9
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr9, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jshortArray data)
+ {
+ jint ret;
+
+ jshort *ptr9 = NULL;
+
+ if ( disp__gluBuild2DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr9 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild2DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr9
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr9, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jintArray data)
+ {
+ jint ret;
+
+ jint *ptr9 = NULL;
+
+ if ( disp__gluBuild2DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr9 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild2DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr9
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr9, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jfloatArray data)
+ {
+ jint ret;
+
+ jfloat *ptr9 = NULL;
+
+ if ( disp__gluBuild2DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr9 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild2DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr9
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr9, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jdoubleArray data)
+ {
+ jint ret;
+
+ jdouble *ptr9 = NULL;
+
+ if ( disp__gluBuild2DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr9 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild2DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr9
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr9, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jbooleanArray data)
+ {
+ jint ret;
+
+ jboolean *ptr9 = NULL;
+
+ if ( disp__gluBuild2DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr9 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild2DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr9
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr9, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jlongArray data)
+ {
+ jint ret;
+
+ jlong *ptr9 = NULL;
+
+ if ( disp__gluBuild2DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr9 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild2DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr9
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr9, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild2DMipmapLevels__IIIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jobject data)
+ {
+ jint ret;
+
+ void *ptr9 = NULL;
+
+ if ( disp__gluBuild2DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr9 = (*env)->GetDirectBufferAddress(env, data);
+ if (ptr9 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 9 was not a direct buffer");
+ return 0;
+ }
+ }
+ ret = (jint) disp__gluBuild2DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr9
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLint gluBuild2DMipmaps ( GLenum target , GLint internalFormat , GLsizei width , GLsizei height , GLenum format , GLenum type , const void * data ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild2DMipmaps__IIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jbyteArray data)
+ {
+ jint ret;
+
+ jbyte *ptr6 = NULL;
+
+ if ( disp__gluBuild2DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild2DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild2DMipmaps__IIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jshortArray data)
+ {
+ jint ret;
+
+ jshort *ptr6 = NULL;
+
+ if ( disp__gluBuild2DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild2DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild2DMipmaps__IIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jintArray data)
+ {
+ jint ret;
+
+ jint *ptr6 = NULL;
+
+ if ( disp__gluBuild2DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild2DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild2DMipmaps__IIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jfloatArray data)
+ {
+ jint ret;
+
+ jfloat *ptr6 = NULL;
+
+ if ( disp__gluBuild2DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild2DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild2DMipmaps__IIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jdoubleArray data)
+ {
+ jint ret;
+
+ jdouble *ptr6 = NULL;
+
+ if ( disp__gluBuild2DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild2DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild2DMipmaps__IIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jbooleanArray data)
+ {
+ jint ret;
+
+ jboolean *ptr6 = NULL;
+
+ if ( disp__gluBuild2DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild2DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild2DMipmaps__IIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jlongArray data)
+ {
+ jint ret;
+
+ jlong *ptr6 = NULL;
+
+ if ( disp__gluBuild2DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild2DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild2DMipmaps__IIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jobject data)
+ {
+ jint ret;
+
+ void *ptr6 = NULL;
+
+ if ( disp__gluBuild2DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr6 = (*env)->GetDirectBufferAddress(env, data);
+ if (ptr6 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 6 was not a direct buffer");
+ return 0;
+ }
+ }
+ ret = (jint) disp__gluBuild2DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr6
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLint gluBuild3DMipmapLevels ( GLenum target , GLint internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , GLint level , GLint base , GLint max , const void * data ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jbyteArray data)
+ {
+ jint ret;
+
+ jbyte *ptr10 = NULL;
+
+ if ( disp__gluBuild3DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr10 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild3DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr10
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr10, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jshortArray data)
+ {
+ jint ret;
+
+ jshort *ptr10 = NULL;
+
+ if ( disp__gluBuild3DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr10 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild3DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr10
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr10, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jintArray data)
+ {
+ jint ret;
+
+ jint *ptr10 = NULL;
+
+ if ( disp__gluBuild3DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr10 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild3DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr10
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr10, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jfloatArray data)
+ {
+ jint ret;
+
+ jfloat *ptr10 = NULL;
+
+ if ( disp__gluBuild3DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr10 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild3DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr10
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr10, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jdoubleArray data)
+ {
+ jint ret;
+
+ jdouble *ptr10 = NULL;
+
+ if ( disp__gluBuild3DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr10 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild3DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr10
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr10, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jbooleanArray data)
+ {
+ jint ret;
+
+ jboolean *ptr10 = NULL;
+
+ if ( disp__gluBuild3DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr10 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild3DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr10
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr10, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jlongArray data)
+ {
+ jint ret;
+
+ jlong *ptr10 = NULL;
+
+ if ( disp__gluBuild3DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr10 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild3DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr10
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr10, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild3DMipmapLevels__IIIIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jint level,
+ jint base,
+ jint max,
+ jobject data)
+ {
+ jint ret;
+
+ void *ptr10 = NULL;
+
+ if ( disp__gluBuild3DMipmapLevels == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr10 = (*env)->GetDirectBufferAddress(env, data);
+ if (ptr10 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 10 was not a direct buffer");
+ return 0;
+ }
+ }
+ ret = (jint) disp__gluBuild3DMipmapLevels (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (GLint) level,
+ (GLint) base,
+ (GLint) max,
+ (const void *) ptr10
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLint gluBuild3DMipmaps ( GLenum target , GLint internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const void * data ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild3DMipmaps__IIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jbyteArray data)
+ {
+ jint ret;
+
+ jbyte *ptr7 = NULL;
+
+ if ( disp__gluBuild3DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr7 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild3DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr7
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr7, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild3DMipmaps__IIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jshortArray data)
+ {
+ jint ret;
+
+ jshort *ptr7 = NULL;
+
+ if ( disp__gluBuild3DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr7 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild3DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr7
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr7, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild3DMipmaps__IIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jintArray data)
+ {
+ jint ret;
+
+ jint *ptr7 = NULL;
+
+ if ( disp__gluBuild3DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr7 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild3DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr7
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr7, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild3DMipmaps__IIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jfloatArray data)
+ {
+ jint ret;
+
+ jfloat *ptr7 = NULL;
+
+ if ( disp__gluBuild3DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr7 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild3DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr7
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr7, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild3DMipmaps__IIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jdoubleArray data)
+ {
+ jint ret;
+
+ jdouble *ptr7 = NULL;
+
+ if ( disp__gluBuild3DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr7 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild3DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr7
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr7, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild3DMipmaps__IIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jbooleanArray data)
+ {
+ jint ret;
+
+ jboolean *ptr7 = NULL;
+
+ if ( disp__gluBuild3DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr7 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild3DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr7
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr7, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild3DMipmaps__IIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jlongArray data)
+ {
+ jint ret;
+
+ jlong *ptr7 = NULL;
+
+ if ( disp__gluBuild3DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr7 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ ret = (jint) disp__gluBuild3DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr7
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr7, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluBuild3DMipmaps__IIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jobject data)
+ {
+ jint ret;
+
+ void *ptr7 = NULL;
+
+ if ( disp__gluBuild3DMipmaps == NULL ) return 0;
+
+ if(data!=NULL)
+ {
+ ptr7 = (*env)->GetDirectBufferAddress(env, data);
+ if (ptr7 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 7 was not a direct buffer");
+ return 0;
+ }
+ }
+ ret = (jint) disp__gluBuild3DMipmaps (
+ (GLenum) target,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const void *) ptr7
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLboolean gluCheckExtension ( const GLubyte * extName , const GLubyte * extString ) ;
+ * </pre>
+ */
+ JNIEXPORT jboolean JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluCheckExtension (
+ JNIEnv *env, jobject obj,
+ jbyteArray extName,
+ jbyteArray extString)
+ {
+ jboolean ret;
+
+ jbyte *ptr0 = NULL;
+ jbyte *ptr1 = NULL;
+
+ if ( disp__gluCheckExtension == NULL ) return 0;
+
+ if(extName!=NULL)
+ {
+ ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, extName, 0);
+ }
+ if(extString!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, extString, 0);
+ }
+ ret = (jboolean) disp__gluCheckExtension (
+ (const GLubyte *) ptr0,
+ (const GLubyte *) ptr1
+ );
+
+ if(extName!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, extName, ptr0, JNI_ABORT);
+ }
+ if(extString!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, extString, ptr1, JNI_ABORT);
+ }
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluCylinder ( GLUquadric * quad , GLdouble base , GLdouble top , GLdouble height , GLint slices , GLint stacks ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluCylinder (
+ JNIEnv *env, jobject obj,
+ jlong quad,
+ jdouble base,
+ jdouble top,
+ jdouble height,
+ jint slices,
+ jint stacks)
+ {
+
+ if ( disp__gluCylinder == NULL ) return;
+
+ disp__gluCylinder (
+ (GLUquadric *) (PointerHolder) quad,
+ (GLdouble) base,
+ (GLdouble) top,
+ (GLdouble) height,
+ (GLint) slices,
+ (GLint) stacks
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluDisk ( GLUquadric * quad , GLdouble inner , GLdouble outer , GLint slices , GLint loops ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluDisk (
+ JNIEnv *env, jobject obj,
+ jlong quad,
+ jdouble inner,
+ jdouble outer,
+ jint slices,
+ jint loops)
+ {
+
+ if ( disp__gluDisk == NULL ) return;
+
+ disp__gluDisk (
+ (GLUquadric *) (PointerHolder) quad,
+ (GLdouble) inner,
+ (GLdouble) outer,
+ (GLint) slices,
+ (GLint) loops
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluEndCurve ( GLUnurbs * nurb ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluEndCurve (
+ JNIEnv *env, jobject obj,
+ jlong nurb)
+ {
+
+ if ( disp__gluEndCurve == NULL ) return;
+
+ disp__gluEndCurve (
+ (GLUnurbs *) (PointerHolder) nurb
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluEndPolygon ( GLUtesselator * tess ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluEndPolygon (
+ JNIEnv *env, jobject obj,
+ jlong tess)
+ {
+
+ if ( disp__gluEndPolygon == NULL ) return;
+
+ disp__gluEndPolygon (
+ (GLUtesselator *) (PointerHolder) tess
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluEndSurface ( GLUnurbs * nurb ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluEndSurface (
+ JNIEnv *env, jobject obj,
+ jlong nurb)
+ {
+
+ if ( disp__gluEndSurface == NULL ) return;
+
+ disp__gluEndSurface (
+ (GLUnurbs *) (PointerHolder) nurb
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluEndTrim ( GLUnurbs * nurb ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluEndTrim (
+ JNIEnv *env, jobject obj,
+ jlong nurb)
+ {
+
+ if ( disp__gluEndTrim == NULL ) return;
+
+ disp__gluEndTrim (
+ (GLUnurbs *) (PointerHolder) nurb
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluGetNurbsProperty ( GLUnurbs * nurb , GLenum property , GLfloat * data ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluGetNurbsProperty (
+ JNIEnv *env, jobject obj,
+ jlong nurb,
+ jint property,
+ jfloatArray data)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__gluGetNurbsProperty == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray2);
+ }
+ disp__gluGetNurbsProperty (
+ (GLUnurbs *) (PointerHolder) nurb,
+ (GLenum) property,
+ (GLfloat *) ptr2
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluGetTessProperty ( GLUtesselator * tess , GLenum which , GLdouble * data ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluGetTessProperty (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jint which,
+ jdoubleArray data)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jdouble *ptr2 = NULL;
+
+ if ( disp__gluGetTessProperty == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray2);
+ }
+ disp__gluGetTessProperty (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLenum) which,
+ (GLdouble *) ptr2
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluLoadSamplingMatrices ( GLUnurbs * nurb , const GLfloat * model , const GLfloat * perspective , const GLint * view ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluLoadSamplingMatrices (
+ JNIEnv *env, jobject obj,
+ jlong nurb,
+ jfloatArray model,
+ jfloatArray perspective,
+ jintArray view)
+ {
+ jfloat *ptr1 = NULL;
+ jfloat *ptr2 = NULL;
+ jint *ptr3 = NULL;
+
+ if ( disp__gluLoadSamplingMatrices == NULL ) return;
+
+ if(model!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, model, 0);
+ }
+ if(perspective!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, perspective, 0);
+ }
+ if(view!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, view, 0);
+ }
+ disp__gluLoadSamplingMatrices (
+ (GLUnurbs *) (PointerHolder) nurb,
+ (const GLfloat *) ptr1,
+ (const GLfloat *) ptr2,
+ (const GLint *) ptr3
+ );
+
+ if(model!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, model, ptr1, JNI_ABORT);
+ }
+ if(perspective!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, perspective, ptr2, JNI_ABORT);
+ }
+ if(view!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, view, ptr3, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluLookAt ( GLdouble eyeX , GLdouble eyeY , GLdouble eyeZ , GLdouble centerX , GLdouble centerY , GLdouble centerZ , GLdouble upX , GLdouble upY , GLdouble upZ ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluLookAt (
+ JNIEnv *env, jobject obj,
+ jdouble eyeX,
+ jdouble eyeY,
+ jdouble eyeZ,
+ jdouble centerX,
+ jdouble centerY,
+ jdouble centerZ,
+ jdouble upX,
+ jdouble upY,
+ jdouble upZ)
+ {
+
+ if ( disp__gluLookAt == NULL ) return;
+
+ disp__gluLookAt (
+ (GLdouble) eyeX,
+ (GLdouble) eyeY,
+ (GLdouble) eyeZ,
+ (GLdouble) centerX,
+ (GLdouble) centerY,
+ (GLdouble) centerZ,
+ (GLdouble) upX,
+ (GLdouble) upY,
+ (GLdouble) upZ
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluNextContour ( GLUtesselator * tess , GLenum type ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluNextContour (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jint type)
+ {
+
+ if ( disp__gluNextContour == NULL ) return;
+
+ disp__gluNextContour (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLenum) type
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluNurbsCurve ( GLUnurbs * nurb , GLint knotCount , GLfloat * knots , GLint stride , GLfloat * control , GLint order , GLenum type ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluNurbsCurve (
+ JNIEnv *env, jobject obj,
+ jlong nurb,
+ jint knotCount,
+ jfloatArray knots,
+ jint stride,
+ jfloatArray control,
+ jint order,
+ jint type)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jfloat *ptr4 = NULL;
+
+ if ( disp__gluNurbsCurve == NULL ) return;
+
+ if(knots!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, knots, &isCopiedArray2);
+ }
+ if(control!=NULL)
+ {
+ ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, control, &isCopiedArray4);
+ }
+ disp__gluNurbsCurve (
+ (GLUnurbs *) (PointerHolder) nurb,
+ (GLint) knotCount,
+ (GLfloat *) ptr2,
+ (GLint) stride,
+ (GLfloat *) ptr4,
+ (GLint) order,
+ (GLenum) type
+ );
+
+ if(knots!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, knots, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(control!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, control, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluNurbsProperty ( GLUnurbs * nurb , GLenum property , GLfloat value ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluNurbsProperty (
+ JNIEnv *env, jobject obj,
+ jlong nurb,
+ jint property,
+ jfloat value)
+ {
+
+ if ( disp__gluNurbsProperty == NULL ) return;
+
+ disp__gluNurbsProperty (
+ (GLUnurbs *) (PointerHolder) nurb,
+ (GLenum) property,
+ (GLfloat) value
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluNurbsSurface ( GLUnurbs * nurb , GLint sKnotCount , GLfloat * sKnots , GLint tKnotCount , GLfloat * tKnots , GLint sStride , GLint tStride , GLfloat * control , GLint sOrder , GLint tOrder , GLenum type ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluNurbsSurface (
+ JNIEnv *env, jobject obj,
+ jlong nurb,
+ jint sKnotCount,
+ jfloatArray sKnots,
+ jint tKnotCount,
+ jfloatArray tKnots,
+ jint sStride,
+ jint tStride,
+ jfloatArray control,
+ jint sOrder,
+ jint tOrder,
+ jint type)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jfloat *ptr4 = NULL;
+ jboolean isCopiedArray7 = JNI_FALSE;
+ jfloat *ptr7 = NULL;
+
+ if ( disp__gluNurbsSurface == NULL ) return;
+
+ if(sKnots!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, sKnots, &isCopiedArray2);
+ }
+ if(tKnots!=NULL)
+ {
+ ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, tKnots, &isCopiedArray4);
+ }
+ if(control!=NULL)
+ {
+ ptr7 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, control, &isCopiedArray7);
+ }
+ disp__gluNurbsSurface (
+ (GLUnurbs *) (PointerHolder) nurb,
+ (GLint) sKnotCount,
+ (GLfloat *) ptr2,
+ (GLint) tKnotCount,
+ (GLfloat *) ptr4,
+ (GLint) sStride,
+ (GLint) tStride,
+ (GLfloat *) ptr7,
+ (GLint) sOrder,
+ (GLint) tOrder,
+ (GLenum) type
+ );
+
+ if(sKnots!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, sKnots, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(tKnots!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, tKnots, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(control!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, control, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluOrtho2D (
+ JNIEnv *env, jobject obj,
+ jdouble left,
+ jdouble right,
+ jdouble bottom,
+ jdouble top)
+ {
+
+ if ( disp__gluOrtho2D == NULL ) return;
+
+ disp__gluOrtho2D (
+ (GLdouble) left,
+ (GLdouble) right,
+ (GLdouble) bottom,
+ (GLdouble) top
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluPartialDisk ( GLUquadric * quad , GLdouble inner , GLdouble outer , GLint slices , GLint loops , GLdouble start , GLdouble sweep ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluPartialDisk (
+ JNIEnv *env, jobject obj,
+ jlong quad,
+ jdouble inner,
+ jdouble outer,
+ jint slices,
+ jint loops,
+ jdouble start,
+ jdouble sweep)
+ {
+
+ if ( disp__gluPartialDisk == NULL ) return;
+
+ disp__gluPartialDisk (
+ (GLUquadric *) (PointerHolder) quad,
+ (GLdouble) inner,
+ (GLdouble) outer,
+ (GLint) slices,
+ (GLint) loops,
+ (GLdouble) start,
+ (GLdouble) sweep
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluPerspective (
+ JNIEnv *env, jobject obj,
+ jdouble fovy,
+ jdouble aspect,
+ jdouble zNear,
+ jdouble zFar)
+ {
+
+ if ( disp__gluPerspective == NULL ) return;
+
+ disp__gluPerspective (
+ (GLdouble) fovy,
+ (GLdouble) aspect,
+ (GLdouble) zNear,
+ (GLdouble) zFar
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble delX , GLdouble delY , GLint * viewport ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluPickMatrix (
+ JNIEnv *env, jobject obj,
+ jdouble x,
+ jdouble y,
+ jdouble delX,
+ jdouble delY,
+ jintArray viewport)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jint *ptr4 = NULL;
+
+ if ( disp__gluPickMatrix == NULL ) return;
+
+ if(viewport!=NULL)
+ {
+ ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, viewport, &isCopiedArray4);
+ }
+ disp__gluPickMatrix (
+ (GLdouble) x,
+ (GLdouble) y,
+ (GLdouble) delX,
+ (GLdouble) delY,
+ (GLint *) ptr4
+ );
+
+ if(viewport!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, viewport, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLint gluProject ( GLdouble objX , GLdouble objY , GLdouble objZ , const GLdouble * model , const GLdouble * proj , const GLint * view , GLdouble * winX , GLdouble * winY , GLdouble * winZ ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluProject (
+ JNIEnv *env, jobject obj,
+ jdouble objX,
+ jdouble objY,
+ jdouble objZ,
+ jdoubleArray model,
+ jdoubleArray proj,
+ jintArray view,
+ jdoubleArray winX,
+ jdoubleArray winY,
+ jdoubleArray winZ)
+ {
+ jint ret;
+
+ jdouble *ptr3 = NULL;
+ jdouble *ptr4 = NULL;
+ jint *ptr5 = NULL;
+ jboolean isCopiedArray6 = JNI_FALSE;
+ jdouble *ptr6 = NULL;
+ jboolean isCopiedArray7 = JNI_FALSE;
+ jdouble *ptr7 = NULL;
+ jboolean isCopiedArray8 = JNI_FALSE;
+ jdouble *ptr8 = NULL;
+
+ if ( disp__gluProject == NULL ) return 0;
+
+ if(model!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, model, 0);
+ }
+ if(proj!=NULL)
+ {
+ ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, proj, 0);
+ }
+ if(view!=NULL)
+ {
+ ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, view, 0);
+ }
+ if(winX!=NULL)
+ {
+ ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, winX, &isCopiedArray6);
+ }
+ if(winY!=NULL)
+ {
+ ptr7 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, winY, &isCopiedArray7);
+ }
+ if(winZ!=NULL)
+ {
+ ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, winZ, &isCopiedArray8);
+ }
+ ret = (jint) disp__gluProject (
+ (GLdouble) objX,
+ (GLdouble) objY,
+ (GLdouble) objZ,
+ (const GLdouble *) ptr3,
+ (const GLdouble *) ptr4,
+ (const GLint *) ptr5,
+ (GLdouble *) ptr6,
+ (GLdouble *) ptr7,
+ (GLdouble *) ptr8
+ );
+
+ if(model!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, model, ptr3, JNI_ABORT);
+ }
+ if(proj!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, proj, ptr4, JNI_ABORT);
+ }
+ if(view!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, view, ptr5, JNI_ABORT);
+ }
+ if(winX!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, winX, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(winY!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, winY, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(winZ!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, winZ, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluPwlCurve ( GLUnurbs * nurb , GLint count , GLfloat * data , GLint stride , GLenum type ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluPwlCurve (
+ JNIEnv *env, jobject obj,
+ jlong nurb,
+ jint count,
+ jfloatArray data,
+ jint stride,
+ jint type)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__gluPwlCurve == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray2);
+ }
+ disp__gluPwlCurve (
+ (GLUnurbs *) (PointerHolder) nurb,
+ (GLint) count,
+ (GLfloat *) ptr2,
+ (GLint) stride,
+ (GLenum) type
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluQuadricDrawStyle ( GLUquadric * quad , GLenum draw ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluQuadricDrawStyle (
+ JNIEnv *env, jobject obj,
+ jlong quad,
+ jint draw)
+ {
+
+ if ( disp__gluQuadricDrawStyle == NULL ) return;
+
+ disp__gluQuadricDrawStyle (
+ (GLUquadric *) (PointerHolder) quad,
+ (GLenum) draw
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluQuadricNormals ( GLUquadric * quad , GLenum normal ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluQuadricNormals (
+ JNIEnv *env, jobject obj,
+ jlong quad,
+ jint normal)
+ {
+
+ if ( disp__gluQuadricNormals == NULL ) return;
+
+ disp__gluQuadricNormals (
+ (GLUquadric *) (PointerHolder) quad,
+ (GLenum) normal
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluQuadricOrientation ( GLUquadric * quad , GLenum orientation ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluQuadricOrientation (
+ JNIEnv *env, jobject obj,
+ jlong quad,
+ jint orientation)
+ {
+
+ if ( disp__gluQuadricOrientation == NULL ) return;
+
+ disp__gluQuadricOrientation (
+ (GLUquadric *) (PointerHolder) quad,
+ (GLenum) orientation
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluQuadricTexture ( GLUquadric * quad , GLboolean texture ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluQuadricTexture (
+ JNIEnv *env, jobject obj,
+ jlong quad,
+ jboolean texture)
+ {
+
+ if ( disp__gluQuadricTexture == NULL ) return;
+
+ disp__gluQuadricTexture (
+ (GLUquadric *) (PointerHolder) quad,
+ (GLboolean) texture
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLint gluScaleImage ( GLenum format , GLsizei wIn , GLsizei hIn , GLenum typeIn , const void * dataIn , GLsizei wOut , GLsizei hOut , GLenum typeOut , GLvoid * dataOut ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluScaleImage__IIII_3BIII_3B (
+ JNIEnv *env, jobject obj,
+ jint format,
+ jint wIn,
+ jint hIn,
+ jint typeIn,
+ jbyteArray dataIn,
+ jint wOut,
+ jint hOut,
+ jint typeOut,
+ jbyteArray dataOut)
+ {
+ jint ret;
+
+ jbyte *ptr4 = NULL;
+ jboolean isCopiedArray8 = JNI_FALSE;
+ jbyte *ptr8 = NULL;
+
+ if ( disp__gluScaleImage == NULL ) return 0;
+
+ if(dataIn!=NULL)
+ {
+ ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, dataIn, 0);
+ }
+ if(dataOut!=NULL)
+ {
+ ptr8 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, dataOut, &isCopiedArray8);
+ }
+ ret = (jint) disp__gluScaleImage (
+ (GLenum) format,
+ (GLsizei) wIn,
+ (GLsizei) hIn,
+ (GLenum) typeIn,
+ (const void *) ptr4,
+ (GLsizei) wOut,
+ (GLsizei) hOut,
+ (GLenum) typeOut,
+ (GLvoid *) ptr8
+ );
+
+ if(dataIn!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, dataIn, ptr4, JNI_ABORT);
+ }
+ if(dataOut!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluScaleImage__IIII_3SIII_3S (
+ JNIEnv *env, jobject obj,
+ jint format,
+ jint wIn,
+ jint hIn,
+ jint typeIn,
+ jshortArray dataIn,
+ jint wOut,
+ jint hOut,
+ jint typeOut,
+ jshortArray dataOut)
+ {
+ jint ret;
+
+ jshort *ptr4 = NULL;
+ jboolean isCopiedArray8 = JNI_FALSE;
+ jshort *ptr8 = NULL;
+
+ if ( disp__gluScaleImage == NULL ) return 0;
+
+ if(dataIn!=NULL)
+ {
+ ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, dataIn, 0);
+ }
+ if(dataOut!=NULL)
+ {
+ ptr8 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, dataOut, &isCopiedArray8);
+ }
+ ret = (jint) disp__gluScaleImage (
+ (GLenum) format,
+ (GLsizei) wIn,
+ (GLsizei) hIn,
+ (GLenum) typeIn,
+ (const void *) ptr4,
+ (GLsizei) wOut,
+ (GLsizei) hOut,
+ (GLenum) typeOut,
+ (GLvoid *) ptr8
+ );
+
+ if(dataIn!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, dataIn, ptr4, JNI_ABORT);
+ }
+ if(dataOut!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluScaleImage__IIII_3IIII_3I (
+ JNIEnv *env, jobject obj,
+ jint format,
+ jint wIn,
+ jint hIn,
+ jint typeIn,
+ jintArray dataIn,
+ jint wOut,
+ jint hOut,
+ jint typeOut,
+ jintArray dataOut)
+ {
+ jint ret;
+
+ jint *ptr4 = NULL;
+ jboolean isCopiedArray8 = JNI_FALSE;
+ jint *ptr8 = NULL;
+
+ if ( disp__gluScaleImage == NULL ) return 0;
+
+ if(dataIn!=NULL)
+ {
+ ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, dataIn, 0);
+ }
+ if(dataOut!=NULL)
+ {
+ ptr8 = (jint *) (*env)->GetPrimitiveArrayCritical(env, dataOut, &isCopiedArray8);
+ }
+ ret = (jint) disp__gluScaleImage (
+ (GLenum) format,
+ (GLsizei) wIn,
+ (GLsizei) hIn,
+ (GLenum) typeIn,
+ (const void *) ptr4,
+ (GLsizei) wOut,
+ (GLsizei) hOut,
+ (GLenum) typeOut,
+ (GLvoid *) ptr8
+ );
+
+ if(dataIn!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, dataIn, ptr4, JNI_ABORT);
+ }
+ if(dataOut!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluScaleImage__IIII_3FIII_3F (
+ JNIEnv *env, jobject obj,
+ jint format,
+ jint wIn,
+ jint hIn,
+ jint typeIn,
+ jfloatArray dataIn,
+ jint wOut,
+ jint hOut,
+ jint typeOut,
+ jfloatArray dataOut)
+ {
+ jint ret;
+
+ jfloat *ptr4 = NULL;
+ jboolean isCopiedArray8 = JNI_FALSE;
+ jfloat *ptr8 = NULL;
+
+ if ( disp__gluScaleImage == NULL ) return 0;
+
+ if(dataIn!=NULL)
+ {
+ ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, dataIn, 0);
+ }
+ if(dataOut!=NULL)
+ {
+ ptr8 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, dataOut, &isCopiedArray8);
+ }
+ ret = (jint) disp__gluScaleImage (
+ (GLenum) format,
+ (GLsizei) wIn,
+ (GLsizei) hIn,
+ (GLenum) typeIn,
+ (const void *) ptr4,
+ (GLsizei) wOut,
+ (GLsizei) hOut,
+ (GLenum) typeOut,
+ (GLvoid *) ptr8
+ );
+
+ if(dataIn!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, dataIn, ptr4, JNI_ABORT);
+ }
+ if(dataOut!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluScaleImage__IIII_3DIII_3D (
+ JNIEnv *env, jobject obj,
+ jint format,
+ jint wIn,
+ jint hIn,
+ jint typeIn,
+ jdoubleArray dataIn,
+ jint wOut,
+ jint hOut,
+ jint typeOut,
+ jdoubleArray dataOut)
+ {
+ jint ret;
+
+ jdouble *ptr4 = NULL;
+ jboolean isCopiedArray8 = JNI_FALSE;
+ jdouble *ptr8 = NULL;
+
+ if ( disp__gluScaleImage == NULL ) return 0;
+
+ if(dataIn!=NULL)
+ {
+ ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, dataIn, 0);
+ }
+ if(dataOut!=NULL)
+ {
+ ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, dataOut, &isCopiedArray8);
+ }
+ ret = (jint) disp__gluScaleImage (
+ (GLenum) format,
+ (GLsizei) wIn,
+ (GLsizei) hIn,
+ (GLenum) typeIn,
+ (const void *) ptr4,
+ (GLsizei) wOut,
+ (GLsizei) hOut,
+ (GLenum) typeOut,
+ (GLvoid *) ptr8
+ );
+
+ if(dataIn!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, dataIn, ptr4, JNI_ABORT);
+ }
+ if(dataOut!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluScaleImage__IIII_3ZIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint format,
+ jint wIn,
+ jint hIn,
+ jint typeIn,
+ jbooleanArray dataIn,
+ jint wOut,
+ jint hOut,
+ jint typeOut,
+ jbooleanArray dataOut)
+ {
+ jint ret;
+
+ jboolean *ptr4 = NULL;
+ jboolean isCopiedArray8 = JNI_FALSE;
+ jboolean *ptr8 = NULL;
+
+ if ( disp__gluScaleImage == NULL ) return 0;
+
+ if(dataIn!=NULL)
+ {
+ ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, dataIn, 0);
+ }
+ if(dataOut!=NULL)
+ {
+ ptr8 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, dataOut, &isCopiedArray8);
+ }
+ ret = (jint) disp__gluScaleImage (
+ (GLenum) format,
+ (GLsizei) wIn,
+ (GLsizei) hIn,
+ (GLenum) typeIn,
+ (const void *) ptr4,
+ (GLsizei) wOut,
+ (GLsizei) hOut,
+ (GLenum) typeOut,
+ (GLvoid *) ptr8
+ );
+
+ if(dataIn!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, dataIn, ptr4, JNI_ABORT);
+ }
+ if(dataOut!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluScaleImage__IIII_3JIII_3J (
+ JNIEnv *env, jobject obj,
+ jint format,
+ jint wIn,
+ jint hIn,
+ jint typeIn,
+ jlongArray dataIn,
+ jint wOut,
+ jint hOut,
+ jint typeOut,
+ jlongArray dataOut)
+ {
+ jint ret;
+
+ jlong *ptr4 = NULL;
+ jboolean isCopiedArray8 = JNI_FALSE;
+ jlong *ptr8 = NULL;
+
+ if ( disp__gluScaleImage == NULL ) return 0;
+
+ if(dataIn!=NULL)
+ {
+ ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, dataIn, 0);
+ }
+ if(dataOut!=NULL)
+ {
+ ptr8 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, dataOut, &isCopiedArray8);
+ }
+ ret = (jint) disp__gluScaleImage (
+ (GLenum) format,
+ (GLsizei) wIn,
+ (GLsizei) hIn,
+ (GLenum) typeIn,
+ (const void *) ptr4,
+ (GLsizei) wOut,
+ (GLsizei) hOut,
+ (GLenum) typeOut,
+ (GLvoid *) ptr8
+ );
+
+ if(dataIn!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, dataIn, ptr4, JNI_ABORT);
+ }
+ if(dataOut!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluScaleImage__IIIILjava_nio_Buffer_2IIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint format,
+ jint wIn,
+ jint hIn,
+ jint typeIn,
+ jobject dataIn,
+ jint wOut,
+ jint hOut,
+ jint typeOut,
+ jobject dataOut)
+ {
+ jint ret;
+
+ void *ptr4 = NULL;
+ void *ptr8 = NULL;
+
+ if ( disp__gluScaleImage == NULL ) return 0;
+
+ if(dataIn!=NULL)
+ {
+ ptr4 = (*env)->GetDirectBufferAddress(env, dataIn);
+ if (ptr4 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 4 was not a direct buffer");
+ return 0;
+ }
+ }
+ if(dataOut!=NULL)
+ {
+ ptr8 = (*env)->GetDirectBufferAddress(env, dataOut);
+ if (ptr8 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 8 was not a direct buffer");
+ return 0;
+ }
+ }
+ ret = (jint) disp__gluScaleImage (
+ (GLenum) format,
+ (GLsizei) wIn,
+ (GLsizei) hIn,
+ (GLenum) typeIn,
+ (const void *) ptr4,
+ (GLsizei) wOut,
+ (GLsizei) hOut,
+ (GLenum) typeOut,
+ (GLvoid *) ptr8
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluSphere ( GLUquadric * quad , GLdouble radius , GLint slices , GLint stacks ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluSphere (
+ JNIEnv *env, jobject obj,
+ jlong quad,
+ jdouble radius,
+ jint slices,
+ jint stacks)
+ {
+
+ if ( disp__gluSphere == NULL ) return;
+
+ disp__gluSphere (
+ (GLUquadric *) (PointerHolder) quad,
+ (GLdouble) radius,
+ (GLint) slices,
+ (GLint) stacks
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluTessBeginContour ( GLUtesselator * tess ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessBeginContour (
+ JNIEnv *env, jobject obj,
+ jlong tess)
+ {
+
+ if ( disp__gluTessBeginContour == NULL ) return;
+
+ disp__gluTessBeginContour (
+ (GLUtesselator *) (PointerHolder) tess
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluTessBeginPolygon ( GLUtesselator * tess , GLvoid * data ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessBeginPolygon__J_3B (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jbyteArray data)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jbyte *ptr1 = NULL;
+
+ if ( disp__gluTessBeginPolygon == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray1);
+ }
+ disp__gluTessBeginPolygon (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLvoid *) ptr1
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessBeginPolygon__J_3S (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jshortArray data)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jshort *ptr1 = NULL;
+
+ if ( disp__gluTessBeginPolygon == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray1);
+ }
+ disp__gluTessBeginPolygon (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLvoid *) ptr1
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessBeginPolygon__J_3I (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jintArray data)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jint *ptr1 = NULL;
+
+ if ( disp__gluTessBeginPolygon == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray1);
+ }
+ disp__gluTessBeginPolygon (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLvoid *) ptr1
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessBeginPolygon__J_3F (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jfloatArray data)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__gluTessBeginPolygon == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray1);
+ }
+ disp__gluTessBeginPolygon (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLvoid *) ptr1
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessBeginPolygon__J_3D (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jdoubleArray data)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jdouble *ptr1 = NULL;
+
+ if ( disp__gluTessBeginPolygon == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray1);
+ }
+ disp__gluTessBeginPolygon (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLvoid *) ptr1
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessBeginPolygon__J_3Z (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jbooleanArray data)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jboolean *ptr1 = NULL;
+
+ if ( disp__gluTessBeginPolygon == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray1);
+ }
+ disp__gluTessBeginPolygon (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLvoid *) ptr1
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessBeginPolygon__J_3J (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jlongArray data)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jlong *ptr1 = NULL;
+
+ if ( disp__gluTessBeginPolygon == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr1 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray1);
+ }
+ disp__gluTessBeginPolygon (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLvoid *) ptr1
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessBeginPolygon__JLjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jobject data)
+ {
+ void *ptr1 = NULL;
+
+ if ( disp__gluTessBeginPolygon == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr1 = (*env)->GetDirectBufferAddress(env, data);
+ if (ptr1 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 1 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__gluTessBeginPolygon (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLvoid *) ptr1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluTessEndContour ( GLUtesselator * tess ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessEndContour (
+ JNIEnv *env, jobject obj,
+ jlong tess)
+ {
+
+ if ( disp__gluTessEndContour == NULL ) return;
+
+ disp__gluTessEndContour (
+ (GLUtesselator *) (PointerHolder) tess
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluTessEndPolygon ( GLUtesselator * tess ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessEndPolygon (
+ JNIEnv *env, jobject obj,
+ jlong tess)
+ {
+
+ if ( disp__gluTessEndPolygon == NULL ) return;
+
+ disp__gluTessEndPolygon (
+ (GLUtesselator *) (PointerHolder) tess
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluTessNormal ( GLUtesselator * tess , GLdouble valueX , GLdouble valueY , GLdouble valueZ ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessNormal (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jdouble valueX,
+ jdouble valueY,
+ jdouble valueZ)
+ {
+
+ if ( disp__gluTessNormal == NULL ) return;
+
+ disp__gluTessNormal (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLdouble) valueX,
+ (GLdouble) valueY,
+ (GLdouble) valueZ
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluTessProperty ( GLUtesselator * tess , GLenum which , GLdouble data ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessProperty (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jint which,
+ jdouble data)
+ {
+
+ if ( disp__gluTessProperty == NULL ) return;
+
+ disp__gluTessProperty (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLenum) which,
+ (GLdouble) data
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void gluTessVertex ( GLUtesselator * tess , GLdouble * location , GLvoid * data ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessVertex__J_3D_3B (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jdoubleArray location,
+ jbyteArray data)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jdouble *ptr1 = NULL;
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jbyte *ptr2 = NULL;
+
+ if ( disp__gluTessVertex == NULL ) return;
+
+ if(location!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, location, &isCopiedArray1);
+ }
+ if(data!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray2);
+ }
+ disp__gluTessVertex (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLdouble *) ptr1,
+ (GLvoid *) ptr2
+ );
+
+ if(location!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessVertex__J_3D_3S (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jdoubleArray location,
+ jshortArray data)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jdouble *ptr1 = NULL;
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jshort *ptr2 = NULL;
+
+ if ( disp__gluTessVertex == NULL ) return;
+
+ if(location!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, location, &isCopiedArray1);
+ }
+ if(data!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray2);
+ }
+ disp__gluTessVertex (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLdouble *) ptr1,
+ (GLvoid *) ptr2
+ );
+
+ if(location!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessVertex__J_3D_3I (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jdoubleArray location,
+ jintArray data)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jdouble *ptr1 = NULL;
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__gluTessVertex == NULL ) return;
+
+ if(location!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, location, &isCopiedArray1);
+ }
+ if(data!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray2);
+ }
+ disp__gluTessVertex (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLdouble *) ptr1,
+ (GLvoid *) ptr2
+ );
+
+ if(location!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessVertex__J_3D_3F (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jdoubleArray location,
+ jfloatArray data)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jdouble *ptr1 = NULL;
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__gluTessVertex == NULL ) return;
+
+ if(location!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, location, &isCopiedArray1);
+ }
+ if(data!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray2);
+ }
+ disp__gluTessVertex (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLdouble *) ptr1,
+ (GLvoid *) ptr2
+ );
+
+ if(location!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessVertex__J_3D_3D (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jdoubleArray location,
+ jdoubleArray data)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jdouble *ptr1 = NULL;
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jdouble *ptr2 = NULL;
+
+ if ( disp__gluTessVertex == NULL ) return;
+
+ if(location!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, location, &isCopiedArray1);
+ }
+ if(data!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray2);
+ }
+ disp__gluTessVertex (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLdouble *) ptr1,
+ (GLvoid *) ptr2
+ );
+
+ if(location!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessVertex__J_3D_3Z (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jdoubleArray location,
+ jbooleanArray data)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jdouble *ptr1 = NULL;
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jboolean *ptr2 = NULL;
+
+ if ( disp__gluTessVertex == NULL ) return;
+
+ if(location!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, location, &isCopiedArray1);
+ }
+ if(data!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray2);
+ }
+ disp__gluTessVertex (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLdouble *) ptr1,
+ (GLvoid *) ptr2
+ );
+
+ if(location!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessVertex__J_3D_3J (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jdoubleArray location,
+ jlongArray data)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jdouble *ptr1 = NULL;
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jlong *ptr2 = NULL;
+
+ if ( disp__gluTessVertex == NULL ) return;
+
+ if(location!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, location, &isCopiedArray1);
+ }
+ if(data!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray2);
+ }
+ disp__gluTessVertex (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLdouble *) ptr1,
+ (GLvoid *) ptr2
+ );
+
+ if(location!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluTessVertex__J_3DLjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jlong tess,
+ jdoubleArray location,
+ jobject data)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jdouble *ptr1 = NULL;
+ void *ptr2 = NULL;
+
+ if ( disp__gluTessVertex == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr2 = (*env)->GetDirectBufferAddress(env, data);
+ if (ptr2 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 2 was not a direct buffer");
+ return ;
+ }
+ }
+ if(location!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, location, &isCopiedArray1);
+ }
+ disp__gluTessVertex (
+ (GLUtesselator *) (PointerHolder) tess,
+ (GLdouble *) ptr1,
+ (GLvoid *) ptr2
+ );
+
+ if(location!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLint gluUnProject ( GLdouble winX , GLdouble winY , GLdouble winZ , const GLdouble * model , const GLdouble * proj , const GLint * view , GLdouble * objX , GLdouble * objY , GLdouble * objZ ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluUnProject (
+ JNIEnv *env, jobject obj,
+ jdouble winX,
+ jdouble winY,
+ jdouble winZ,
+ jdoubleArray model,
+ jdoubleArray proj,
+ jintArray view,
+ jdoubleArray objX,
+ jdoubleArray objY,
+ jdoubleArray objZ)
+ {
+ jint ret;
+
+ jdouble *ptr3 = NULL;
+ jdouble *ptr4 = NULL;
+ jint *ptr5 = NULL;
+ jboolean isCopiedArray6 = JNI_FALSE;
+ jdouble *ptr6 = NULL;
+ jboolean isCopiedArray7 = JNI_FALSE;
+ jdouble *ptr7 = NULL;
+ jboolean isCopiedArray8 = JNI_FALSE;
+ jdouble *ptr8 = NULL;
+
+ if ( disp__gluUnProject == NULL ) return 0;
+
+ if(model!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, model, 0);
+ }
+ if(proj!=NULL)
+ {
+ ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, proj, 0);
+ }
+ if(view!=NULL)
+ {
+ ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, view, 0);
+ }
+ if(objX!=NULL)
+ {
+ ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, objX, &isCopiedArray6);
+ }
+ if(objY!=NULL)
+ {
+ ptr7 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, objY, &isCopiedArray7);
+ }
+ if(objZ!=NULL)
+ {
+ ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, objZ, &isCopiedArray8);
+ }
+ ret = (jint) disp__gluUnProject (
+ (GLdouble) winX,
+ (GLdouble) winY,
+ (GLdouble) winZ,
+ (const GLdouble *) ptr3,
+ (const GLdouble *) ptr4,
+ (const GLint *) ptr5,
+ (GLdouble *) ptr6,
+ (GLdouble *) ptr7,
+ (GLdouble *) ptr8
+ );
+
+ if(model!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, model, ptr3, JNI_ABORT);
+ }
+ if(proj!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, proj, ptr4, JNI_ABORT);
+ }
+ if(view!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, view, ptr5, JNI_ABORT);
+ }
+ if(objX!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, objX, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(objY!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, objY, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(objZ!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, objZ, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLint gluUnProject4 ( GLdouble winX , GLdouble winY , GLdouble winZ , GLdouble clipW , const GLdouble * model , const GLdouble * proj , const GLint * view , GLdouble nearVal , GLdouble farVal , GLdouble * objX , GLdouble * objY , GLdouble * objZ , GLdouble * objW ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLUFunc14JauJNI_gluUnProject4 (
+ JNIEnv *env, jobject obj,
+ jdouble winX,
+ jdouble winY,
+ jdouble winZ,
+ jdouble clipW,
+ jdoubleArray model,
+ jdoubleArray proj,
+ jintArray view,
+ jdouble nearVal,
+ jdouble farVal,
+ jdoubleArray objX,
+ jdoubleArray objY,
+ jdoubleArray objZ,
+ jdoubleArray objW)
+ {
+ jint ret;
+
+ jdouble *ptr4 = NULL;
+ jdouble *ptr5 = NULL;
+ jint *ptr6 = NULL;
+ jboolean isCopiedArray9 = JNI_FALSE;
+ jdouble *ptr9 = NULL;
+ jboolean isCopiedArray10 = JNI_FALSE;
+ jdouble *ptr10 = NULL;
+ jboolean isCopiedArray11 = JNI_FALSE;
+ jdouble *ptr11 = NULL;
+ jboolean isCopiedArray12 = JNI_FALSE;
+ jdouble *ptr12 = NULL;
+
+ if ( disp__gluUnProject4 == NULL ) return 0;
+
+ if(model!=NULL)
+ {
+ ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, model, 0);
+ }
+ if(proj!=NULL)
+ {
+ ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, proj, 0);
+ }
+ if(view!=NULL)
+ {
+ ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, view, 0);
+ }
+ if(objX!=NULL)
+ {
+ ptr9 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, objX, &isCopiedArray9);
+ }
+ if(objY!=NULL)
+ {
+ ptr10 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, objY, &isCopiedArray10);
+ }
+ if(objZ!=NULL)
+ {
+ ptr11 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, objZ, &isCopiedArray11);
+ }
+ if(objW!=NULL)
+ {
+ ptr12 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, objW, &isCopiedArray12);
+ }
+ ret = (jint) disp__gluUnProject4 (
+ (GLdouble) winX,
+ (GLdouble) winY,
+ (GLdouble) winZ,
+ (GLdouble) clipW,
+ (const GLdouble *) ptr4,
+ (const GLdouble *) ptr5,
+ (const GLint *) ptr6,
+ (GLdouble) nearVal,
+ (GLdouble) farVal,
+ (GLdouble *) ptr9,
+ (GLdouble *) ptr10,
+ (GLdouble *) ptr11,
+ (GLdouble *) ptr12
+ );
+
+ if(model!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, model, ptr4, JNI_ABORT);
+ }
+ if(proj!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, proj, ptr5, JNI_ABORT);
+ }
+ if(view!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, view, ptr6, JNI_ABORT);
+ }
+ if(objX!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, objX, ptr9, (isCopiedArray9 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(objY!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, objY, ptr10, (isCopiedArray10 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(objZ!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, objZ, ptr11, (isCopiedArray11 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(objW!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, objW, ptr12, (isCopiedArray12 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ return ret;
+ }
+
+/* C2J Parser Version 3.0: Java program parsed successfully. */
diff --git a/CNativeCode/OpenGLU_funcs14.c.skel b/CNativeCode/OpenGLU_funcs14.c.skel
new file mode 100644
index 0000000..649a2d1
--- /dev/null
+++ b/CNativeCode/OpenGLU_funcs14.c.skel
@@ -0,0 +1,29 @@
+/*
+ * Leo Chan -- 1995
+ *
+ * This C file takes care of all the native implementation for the
+ * OpenGL utility commands
+ * ---------------
+ *
+ * Sven Goethel
+ *
+ * September 1997
+ */
+
+
+/*--------------------------------------------------------------------------
+ * here on in is just regular apple pie C
+ */
+
+#include "OpenGL_misc.h"
+
+#include "gl4java_GLUFunc14JauJNI.h"
+
+#include "GLCallbackHelperJNI.h"
+#include "GLUCallbackJNI.h"
+#include "jnitools.h"
+
+/**
+ * herein lies the native JAVA methods for the OpenGL functions.
+ */
+
diff --git a/CNativeCode/OpenGL_JauJNI14_funcs.c b/CNativeCode/OpenGL_JauJNI14_funcs.c
new file mode 100644
index 0000000..fd518d5
--- /dev/null
+++ b/CNativeCode/OpenGL_JauJNI14_funcs.c
@@ -0,0 +1,51456 @@
+/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!!
+
+ DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!!
+*/
+
+
+/*
+ * Leo Chan -- 1995
+ * [email protected]
+ *
+ * This mammoth C file takes care of all the native implementation for the
+ * bulk of OpenGL commands
+ * ---------------
+ *
+ * Sven Goethel
+ *
+ * September 1997
+ */
+
+/*
+ * need to include the JAVA internal header files for macros and function
+ * prototypes required to maipulated JAVA data structures and functions
+ *
+ * StubPreamble.h includes the structure and macro definitions neede to
+ * convert JAVA data structures into C data structures.
+ *
+ */
+
+#include "OpenGL_misc.h"
+
+/*
+ * the next thing to include are special headers that were created by
+ * JAVAH. They include the C structure definitions for the JAVA classes
+ */
+#include "gl4java_GLFunc14JauJNI.h"
+
+/*--------------------------------------------------------------------------
+ * here on in is just regular apple pie C
+ */
+
+#ifndef LIBAPIENTRY
+ #define LIBAPIENTRY
+#endif
+#ifndef LIBAPI
+ #define LIBAPI
+#endif
+
+#ifndef CALLBACK
+ #define CALLBACK
+#endif
+/** THIS IS A MANUAL CODED PART
+ gl-manualCodedImplJNI.java
+*/
+
+static const char _gl_n_a_string[] = "GL-String not avaiable !";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFunc14JauJNI_glGetString ( JNIEnv *env, jobject obj,
+ jint name )
+{
+ const char * tmpString=0;
+
+ if ( disp__glGetString == NULL )
+ return (*env)->NewStringUTF(env, _gl_n_a_string);
+
+ tmpString = disp__glGetString ( /* jint */ name);
+ if(tmpString==NULL)
+ tmpString=_gl_n_a_string;
+
+ return (*env)->NewStringUTF(env, tmpString);
+}
+
+static const char * _gl_lib_vendor_="Jausoft - Sven Goethel Software Development";
+static const char * _gl_lib_version_="2.8.0.8";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFunc14JauJNI_getNativeVendor ( JNIEnv *env, jobject obj )
+{
+ return (*env)->NewStringUTF(env, _gl_lib_vendor_);
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFunc14JauJNI_getNativeVersion ( JNIEnv *env, jobject obj )
+{
+ return (*env)->NewStringUTF(env, _gl_lib_version_);
+}
+
+/**
+ * C2J Parser Version 3.0
+ * Jausoft - Sven Goethel Software Development
+ * Reading from file: gl-proto-auto.orig.h . . .
+ * Destination-Class: gl4java_GLFunc14JauJNI !
+ */
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glClearIndex ( GLfloat c ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glClearIndex (
+ JNIEnv *env, jobject obj,
+ jfloat c)
+ {
+
+ if ( disp__glClearIndex == NULL ) return;
+
+ disp__glClearIndex (
+ (GLfloat) c
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glClearColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glClearColor (
+ JNIEnv *env, jobject obj,
+ jfloat red,
+ jfloat green,
+ jfloat blue,
+ jfloat alpha)
+ {
+
+ if ( disp__glClearColor == NULL ) return;
+
+ disp__glClearColor (
+ (GLclampf) red,
+ (GLclampf) green,
+ (GLclampf) blue,
+ (GLclampf) alpha
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glClear ( GLbitfield mask ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glClear (
+ JNIEnv *env, jobject obj,
+ jint mask)
+ {
+
+ if ( disp__glClear == NULL ) return;
+
+ disp__glClear (
+ (GLbitfield) mask
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glIndexMask ( GLuint mask ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexMask (
+ JNIEnv *env, jobject obj,
+ jint mask)
+ {
+
+ if ( disp__glIndexMask == NULL ) return;
+
+ disp__glIndexMask (
+ (GLuint) mask
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorMask ( GLboolean red , GLboolean green , GLboolean blue , GLboolean alpha ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorMask (
+ JNIEnv *env, jobject obj,
+ jboolean red,
+ jboolean green,
+ jboolean blue,
+ jboolean alpha)
+ {
+
+ if ( disp__glColorMask == NULL ) return;
+
+ disp__glColorMask (
+ (GLboolean) red,
+ (GLboolean) green,
+ (GLboolean) blue,
+ (GLboolean) alpha
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glAlphaFunc ( GLenum func , GLclampf ref ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glAlphaFunc (
+ JNIEnv *env, jobject obj,
+ jint func,
+ jfloat ref)
+ {
+
+ if ( disp__glAlphaFunc == NULL ) return;
+
+ disp__glAlphaFunc (
+ (GLenum) func,
+ (GLclampf) ref
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBlendFunc ( GLenum sfactor , GLenum dfactor ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBlendFunc (
+ JNIEnv *env, jobject obj,
+ jint sfactor,
+ jint dfactor)
+ {
+
+ if ( disp__glBlendFunc == NULL ) return;
+
+ disp__glBlendFunc (
+ (GLenum) sfactor,
+ (GLenum) dfactor
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLogicOp ( GLenum opcode ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLogicOp (
+ JNIEnv *env, jobject obj,
+ jint opcode)
+ {
+
+ if ( disp__glLogicOp == NULL ) return;
+
+ disp__glLogicOp (
+ (GLenum) opcode
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCullFace ( GLenum mode ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCullFace (
+ JNIEnv *env, jobject obj,
+ jint mode)
+ {
+
+ if ( disp__glCullFace == NULL ) return;
+
+ disp__glCullFace (
+ (GLenum) mode
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFrontFace ( GLenum mode ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFrontFace (
+ JNIEnv *env, jobject obj,
+ jint mode)
+ {
+
+ if ( disp__glFrontFace == NULL ) return;
+
+ disp__glFrontFace (
+ (GLenum) mode
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPointSize ( GLfloat size ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPointSize (
+ JNIEnv *env, jobject obj,
+ jfloat size)
+ {
+
+ if ( disp__glPointSize == NULL ) return;
+
+ disp__glPointSize (
+ (GLfloat) size
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLineWidth ( GLfloat width ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLineWidth (
+ JNIEnv *env, jobject obj,
+ jfloat width)
+ {
+
+ if ( disp__glLineWidth == NULL ) return;
+
+ disp__glLineWidth (
+ (GLfloat) width
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLineStipple ( GLint factor , GLushort pattern ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLineStipple (
+ JNIEnv *env, jobject obj,
+ jint factor,
+ jshort pattern)
+ {
+
+ if ( disp__glLineStipple == NULL ) return;
+
+ disp__glLineStipple (
+ (GLint) factor,
+ (GLushort) pattern
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPolygonMode ( GLenum face , GLenum mode ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPolygonMode (
+ JNIEnv *env, jobject obj,
+ jint face,
+ jint mode)
+ {
+
+ if ( disp__glPolygonMode == NULL ) return;
+
+ disp__glPolygonMode (
+ (GLenum) face,
+ (GLenum) mode
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPolygonOffset ( GLfloat factor , GLfloat units ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPolygonOffset (
+ JNIEnv *env, jobject obj,
+ jfloat factor,
+ jfloat units)
+ {
+
+ if ( disp__glPolygonOffset == NULL ) return;
+
+ disp__glPolygonOffset (
+ (GLfloat) factor,
+ (GLfloat) units
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPolygonStipple ( const GLubyte * mask ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPolygonStipple (
+ JNIEnv *env, jobject obj,
+ jbyteArray mask)
+ {
+ jbyte *ptr0 = NULL;
+
+ if ( disp__glPolygonStipple == NULL ) return;
+
+ if(mask!=NULL)
+ {
+ ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, mask, 0);
+ }
+ disp__glPolygonStipple (
+ (const GLubyte *) ptr0
+ );
+
+ if(mask!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, mask, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetPolygonStipple ( GLubyte * mask ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPolygonStipple (
+ JNIEnv *env, jobject obj,
+ jbyteArray mask)
+ {
+ jboolean isCopiedArray0 = JNI_FALSE;
+ jbyte *ptr0 = NULL;
+
+ if ( disp__glGetPolygonStipple == NULL ) return;
+
+ if(mask!=NULL)
+ {
+ ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, mask, &isCopiedArray0);
+ }
+ disp__glGetPolygonStipple (
+ (GLubyte *) ptr0
+ );
+
+ if(mask!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, mask, ptr0, (isCopiedArray0 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEdgeFlag ( GLboolean flag ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEdgeFlag (
+ JNIEnv *env, jobject obj,
+ jboolean flag)
+ {
+
+ if ( disp__glEdgeFlag == NULL ) return;
+
+ disp__glEdgeFlag (
+ (GLboolean) flag
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEdgeFlagv ( const GLboolean * flag ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEdgeFlagv (
+ JNIEnv *env, jobject obj,
+ jbooleanArray flag)
+ {
+ jboolean *ptr0 = NULL;
+
+ if ( disp__glEdgeFlagv == NULL ) return;
+
+ if(flag!=NULL)
+ {
+ ptr0 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, flag, 0);
+ }
+ disp__glEdgeFlagv (
+ (const GLboolean *) ptr0
+ );
+
+ if(flag!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, flag, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glScissor ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glScissor (
+ JNIEnv *env, jobject obj,
+ jint x,
+ jint y,
+ jint width,
+ jint height)
+ {
+
+ if ( disp__glScissor == NULL ) return;
+
+ disp__glScissor (
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width,
+ (GLsizei) height
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glClipPlane ( GLenum plane , const GLdouble * equation ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glClipPlane (
+ JNIEnv *env, jobject obj,
+ jint plane,
+ jdoubleArray equation)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glClipPlane == NULL ) return;
+
+ if(equation!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, equation, 0);
+ }
+ disp__glClipPlane (
+ (GLenum) plane,
+ (const GLdouble *) ptr1
+ );
+
+ if(equation!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, equation, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetClipPlane ( GLenum plane , GLdouble * equation ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetClipPlane (
+ JNIEnv *env, jobject obj,
+ jint plane,
+ jdoubleArray equation)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glGetClipPlane == NULL ) return;
+
+ if(equation!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, equation, &isCopiedArray1);
+ }
+ disp__glGetClipPlane (
+ (GLenum) plane,
+ (GLdouble *) ptr1
+ );
+
+ if(equation!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, equation, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDrawBuffer ( GLenum mode ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawBuffer (
+ JNIEnv *env, jobject obj,
+ jint mode)
+ {
+
+ if ( disp__glDrawBuffer == NULL ) return;
+
+ disp__glDrawBuffer (
+ (GLenum) mode
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReadBuffer ( GLenum mode ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReadBuffer (
+ JNIEnv *env, jobject obj,
+ jint mode)
+ {
+
+ if ( disp__glReadBuffer == NULL ) return;
+
+ disp__glReadBuffer (
+ (GLenum) mode
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEnable ( GLenum cap ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEnable (
+ JNIEnv *env, jobject obj,
+ jint cap)
+ {
+
+ if ( disp__glEnable == NULL ) return;
+
+ disp__glEnable (
+ (GLenum) cap
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDisable ( GLenum cap ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDisable (
+ JNIEnv *env, jobject obj,
+ jint cap)
+ {
+
+ if ( disp__glDisable == NULL ) return;
+
+ disp__glDisable (
+ (GLenum) cap
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLboolean glIsEnabled ( GLenum cap ) ;
+ * </pre>
+ */
+ JNIEXPORT jboolean JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIsEnabled (
+ JNIEnv *env, jobject obj,
+ jint cap)
+ {
+ jboolean ret;
+
+
+ if ( disp__glIsEnabled == NULL ) return 0;
+
+ ret = (jboolean) disp__glIsEnabled (
+ (GLenum) cap
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEnableClientState ( GLenum cap ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEnableClientState (
+ JNIEnv *env, jobject obj,
+ jint cap)
+ {
+
+ if ( disp__glEnableClientState == NULL ) return;
+
+ disp__glEnableClientState (
+ (GLenum) cap
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDisableClientState ( GLenum cap ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDisableClientState (
+ JNIEnv *env, jobject obj,
+ jint cap)
+ {
+
+ if ( disp__glDisableClientState == NULL ) return;
+
+ disp__glDisableClientState (
+ (GLenum) cap
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetBooleanv ( GLenum pname , GLboolean * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetBooleanv (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jbooleanArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jboolean *ptr1 = NULL;
+
+ if ( disp__glGetBooleanv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetBooleanv (
+ (GLenum) pname,
+ (GLboolean *) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetDoublev ( GLenum pname , GLdouble * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetDoublev (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jdoubleArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glGetDoublev == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetDoublev (
+ (GLenum) pname,
+ (GLdouble *) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetFloatv ( GLenum pname , GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetFloatv (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jfloatArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glGetFloatv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetFloatv (
+ (GLenum) pname,
+ (GLfloat *) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetIntegerv ( GLenum pname , GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetIntegerv (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jintArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jint *ptr1 = NULL;
+
+ if ( disp__glGetIntegerv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetIntegerv (
+ (GLenum) pname,
+ (GLint *) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPushAttrib ( GLbitfield mask ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPushAttrib (
+ JNIEnv *env, jobject obj,
+ jint mask)
+ {
+
+ if ( disp__glPushAttrib == NULL ) return;
+
+ disp__glPushAttrib (
+ (GLbitfield) mask
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPopAttrib ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPopAttrib (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glPopAttrib == NULL ) return;
+
+ disp__glPopAttrib (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPushClientAttrib ( GLbitfield mask ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPushClientAttrib (
+ JNIEnv *env, jobject obj,
+ jint mask)
+ {
+
+ if ( disp__glPushClientAttrib == NULL ) return;
+
+ disp__glPushClientAttrib (
+ (GLbitfield) mask
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPopClientAttrib ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPopClientAttrib (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glPopClientAttrib == NULL ) return;
+
+ disp__glPopClientAttrib (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLint glRenderMode ( GLenum mode ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRenderMode (
+ JNIEnv *env, jobject obj,
+ jint mode)
+ {
+ jint ret;
+
+
+ if ( disp__glRenderMode == NULL ) return 0;
+
+ ret = (jint) disp__glRenderMode (
+ (GLenum) mode
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLenum glGetError ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetError (
+ JNIEnv *env, jobject obj)
+ {
+ jint ret;
+
+
+ if ( disp__glGetError == NULL ) return 0;
+
+ ret = (jint) disp__glGetError (
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFinish ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFinish (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glFinish == NULL ) return;
+
+ disp__glFinish (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFlush ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFlush (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glFlush == NULL ) return;
+
+ disp__glFlush (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glHint ( GLenum target , GLenum mode ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glHint (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint mode)
+ {
+
+ if ( disp__glHint == NULL ) return;
+
+ disp__glHint (
+ (GLenum) target,
+ (GLenum) mode
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glClearDepth ( GLclampd depth ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glClearDepth (
+ JNIEnv *env, jobject obj,
+ jdouble depth)
+ {
+
+ if ( disp__glClearDepth == NULL ) return;
+
+ disp__glClearDepth (
+ (GLclampd) depth
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDepthFunc ( GLenum func ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDepthFunc (
+ JNIEnv *env, jobject obj,
+ jint func)
+ {
+
+ if ( disp__glDepthFunc == NULL ) return;
+
+ disp__glDepthFunc (
+ (GLenum) func
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDepthMask ( GLboolean flag ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDepthMask (
+ JNIEnv *env, jobject obj,
+ jboolean flag)
+ {
+
+ if ( disp__glDepthMask == NULL ) return;
+
+ disp__glDepthMask (
+ (GLboolean) flag
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDepthRange ( GLclampd near_val , GLclampd far_val ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDepthRange (
+ JNIEnv *env, jobject obj,
+ jdouble near_val,
+ jdouble far_val)
+ {
+
+ if ( disp__glDepthRange == NULL ) return;
+
+ disp__glDepthRange (
+ (GLclampd) near_val,
+ (GLclampd) far_val
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glClearAccum ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glClearAccum (
+ JNIEnv *env, jobject obj,
+ jfloat red,
+ jfloat green,
+ jfloat blue,
+ jfloat alpha)
+ {
+
+ if ( disp__glClearAccum == NULL ) return;
+
+ disp__glClearAccum (
+ (GLfloat) red,
+ (GLfloat) green,
+ (GLfloat) blue,
+ (GLfloat) alpha
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glAccum ( GLenum op , GLfloat value ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glAccum (
+ JNIEnv *env, jobject obj,
+ jint op,
+ jfloat value)
+ {
+
+ if ( disp__glAccum == NULL ) return;
+
+ disp__glAccum (
+ (GLenum) op,
+ (GLfloat) value
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMatrixMode ( GLenum mode ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMatrixMode (
+ JNIEnv *env, jobject obj,
+ jint mode)
+ {
+
+ if ( disp__glMatrixMode == NULL ) return;
+
+ disp__glMatrixMode (
+ (GLenum) mode
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glOrtho ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glOrtho (
+ JNIEnv *env, jobject obj,
+ jdouble left,
+ jdouble right,
+ jdouble bottom,
+ jdouble top,
+ jdouble near_val,
+ jdouble far_val)
+ {
+
+ if ( disp__glOrtho == NULL ) return;
+
+ disp__glOrtho (
+ (GLdouble) left,
+ (GLdouble) right,
+ (GLdouble) bottom,
+ (GLdouble) top,
+ (GLdouble) near_val,
+ (GLdouble) far_val
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFrustum ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFrustum (
+ JNIEnv *env, jobject obj,
+ jdouble left,
+ jdouble right,
+ jdouble bottom,
+ jdouble top,
+ jdouble near_val,
+ jdouble far_val)
+ {
+
+ if ( disp__glFrustum == NULL ) return;
+
+ disp__glFrustum (
+ (GLdouble) left,
+ (GLdouble) right,
+ (GLdouble) bottom,
+ (GLdouble) top,
+ (GLdouble) near_val,
+ (GLdouble) far_val
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glViewport ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glViewport (
+ JNIEnv *env, jobject obj,
+ jint x,
+ jint y,
+ jint width,
+ jint height)
+ {
+
+ if ( disp__glViewport == NULL ) return;
+
+ disp__glViewport (
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width,
+ (GLsizei) height
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPushMatrix ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPushMatrix (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glPushMatrix == NULL ) return;
+
+ disp__glPushMatrix (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPopMatrix ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPopMatrix (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glPopMatrix == NULL ) return;
+
+ disp__glPopMatrix (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLoadIdentity ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLoadIdentity (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glLoadIdentity == NULL ) return;
+
+ disp__glLoadIdentity (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLoadMatrixd ( const GLdouble * m ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLoadMatrixd (
+ JNIEnv *env, jobject obj,
+ jdoubleArray m)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glLoadMatrixd == NULL ) return;
+
+ if(m!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, m, 0);
+ }
+ disp__glLoadMatrixd (
+ (const GLdouble *) ptr0
+ );
+
+ if(m!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, m, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLoadMatrixf ( const GLfloat * m ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLoadMatrixf (
+ JNIEnv *env, jobject obj,
+ jfloatArray m)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glLoadMatrixf == NULL ) return;
+
+ if(m!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, m, 0);
+ }
+ disp__glLoadMatrixf (
+ (const GLfloat *) ptr0
+ );
+
+ if(m!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, m, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultMatrixd ( const GLdouble * m ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultMatrixd (
+ JNIEnv *env, jobject obj,
+ jdoubleArray m)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glMultMatrixd == NULL ) return;
+
+ if(m!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, m, 0);
+ }
+ disp__glMultMatrixd (
+ (const GLdouble *) ptr0
+ );
+
+ if(m!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, m, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultMatrixf ( const GLfloat * m ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultMatrixf (
+ JNIEnv *env, jobject obj,
+ jfloatArray m)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glMultMatrixf == NULL ) return;
+
+ if(m!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, m, 0);
+ }
+ disp__glMultMatrixf (
+ (const GLfloat *) ptr0
+ );
+
+ if(m!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, m, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRotated ( GLdouble angle , GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRotated (
+ JNIEnv *env, jobject obj,
+ jdouble angle,
+ jdouble x,
+ jdouble y,
+ jdouble z)
+ {
+
+ if ( disp__glRotated == NULL ) return;
+
+ disp__glRotated (
+ (GLdouble) angle,
+ (GLdouble) x,
+ (GLdouble) y,
+ (GLdouble) z
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRotatef ( GLfloat angle , GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRotatef (
+ JNIEnv *env, jobject obj,
+ jfloat angle,
+ jfloat x,
+ jfloat y,
+ jfloat z)
+ {
+
+ if ( disp__glRotatef == NULL ) return;
+
+ disp__glRotatef (
+ (GLfloat) angle,
+ (GLfloat) x,
+ (GLfloat) y,
+ (GLfloat) z
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glScaled ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glScaled (
+ JNIEnv *env, jobject obj,
+ jdouble x,
+ jdouble y,
+ jdouble z)
+ {
+
+ if ( disp__glScaled == NULL ) return;
+
+ disp__glScaled (
+ (GLdouble) x,
+ (GLdouble) y,
+ (GLdouble) z
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glScalef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glScalef (
+ JNIEnv *env, jobject obj,
+ jfloat x,
+ jfloat y,
+ jfloat z)
+ {
+
+ if ( disp__glScalef == NULL ) return;
+
+ disp__glScalef (
+ (GLfloat) x,
+ (GLfloat) y,
+ (GLfloat) z
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTranslated ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTranslated (
+ JNIEnv *env, jobject obj,
+ jdouble x,
+ jdouble y,
+ jdouble z)
+ {
+
+ if ( disp__glTranslated == NULL ) return;
+
+ disp__glTranslated (
+ (GLdouble) x,
+ (GLdouble) y,
+ (GLdouble) z
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTranslatef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTranslatef (
+ JNIEnv *env, jobject obj,
+ jfloat x,
+ jfloat y,
+ jfloat z)
+ {
+
+ if ( disp__glTranslatef == NULL ) return;
+
+ disp__glTranslatef (
+ (GLfloat) x,
+ (GLfloat) y,
+ (GLfloat) z
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLboolean glIsList ( GLuint list ) ;
+ * </pre>
+ */
+ JNIEXPORT jboolean JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIsList (
+ JNIEnv *env, jobject obj,
+ jint list)
+ {
+ jboolean ret;
+
+
+ if ( disp__glIsList == NULL ) return 0;
+
+ ret = (jboolean) disp__glIsList (
+ (GLuint) list
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDeleteLists ( GLuint list , GLsizei range ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDeleteLists (
+ JNIEnv *env, jobject obj,
+ jint list,
+ jint range)
+ {
+
+ if ( disp__glDeleteLists == NULL ) return;
+
+ disp__glDeleteLists (
+ (GLuint) list,
+ (GLsizei) range
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLuint glGenLists ( GLsizei range ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGenLists (
+ JNIEnv *env, jobject obj,
+ jint range)
+ {
+ jint ret;
+
+
+ if ( disp__glGenLists == NULL ) return 0;
+
+ ret = (jint) disp__glGenLists (
+ (GLsizei) range
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNewList ( GLuint list , GLenum mode ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNewList (
+ JNIEnv *env, jobject obj,
+ jint list,
+ jint mode)
+ {
+
+ if ( disp__glNewList == NULL ) return;
+
+ disp__glNewList (
+ (GLuint) list,
+ (GLenum) mode
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEndList ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEndList (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glEndList == NULL ) return;
+
+ disp__glEndList (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCallList ( GLuint list ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCallList (
+ JNIEnv *env, jobject obj,
+ jint list)
+ {
+
+ if ( disp__glCallList == NULL ) return;
+
+ disp__glCallList (
+ (GLuint) list
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCallLists ( GLsizei n , GLenum type , const GLvoid * lists ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCallLists__II_3B (
+ JNIEnv *env, jobject obj,
+ jint n,
+ jint type,
+ jbyteArray lists)
+ {
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glCallLists == NULL ) return;
+
+ if(lists!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, lists, 0);
+ }
+ disp__glCallLists (
+ (GLsizei) n,
+ (GLenum) type,
+ (const GLvoid *) ptr2
+ );
+
+ if(lists!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, lists, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCallLists__II_3S (
+ JNIEnv *env, jobject obj,
+ jint n,
+ jint type,
+ jshortArray lists)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glCallLists == NULL ) return;
+
+ if(lists!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, lists, 0);
+ }
+ disp__glCallLists (
+ (GLsizei) n,
+ (GLenum) type,
+ (const GLvoid *) ptr2
+ );
+
+ if(lists!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, lists, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCallLists__II_3I (
+ JNIEnv *env, jobject obj,
+ jint n,
+ jint type,
+ jintArray lists)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glCallLists == NULL ) return;
+
+ if(lists!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, lists, 0);
+ }
+ disp__glCallLists (
+ (GLsizei) n,
+ (GLenum) type,
+ (const GLvoid *) ptr2
+ );
+
+ if(lists!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, lists, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCallLists__II_3F (
+ JNIEnv *env, jobject obj,
+ jint n,
+ jint type,
+ jfloatArray lists)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glCallLists == NULL ) return;
+
+ if(lists!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, lists, 0);
+ }
+ disp__glCallLists (
+ (GLsizei) n,
+ (GLenum) type,
+ (const GLvoid *) ptr2
+ );
+
+ if(lists!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, lists, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCallLists__II_3D (
+ JNIEnv *env, jobject obj,
+ jint n,
+ jint type,
+ jdoubleArray lists)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glCallLists == NULL ) return;
+
+ if(lists!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, lists, 0);
+ }
+ disp__glCallLists (
+ (GLsizei) n,
+ (GLenum) type,
+ (const GLvoid *) ptr2
+ );
+
+ if(lists!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, lists, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCallLists__II_3Z (
+ JNIEnv *env, jobject obj,
+ jint n,
+ jint type,
+ jbooleanArray lists)
+ {
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glCallLists == NULL ) return;
+
+ if(lists!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, lists, 0);
+ }
+ disp__glCallLists (
+ (GLsizei) n,
+ (GLenum) type,
+ (const GLvoid *) ptr2
+ );
+
+ if(lists!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, lists, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCallLists__II_3J (
+ JNIEnv *env, jobject obj,
+ jint n,
+ jint type,
+ jlongArray lists)
+ {
+ jlong *ptr2 = NULL;
+
+ if ( disp__glCallLists == NULL ) return;
+
+ if(lists!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, lists, 0);
+ }
+ disp__glCallLists (
+ (GLsizei) n,
+ (GLenum) type,
+ (const GLvoid *) ptr2
+ );
+
+ if(lists!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, lists, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCallLists__IILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint n,
+ jint type,
+ jobject lists)
+ {
+ void *ptr2 = NULL;
+
+ if ( disp__glCallLists == NULL ) return;
+
+ if(lists!=NULL)
+ {
+ ptr2 = (*env)->GetDirectBufferAddress(env, lists);
+ if (ptr2 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 2 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glCallLists (
+ (GLsizei) n,
+ (GLenum) type,
+ (const GLvoid *) ptr2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glListBase ( GLuint base ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glListBase (
+ JNIEnv *env, jobject obj,
+ jint base)
+ {
+
+ if ( disp__glListBase == NULL ) return;
+
+ disp__glListBase (
+ (GLuint) base
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBegin ( GLenum mode ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBegin (
+ JNIEnv *env, jobject obj,
+ jint mode)
+ {
+
+ if ( disp__glBegin == NULL ) return;
+
+ disp__glBegin (
+ (GLenum) mode
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEnd ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEnd (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glEnd == NULL ) return;
+
+ disp__glEnd (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex2d ( GLdouble x , GLdouble y ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex2d (
+ JNIEnv *env, jobject obj,
+ jdouble x,
+ jdouble y)
+ {
+
+ if ( disp__glVertex2d == NULL ) return;
+
+ disp__glVertex2d (
+ (GLdouble) x,
+ (GLdouble) y
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex2f ( GLfloat x , GLfloat y ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex2f (
+ JNIEnv *env, jobject obj,
+ jfloat x,
+ jfloat y)
+ {
+
+ if ( disp__glVertex2f == NULL ) return;
+
+ disp__glVertex2f (
+ (GLfloat) x,
+ (GLfloat) y
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex2i ( GLint x , GLint y ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex2i (
+ JNIEnv *env, jobject obj,
+ jint x,
+ jint y)
+ {
+
+ if ( disp__glVertex2i == NULL ) return;
+
+ disp__glVertex2i (
+ (GLint) x,
+ (GLint) y
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex2s ( GLshort x , GLshort y ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex2s (
+ JNIEnv *env, jobject obj,
+ jshort x,
+ jshort y)
+ {
+
+ if ( disp__glVertex2s == NULL ) return;
+
+ disp__glVertex2s (
+ (GLshort) x,
+ (GLshort) y
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex3d (
+ JNIEnv *env, jobject obj,
+ jdouble x,
+ jdouble y,
+ jdouble z)
+ {
+
+ if ( disp__glVertex3d == NULL ) return;
+
+ disp__glVertex3d (
+ (GLdouble) x,
+ (GLdouble) y,
+ (GLdouble) z
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex3f (
+ JNIEnv *env, jobject obj,
+ jfloat x,
+ jfloat y,
+ jfloat z)
+ {
+
+ if ( disp__glVertex3f == NULL ) return;
+
+ disp__glVertex3f (
+ (GLfloat) x,
+ (GLfloat) y,
+ (GLfloat) z
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex3i ( GLint x , GLint y , GLint z ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex3i (
+ JNIEnv *env, jobject obj,
+ jint x,
+ jint y,
+ jint z)
+ {
+
+ if ( disp__glVertex3i == NULL ) return;
+
+ disp__glVertex3i (
+ (GLint) x,
+ (GLint) y,
+ (GLint) z
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex3s ( GLshort x , GLshort y , GLshort z ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex3s (
+ JNIEnv *env, jobject obj,
+ jshort x,
+ jshort y,
+ jshort z)
+ {
+
+ if ( disp__glVertex3s == NULL ) return;
+
+ disp__glVertex3s (
+ (GLshort) x,
+ (GLshort) y,
+ (GLshort) z
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex4d (
+ JNIEnv *env, jobject obj,
+ jdouble x,
+ jdouble y,
+ jdouble z,
+ jdouble w)
+ {
+
+ if ( disp__glVertex4d == NULL ) return;
+
+ disp__glVertex4d (
+ (GLdouble) x,
+ (GLdouble) y,
+ (GLdouble) z,
+ (GLdouble) w
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex4f (
+ JNIEnv *env, jobject obj,
+ jfloat x,
+ jfloat y,
+ jfloat z,
+ jfloat w)
+ {
+
+ if ( disp__glVertex4f == NULL ) return;
+
+ disp__glVertex4f (
+ (GLfloat) x,
+ (GLfloat) y,
+ (GLfloat) z,
+ (GLfloat) w
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex4i (
+ JNIEnv *env, jobject obj,
+ jint x,
+ jint y,
+ jint z,
+ jint w)
+ {
+
+ if ( disp__glVertex4i == NULL ) return;
+
+ disp__glVertex4i (
+ (GLint) x,
+ (GLint) y,
+ (GLint) z,
+ (GLint) w
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex4s (
+ JNIEnv *env, jobject obj,
+ jshort x,
+ jshort y,
+ jshort z,
+ jshort w)
+ {
+
+ if ( disp__glVertex4s == NULL ) return;
+
+ disp__glVertex4s (
+ (GLshort) x,
+ (GLshort) y,
+ (GLshort) z,
+ (GLshort) w
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex2dv ( const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex2dv (
+ JNIEnv *env, jobject obj,
+ jdoubleArray v)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glVertex2dv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glVertex2dv (
+ (const GLdouble *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex2fv ( const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex2fv (
+ JNIEnv *env, jobject obj,
+ jfloatArray v)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glVertex2fv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glVertex2fv (
+ (const GLfloat *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex2iv ( const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex2iv (
+ JNIEnv *env, jobject obj,
+ jintArray v)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glVertex2iv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glVertex2iv (
+ (const GLint *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex2sv ( const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex2sv (
+ JNIEnv *env, jobject obj,
+ jshortArray v)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glVertex2sv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glVertex2sv (
+ (const GLshort *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex3dv ( const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex3dv (
+ JNIEnv *env, jobject obj,
+ jdoubleArray v)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glVertex3dv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glVertex3dv (
+ (const GLdouble *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex3fv ( const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex3fv (
+ JNIEnv *env, jobject obj,
+ jfloatArray v)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glVertex3fv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glVertex3fv (
+ (const GLfloat *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex3iv ( const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex3iv (
+ JNIEnv *env, jobject obj,
+ jintArray v)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glVertex3iv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glVertex3iv (
+ (const GLint *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex3sv ( const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex3sv (
+ JNIEnv *env, jobject obj,
+ jshortArray v)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glVertex3sv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glVertex3sv (
+ (const GLshort *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex4dv ( const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex4dv (
+ JNIEnv *env, jobject obj,
+ jdoubleArray v)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glVertex4dv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glVertex4dv (
+ (const GLdouble *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex4fv ( const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex4fv (
+ JNIEnv *env, jobject obj,
+ jfloatArray v)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glVertex4fv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glVertex4fv (
+ (const GLfloat *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex4iv ( const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex4iv (
+ JNIEnv *env, jobject obj,
+ jintArray v)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glVertex4iv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glVertex4iv (
+ (const GLint *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertex4sv ( const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertex4sv (
+ JNIEnv *env, jobject obj,
+ jshortArray v)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glVertex4sv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glVertex4sv (
+ (const GLshort *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormal3b ( GLbyte nx , GLbyte ny , GLbyte nz ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormal3b (
+ JNIEnv *env, jobject obj,
+ jbyte nx,
+ jbyte ny,
+ jbyte nz)
+ {
+
+ if ( disp__glNormal3b == NULL ) return;
+
+ disp__glNormal3b (
+ (GLbyte) nx,
+ (GLbyte) ny,
+ (GLbyte) nz
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormal3d ( GLdouble nx , GLdouble ny , GLdouble nz ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormal3d (
+ JNIEnv *env, jobject obj,
+ jdouble nx,
+ jdouble ny,
+ jdouble nz)
+ {
+
+ if ( disp__glNormal3d == NULL ) return;
+
+ disp__glNormal3d (
+ (GLdouble) nx,
+ (GLdouble) ny,
+ (GLdouble) nz
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormal3f ( GLfloat nx , GLfloat ny , GLfloat nz ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormal3f (
+ JNIEnv *env, jobject obj,
+ jfloat nx,
+ jfloat ny,
+ jfloat nz)
+ {
+
+ if ( disp__glNormal3f == NULL ) return;
+
+ disp__glNormal3f (
+ (GLfloat) nx,
+ (GLfloat) ny,
+ (GLfloat) nz
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormal3i ( GLint nx , GLint ny , GLint nz ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormal3i (
+ JNIEnv *env, jobject obj,
+ jint nx,
+ jint ny,
+ jint nz)
+ {
+
+ if ( disp__glNormal3i == NULL ) return;
+
+ disp__glNormal3i (
+ (GLint) nx,
+ (GLint) ny,
+ (GLint) nz
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormal3s ( GLshort nx , GLshort ny , GLshort nz ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormal3s (
+ JNIEnv *env, jobject obj,
+ jshort nx,
+ jshort ny,
+ jshort nz)
+ {
+
+ if ( disp__glNormal3s == NULL ) return;
+
+ disp__glNormal3s (
+ (GLshort) nx,
+ (GLshort) ny,
+ (GLshort) nz
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormal3bv ( const GLbyte * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormal3bv (
+ JNIEnv *env, jobject obj,
+ jbyteArray v)
+ {
+ jbyte *ptr0 = NULL;
+
+ if ( disp__glNormal3bv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glNormal3bv (
+ (const GLbyte *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormal3dv ( const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormal3dv (
+ JNIEnv *env, jobject obj,
+ jdoubleArray v)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glNormal3dv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glNormal3dv (
+ (const GLdouble *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormal3fv ( const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormal3fv (
+ JNIEnv *env, jobject obj,
+ jfloatArray v)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glNormal3fv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glNormal3fv (
+ (const GLfloat *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormal3iv ( const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormal3iv (
+ JNIEnv *env, jobject obj,
+ jintArray v)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glNormal3iv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glNormal3iv (
+ (const GLint *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormal3sv ( const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormal3sv (
+ JNIEnv *env, jobject obj,
+ jshortArray v)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glNormal3sv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glNormal3sv (
+ (const GLshort *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glIndexd ( GLdouble c ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexd (
+ JNIEnv *env, jobject obj,
+ jdouble c)
+ {
+
+ if ( disp__glIndexd == NULL ) return;
+
+ disp__glIndexd (
+ (GLdouble) c
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glIndexf ( GLfloat c ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexf (
+ JNIEnv *env, jobject obj,
+ jfloat c)
+ {
+
+ if ( disp__glIndexf == NULL ) return;
+
+ disp__glIndexf (
+ (GLfloat) c
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glIndexi ( GLint c ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexi (
+ JNIEnv *env, jobject obj,
+ jint c)
+ {
+
+ if ( disp__glIndexi == NULL ) return;
+
+ disp__glIndexi (
+ (GLint) c
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glIndexs ( GLshort c ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexs (
+ JNIEnv *env, jobject obj,
+ jshort c)
+ {
+
+ if ( disp__glIndexs == NULL ) return;
+
+ disp__glIndexs (
+ (GLshort) c
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glIndexub ( GLubyte c ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexub (
+ JNIEnv *env, jobject obj,
+ jbyte c)
+ {
+
+ if ( disp__glIndexub == NULL ) return;
+
+ disp__glIndexub (
+ (GLubyte) c
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glIndexdv ( const GLdouble * c ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexdv (
+ JNIEnv *env, jobject obj,
+ jdoubleArray c)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glIndexdv == NULL ) return;
+
+ if(c!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, c, 0);
+ }
+ disp__glIndexdv (
+ (const GLdouble *) ptr0
+ );
+
+ if(c!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, c, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glIndexfv ( const GLfloat * c ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexfv (
+ JNIEnv *env, jobject obj,
+ jfloatArray c)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glIndexfv == NULL ) return;
+
+ if(c!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, c, 0);
+ }
+ disp__glIndexfv (
+ (const GLfloat *) ptr0
+ );
+
+ if(c!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, c, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glIndexiv ( const GLint * c ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexiv (
+ JNIEnv *env, jobject obj,
+ jintArray c)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glIndexiv == NULL ) return;
+
+ if(c!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, c, 0);
+ }
+ disp__glIndexiv (
+ (const GLint *) ptr0
+ );
+
+ if(c!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, c, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glIndexsv ( const GLshort * c ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexsv (
+ JNIEnv *env, jobject obj,
+ jshortArray c)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glIndexsv == NULL ) return;
+
+ if(c!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, c, 0);
+ }
+ disp__glIndexsv (
+ (const GLshort *) ptr0
+ );
+
+ if(c!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, c, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glIndexubv ( const GLubyte * c ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexubv (
+ JNIEnv *env, jobject obj,
+ jbyteArray c)
+ {
+ jbyte *ptr0 = NULL;
+
+ if ( disp__glIndexubv == NULL ) return;
+
+ if(c!=NULL)
+ {
+ ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, c, 0);
+ }
+ disp__glIndexubv (
+ (const GLubyte *) ptr0
+ );
+
+ if(c!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, c, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3b ( GLbyte red , GLbyte green , GLbyte blue ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3b (
+ JNIEnv *env, jobject obj,
+ jbyte red,
+ jbyte green,
+ jbyte blue)
+ {
+
+ if ( disp__glColor3b == NULL ) return;
+
+ disp__glColor3b (
+ (GLbyte) red,
+ (GLbyte) green,
+ (GLbyte) blue
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3d ( GLdouble red , GLdouble green , GLdouble blue ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3d (
+ JNIEnv *env, jobject obj,
+ jdouble red,
+ jdouble green,
+ jdouble blue)
+ {
+
+ if ( disp__glColor3d == NULL ) return;
+
+ disp__glColor3d (
+ (GLdouble) red,
+ (GLdouble) green,
+ (GLdouble) blue
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3f ( GLfloat red , GLfloat green , GLfloat blue ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3f (
+ JNIEnv *env, jobject obj,
+ jfloat red,
+ jfloat green,
+ jfloat blue)
+ {
+
+ if ( disp__glColor3f == NULL ) return;
+
+ disp__glColor3f (
+ (GLfloat) red,
+ (GLfloat) green,
+ (GLfloat) blue
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3i ( GLint red , GLint green , GLint blue ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3i (
+ JNIEnv *env, jobject obj,
+ jint red,
+ jint green,
+ jint blue)
+ {
+
+ if ( disp__glColor3i == NULL ) return;
+
+ disp__glColor3i (
+ (GLint) red,
+ (GLint) green,
+ (GLint) blue
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3s ( GLshort red , GLshort green , GLshort blue ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3s (
+ JNIEnv *env, jobject obj,
+ jshort red,
+ jshort green,
+ jshort blue)
+ {
+
+ if ( disp__glColor3s == NULL ) return;
+
+ disp__glColor3s (
+ (GLshort) red,
+ (GLshort) green,
+ (GLshort) blue
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3ub ( GLubyte red , GLubyte green , GLubyte blue ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3ub (
+ JNIEnv *env, jobject obj,
+ jbyte red,
+ jbyte green,
+ jbyte blue)
+ {
+
+ if ( disp__glColor3ub == NULL ) return;
+
+ disp__glColor3ub (
+ (GLubyte) red,
+ (GLubyte) green,
+ (GLubyte) blue
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3ui ( GLuint red , GLuint green , GLuint blue ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3ui (
+ JNIEnv *env, jobject obj,
+ jint red,
+ jint green,
+ jint blue)
+ {
+
+ if ( disp__glColor3ui == NULL ) return;
+
+ disp__glColor3ui (
+ (GLuint) red,
+ (GLuint) green,
+ (GLuint) blue
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3us ( GLushort red , GLushort green , GLushort blue ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3us (
+ JNIEnv *env, jobject obj,
+ jshort red,
+ jshort green,
+ jshort blue)
+ {
+
+ if ( disp__glColor3us == NULL ) return;
+
+ disp__glColor3us (
+ (GLushort) red,
+ (GLushort) green,
+ (GLushort) blue
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4b ( GLbyte red , GLbyte green , GLbyte blue , GLbyte alpha ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4b (
+ JNIEnv *env, jobject obj,
+ jbyte red,
+ jbyte green,
+ jbyte blue,
+ jbyte alpha)
+ {
+
+ if ( disp__glColor4b == NULL ) return;
+
+ disp__glColor4b (
+ (GLbyte) red,
+ (GLbyte) green,
+ (GLbyte) blue,
+ (GLbyte) alpha
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4d ( GLdouble red , GLdouble green , GLdouble blue , GLdouble alpha ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4d (
+ JNIEnv *env, jobject obj,
+ jdouble red,
+ jdouble green,
+ jdouble blue,
+ jdouble alpha)
+ {
+
+ if ( disp__glColor4d == NULL ) return;
+
+ disp__glColor4d (
+ (GLdouble) red,
+ (GLdouble) green,
+ (GLdouble) blue,
+ (GLdouble) alpha
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4f ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4f (
+ JNIEnv *env, jobject obj,
+ jfloat red,
+ jfloat green,
+ jfloat blue,
+ jfloat alpha)
+ {
+
+ if ( disp__glColor4f == NULL ) return;
+
+ disp__glColor4f (
+ (GLfloat) red,
+ (GLfloat) green,
+ (GLfloat) blue,
+ (GLfloat) alpha
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4i ( GLint red , GLint green , GLint blue , GLint alpha ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4i (
+ JNIEnv *env, jobject obj,
+ jint red,
+ jint green,
+ jint blue,
+ jint alpha)
+ {
+
+ if ( disp__glColor4i == NULL ) return;
+
+ disp__glColor4i (
+ (GLint) red,
+ (GLint) green,
+ (GLint) blue,
+ (GLint) alpha
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4s ( GLshort red , GLshort green , GLshort blue , GLshort alpha ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4s (
+ JNIEnv *env, jobject obj,
+ jshort red,
+ jshort green,
+ jshort blue,
+ jshort alpha)
+ {
+
+ if ( disp__glColor4s == NULL ) return;
+
+ disp__glColor4s (
+ (GLshort) red,
+ (GLshort) green,
+ (GLshort) blue,
+ (GLshort) alpha
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4ub ( GLubyte red , GLubyte green , GLubyte blue , GLubyte alpha ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4ub (
+ JNIEnv *env, jobject obj,
+ jbyte red,
+ jbyte green,
+ jbyte blue,
+ jbyte alpha)
+ {
+
+ if ( disp__glColor4ub == NULL ) return;
+
+ disp__glColor4ub (
+ (GLubyte) red,
+ (GLubyte) green,
+ (GLubyte) blue,
+ (GLubyte) alpha
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4ui ( GLuint red , GLuint green , GLuint blue , GLuint alpha ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4ui (
+ JNIEnv *env, jobject obj,
+ jint red,
+ jint green,
+ jint blue,
+ jint alpha)
+ {
+
+ if ( disp__glColor4ui == NULL ) return;
+
+ disp__glColor4ui (
+ (GLuint) red,
+ (GLuint) green,
+ (GLuint) blue,
+ (GLuint) alpha
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4us ( GLushort red , GLushort green , GLushort blue , GLushort alpha ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4us (
+ JNIEnv *env, jobject obj,
+ jshort red,
+ jshort green,
+ jshort blue,
+ jshort alpha)
+ {
+
+ if ( disp__glColor4us == NULL ) return;
+
+ disp__glColor4us (
+ (GLushort) red,
+ (GLushort) green,
+ (GLushort) blue,
+ (GLushort) alpha
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3bv ( const GLbyte * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3bv (
+ JNIEnv *env, jobject obj,
+ jbyteArray v)
+ {
+ jbyte *ptr0 = NULL;
+
+ if ( disp__glColor3bv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glColor3bv (
+ (const GLbyte *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3dv ( const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3dv (
+ JNIEnv *env, jobject obj,
+ jdoubleArray v)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glColor3dv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glColor3dv (
+ (const GLdouble *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3fv ( const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3fv (
+ JNIEnv *env, jobject obj,
+ jfloatArray v)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glColor3fv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glColor3fv (
+ (const GLfloat *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3iv ( const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3iv (
+ JNIEnv *env, jobject obj,
+ jintArray v)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glColor3iv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glColor3iv (
+ (const GLint *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3sv ( const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3sv (
+ JNIEnv *env, jobject obj,
+ jshortArray v)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glColor3sv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glColor3sv (
+ (const GLshort *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3ubv ( const GLubyte * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3ubv (
+ JNIEnv *env, jobject obj,
+ jbyteArray v)
+ {
+ jbyte *ptr0 = NULL;
+
+ if ( disp__glColor3ubv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glColor3ubv (
+ (const GLubyte *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3uiv ( const GLuint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3uiv (
+ JNIEnv *env, jobject obj,
+ jintArray v)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glColor3uiv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glColor3uiv (
+ (const GLuint *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3usv ( const GLushort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3usv (
+ JNIEnv *env, jobject obj,
+ jshortArray v)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glColor3usv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glColor3usv (
+ (const GLushort *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4bv ( const GLbyte * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4bv (
+ JNIEnv *env, jobject obj,
+ jbyteArray v)
+ {
+ jbyte *ptr0 = NULL;
+
+ if ( disp__glColor4bv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glColor4bv (
+ (const GLbyte *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4dv ( const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4dv (
+ JNIEnv *env, jobject obj,
+ jdoubleArray v)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glColor4dv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glColor4dv (
+ (const GLdouble *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4fv ( const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4fv (
+ JNIEnv *env, jobject obj,
+ jfloatArray v)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glColor4fv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glColor4fv (
+ (const GLfloat *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4iv ( const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4iv (
+ JNIEnv *env, jobject obj,
+ jintArray v)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glColor4iv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glColor4iv (
+ (const GLint *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4sv ( const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4sv (
+ JNIEnv *env, jobject obj,
+ jshortArray v)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glColor4sv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glColor4sv (
+ (const GLshort *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4ubv ( const GLubyte * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4ubv (
+ JNIEnv *env, jobject obj,
+ jbyteArray v)
+ {
+ jbyte *ptr0 = NULL;
+
+ if ( disp__glColor4ubv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glColor4ubv (
+ (const GLubyte *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4uiv ( const GLuint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4uiv (
+ JNIEnv *env, jobject obj,
+ jintArray v)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glColor4uiv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glColor4uiv (
+ (const GLuint *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4usv ( const GLushort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4usv (
+ JNIEnv *env, jobject obj,
+ jshortArray v)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glColor4usv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glColor4usv (
+ (const GLushort *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord1d ( GLdouble s ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord1d (
+ JNIEnv *env, jobject obj,
+ jdouble s)
+ {
+
+ if ( disp__glTexCoord1d == NULL ) return;
+
+ disp__glTexCoord1d (
+ (GLdouble) s
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord1f ( GLfloat s ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord1f (
+ JNIEnv *env, jobject obj,
+ jfloat s)
+ {
+
+ if ( disp__glTexCoord1f == NULL ) return;
+
+ disp__glTexCoord1f (
+ (GLfloat) s
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord1i ( GLint s ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord1i (
+ JNIEnv *env, jobject obj,
+ jint s)
+ {
+
+ if ( disp__glTexCoord1i == NULL ) return;
+
+ disp__glTexCoord1i (
+ (GLint) s
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord1s ( GLshort s ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord1s (
+ JNIEnv *env, jobject obj,
+ jshort s)
+ {
+
+ if ( disp__glTexCoord1s == NULL ) return;
+
+ disp__glTexCoord1s (
+ (GLshort) s
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2d ( GLdouble s , GLdouble t ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2d (
+ JNIEnv *env, jobject obj,
+ jdouble s,
+ jdouble t)
+ {
+
+ if ( disp__glTexCoord2d == NULL ) return;
+
+ disp__glTexCoord2d (
+ (GLdouble) s,
+ (GLdouble) t
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2f ( GLfloat s , GLfloat t ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2f (
+ JNIEnv *env, jobject obj,
+ jfloat s,
+ jfloat t)
+ {
+
+ if ( disp__glTexCoord2f == NULL ) return;
+
+ disp__glTexCoord2f (
+ (GLfloat) s,
+ (GLfloat) t
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2i ( GLint s , GLint t ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2i (
+ JNIEnv *env, jobject obj,
+ jint s,
+ jint t)
+ {
+
+ if ( disp__glTexCoord2i == NULL ) return;
+
+ disp__glTexCoord2i (
+ (GLint) s,
+ (GLint) t
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2s ( GLshort s , GLshort t ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2s (
+ JNIEnv *env, jobject obj,
+ jshort s,
+ jshort t)
+ {
+
+ if ( disp__glTexCoord2s == NULL ) return;
+
+ disp__glTexCoord2s (
+ (GLshort) s,
+ (GLshort) t
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord3d ( GLdouble s , GLdouble t , GLdouble r ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord3d (
+ JNIEnv *env, jobject obj,
+ jdouble s,
+ jdouble t,
+ jdouble r)
+ {
+
+ if ( disp__glTexCoord3d == NULL ) return;
+
+ disp__glTexCoord3d (
+ (GLdouble) s,
+ (GLdouble) t,
+ (GLdouble) r
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord3f ( GLfloat s , GLfloat t , GLfloat r ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord3f (
+ JNIEnv *env, jobject obj,
+ jfloat s,
+ jfloat t,
+ jfloat r)
+ {
+
+ if ( disp__glTexCoord3f == NULL ) return;
+
+ disp__glTexCoord3f (
+ (GLfloat) s,
+ (GLfloat) t,
+ (GLfloat) r
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord3i ( GLint s , GLint t , GLint r ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord3i (
+ JNIEnv *env, jobject obj,
+ jint s,
+ jint t,
+ jint r)
+ {
+
+ if ( disp__glTexCoord3i == NULL ) return;
+
+ disp__glTexCoord3i (
+ (GLint) s,
+ (GLint) t,
+ (GLint) r
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord3s ( GLshort s , GLshort t , GLshort r ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord3s (
+ JNIEnv *env, jobject obj,
+ jshort s,
+ jshort t,
+ jshort r)
+ {
+
+ if ( disp__glTexCoord3s == NULL ) return;
+
+ disp__glTexCoord3s (
+ (GLshort) s,
+ (GLshort) t,
+ (GLshort) r
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord4d ( GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord4d (
+ JNIEnv *env, jobject obj,
+ jdouble s,
+ jdouble t,
+ jdouble r,
+ jdouble q)
+ {
+
+ if ( disp__glTexCoord4d == NULL ) return;
+
+ disp__glTexCoord4d (
+ (GLdouble) s,
+ (GLdouble) t,
+ (GLdouble) r,
+ (GLdouble) q
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord4f ( GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord4f (
+ JNIEnv *env, jobject obj,
+ jfloat s,
+ jfloat t,
+ jfloat r,
+ jfloat q)
+ {
+
+ if ( disp__glTexCoord4f == NULL ) return;
+
+ disp__glTexCoord4f (
+ (GLfloat) s,
+ (GLfloat) t,
+ (GLfloat) r,
+ (GLfloat) q
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord4i ( GLint s , GLint t , GLint r , GLint q ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord4i (
+ JNIEnv *env, jobject obj,
+ jint s,
+ jint t,
+ jint r,
+ jint q)
+ {
+
+ if ( disp__glTexCoord4i == NULL ) return;
+
+ disp__glTexCoord4i (
+ (GLint) s,
+ (GLint) t,
+ (GLint) r,
+ (GLint) q
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord4s ( GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord4s (
+ JNIEnv *env, jobject obj,
+ jshort s,
+ jshort t,
+ jshort r,
+ jshort q)
+ {
+
+ if ( disp__glTexCoord4s == NULL ) return;
+
+ disp__glTexCoord4s (
+ (GLshort) s,
+ (GLshort) t,
+ (GLshort) r,
+ (GLshort) q
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord1dv ( const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord1dv (
+ JNIEnv *env, jobject obj,
+ jdoubleArray v)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glTexCoord1dv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glTexCoord1dv (
+ (const GLdouble *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord1fv ( const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord1fv (
+ JNIEnv *env, jobject obj,
+ jfloatArray v)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glTexCoord1fv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glTexCoord1fv (
+ (const GLfloat *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord1iv ( const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord1iv (
+ JNIEnv *env, jobject obj,
+ jintArray v)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glTexCoord1iv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glTexCoord1iv (
+ (const GLint *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord1sv ( const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord1sv (
+ JNIEnv *env, jobject obj,
+ jshortArray v)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glTexCoord1sv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glTexCoord1sv (
+ (const GLshort *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2dv ( const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2dv (
+ JNIEnv *env, jobject obj,
+ jdoubleArray v)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glTexCoord2dv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glTexCoord2dv (
+ (const GLdouble *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2fv ( const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2fv (
+ JNIEnv *env, jobject obj,
+ jfloatArray v)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glTexCoord2fv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glTexCoord2fv (
+ (const GLfloat *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2iv ( const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2iv (
+ JNIEnv *env, jobject obj,
+ jintArray v)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glTexCoord2iv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glTexCoord2iv (
+ (const GLint *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2sv ( const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2sv (
+ JNIEnv *env, jobject obj,
+ jshortArray v)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glTexCoord2sv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glTexCoord2sv (
+ (const GLshort *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord3dv ( const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord3dv (
+ JNIEnv *env, jobject obj,
+ jdoubleArray v)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glTexCoord3dv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glTexCoord3dv (
+ (const GLdouble *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord3fv ( const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord3fv (
+ JNIEnv *env, jobject obj,
+ jfloatArray v)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glTexCoord3fv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glTexCoord3fv (
+ (const GLfloat *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord3iv ( const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord3iv (
+ JNIEnv *env, jobject obj,
+ jintArray v)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glTexCoord3iv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glTexCoord3iv (
+ (const GLint *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord3sv ( const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord3sv (
+ JNIEnv *env, jobject obj,
+ jshortArray v)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glTexCoord3sv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glTexCoord3sv (
+ (const GLshort *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord4dv ( const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord4dv (
+ JNIEnv *env, jobject obj,
+ jdoubleArray v)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glTexCoord4dv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glTexCoord4dv (
+ (const GLdouble *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord4fv ( const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord4fv (
+ JNIEnv *env, jobject obj,
+ jfloatArray v)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glTexCoord4fv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glTexCoord4fv (
+ (const GLfloat *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord4iv ( const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord4iv (
+ JNIEnv *env, jobject obj,
+ jintArray v)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glTexCoord4iv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glTexCoord4iv (
+ (const GLint *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord4sv ( const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord4sv (
+ JNIEnv *env, jobject obj,
+ jshortArray v)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glTexCoord4sv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glTexCoord4sv (
+ (const GLshort *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos2d ( GLdouble x , GLdouble y ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos2d (
+ JNIEnv *env, jobject obj,
+ jdouble x,
+ jdouble y)
+ {
+
+ if ( disp__glRasterPos2d == NULL ) return;
+
+ disp__glRasterPos2d (
+ (GLdouble) x,
+ (GLdouble) y
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos2f ( GLfloat x , GLfloat y ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos2f (
+ JNIEnv *env, jobject obj,
+ jfloat x,
+ jfloat y)
+ {
+
+ if ( disp__glRasterPos2f == NULL ) return;
+
+ disp__glRasterPos2f (
+ (GLfloat) x,
+ (GLfloat) y
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos2i ( GLint x , GLint y ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos2i (
+ JNIEnv *env, jobject obj,
+ jint x,
+ jint y)
+ {
+
+ if ( disp__glRasterPos2i == NULL ) return;
+
+ disp__glRasterPos2i (
+ (GLint) x,
+ (GLint) y
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos2s ( GLshort x , GLshort y ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos2s (
+ JNIEnv *env, jobject obj,
+ jshort x,
+ jshort y)
+ {
+
+ if ( disp__glRasterPos2s == NULL ) return;
+
+ disp__glRasterPos2s (
+ (GLshort) x,
+ (GLshort) y
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos3d (
+ JNIEnv *env, jobject obj,
+ jdouble x,
+ jdouble y,
+ jdouble z)
+ {
+
+ if ( disp__glRasterPos3d == NULL ) return;
+
+ disp__glRasterPos3d (
+ (GLdouble) x,
+ (GLdouble) y,
+ (GLdouble) z
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos3f (
+ JNIEnv *env, jobject obj,
+ jfloat x,
+ jfloat y,
+ jfloat z)
+ {
+
+ if ( disp__glRasterPos3f == NULL ) return;
+
+ disp__glRasterPos3f (
+ (GLfloat) x,
+ (GLfloat) y,
+ (GLfloat) z
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos3i ( GLint x , GLint y , GLint z ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos3i (
+ JNIEnv *env, jobject obj,
+ jint x,
+ jint y,
+ jint z)
+ {
+
+ if ( disp__glRasterPos3i == NULL ) return;
+
+ disp__glRasterPos3i (
+ (GLint) x,
+ (GLint) y,
+ (GLint) z
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos3s ( GLshort x , GLshort y , GLshort z ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos3s (
+ JNIEnv *env, jobject obj,
+ jshort x,
+ jshort y,
+ jshort z)
+ {
+
+ if ( disp__glRasterPos3s == NULL ) return;
+
+ disp__glRasterPos3s (
+ (GLshort) x,
+ (GLshort) y,
+ (GLshort) z
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos4d (
+ JNIEnv *env, jobject obj,
+ jdouble x,
+ jdouble y,
+ jdouble z,
+ jdouble w)
+ {
+
+ if ( disp__glRasterPos4d == NULL ) return;
+
+ disp__glRasterPos4d (
+ (GLdouble) x,
+ (GLdouble) y,
+ (GLdouble) z,
+ (GLdouble) w
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos4f (
+ JNIEnv *env, jobject obj,
+ jfloat x,
+ jfloat y,
+ jfloat z,
+ jfloat w)
+ {
+
+ if ( disp__glRasterPos4f == NULL ) return;
+
+ disp__glRasterPos4f (
+ (GLfloat) x,
+ (GLfloat) y,
+ (GLfloat) z,
+ (GLfloat) w
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos4i (
+ JNIEnv *env, jobject obj,
+ jint x,
+ jint y,
+ jint z,
+ jint w)
+ {
+
+ if ( disp__glRasterPos4i == NULL ) return;
+
+ disp__glRasterPos4i (
+ (GLint) x,
+ (GLint) y,
+ (GLint) z,
+ (GLint) w
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos4s (
+ JNIEnv *env, jobject obj,
+ jshort x,
+ jshort y,
+ jshort z,
+ jshort w)
+ {
+
+ if ( disp__glRasterPos4s == NULL ) return;
+
+ disp__glRasterPos4s (
+ (GLshort) x,
+ (GLshort) y,
+ (GLshort) z,
+ (GLshort) w
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos2dv ( const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos2dv (
+ JNIEnv *env, jobject obj,
+ jdoubleArray v)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glRasterPos2dv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glRasterPos2dv (
+ (const GLdouble *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos2fv ( const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos2fv (
+ JNIEnv *env, jobject obj,
+ jfloatArray v)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glRasterPos2fv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glRasterPos2fv (
+ (const GLfloat *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos2iv ( const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos2iv (
+ JNIEnv *env, jobject obj,
+ jintArray v)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glRasterPos2iv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glRasterPos2iv (
+ (const GLint *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos2sv ( const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos2sv (
+ JNIEnv *env, jobject obj,
+ jshortArray v)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glRasterPos2sv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glRasterPos2sv (
+ (const GLshort *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos3dv ( const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos3dv (
+ JNIEnv *env, jobject obj,
+ jdoubleArray v)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glRasterPos3dv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glRasterPos3dv (
+ (const GLdouble *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos3fv ( const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos3fv (
+ JNIEnv *env, jobject obj,
+ jfloatArray v)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glRasterPos3fv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glRasterPos3fv (
+ (const GLfloat *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos3iv ( const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos3iv (
+ JNIEnv *env, jobject obj,
+ jintArray v)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glRasterPos3iv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glRasterPos3iv (
+ (const GLint *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos3sv ( const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos3sv (
+ JNIEnv *env, jobject obj,
+ jshortArray v)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glRasterPos3sv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glRasterPos3sv (
+ (const GLshort *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos4dv ( const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos4dv (
+ JNIEnv *env, jobject obj,
+ jdoubleArray v)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glRasterPos4dv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glRasterPos4dv (
+ (const GLdouble *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos4fv ( const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos4fv (
+ JNIEnv *env, jobject obj,
+ jfloatArray v)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glRasterPos4fv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glRasterPos4fv (
+ (const GLfloat *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos4iv ( const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos4iv (
+ JNIEnv *env, jobject obj,
+ jintArray v)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glRasterPos4iv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glRasterPos4iv (
+ (const GLint *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRasterPos4sv ( const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRasterPos4sv (
+ JNIEnv *env, jobject obj,
+ jshortArray v)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glRasterPos4sv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glRasterPos4sv (
+ (const GLshort *) ptr0
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRectd ( GLdouble x1 , GLdouble y1 , GLdouble x2 , GLdouble y2 ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRectd (
+ JNIEnv *env, jobject obj,
+ jdouble x1,
+ jdouble y1,
+ jdouble x2,
+ jdouble y2)
+ {
+
+ if ( disp__glRectd == NULL ) return;
+
+ disp__glRectd (
+ (GLdouble) x1,
+ (GLdouble) y1,
+ (GLdouble) x2,
+ (GLdouble) y2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRectf ( GLfloat x1 , GLfloat y1 , GLfloat x2 , GLfloat y2 ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRectf (
+ JNIEnv *env, jobject obj,
+ jfloat x1,
+ jfloat y1,
+ jfloat x2,
+ jfloat y2)
+ {
+
+ if ( disp__glRectf == NULL ) return;
+
+ disp__glRectf (
+ (GLfloat) x1,
+ (GLfloat) y1,
+ (GLfloat) x2,
+ (GLfloat) y2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRecti ( GLint x1 , GLint y1 , GLint x2 , GLint y2 ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRecti (
+ JNIEnv *env, jobject obj,
+ jint x1,
+ jint y1,
+ jint x2,
+ jint y2)
+ {
+
+ if ( disp__glRecti == NULL ) return;
+
+ disp__glRecti (
+ (GLint) x1,
+ (GLint) y1,
+ (GLint) x2,
+ (GLint) y2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRects ( GLshort x1 , GLshort y1 , GLshort x2 , GLshort y2 ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRects (
+ JNIEnv *env, jobject obj,
+ jshort x1,
+ jshort y1,
+ jshort x2,
+ jshort y2)
+ {
+
+ if ( disp__glRects == NULL ) return;
+
+ disp__glRects (
+ (GLshort) x1,
+ (GLshort) y1,
+ (GLshort) x2,
+ (GLshort) y2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRectdv ( const GLdouble * v1 , const GLdouble * v2 ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRectdv (
+ JNIEnv *env, jobject obj,
+ jdoubleArray v1,
+ jdoubleArray v2)
+ {
+ jdouble *ptr0 = NULL;
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glRectdv == NULL ) return;
+
+ if(v1!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v1, 0);
+ }
+ if(v2!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v2, 0);
+ }
+ disp__glRectdv (
+ (const GLdouble *) ptr0,
+ (const GLdouble *) ptr1
+ );
+
+ if(v1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v1, ptr0, JNI_ABORT);
+ }
+ if(v2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v2, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRectfv ( const GLfloat * v1 , const GLfloat * v2 ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRectfv (
+ JNIEnv *env, jobject obj,
+ jfloatArray v1,
+ jfloatArray v2)
+ {
+ jfloat *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glRectfv == NULL ) return;
+
+ if(v1!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v1, 0);
+ }
+ if(v2!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v2, 0);
+ }
+ disp__glRectfv (
+ (const GLfloat *) ptr0,
+ (const GLfloat *) ptr1
+ );
+
+ if(v1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v1, ptr0, JNI_ABORT);
+ }
+ if(v2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v2, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRectiv ( const GLint * v1 , const GLint * v2 ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRectiv (
+ JNIEnv *env, jobject obj,
+ jintArray v1,
+ jintArray v2)
+ {
+ jint *ptr0 = NULL;
+ jint *ptr1 = NULL;
+
+ if ( disp__glRectiv == NULL ) return;
+
+ if(v1!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v1, 0);
+ }
+ if(v2!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v2, 0);
+ }
+ disp__glRectiv (
+ (const GLint *) ptr0,
+ (const GLint *) ptr1
+ );
+
+ if(v1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v1, ptr0, JNI_ABORT);
+ }
+ if(v2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v2, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRectsv ( const GLshort * v1 , const GLshort * v2 ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRectsv (
+ JNIEnv *env, jobject obj,
+ jshortArray v1,
+ jshortArray v2)
+ {
+ jshort *ptr0 = NULL;
+ jshort *ptr1 = NULL;
+
+ if ( disp__glRectsv == NULL ) return;
+
+ if(v1!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v1, 0);
+ }
+ if(v2!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v2, 0);
+ }
+ disp__glRectsv (
+ (const GLshort *) ptr0,
+ (const GLshort *) ptr1
+ );
+
+ if(v1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v1, ptr0, JNI_ABORT);
+ }
+ if(v2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v2, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointer__III_3B (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jbyteArray ptr)
+ {
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glVertexPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glVertexPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointer__III_3S (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jshortArray ptr)
+ {
+ jshort *ptr3 = NULL;
+
+ if ( disp__glVertexPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glVertexPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointer__III_3I (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jintArray ptr)
+ {
+ jint *ptr3 = NULL;
+
+ if ( disp__glVertexPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glVertexPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointer__III_3F (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jfloatArray ptr)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glVertexPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glVertexPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointer__III_3D (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jdoubleArray ptr)
+ {
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glVertexPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glVertexPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointer__III_3Z (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jbooleanArray ptr)
+ {
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glVertexPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glVertexPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointer__III_3J (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jlongArray ptr)
+ {
+ jlong *ptr3 = NULL;
+
+ if ( disp__glVertexPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glVertexPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointer__IIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jobject ptr)
+ {
+ void *ptr3 = NULL;
+
+ if ( disp__glVertexPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, ptr);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glVertexPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormalPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointer__II_3B (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jbyteArray ptr)
+ {
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glNormalPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glNormalPointer (
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointer__II_3S (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jshortArray ptr)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glNormalPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glNormalPointer (
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointer__II_3I (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jintArray ptr)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glNormalPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glNormalPointer (
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointer__II_3F (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jfloatArray ptr)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glNormalPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glNormalPointer (
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointer__II_3D (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jdoubleArray ptr)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glNormalPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glNormalPointer (
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointer__II_3Z (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jbooleanArray ptr)
+ {
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glNormalPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glNormalPointer (
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointer__II_3J (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jlongArray ptr)
+ {
+ jlong *ptr2 = NULL;
+
+ if ( disp__glNormalPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glNormalPointer (
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointer__IILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jobject ptr)
+ {
+ void *ptr2 = NULL;
+
+ if ( disp__glNormalPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr2 = (*env)->GetDirectBufferAddress(env, ptr);
+ if (ptr2 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 2 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glNormalPointer (
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointer__III_3B (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jbyteArray ptr)
+ {
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glColorPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glColorPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointer__III_3S (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jshortArray ptr)
+ {
+ jshort *ptr3 = NULL;
+
+ if ( disp__glColorPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glColorPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointer__III_3I (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jintArray ptr)
+ {
+ jint *ptr3 = NULL;
+
+ if ( disp__glColorPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glColorPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointer__III_3F (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jfloatArray ptr)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glColorPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glColorPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointer__III_3D (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jdoubleArray ptr)
+ {
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glColorPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glColorPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointer__III_3Z (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jbooleanArray ptr)
+ {
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glColorPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glColorPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointer__III_3J (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jlongArray ptr)
+ {
+ jlong *ptr3 = NULL;
+
+ if ( disp__glColorPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glColorPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointer__IIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jobject ptr)
+ {
+ void *ptr3 = NULL;
+
+ if ( disp__glColorPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, ptr);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glColorPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glIndexPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointer__II_3B (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jbyteArray ptr)
+ {
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glIndexPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glIndexPointer (
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointer__II_3S (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jshortArray ptr)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glIndexPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glIndexPointer (
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointer__II_3I (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jintArray ptr)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glIndexPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glIndexPointer (
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointer__II_3F (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jfloatArray ptr)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glIndexPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glIndexPointer (
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointer__II_3D (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jdoubleArray ptr)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glIndexPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glIndexPointer (
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointer__II_3Z (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jbooleanArray ptr)
+ {
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glIndexPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glIndexPointer (
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointer__II_3J (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jlongArray ptr)
+ {
+ jlong *ptr2 = NULL;
+
+ if ( disp__glIndexPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glIndexPointer (
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointer__IILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jobject ptr)
+ {
+ void *ptr2 = NULL;
+
+ if ( disp__glIndexPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr2 = (*env)->GetDirectBufferAddress(env, ptr);
+ if (ptr2 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 2 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glIndexPointer (
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoordPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointer__III_3B (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jbyteArray ptr)
+ {
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glTexCoordPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glTexCoordPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointer__III_3S (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jshortArray ptr)
+ {
+ jshort *ptr3 = NULL;
+
+ if ( disp__glTexCoordPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glTexCoordPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointer__III_3I (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jintArray ptr)
+ {
+ jint *ptr3 = NULL;
+
+ if ( disp__glTexCoordPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glTexCoordPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointer__III_3F (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jfloatArray ptr)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glTexCoordPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glTexCoordPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointer__III_3D (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jdoubleArray ptr)
+ {
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glTexCoordPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glTexCoordPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointer__III_3Z (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jbooleanArray ptr)
+ {
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glTexCoordPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glTexCoordPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointer__III_3J (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jlongArray ptr)
+ {
+ jlong *ptr3 = NULL;
+
+ if ( disp__glTexCoordPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glTexCoordPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointer__IIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jobject ptr)
+ {
+ void *ptr3 = NULL;
+
+ if ( disp__glTexCoordPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, ptr);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glTexCoordPointer (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (const GLvoid *) ptr3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEdgeFlagPointer ( GLsizei stride , const GLvoid * ptr ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEdgeFlagPointer__I_3B (
+ JNIEnv *env, jobject obj,
+ jint stride,
+ jbyteArray ptr)
+ {
+ jbyte *ptr1 = NULL;
+
+ if ( disp__glEdgeFlagPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glEdgeFlagPointer (
+ (GLsizei) stride,
+ (const GLvoid *) ptr1
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEdgeFlagPointer__I_3S (
+ JNIEnv *env, jobject obj,
+ jint stride,
+ jshortArray ptr)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glEdgeFlagPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glEdgeFlagPointer (
+ (GLsizei) stride,
+ (const GLvoid *) ptr1
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEdgeFlagPointer__I_3I (
+ JNIEnv *env, jobject obj,
+ jint stride,
+ jintArray ptr)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glEdgeFlagPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glEdgeFlagPointer (
+ (GLsizei) stride,
+ (const GLvoid *) ptr1
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEdgeFlagPointer__I_3F (
+ JNIEnv *env, jobject obj,
+ jint stride,
+ jfloatArray ptr)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glEdgeFlagPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glEdgeFlagPointer (
+ (GLsizei) stride,
+ (const GLvoid *) ptr1
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEdgeFlagPointer__I_3D (
+ JNIEnv *env, jobject obj,
+ jint stride,
+ jdoubleArray ptr)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glEdgeFlagPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glEdgeFlagPointer (
+ (GLsizei) stride,
+ (const GLvoid *) ptr1
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEdgeFlagPointer__I_3Z (
+ JNIEnv *env, jobject obj,
+ jint stride,
+ jbooleanArray ptr)
+ {
+ jboolean *ptr1 = NULL;
+
+ if ( disp__glEdgeFlagPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glEdgeFlagPointer (
+ (GLsizei) stride,
+ (const GLvoid *) ptr1
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEdgeFlagPointer__I_3J (
+ JNIEnv *env, jobject obj,
+ jint stride,
+ jlongArray ptr)
+ {
+ jlong *ptr1 = NULL;
+
+ if ( disp__glEdgeFlagPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr1 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glEdgeFlagPointer (
+ (GLsizei) stride,
+ (const GLvoid *) ptr1
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEdgeFlagPointer__ILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint stride,
+ jobject ptr)
+ {
+ void *ptr1 = NULL;
+
+ if ( disp__glEdgeFlagPointer == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr1 = (*env)->GetDirectBufferAddress(env, ptr);
+ if (ptr1 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 1 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glEdgeFlagPointer (
+ (GLsizei) stride,
+ (const GLvoid *) ptr1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetPointerv ( GLenum pname , GLvoid * * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPointerv__I_3_3B (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jbyteArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jbyte *ptr1 = NULL;
+
+ if ( disp__glGetPointerv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetPointerv (
+ (GLenum) pname,
+ (GLvoid **) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPointerv__I_3_3S (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jshortArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jshort *ptr1 = NULL;
+
+ if ( disp__glGetPointerv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetPointerv (
+ (GLenum) pname,
+ (GLvoid **) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPointerv__I_3_3I (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jintArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jint *ptr1 = NULL;
+
+ if ( disp__glGetPointerv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetPointerv (
+ (GLenum) pname,
+ (GLvoid **) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPointerv__I_3_3F (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jfloatArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glGetPointerv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetPointerv (
+ (GLenum) pname,
+ (GLvoid **) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPointerv__I_3_3D (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jdoubleArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glGetPointerv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetPointerv (
+ (GLenum) pname,
+ (GLvoid **) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPointerv__I_3_3Z (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jbooleanArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jboolean *ptr1 = NULL;
+
+ if ( disp__glGetPointerv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetPointerv (
+ (GLenum) pname,
+ (GLvoid **) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPointerv__I_3_3J (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jlongArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jlong *ptr1 = NULL;
+
+ if ( disp__glGetPointerv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetPointerv (
+ (GLenum) pname,
+ (GLvoid **) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glArrayElement ( GLint i ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glArrayElement (
+ JNIEnv *env, jobject obj,
+ jint i)
+ {
+
+ if ( disp__glArrayElement == NULL ) return;
+
+ disp__glArrayElement (
+ (GLint) i
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDrawArrays ( GLenum mode , GLint first , GLsizei count ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawArrays (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint first,
+ jint count)
+ {
+
+ if ( disp__glDrawArrays == NULL ) return;
+
+ disp__glDrawArrays (
+ (GLenum) mode,
+ (GLint) first,
+ (GLsizei) count
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDrawElements ( GLenum mode , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawElements__III_3B (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint count,
+ jint type,
+ jbyteArray indices)
+ {
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glDrawElements == NULL ) return;
+
+ if(indices!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+ }
+ disp__glDrawElements (
+ (GLenum) mode,
+ (GLsizei) count,
+ (GLenum) type,
+ (const GLvoid *) ptr3
+ );
+
+ if(indices!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, indices, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawElements__III_3S (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint count,
+ jint type,
+ jshortArray indices)
+ {
+ jshort *ptr3 = NULL;
+
+ if ( disp__glDrawElements == NULL ) return;
+
+ if(indices!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+ }
+ disp__glDrawElements (
+ (GLenum) mode,
+ (GLsizei) count,
+ (GLenum) type,
+ (const GLvoid *) ptr3
+ );
+
+ if(indices!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, indices, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawElements__III_3I (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint count,
+ jint type,
+ jintArray indices)
+ {
+ jint *ptr3 = NULL;
+
+ if ( disp__glDrawElements == NULL ) return;
+
+ if(indices!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+ }
+ disp__glDrawElements (
+ (GLenum) mode,
+ (GLsizei) count,
+ (GLenum) type,
+ (const GLvoid *) ptr3
+ );
+
+ if(indices!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, indices, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawElements__III_3F (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint count,
+ jint type,
+ jfloatArray indices)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glDrawElements == NULL ) return;
+
+ if(indices!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+ }
+ disp__glDrawElements (
+ (GLenum) mode,
+ (GLsizei) count,
+ (GLenum) type,
+ (const GLvoid *) ptr3
+ );
+
+ if(indices!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, indices, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawElements__III_3D (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint count,
+ jint type,
+ jdoubleArray indices)
+ {
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glDrawElements == NULL ) return;
+
+ if(indices!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+ }
+ disp__glDrawElements (
+ (GLenum) mode,
+ (GLsizei) count,
+ (GLenum) type,
+ (const GLvoid *) ptr3
+ );
+
+ if(indices!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, indices, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawElements__III_3Z (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint count,
+ jint type,
+ jbooleanArray indices)
+ {
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glDrawElements == NULL ) return;
+
+ if(indices!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+ }
+ disp__glDrawElements (
+ (GLenum) mode,
+ (GLsizei) count,
+ (GLenum) type,
+ (const GLvoid *) ptr3
+ );
+
+ if(indices!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, indices, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawElements__III_3J (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint count,
+ jint type,
+ jlongArray indices)
+ {
+ jlong *ptr3 = NULL;
+
+ if ( disp__glDrawElements == NULL ) return;
+
+ if(indices!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+ }
+ disp__glDrawElements (
+ (GLenum) mode,
+ (GLsizei) count,
+ (GLenum) type,
+ (const GLvoid *) ptr3
+ );
+
+ if(indices!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, indices, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawElements__IIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint count,
+ jint type,
+ jobject indices)
+ {
+ void *ptr3 = NULL;
+
+ if ( disp__glDrawElements == NULL ) return;
+
+ if(indices!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, indices);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glDrawElements (
+ (GLenum) mode,
+ (GLsizei) count,
+ (GLenum) type,
+ (const GLvoid *) ptr3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glInterleavedArrays ( GLenum format , GLsizei stride , const GLvoid * pointer ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glInterleavedArrays__II_3B (
+ JNIEnv *env, jobject obj,
+ jint format,
+ jint stride,
+ jbyteArray pointer)
+ {
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glInterleavedArrays == NULL ) return;
+
+ if(pointer!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pointer, 0);
+ }
+ disp__glInterleavedArrays (
+ (GLenum) format,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(pointer!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pointer, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glInterleavedArrays__II_3S (
+ JNIEnv *env, jobject obj,
+ jint format,
+ jint stride,
+ jshortArray pointer)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glInterleavedArrays == NULL ) return;
+
+ if(pointer!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pointer, 0);
+ }
+ disp__glInterleavedArrays (
+ (GLenum) format,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(pointer!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pointer, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glInterleavedArrays__II_3I (
+ JNIEnv *env, jobject obj,
+ jint format,
+ jint stride,
+ jintArray pointer)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glInterleavedArrays == NULL ) return;
+
+ if(pointer!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pointer, 0);
+ }
+ disp__glInterleavedArrays (
+ (GLenum) format,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(pointer!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pointer, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glInterleavedArrays__II_3F (
+ JNIEnv *env, jobject obj,
+ jint format,
+ jint stride,
+ jfloatArray pointer)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glInterleavedArrays == NULL ) return;
+
+ if(pointer!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pointer, 0);
+ }
+ disp__glInterleavedArrays (
+ (GLenum) format,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(pointer!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pointer, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glInterleavedArrays__II_3D (
+ JNIEnv *env, jobject obj,
+ jint format,
+ jint stride,
+ jdoubleArray pointer)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glInterleavedArrays == NULL ) return;
+
+ if(pointer!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pointer, 0);
+ }
+ disp__glInterleavedArrays (
+ (GLenum) format,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(pointer!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pointer, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glInterleavedArrays__II_3Z (
+ JNIEnv *env, jobject obj,
+ jint format,
+ jint stride,
+ jbooleanArray pointer)
+ {
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glInterleavedArrays == NULL ) return;
+
+ if(pointer!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pointer, 0);
+ }
+ disp__glInterleavedArrays (
+ (GLenum) format,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(pointer!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pointer, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glInterleavedArrays__II_3J (
+ JNIEnv *env, jobject obj,
+ jint format,
+ jint stride,
+ jlongArray pointer)
+ {
+ jlong *ptr2 = NULL;
+
+ if ( disp__glInterleavedArrays == NULL ) return;
+
+ if(pointer!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pointer, 0);
+ }
+ disp__glInterleavedArrays (
+ (GLenum) format,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ if(pointer!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pointer, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glInterleavedArrays__IILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint format,
+ jint stride,
+ jobject pointer)
+ {
+ void *ptr2 = NULL;
+
+ if ( disp__glInterleavedArrays == NULL ) return;
+
+ if(pointer!=NULL)
+ {
+ ptr2 = (*env)->GetDirectBufferAddress(env, pointer);
+ if (ptr2 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 2 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glInterleavedArrays (
+ (GLenum) format,
+ (GLsizei) stride,
+ (const GLvoid *) ptr2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glShadeModel ( GLenum mode ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glShadeModel (
+ JNIEnv *env, jobject obj,
+ jint mode)
+ {
+
+ if ( disp__glShadeModel == NULL ) return;
+
+ disp__glShadeModel (
+ (GLenum) mode
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLightf ( GLenum light , GLenum pname , GLfloat param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLightf (
+ JNIEnv *env, jobject obj,
+ jint light,
+ jint pname,
+ jfloat param)
+ {
+
+ if ( disp__glLightf == NULL ) return;
+
+ disp__glLightf (
+ (GLenum) light,
+ (GLenum) pname,
+ (GLfloat) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLighti ( GLenum light , GLenum pname , GLint param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLighti (
+ JNIEnv *env, jobject obj,
+ jint light,
+ jint pname,
+ jint param)
+ {
+
+ if ( disp__glLighti == NULL ) return;
+
+ disp__glLighti (
+ (GLenum) light,
+ (GLenum) pname,
+ (GLint) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLightfv ( GLenum light , GLenum pname , const GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLightfv (
+ JNIEnv *env, jobject obj,
+ jint light,
+ jint pname,
+ jfloatArray params)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glLightfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glLightfv (
+ (GLenum) light,
+ (GLenum) pname,
+ (const GLfloat *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLightiv ( GLenum light , GLenum pname , const GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLightiv (
+ JNIEnv *env, jobject obj,
+ jint light,
+ jint pname,
+ jintArray params)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glLightiv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glLightiv (
+ (GLenum) light,
+ (GLenum) pname,
+ (const GLint *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetLightfv ( GLenum light , GLenum pname , GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetLightfv (
+ JNIEnv *env, jobject obj,
+ jint light,
+ jint pname,
+ jfloatArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetLightfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetLightfv (
+ (GLenum) light,
+ (GLenum) pname,
+ (GLfloat *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetLightiv ( GLenum light , GLenum pname , GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetLightiv (
+ JNIEnv *env, jobject obj,
+ jint light,
+ jint pname,
+ jintArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetLightiv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetLightiv (
+ (GLenum) light,
+ (GLenum) pname,
+ (GLint *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLightModelf ( GLenum pname , GLfloat param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLightModelf (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jfloat param)
+ {
+
+ if ( disp__glLightModelf == NULL ) return;
+
+ disp__glLightModelf (
+ (GLenum) pname,
+ (GLfloat) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLightModeli ( GLenum pname , GLint param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLightModeli (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jint param)
+ {
+
+ if ( disp__glLightModeli == NULL ) return;
+
+ disp__glLightModeli (
+ (GLenum) pname,
+ (GLint) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLightModelfv ( GLenum pname , const GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLightModelfv (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jfloatArray params)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glLightModelfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glLightModelfv (
+ (GLenum) pname,
+ (const GLfloat *) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLightModeliv ( GLenum pname , const GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLightModeliv (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jintArray params)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glLightModeliv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glLightModeliv (
+ (GLenum) pname,
+ (const GLint *) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMaterialf ( GLenum face , GLenum pname , GLfloat param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMaterialf (
+ JNIEnv *env, jobject obj,
+ jint face,
+ jint pname,
+ jfloat param)
+ {
+
+ if ( disp__glMaterialf == NULL ) return;
+
+ disp__glMaterialf (
+ (GLenum) face,
+ (GLenum) pname,
+ (GLfloat) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMateriali ( GLenum face , GLenum pname , GLint param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMateriali (
+ JNIEnv *env, jobject obj,
+ jint face,
+ jint pname,
+ jint param)
+ {
+
+ if ( disp__glMateriali == NULL ) return;
+
+ disp__glMateriali (
+ (GLenum) face,
+ (GLenum) pname,
+ (GLint) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMaterialfv ( GLenum face , GLenum pname , const GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMaterialfv (
+ JNIEnv *env, jobject obj,
+ jint face,
+ jint pname,
+ jfloatArray params)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glMaterialfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glMaterialfv (
+ (GLenum) face,
+ (GLenum) pname,
+ (const GLfloat *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMaterialiv ( GLenum face , GLenum pname , const GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMaterialiv (
+ JNIEnv *env, jobject obj,
+ jint face,
+ jint pname,
+ jintArray params)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glMaterialiv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glMaterialiv (
+ (GLenum) face,
+ (GLenum) pname,
+ (const GLint *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetMaterialfv ( GLenum face , GLenum pname , GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMaterialfv (
+ JNIEnv *env, jobject obj,
+ jint face,
+ jint pname,
+ jfloatArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetMaterialfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetMaterialfv (
+ (GLenum) face,
+ (GLenum) pname,
+ (GLfloat *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetMaterialiv ( GLenum face , GLenum pname , GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMaterialiv (
+ JNIEnv *env, jobject obj,
+ jint face,
+ jint pname,
+ jintArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetMaterialiv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetMaterialiv (
+ (GLenum) face,
+ (GLenum) pname,
+ (GLint *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorMaterial ( GLenum face , GLenum mode ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorMaterial (
+ JNIEnv *env, jobject obj,
+ jint face,
+ jint mode)
+ {
+
+ if ( disp__glColorMaterial == NULL ) return;
+
+ disp__glColorMaterial (
+ (GLenum) face,
+ (GLenum) mode
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPixelZoom ( GLfloat xfactor , GLfloat yfactor ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPixelZoom (
+ JNIEnv *env, jobject obj,
+ jfloat xfactor,
+ jfloat yfactor)
+ {
+
+ if ( disp__glPixelZoom == NULL ) return;
+
+ disp__glPixelZoom (
+ (GLfloat) xfactor,
+ (GLfloat) yfactor
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPixelStoref ( GLenum pname , GLfloat param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPixelStoref (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jfloat param)
+ {
+
+ if ( disp__glPixelStoref == NULL ) return;
+
+ disp__glPixelStoref (
+ (GLenum) pname,
+ (GLfloat) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPixelStorei ( GLenum pname , GLint param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPixelStorei (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jint param)
+ {
+
+ if ( disp__glPixelStorei == NULL ) return;
+
+ disp__glPixelStorei (
+ (GLenum) pname,
+ (GLint) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPixelTransferf ( GLenum pname , GLfloat param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPixelTransferf (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jfloat param)
+ {
+
+ if ( disp__glPixelTransferf == NULL ) return;
+
+ disp__glPixelTransferf (
+ (GLenum) pname,
+ (GLfloat) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPixelTransferi ( GLenum pname , GLint param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPixelTransferi (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jint param)
+ {
+
+ if ( disp__glPixelTransferi == NULL ) return;
+
+ disp__glPixelTransferi (
+ (GLenum) pname,
+ (GLint) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPixelMapfv ( GLenum map , GLint mapsize , const GLfloat * values ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPixelMapfv (
+ JNIEnv *env, jobject obj,
+ jint map,
+ jint mapsize,
+ jfloatArray values)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glPixelMapfv == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, values, 0);
+ }
+ disp__glPixelMapfv (
+ (GLenum) map,
+ (GLint) mapsize,
+ (const GLfloat *) ptr2
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPixelMapuiv ( GLenum map , GLint mapsize , const GLuint * values ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPixelMapuiv (
+ JNIEnv *env, jobject obj,
+ jint map,
+ jint mapsize,
+ jintArray values)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glPixelMapuiv == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, values, 0);
+ }
+ disp__glPixelMapuiv (
+ (GLenum) map,
+ (GLint) mapsize,
+ (const GLuint *) ptr2
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPixelMapusv ( GLenum map , GLint mapsize , const GLushort * values ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPixelMapusv (
+ JNIEnv *env, jobject obj,
+ jint map,
+ jint mapsize,
+ jshortArray values)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glPixelMapusv == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, values, 0);
+ }
+ disp__glPixelMapusv (
+ (GLenum) map,
+ (GLint) mapsize,
+ (const GLushort *) ptr2
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetPixelMapfv ( GLenum map , GLfloat * values ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPixelMapfv (
+ JNIEnv *env, jobject obj,
+ jint map,
+ jfloatArray values)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glGetPixelMapfv == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray1);
+ }
+ disp__glGetPixelMapfv (
+ (GLenum) map,
+ (GLfloat *) ptr1
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetPixelMapuiv ( GLenum map , GLuint * values ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPixelMapuiv (
+ JNIEnv *env, jobject obj,
+ jint map,
+ jintArray values)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jint *ptr1 = NULL;
+
+ if ( disp__glGetPixelMapuiv == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray1);
+ }
+ disp__glGetPixelMapuiv (
+ (GLenum) map,
+ (GLuint *) ptr1
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetPixelMapusv ( GLenum map , GLushort * values ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPixelMapusv (
+ JNIEnv *env, jobject obj,
+ jint map,
+ jshortArray values)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jshort *ptr1 = NULL;
+
+ if ( disp__glGetPixelMapusv == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray1);
+ }
+ disp__glGetPixelMapusv (
+ (GLenum) map,
+ (GLushort *) ptr1
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBitmap ( GLsizei width , GLsizei height , GLfloat xorig , GLfloat yorig , GLfloat xmove , GLfloat ymove , const GLubyte * bitmap ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBitmap (
+ JNIEnv *env, jobject obj,
+ jint width,
+ jint height,
+ jfloat xorig,
+ jfloat yorig,
+ jfloat xmove,
+ jfloat ymove,
+ jbyteArray bitmap)
+ {
+ jbyte *ptr6 = NULL;
+
+ if ( disp__glBitmap == NULL ) return;
+
+ if(bitmap!=NULL)
+ {
+ ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, bitmap, 0);
+ }
+ disp__glBitmap (
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLfloat) xorig,
+ (GLfloat) yorig,
+ (GLfloat) xmove,
+ (GLfloat) ymove,
+ (const GLubyte *) ptr6
+ );
+
+ if(bitmap!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, bitmap, ptr6, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReadPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum format , GLenum type , GLvoid * pixels ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReadPixels__IIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint x,
+ jint y,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jbyteArray pixels)
+ {
+ jboolean isCopiedArray6 = JNI_FALSE;
+ jbyte *ptr6 = NULL;
+
+ if ( disp__glReadPixels == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+ }
+ disp__glReadPixels (
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr6
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReadPixels__IIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint x,
+ jint y,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jshortArray pixels)
+ {
+ jboolean isCopiedArray6 = JNI_FALSE;
+ jshort *ptr6 = NULL;
+
+ if ( disp__glReadPixels == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+ }
+ disp__glReadPixels (
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr6
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReadPixels__IIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint x,
+ jint y,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jintArray pixels)
+ {
+ jboolean isCopiedArray6 = JNI_FALSE;
+ jint *ptr6 = NULL;
+
+ if ( disp__glReadPixels == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+ }
+ disp__glReadPixels (
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr6
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReadPixels__IIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint x,
+ jint y,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jfloatArray pixels)
+ {
+ jboolean isCopiedArray6 = JNI_FALSE;
+ jfloat *ptr6 = NULL;
+
+ if ( disp__glReadPixels == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+ }
+ disp__glReadPixels (
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr6
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReadPixels__IIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint x,
+ jint y,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jdoubleArray pixels)
+ {
+ jboolean isCopiedArray6 = JNI_FALSE;
+ jdouble *ptr6 = NULL;
+
+ if ( disp__glReadPixels == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+ }
+ disp__glReadPixels (
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr6
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReadPixels__IIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint x,
+ jint y,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jbooleanArray pixels)
+ {
+ jboolean isCopiedArray6 = JNI_FALSE;
+ jboolean *ptr6 = NULL;
+
+ if ( disp__glReadPixels == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+ }
+ disp__glReadPixels (
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr6
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReadPixels__IIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint x,
+ jint y,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jlongArray pixels)
+ {
+ jboolean isCopiedArray6 = JNI_FALSE;
+ jlong *ptr6 = NULL;
+
+ if ( disp__glReadPixels == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+ }
+ disp__glReadPixels (
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr6
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReadPixels__IIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint x,
+ jint y,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jobject pixels)
+ {
+ void *ptr6 = NULL;
+
+ if ( disp__glReadPixels == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr6 = (*env)->GetDirectBufferAddress(env, pixels);
+ if (ptr6 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 6 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glReadPixels (
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr6
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDrawPixels ( GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawPixels__IIII_3B (
+ JNIEnv *env, jobject obj,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jbyteArray pixels)
+ {
+ jbyte *ptr4 = NULL;
+
+ if ( disp__glDrawPixels == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glDrawPixels (
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr4
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawPixels__IIII_3S (
+ JNIEnv *env, jobject obj,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jshortArray pixels)
+ {
+ jshort *ptr4 = NULL;
+
+ if ( disp__glDrawPixels == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glDrawPixels (
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr4
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawPixels__IIII_3I (
+ JNIEnv *env, jobject obj,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jintArray pixels)
+ {
+ jint *ptr4 = NULL;
+
+ if ( disp__glDrawPixels == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glDrawPixels (
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr4
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawPixels__IIII_3F (
+ JNIEnv *env, jobject obj,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jfloatArray pixels)
+ {
+ jfloat *ptr4 = NULL;
+
+ if ( disp__glDrawPixels == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glDrawPixels (
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr4
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawPixels__IIII_3D (
+ JNIEnv *env, jobject obj,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jdoubleArray pixels)
+ {
+ jdouble *ptr4 = NULL;
+
+ if ( disp__glDrawPixels == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glDrawPixels (
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr4
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawPixels__IIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jbooleanArray pixels)
+ {
+ jboolean *ptr4 = NULL;
+
+ if ( disp__glDrawPixels == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glDrawPixels (
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr4
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawPixels__IIII_3J (
+ JNIEnv *env, jobject obj,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jlongArray pixels)
+ {
+ jlong *ptr4 = NULL;
+
+ if ( disp__glDrawPixels == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glDrawPixels (
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr4
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawPixels__IIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jobject pixels)
+ {
+ void *ptr4 = NULL;
+
+ if ( disp__glDrawPixels == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr4 = (*env)->GetDirectBufferAddress(env, pixels);
+ if (ptr4 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 4 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glDrawPixels (
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum type ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyPixels (
+ JNIEnv *env, jobject obj,
+ jint x,
+ jint y,
+ jint width,
+ jint height,
+ jint type)
+ {
+
+ if ( disp__glCopyPixels == NULL ) return;
+
+ disp__glCopyPixels (
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) type
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glStencilFunc ( GLenum func , GLint ref , GLuint mask ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glStencilFunc (
+ JNIEnv *env, jobject obj,
+ jint func,
+ jint ref,
+ jint mask)
+ {
+
+ if ( disp__glStencilFunc == NULL ) return;
+
+ disp__glStencilFunc (
+ (GLenum) func,
+ (GLint) ref,
+ (GLuint) mask
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glStencilMask ( GLuint mask ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glStencilMask (
+ JNIEnv *env, jobject obj,
+ jint mask)
+ {
+
+ if ( disp__glStencilMask == NULL ) return;
+
+ disp__glStencilMask (
+ (GLuint) mask
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glStencilOp ( GLenum fail , GLenum zfail , GLenum zpass ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glStencilOp (
+ JNIEnv *env, jobject obj,
+ jint fail,
+ jint zfail,
+ jint zpass)
+ {
+
+ if ( disp__glStencilOp == NULL ) return;
+
+ disp__glStencilOp (
+ (GLenum) fail,
+ (GLenum) zfail,
+ (GLenum) zpass
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glClearStencil ( GLint s ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glClearStencil (
+ JNIEnv *env, jobject obj,
+ jint s)
+ {
+
+ if ( disp__glClearStencil == NULL ) return;
+
+ disp__glClearStencil (
+ (GLint) s
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexGend ( GLenum coord , GLenum pname , GLdouble param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexGend (
+ JNIEnv *env, jobject obj,
+ jint coord,
+ jint pname,
+ jdouble param)
+ {
+
+ if ( disp__glTexGend == NULL ) return;
+
+ disp__glTexGend (
+ (GLenum) coord,
+ (GLenum) pname,
+ (GLdouble) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexGenf ( GLenum coord , GLenum pname , GLfloat param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexGenf (
+ JNIEnv *env, jobject obj,
+ jint coord,
+ jint pname,
+ jfloat param)
+ {
+
+ if ( disp__glTexGenf == NULL ) return;
+
+ disp__glTexGenf (
+ (GLenum) coord,
+ (GLenum) pname,
+ (GLfloat) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexGeni ( GLenum coord , GLenum pname , GLint param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexGeni (
+ JNIEnv *env, jobject obj,
+ jint coord,
+ jint pname,
+ jint param)
+ {
+
+ if ( disp__glTexGeni == NULL ) return;
+
+ disp__glTexGeni (
+ (GLenum) coord,
+ (GLenum) pname,
+ (GLint) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexGendv ( GLenum coord , GLenum pname , const GLdouble * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexGendv (
+ JNIEnv *env, jobject obj,
+ jint coord,
+ jint pname,
+ jdoubleArray params)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glTexGendv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glTexGendv (
+ (GLenum) coord,
+ (GLenum) pname,
+ (const GLdouble *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexGenfv ( GLenum coord , GLenum pname , const GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexGenfv (
+ JNIEnv *env, jobject obj,
+ jint coord,
+ jint pname,
+ jfloatArray params)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glTexGenfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glTexGenfv (
+ (GLenum) coord,
+ (GLenum) pname,
+ (const GLfloat *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexGeniv ( GLenum coord , GLenum pname , const GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexGeniv (
+ JNIEnv *env, jobject obj,
+ jint coord,
+ jint pname,
+ jintArray params)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glTexGeniv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glTexGeniv (
+ (GLenum) coord,
+ (GLenum) pname,
+ (const GLint *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetTexGendv ( GLenum coord , GLenum pname , GLdouble * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexGendv (
+ JNIEnv *env, jobject obj,
+ jint coord,
+ jint pname,
+ jdoubleArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glGetTexGendv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetTexGendv (
+ (GLenum) coord,
+ (GLenum) pname,
+ (GLdouble *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetTexGenfv ( GLenum coord , GLenum pname , GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexGenfv (
+ JNIEnv *env, jobject obj,
+ jint coord,
+ jint pname,
+ jfloatArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetTexGenfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetTexGenfv (
+ (GLenum) coord,
+ (GLenum) pname,
+ (GLfloat *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetTexGeniv ( GLenum coord , GLenum pname , GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexGeniv (
+ JNIEnv *env, jobject obj,
+ jint coord,
+ jint pname,
+ jintArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetTexGeniv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetTexGeniv (
+ (GLenum) coord,
+ (GLenum) pname,
+ (GLint *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexEnvf ( GLenum target , GLenum pname , GLfloat param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexEnvf (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jfloat param)
+ {
+
+ if ( disp__glTexEnvf == NULL ) return;
+
+ disp__glTexEnvf (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLfloat) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexEnvi ( GLenum target , GLenum pname , GLint param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexEnvi (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jint param)
+ {
+
+ if ( disp__glTexEnvi == NULL ) return;
+
+ disp__glTexEnvi (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLint) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexEnvfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexEnvfv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jfloatArray params)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glTexEnvfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glTexEnvfv (
+ (GLenum) target,
+ (GLenum) pname,
+ (const GLfloat *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexEnviv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexEnviv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jintArray params)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glTexEnviv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glTexEnviv (
+ (GLenum) target,
+ (GLenum) pname,
+ (const GLint *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetTexEnvfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexEnvfv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jfloatArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetTexEnvfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetTexEnvfv (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLfloat *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetTexEnviv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexEnviv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jintArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetTexEnviv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetTexEnviv (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLint *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexParameterf ( GLenum target , GLenum pname , GLfloat param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexParameterf (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jfloat param)
+ {
+
+ if ( disp__glTexParameterf == NULL ) return;
+
+ disp__glTexParameterf (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLfloat) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexParameteri ( GLenum target , GLenum pname , GLint param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexParameteri (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jint param)
+ {
+
+ if ( disp__glTexParameteri == NULL ) return;
+
+ disp__glTexParameteri (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLint) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexParameterfv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jfloatArray params)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glTexParameterfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glTexParameterfv (
+ (GLenum) target,
+ (GLenum) pname,
+ (const GLfloat *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexParameteriv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jintArray params)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glTexParameteriv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glTexParameteriv (
+ (GLenum) target,
+ (GLenum) pname,
+ (const GLint *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetTexParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexParameterfv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jfloatArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetTexParameterfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetTexParameterfv (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLfloat *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetTexParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexParameteriv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jintArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetTexParameteriv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetTexParameteriv (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLint *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetTexLevelParameterfv ( GLenum target , GLint level , GLenum pname , GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexLevelParameterfv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint pname,
+ jfloatArray params)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glGetTexLevelParameterfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray3);
+ }
+ disp__glGetTexLevelParameterfv (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) pname,
+ (GLfloat *) ptr3
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetTexLevelParameteriv ( GLenum target , GLint level , GLenum pname , GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexLevelParameteriv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint pname,
+ jintArray params)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jint *ptr3 = NULL;
+
+ if ( disp__glGetTexLevelParameteriv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray3);
+ }
+ disp__glGetTexLevelParameteriv (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) pname,
+ (GLint *) ptr3
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexImage1D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage1D__IIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint border,
+ jint format,
+ jint type,
+ jbyteArray pixels)
+ {
+ jbyte *ptr7 = NULL;
+
+ if ( disp__glTexImage1D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr7 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr7
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage1D__IIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint border,
+ jint format,
+ jint type,
+ jshortArray pixels)
+ {
+ jshort *ptr7 = NULL;
+
+ if ( disp__glTexImage1D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr7 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr7
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage1D__IIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint border,
+ jint format,
+ jint type,
+ jintArray pixels)
+ {
+ jint *ptr7 = NULL;
+
+ if ( disp__glTexImage1D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr7 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr7
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage1D__IIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint border,
+ jint format,
+ jint type,
+ jfloatArray pixels)
+ {
+ jfloat *ptr7 = NULL;
+
+ if ( disp__glTexImage1D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr7 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr7
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage1D__IIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint border,
+ jint format,
+ jint type,
+ jdoubleArray pixels)
+ {
+ jdouble *ptr7 = NULL;
+
+ if ( disp__glTexImage1D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr7 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr7
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage1D__IIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint border,
+ jint format,
+ jint type,
+ jbooleanArray pixels)
+ {
+ jboolean *ptr7 = NULL;
+
+ if ( disp__glTexImage1D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr7 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr7
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage1D__IIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint border,
+ jint format,
+ jint type,
+ jlongArray pixels)
+ {
+ jlong *ptr7 = NULL;
+
+ if ( disp__glTexImage1D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr7 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr7
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage1D__IIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint border,
+ jint format,
+ jint type,
+ jobject pixels)
+ {
+ void *ptr7 = NULL;
+
+ if ( disp__glTexImage1D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr7 = (*env)->GetDirectBufferAddress(env, pixels);
+ if (ptr7 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 7 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glTexImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr7
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexImage2D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage2D__IIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint border,
+ jint format,
+ jint type,
+ jbyteArray pixels)
+ {
+ jbyte *ptr8 = NULL;
+
+ if ( disp__glTexImage2D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr8 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr8
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage2D__IIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint border,
+ jint format,
+ jint type,
+ jshortArray pixels)
+ {
+ jshort *ptr8 = NULL;
+
+ if ( disp__glTexImage2D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr8 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr8
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage2D__IIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint border,
+ jint format,
+ jint type,
+ jintArray pixels)
+ {
+ jint *ptr8 = NULL;
+
+ if ( disp__glTexImage2D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr8 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr8
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage2D__IIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint border,
+ jint format,
+ jint type,
+ jfloatArray pixels)
+ {
+ jfloat *ptr8 = NULL;
+
+ if ( disp__glTexImage2D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr8 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr8
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage2D__IIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint border,
+ jint format,
+ jint type,
+ jdoubleArray pixels)
+ {
+ jdouble *ptr8 = NULL;
+
+ if ( disp__glTexImage2D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr8
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage2D__IIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint border,
+ jint format,
+ jint type,
+ jbooleanArray pixels)
+ {
+ jboolean *ptr8 = NULL;
+
+ if ( disp__glTexImage2D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr8 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr8
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage2D__IIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint border,
+ jint format,
+ jint type,
+ jlongArray pixels)
+ {
+ jlong *ptr8 = NULL;
+
+ if ( disp__glTexImage2D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr8 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr8
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage2D__IIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint border,
+ jint format,
+ jint type,
+ jobject pixels)
+ {
+ void *ptr8 = NULL;
+
+ if ( disp__glTexImage2D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr8 = (*env)->GetDirectBufferAddress(env, pixels);
+ if (ptr8 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 8 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glTexImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr8
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetTexImage ( GLenum target , GLint level , GLenum format , GLenum type , GLvoid * pixels ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexImage__IIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint format,
+ jint type,
+ jbyteArray pixels)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jbyte *ptr4 = NULL;
+
+ if ( disp__glGetTexImage == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+ }
+ disp__glGetTexImage (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr4
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexImage__IIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint format,
+ jint type,
+ jshortArray pixels)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jshort *ptr4 = NULL;
+
+ if ( disp__glGetTexImage == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+ }
+ disp__glGetTexImage (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr4
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexImage__IIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint format,
+ jint type,
+ jintArray pixels)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jint *ptr4 = NULL;
+
+ if ( disp__glGetTexImage == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+ }
+ disp__glGetTexImage (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr4
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexImage__IIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint format,
+ jint type,
+ jfloatArray pixels)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jfloat *ptr4 = NULL;
+
+ if ( disp__glGetTexImage == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+ }
+ disp__glGetTexImage (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr4
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexImage__IIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint format,
+ jint type,
+ jdoubleArray pixels)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jdouble *ptr4 = NULL;
+
+ if ( disp__glGetTexImage == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+ }
+ disp__glGetTexImage (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr4
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexImage__IIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint format,
+ jint type,
+ jbooleanArray pixels)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jboolean *ptr4 = NULL;
+
+ if ( disp__glGetTexImage == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+ }
+ disp__glGetTexImage (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr4
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexImage__IIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint format,
+ jint type,
+ jlongArray pixels)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jlong *ptr4 = NULL;
+
+ if ( disp__glGetTexImage == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+ }
+ disp__glGetTexImage (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr4
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexImage__IIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint format,
+ jint type,
+ jobject pixels)
+ {
+ void *ptr4 = NULL;
+
+ if ( disp__glGetTexImage == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr4 = (*env)->GetDirectBufferAddress(env, pixels);
+ if (ptr4 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 4 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glGetTexImage (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGenTextures ( GLsizei n , GLuint * textures ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGenTextures (
+ JNIEnv *env, jobject obj,
+ jint n,
+ jintArray textures)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jint *ptr1 = NULL;
+
+ if ( disp__glGenTextures == NULL ) return;
+
+ if(textures!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, &isCopiedArray1);
+ }
+ disp__glGenTextures (
+ (GLsizei) n,
+ (GLuint *) ptr1
+ );
+
+ if(textures!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, textures, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDeleteTextures ( GLsizei n , const GLuint * textures ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDeleteTextures (
+ JNIEnv *env, jobject obj,
+ jint n,
+ jintArray textures)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glDeleteTextures == NULL ) return;
+
+ if(textures!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, 0);
+ }
+ disp__glDeleteTextures (
+ (GLsizei) n,
+ (const GLuint *) ptr1
+ );
+
+ if(textures!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, textures, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBindTexture ( GLenum target , GLuint texture ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBindTexture (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint texture)
+ {
+
+ if ( disp__glBindTexture == NULL ) return;
+
+ disp__glBindTexture (
+ (GLenum) target,
+ (GLuint) texture
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPrioritizeTextures ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPrioritizeTextures (
+ JNIEnv *env, jobject obj,
+ jint n,
+ jintArray textures,
+ jfloatArray priorities)
+ {
+ jint *ptr1 = NULL;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glPrioritizeTextures == NULL ) return;
+
+ if(textures!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, 0);
+ }
+ if(priorities!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, priorities, 0);
+ }
+ disp__glPrioritizeTextures (
+ (GLsizei) n,
+ (const GLuint *) ptr1,
+ (const GLclampf *) ptr2
+ );
+
+ if(textures!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, textures, ptr1, JNI_ABORT);
+ }
+ if(priorities!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, priorities, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLboolean glAreTexturesResident ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ * </pre>
+ */
+ JNIEXPORT jboolean JNICALL
+ Java_gl4java_GLFunc14JauJNI_glAreTexturesResident (
+ JNIEnv *env, jobject obj,
+ jint n,
+ jintArray textures,
+ jbooleanArray residences)
+ {
+ jboolean ret;
+
+ jint *ptr1 = NULL;
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glAreTexturesResident == NULL ) return 0;
+
+ if(textures!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, 0);
+ }
+ if(residences!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, residences, &isCopiedArray2);
+ }
+ ret = (jboolean) disp__glAreTexturesResident (
+ (GLsizei) n,
+ (const GLuint *) ptr1,
+ (GLboolean *) ptr2
+ );
+
+ if(textures!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, textures, ptr1, JNI_ABORT);
+ }
+ if(residences!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, residences, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLboolean glIsTexture ( GLuint texture ) ;
+ * </pre>
+ */
+ JNIEXPORT jboolean JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIsTexture (
+ JNIEnv *env, jobject obj,
+ jint texture)
+ {
+ jboolean ret;
+
+
+ if ( disp__glIsTexture == NULL ) return 0;
+
+ ret = (jboolean) disp__glIsTexture (
+ (GLuint) texture
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLsizei width , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage1D__IIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint width,
+ jint format,
+ jint type,
+ jbyteArray pixels)
+ {
+ jbyte *ptr6 = NULL;
+
+ if ( disp__glTexSubImage1D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage1D__IIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint width,
+ jint format,
+ jint type,
+ jshortArray pixels)
+ {
+ jshort *ptr6 = NULL;
+
+ if ( disp__glTexSubImage1D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage1D__IIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint width,
+ jint format,
+ jint type,
+ jintArray pixels)
+ {
+ jint *ptr6 = NULL;
+
+ if ( disp__glTexSubImage1D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage1D__IIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint width,
+ jint format,
+ jint type,
+ jfloatArray pixels)
+ {
+ jfloat *ptr6 = NULL;
+
+ if ( disp__glTexSubImage1D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage1D__IIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint width,
+ jint format,
+ jint type,
+ jdoubleArray pixels)
+ {
+ jdouble *ptr6 = NULL;
+
+ if ( disp__glTexSubImage1D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage1D__IIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint width,
+ jint format,
+ jint type,
+ jbooleanArray pixels)
+ {
+ jboolean *ptr6 = NULL;
+
+ if ( disp__glTexSubImage1D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage1D__IIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint width,
+ jint format,
+ jint type,
+ jlongArray pixels)
+ {
+ jlong *ptr6 = NULL;
+
+ if ( disp__glTexSubImage1D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage1D__IIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint width,
+ jint format,
+ jint type,
+ jobject pixels)
+ {
+ void *ptr6 = NULL;
+
+ if ( disp__glTexSubImage1D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr6 = (*env)->GetDirectBufferAddress(env, pixels);
+ if (ptr6 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 6 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glTexSubImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage2D__IIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jbyteArray pixels)
+ {
+ jbyte *ptr8 = NULL;
+
+ if ( disp__glTexSubImage2D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr8 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr8
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage2D__IIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jshortArray pixels)
+ {
+ jshort *ptr8 = NULL;
+
+ if ( disp__glTexSubImage2D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr8 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr8
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage2D__IIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jintArray pixels)
+ {
+ jint *ptr8 = NULL;
+
+ if ( disp__glTexSubImage2D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr8 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr8
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage2D__IIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jfloatArray pixels)
+ {
+ jfloat *ptr8 = NULL;
+
+ if ( disp__glTexSubImage2D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr8 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr8
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage2D__IIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jdoubleArray pixels)
+ {
+ jdouble *ptr8 = NULL;
+
+ if ( disp__glTexSubImage2D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr8
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage2D__IIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jbooleanArray pixels)
+ {
+ jboolean *ptr8 = NULL;
+
+ if ( disp__glTexSubImage2D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr8 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr8
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage2D__IIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jlongArray pixels)
+ {
+ jlong *ptr8 = NULL;
+
+ if ( disp__glTexSubImage2D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr8 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr8
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jobject pixels)
+ {
+ void *ptr8 = NULL;
+
+ if ( disp__glTexSubImage2D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr8 = (*env)->GetDirectBufferAddress(env, pixels);
+ if (ptr8 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 8 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glTexSubImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr8
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyTexImage1D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLint border ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyTexImage1D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint x,
+ jint y,
+ jint width,
+ jint border)
+ {
+
+ if ( disp__glCopyTexImage1D == NULL ) return;
+
+ disp__glCopyTexImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width,
+ (GLint) border
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyTexImage2D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height , GLint border ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyTexImage2D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint x,
+ jint y,
+ jint width,
+ jint height,
+ jint border)
+ {
+
+ if ( disp__glCopyTexImage2D == NULL ) return;
+
+ disp__glCopyTexImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLint) border
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLint x , GLint y , GLsizei width ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyTexSubImage1D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint x,
+ jint y,
+ jint width)
+ {
+
+ if ( disp__glCopyTexSubImage1D == NULL ) return;
+
+ disp__glCopyTexSubImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyTexSubImage2D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint x,
+ jint y,
+ jint width,
+ jint height)
+ {
+
+ if ( disp__glCopyTexSubImage2D == NULL ) return;
+
+ disp__glCopyTexSubImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width,
+ (GLsizei) height
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMap1d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint stride , GLint order , const GLdouble * points ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMap1d (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdouble u1,
+ jdouble u2,
+ jint stride,
+ jint order,
+ jdoubleArray points)
+ {
+ jdouble *ptr5 = NULL;
+
+ if ( disp__glMap1d == NULL ) return;
+
+ if(points!=NULL)
+ {
+ ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, points, 0);
+ }
+ disp__glMap1d (
+ (GLenum) target,
+ (GLdouble) u1,
+ (GLdouble) u2,
+ (GLint) stride,
+ (GLint) order,
+ (const GLdouble *) ptr5
+ );
+
+ if(points!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, points, ptr5, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMap1f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint stride , GLint order , const GLfloat * points ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMap1f (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloat u1,
+ jfloat u2,
+ jint stride,
+ jint order,
+ jfloatArray points)
+ {
+ jfloat *ptr5 = NULL;
+
+ if ( disp__glMap1f == NULL ) return;
+
+ if(points!=NULL)
+ {
+ ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, points, 0);
+ }
+ disp__glMap1f (
+ (GLenum) target,
+ (GLfloat) u1,
+ (GLfloat) u2,
+ (GLint) stride,
+ (GLint) order,
+ (const GLfloat *) ptr5
+ );
+
+ if(points!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, points, ptr5, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMap2d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint ustride , GLint uorder , GLdouble v1 , GLdouble v2 , GLint vstride , GLint vorder , const GLdouble * points ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMap2d (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdouble u1,
+ jdouble u2,
+ jint ustride,
+ jint uorder,
+ jdouble v1,
+ jdouble v2,
+ jint vstride,
+ jint vorder,
+ jdoubleArray points)
+ {
+ jdouble *ptr9 = NULL;
+
+ if ( disp__glMap2d == NULL ) return;
+
+ if(points!=NULL)
+ {
+ ptr9 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, points, 0);
+ }
+ disp__glMap2d (
+ (GLenum) target,
+ (GLdouble) u1,
+ (GLdouble) u2,
+ (GLint) ustride,
+ (GLint) uorder,
+ (GLdouble) v1,
+ (GLdouble) v2,
+ (GLint) vstride,
+ (GLint) vorder,
+ (const GLdouble *) ptr9
+ );
+
+ if(points!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, points, ptr9, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMap2f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint ustride , GLint uorder , GLfloat v1 , GLfloat v2 , GLint vstride , GLint vorder , const GLfloat * points ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMap2f (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloat u1,
+ jfloat u2,
+ jint ustride,
+ jint uorder,
+ jfloat v1,
+ jfloat v2,
+ jint vstride,
+ jint vorder,
+ jfloatArray points)
+ {
+ jfloat *ptr9 = NULL;
+
+ if ( disp__glMap2f == NULL ) return;
+
+ if(points!=NULL)
+ {
+ ptr9 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, points, 0);
+ }
+ disp__glMap2f (
+ (GLenum) target,
+ (GLfloat) u1,
+ (GLfloat) u2,
+ (GLint) ustride,
+ (GLint) uorder,
+ (GLfloat) v1,
+ (GLfloat) v2,
+ (GLint) vstride,
+ (GLint) vorder,
+ (const GLfloat *) ptr9
+ );
+
+ if(points!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, points, ptr9, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetMapdv ( GLenum target , GLenum query , GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMapdv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint query,
+ jdoubleArray v)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glGetMapdv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray2);
+ }
+ disp__glGetMapdv (
+ (GLenum) target,
+ (GLenum) query,
+ (GLdouble *) ptr2
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetMapfv ( GLenum target , GLenum query , GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMapfv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint query,
+ jfloatArray v)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetMapfv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray2);
+ }
+ disp__glGetMapfv (
+ (GLenum) target,
+ (GLenum) query,
+ (GLfloat *) ptr2
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetMapiv ( GLenum target , GLenum query , GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMapiv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint query,
+ jintArray v)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetMapiv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray2);
+ }
+ disp__glGetMapiv (
+ (GLenum) target,
+ (GLenum) query,
+ (GLint *) ptr2
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEvalCoord1d ( GLdouble u ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEvalCoord1d (
+ JNIEnv *env, jobject obj,
+ jdouble u)
+ {
+
+ if ( disp__glEvalCoord1d == NULL ) return;
+
+ disp__glEvalCoord1d (
+ (GLdouble) u
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEvalCoord1f ( GLfloat u ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEvalCoord1f (
+ JNIEnv *env, jobject obj,
+ jfloat u)
+ {
+
+ if ( disp__glEvalCoord1f == NULL ) return;
+
+ disp__glEvalCoord1f (
+ (GLfloat) u
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEvalCoord1dv ( const GLdouble * u ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEvalCoord1dv (
+ JNIEnv *env, jobject obj,
+ jdoubleArray u)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glEvalCoord1dv == NULL ) return;
+
+ if(u!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, u, 0);
+ }
+ disp__glEvalCoord1dv (
+ (const GLdouble *) ptr0
+ );
+
+ if(u!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, u, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEvalCoord1fv ( const GLfloat * u ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEvalCoord1fv (
+ JNIEnv *env, jobject obj,
+ jfloatArray u)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glEvalCoord1fv == NULL ) return;
+
+ if(u!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, u, 0);
+ }
+ disp__glEvalCoord1fv (
+ (const GLfloat *) ptr0
+ );
+
+ if(u!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, u, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEvalCoord2d ( GLdouble u , GLdouble v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEvalCoord2d (
+ JNIEnv *env, jobject obj,
+ jdouble u,
+ jdouble v)
+ {
+
+ if ( disp__glEvalCoord2d == NULL ) return;
+
+ disp__glEvalCoord2d (
+ (GLdouble) u,
+ (GLdouble) v
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEvalCoord2f ( GLfloat u , GLfloat v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEvalCoord2f (
+ JNIEnv *env, jobject obj,
+ jfloat u,
+ jfloat v)
+ {
+
+ if ( disp__glEvalCoord2f == NULL ) return;
+
+ disp__glEvalCoord2f (
+ (GLfloat) u,
+ (GLfloat) v
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEvalCoord2dv ( const GLdouble * u ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEvalCoord2dv (
+ JNIEnv *env, jobject obj,
+ jdoubleArray u)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glEvalCoord2dv == NULL ) return;
+
+ if(u!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, u, 0);
+ }
+ disp__glEvalCoord2dv (
+ (const GLdouble *) ptr0
+ );
+
+ if(u!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, u, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEvalCoord2fv ( const GLfloat * u ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEvalCoord2fv (
+ JNIEnv *env, jobject obj,
+ jfloatArray u)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glEvalCoord2fv == NULL ) return;
+
+ if(u!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, u, 0);
+ }
+ disp__glEvalCoord2fv (
+ (const GLfloat *) ptr0
+ );
+
+ if(u!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, u, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMapGrid1d ( GLint un , GLdouble u1 , GLdouble u2 ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMapGrid1d (
+ JNIEnv *env, jobject obj,
+ jint un,
+ jdouble u1,
+ jdouble u2)
+ {
+
+ if ( disp__glMapGrid1d == NULL ) return;
+
+ disp__glMapGrid1d (
+ (GLint) un,
+ (GLdouble) u1,
+ (GLdouble) u2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMapGrid1f ( GLint un , GLfloat u1 , GLfloat u2 ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMapGrid1f (
+ JNIEnv *env, jobject obj,
+ jint un,
+ jfloat u1,
+ jfloat u2)
+ {
+
+ if ( disp__glMapGrid1f == NULL ) return;
+
+ disp__glMapGrid1f (
+ (GLint) un,
+ (GLfloat) u1,
+ (GLfloat) u2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMapGrid2d ( GLint un , GLdouble u1 , GLdouble u2 , GLint vn , GLdouble v1 , GLdouble v2 ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMapGrid2d (
+ JNIEnv *env, jobject obj,
+ jint un,
+ jdouble u1,
+ jdouble u2,
+ jint vn,
+ jdouble v1,
+ jdouble v2)
+ {
+
+ if ( disp__glMapGrid2d == NULL ) return;
+
+ disp__glMapGrid2d (
+ (GLint) un,
+ (GLdouble) u1,
+ (GLdouble) u2,
+ (GLint) vn,
+ (GLdouble) v1,
+ (GLdouble) v2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMapGrid2f ( GLint un , GLfloat u1 , GLfloat u2 , GLint vn , GLfloat v1 , GLfloat v2 ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMapGrid2f (
+ JNIEnv *env, jobject obj,
+ jint un,
+ jfloat u1,
+ jfloat u2,
+ jint vn,
+ jfloat v1,
+ jfloat v2)
+ {
+
+ if ( disp__glMapGrid2f == NULL ) return;
+
+ disp__glMapGrid2f (
+ (GLint) un,
+ (GLfloat) u1,
+ (GLfloat) u2,
+ (GLint) vn,
+ (GLfloat) v1,
+ (GLfloat) v2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEvalPoint1 ( GLint i ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEvalPoint1 (
+ JNIEnv *env, jobject obj,
+ jint i)
+ {
+
+ if ( disp__glEvalPoint1 == NULL ) return;
+
+ disp__glEvalPoint1 (
+ (GLint) i
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEvalPoint2 ( GLint i , GLint j ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEvalPoint2 (
+ JNIEnv *env, jobject obj,
+ jint i,
+ jint j)
+ {
+
+ if ( disp__glEvalPoint2 == NULL ) return;
+
+ disp__glEvalPoint2 (
+ (GLint) i,
+ (GLint) j
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEvalMesh1 ( GLenum mode , GLint i1 , GLint i2 ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEvalMesh1 (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint i1,
+ jint i2)
+ {
+
+ if ( disp__glEvalMesh1 == NULL ) return;
+
+ disp__glEvalMesh1 (
+ (GLenum) mode,
+ (GLint) i1,
+ (GLint) i2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEvalMesh2 ( GLenum mode , GLint i1 , GLint i2 , GLint j1 , GLint j2 ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEvalMesh2 (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint i1,
+ jint i2,
+ jint j1,
+ jint j2)
+ {
+
+ if ( disp__glEvalMesh2 == NULL ) return;
+
+ disp__glEvalMesh2 (
+ (GLenum) mode,
+ (GLint) i1,
+ (GLint) i2,
+ (GLint) j1,
+ (GLint) j2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFogf ( GLenum pname , GLfloat param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogf (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jfloat param)
+ {
+
+ if ( disp__glFogf == NULL ) return;
+
+ disp__glFogf (
+ (GLenum) pname,
+ (GLfloat) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFogi ( GLenum pname , GLint param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogi (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jint param)
+ {
+
+ if ( disp__glFogi == NULL ) return;
+
+ disp__glFogi (
+ (GLenum) pname,
+ (GLint) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFogfv ( GLenum pname , const GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogfv (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jfloatArray params)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glFogfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glFogfv (
+ (GLenum) pname,
+ (const GLfloat *) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFogiv ( GLenum pname , const GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogiv (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jintArray params)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glFogiv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glFogiv (
+ (GLenum) pname,
+ (const GLint *) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFeedbackBuffer ( GLsizei size , GLenum type , GLfloat * buffer ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFeedbackBuffer (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jfloatArray buffer)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glFeedbackBuffer == NULL ) return;
+
+ if(buffer!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, buffer, &isCopiedArray2);
+ }
+ disp__glFeedbackBuffer (
+ (GLsizei) size,
+ (GLenum) type,
+ (GLfloat *) ptr2
+ );
+
+ if(buffer!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, buffer, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPassThrough ( GLfloat token ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPassThrough (
+ JNIEnv *env, jobject obj,
+ jfloat token)
+ {
+
+ if ( disp__glPassThrough == NULL ) return;
+
+ disp__glPassThrough (
+ (GLfloat) token
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSelectBuffer ( GLsizei size , GLuint * buffer ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSelectBuffer (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jintArray buffer)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jint *ptr1 = NULL;
+
+ if ( disp__glSelectBuffer == NULL ) return;
+
+ if(buffer!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, buffer, &isCopiedArray1);
+ }
+ disp__glSelectBuffer (
+ (GLsizei) size,
+ (GLuint *) ptr1
+ );
+
+ if(buffer!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, buffer, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glInitNames ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glInitNames (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glInitNames == NULL ) return;
+
+ disp__glInitNames (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLoadName ( GLuint name ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLoadName (
+ JNIEnv *env, jobject obj,
+ jint name)
+ {
+
+ if ( disp__glLoadName == NULL ) return;
+
+ disp__glLoadName (
+ (GLuint) name
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPushName ( GLuint name ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPushName (
+ JNIEnv *env, jobject obj,
+ jint name)
+ {
+
+ if ( disp__glPushName == NULL ) return;
+
+ disp__glPushName (
+ (GLuint) name
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPopName ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPopName (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glPopName == NULL ) return;
+
+ disp__glPopName (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDrawRangeElements ( GLenum mode , GLuint start , GLuint end , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawRangeElements__IIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint start,
+ jint end,
+ jint count,
+ jint type,
+ jbyteArray indices)
+ {
+ jbyte *ptr5 = NULL;
+
+ if ( disp__glDrawRangeElements == NULL ) return;
+
+ if(indices!=NULL)
+ {
+ ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+ }
+ disp__glDrawRangeElements (
+ (GLenum) mode,
+ (GLuint) start,
+ (GLuint) end,
+ (GLsizei) count,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(indices!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, indices, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawRangeElements__IIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint start,
+ jint end,
+ jint count,
+ jint type,
+ jshortArray indices)
+ {
+ jshort *ptr5 = NULL;
+
+ if ( disp__glDrawRangeElements == NULL ) return;
+
+ if(indices!=NULL)
+ {
+ ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+ }
+ disp__glDrawRangeElements (
+ (GLenum) mode,
+ (GLuint) start,
+ (GLuint) end,
+ (GLsizei) count,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(indices!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, indices, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawRangeElements__IIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint start,
+ jint end,
+ jint count,
+ jint type,
+ jintArray indices)
+ {
+ jint *ptr5 = NULL;
+
+ if ( disp__glDrawRangeElements == NULL ) return;
+
+ if(indices!=NULL)
+ {
+ ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+ }
+ disp__glDrawRangeElements (
+ (GLenum) mode,
+ (GLuint) start,
+ (GLuint) end,
+ (GLsizei) count,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(indices!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, indices, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawRangeElements__IIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint start,
+ jint end,
+ jint count,
+ jint type,
+ jfloatArray indices)
+ {
+ jfloat *ptr5 = NULL;
+
+ if ( disp__glDrawRangeElements == NULL ) return;
+
+ if(indices!=NULL)
+ {
+ ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+ }
+ disp__glDrawRangeElements (
+ (GLenum) mode,
+ (GLuint) start,
+ (GLuint) end,
+ (GLsizei) count,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(indices!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, indices, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawRangeElements__IIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint start,
+ jint end,
+ jint count,
+ jint type,
+ jdoubleArray indices)
+ {
+ jdouble *ptr5 = NULL;
+
+ if ( disp__glDrawRangeElements == NULL ) return;
+
+ if(indices!=NULL)
+ {
+ ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+ }
+ disp__glDrawRangeElements (
+ (GLenum) mode,
+ (GLuint) start,
+ (GLuint) end,
+ (GLsizei) count,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(indices!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, indices, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawRangeElements__IIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint start,
+ jint end,
+ jint count,
+ jint type,
+ jbooleanArray indices)
+ {
+ jboolean *ptr5 = NULL;
+
+ if ( disp__glDrawRangeElements == NULL ) return;
+
+ if(indices!=NULL)
+ {
+ ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+ }
+ disp__glDrawRangeElements (
+ (GLenum) mode,
+ (GLuint) start,
+ (GLuint) end,
+ (GLsizei) count,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(indices!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, indices, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawRangeElements__IIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint start,
+ jint end,
+ jint count,
+ jint type,
+ jlongArray indices)
+ {
+ jlong *ptr5 = NULL;
+
+ if ( disp__glDrawRangeElements == NULL ) return;
+
+ if(indices!=NULL)
+ {
+ ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+ }
+ disp__glDrawRangeElements (
+ (GLenum) mode,
+ (GLuint) start,
+ (GLuint) end,
+ (GLsizei) count,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(indices!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, indices, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawRangeElements__IIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint start,
+ jint end,
+ jint count,
+ jint type,
+ jobject indices)
+ {
+ void *ptr5 = NULL;
+
+ if ( disp__glDrawRangeElements == NULL ) return;
+
+ if(indices!=NULL)
+ {
+ ptr5 = (*env)->GetDirectBufferAddress(env, indices);
+ if (ptr5 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 5 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glDrawRangeElements (
+ (GLenum) mode,
+ (GLuint) start,
+ (GLuint) end,
+ (GLsizei) count,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexImage3D ( GLenum target , GLint level , GLenum internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage3D__IIIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint format,
+ jint type,
+ jbyteArray pixels)
+ {
+ jbyte *ptr9 = NULL;
+
+ if ( disp__glTexImage3D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr9 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr9
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr9, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage3D__IIIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint format,
+ jint type,
+ jshortArray pixels)
+ {
+ jshort *ptr9 = NULL;
+
+ if ( disp__glTexImage3D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr9 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr9
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr9, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage3D__IIIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint format,
+ jint type,
+ jintArray pixels)
+ {
+ jint *ptr9 = NULL;
+
+ if ( disp__glTexImage3D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr9 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr9
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr9, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage3D__IIIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint format,
+ jint type,
+ jfloatArray pixels)
+ {
+ jfloat *ptr9 = NULL;
+
+ if ( disp__glTexImage3D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr9 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr9
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr9, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage3D__IIIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint format,
+ jint type,
+ jdoubleArray pixels)
+ {
+ jdouble *ptr9 = NULL;
+
+ if ( disp__glTexImage3D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr9 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr9
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr9, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage3D__IIIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint format,
+ jint type,
+ jbooleanArray pixels)
+ {
+ jboolean *ptr9 = NULL;
+
+ if ( disp__glTexImage3D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr9 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr9
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr9, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage3D__IIIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint format,
+ jint type,
+ jlongArray pixels)
+ {
+ jlong *ptr9 = NULL;
+
+ if ( disp__glTexImage3D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr9 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr9
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr9, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage3D__IIIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint format,
+ jint type,
+ jobject pixels)
+ {
+ void *ptr9 = NULL;
+
+ if ( disp__glTexImage3D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr9 = (*env)->GetDirectBufferAddress(env, pixels);
+ if (ptr9 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 9 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glTexImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr9
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage3D__IIIIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jbyteArray pixels)
+ {
+ jbyte *ptr10 = NULL;
+
+ if ( disp__glTexSubImage3D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr10 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr10
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage3D__IIIIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jshortArray pixels)
+ {
+ jshort *ptr10 = NULL;
+
+ if ( disp__glTexSubImage3D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr10 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr10
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage3D__IIIIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jintArray pixels)
+ {
+ jint *ptr10 = NULL;
+
+ if ( disp__glTexSubImage3D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr10 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr10
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage3D__IIIIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jfloatArray pixels)
+ {
+ jfloat *ptr10 = NULL;
+
+ if ( disp__glTexSubImage3D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr10 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr10
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage3D__IIIIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jdoubleArray pixels)
+ {
+ jdouble *ptr10 = NULL;
+
+ if ( disp__glTexSubImage3D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr10 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr10
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage3D__IIIIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jbooleanArray pixels)
+ {
+ jboolean *ptr10 = NULL;
+
+ if ( disp__glTexSubImage3D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr10 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr10
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage3D__IIIIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jlongArray pixels)
+ {
+ jlong *ptr10 = NULL;
+
+ if ( disp__glTexSubImage3D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr10 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr10
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage3D__IIIIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jobject pixels)
+ {
+ void *ptr10 = NULL;
+
+ if ( disp__glTexSubImage3D == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr10 = (*env)->GetDirectBufferAddress(env, pixels);
+ if (ptr10 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 10 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glTexSubImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr10
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyTexSubImage3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint x,
+ jint y,
+ jint width,
+ jint height)
+ {
+
+ if ( disp__glCopyTexSubImage3D == NULL ) return;
+
+ disp__glCopyTexSubImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width,
+ (GLsizei) height
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorTable ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTable__IIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jbyteArray table)
+ {
+ jbyte *ptr5 = NULL;
+
+ if ( disp__glColorTable == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+ }
+ disp__glColorTable (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTable__IIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jshortArray table)
+ {
+ jshort *ptr5 = NULL;
+
+ if ( disp__glColorTable == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+ }
+ disp__glColorTable (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTable__IIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jintArray table)
+ {
+ jint *ptr5 = NULL;
+
+ if ( disp__glColorTable == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+ }
+ disp__glColorTable (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTable__IIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jfloatArray table)
+ {
+ jfloat *ptr5 = NULL;
+
+ if ( disp__glColorTable == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+ }
+ disp__glColorTable (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTable__IIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jdoubleArray table)
+ {
+ jdouble *ptr5 = NULL;
+
+ if ( disp__glColorTable == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+ }
+ disp__glColorTable (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTable__IIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jbooleanArray table)
+ {
+ jboolean *ptr5 = NULL;
+
+ if ( disp__glColorTable == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+ }
+ disp__glColorTable (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTable__IIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jlongArray table)
+ {
+ jlong *ptr5 = NULL;
+
+ if ( disp__glColorTable == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+ }
+ disp__glColorTable (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTable__IIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jobject table)
+ {
+ void *ptr5 = NULL;
+
+ if ( disp__glColorTable == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr5 = (*env)->GetDirectBufferAddress(env, table);
+ if (ptr5 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 5 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glColorTable (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorSubTable ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorSubTable__IIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint start,
+ jint count,
+ jint format,
+ jint type,
+ jbyteArray data)
+ {
+ jbyte *ptr5 = NULL;
+
+ if ( disp__glColorSubTable == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glColorSubTable (
+ (GLenum) target,
+ (GLsizei) start,
+ (GLsizei) count,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorSubTable__IIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint start,
+ jint count,
+ jint format,
+ jint type,
+ jshortArray data)
+ {
+ jshort *ptr5 = NULL;
+
+ if ( disp__glColorSubTable == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glColorSubTable (
+ (GLenum) target,
+ (GLsizei) start,
+ (GLsizei) count,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorSubTable__IIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint start,
+ jint count,
+ jint format,
+ jint type,
+ jintArray data)
+ {
+ jint *ptr5 = NULL;
+
+ if ( disp__glColorSubTable == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glColorSubTable (
+ (GLenum) target,
+ (GLsizei) start,
+ (GLsizei) count,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorSubTable__IIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint start,
+ jint count,
+ jint format,
+ jint type,
+ jfloatArray data)
+ {
+ jfloat *ptr5 = NULL;
+
+ if ( disp__glColorSubTable == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glColorSubTable (
+ (GLenum) target,
+ (GLsizei) start,
+ (GLsizei) count,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorSubTable__IIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint start,
+ jint count,
+ jint format,
+ jint type,
+ jdoubleArray data)
+ {
+ jdouble *ptr5 = NULL;
+
+ if ( disp__glColorSubTable == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glColorSubTable (
+ (GLenum) target,
+ (GLsizei) start,
+ (GLsizei) count,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorSubTable__IIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint start,
+ jint count,
+ jint format,
+ jint type,
+ jbooleanArray data)
+ {
+ jboolean *ptr5 = NULL;
+
+ if ( disp__glColorSubTable == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glColorSubTable (
+ (GLenum) target,
+ (GLsizei) start,
+ (GLsizei) count,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorSubTable__IIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint start,
+ jint count,
+ jint format,
+ jint type,
+ jlongArray data)
+ {
+ jlong *ptr5 = NULL;
+
+ if ( disp__glColorSubTable == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glColorSubTable (
+ (GLenum) target,
+ (GLsizei) start,
+ (GLsizei) count,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorSubTable__IIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint start,
+ jint count,
+ jint format,
+ jint type,
+ jobject data)
+ {
+ void *ptr5 = NULL;
+
+ if ( disp__glColorSubTable == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr5 = (*env)->GetDirectBufferAddress(env, data);
+ if (ptr5 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 5 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glColorSubTable (
+ (GLenum) target,
+ (GLsizei) start,
+ (GLsizei) count,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorTableParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableParameteriv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jintArray params)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glColorTableParameteriv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glColorTableParameteriv (
+ (GLenum) target,
+ (GLenum) pname,
+ (const GLint *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorTableParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableParameterfv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jfloatArray params)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glColorTableParameterfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glColorTableParameterfv (
+ (GLenum) target,
+ (GLenum) pname,
+ (const GLfloat *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyColorSubTable ( GLenum target , GLsizei start , GLint x , GLint y , GLsizei width ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyColorSubTable (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint start,
+ jint x,
+ jint y,
+ jint width)
+ {
+
+ if ( disp__glCopyColorSubTable == NULL ) return;
+
+ disp__glCopyColorSubTable (
+ (GLenum) target,
+ (GLsizei) start,
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyColorTable ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyColorTable (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint x,
+ jint y,
+ jint width)
+ {
+
+ if ( disp__glCopyColorTable == NULL ) return;
+
+ disp__glCopyColorTable (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetColorTable ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTable__III_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jbyteArray table)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glGetColorTable == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+ }
+ disp__glGetColorTable (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTable__III_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jshortArray table)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jshort *ptr3 = NULL;
+
+ if ( disp__glGetColorTable == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+ }
+ disp__glGetColorTable (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTable__III_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jintArray table)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jint *ptr3 = NULL;
+
+ if ( disp__glGetColorTable == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+ }
+ disp__glGetColorTable (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTable__III_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jfloatArray table)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glGetColorTable == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+ }
+ disp__glGetColorTable (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTable__III_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jdoubleArray table)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glGetColorTable == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+ }
+ disp__glGetColorTable (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTable__III_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jbooleanArray table)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glGetColorTable == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+ }
+ disp__glGetColorTable (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTable__III_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jlongArray table)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jlong *ptr3 = NULL;
+
+ if ( disp__glGetColorTable == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+ }
+ disp__glGetColorTable (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTable__IIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jobject table)
+ {
+ void *ptr3 = NULL;
+
+ if ( disp__glGetColorTable == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, table);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glGetColorTable (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetColorTableParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableParameterfv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jfloatArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetColorTableParameterfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetColorTableParameterfv (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLfloat *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetColorTableParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableParameteriv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jintArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetColorTableParameteriv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetColorTableParameteriv (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLint *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBlendEquation ( GLenum mode ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBlendEquation (
+ JNIEnv *env, jobject obj,
+ jint mode)
+ {
+
+ if ( disp__glBlendEquation == NULL ) return;
+
+ disp__glBlendEquation (
+ (GLenum) mode
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBlendColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBlendColor (
+ JNIEnv *env, jobject obj,
+ jfloat red,
+ jfloat green,
+ jfloat blue,
+ jfloat alpha)
+ {
+
+ if ( disp__glBlendColor == NULL ) return;
+
+ disp__glBlendColor (
+ (GLclampf) red,
+ (GLclampf) green,
+ (GLclampf) blue,
+ (GLclampf) alpha
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glHistogram ( GLenum target , GLsizei width , GLenum internalformat , GLboolean sink ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glHistogram (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint width,
+ jint internalformat,
+ jboolean sink)
+ {
+
+ if ( disp__glHistogram == NULL ) return;
+
+ disp__glHistogram (
+ (GLenum) target,
+ (GLsizei) width,
+ (GLenum) internalformat,
+ (GLboolean) sink
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glResetHistogram ( GLenum target ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glResetHistogram (
+ JNIEnv *env, jobject obj,
+ jint target)
+ {
+
+ if ( disp__glResetHistogram == NULL ) return;
+
+ disp__glResetHistogram (
+ (GLenum) target
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetHistogram ( GLenum target , GLboolean reset , GLenum format , GLenum type , GLvoid * values ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogram__IZII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jboolean reset,
+ jint format,
+ jint type,
+ jbyteArray values)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jbyte *ptr4 = NULL;
+
+ if ( disp__glGetHistogram == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+ }
+ disp__glGetHistogram (
+ (GLenum) target,
+ (GLboolean) reset,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr4
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogram__IZII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jboolean reset,
+ jint format,
+ jint type,
+ jshortArray values)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jshort *ptr4 = NULL;
+
+ if ( disp__glGetHistogram == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+ }
+ disp__glGetHistogram (
+ (GLenum) target,
+ (GLboolean) reset,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr4
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogram__IZII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jboolean reset,
+ jint format,
+ jint type,
+ jintArray values)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jint *ptr4 = NULL;
+
+ if ( disp__glGetHistogram == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+ }
+ disp__glGetHistogram (
+ (GLenum) target,
+ (GLboolean) reset,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr4
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogram__IZII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jboolean reset,
+ jint format,
+ jint type,
+ jfloatArray values)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jfloat *ptr4 = NULL;
+
+ if ( disp__glGetHistogram == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+ }
+ disp__glGetHistogram (
+ (GLenum) target,
+ (GLboolean) reset,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr4
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogram__IZII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jboolean reset,
+ jint format,
+ jint type,
+ jdoubleArray values)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jdouble *ptr4 = NULL;
+
+ if ( disp__glGetHistogram == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+ }
+ disp__glGetHistogram (
+ (GLenum) target,
+ (GLboolean) reset,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr4
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogram__IZII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jboolean reset,
+ jint format,
+ jint type,
+ jbooleanArray values)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jboolean *ptr4 = NULL;
+
+ if ( disp__glGetHistogram == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+ }
+ disp__glGetHistogram (
+ (GLenum) target,
+ (GLboolean) reset,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr4
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogram__IZII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jboolean reset,
+ jint format,
+ jint type,
+ jlongArray values)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jlong *ptr4 = NULL;
+
+ if ( disp__glGetHistogram == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+ }
+ disp__glGetHistogram (
+ (GLenum) target,
+ (GLboolean) reset,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr4
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogram__IZIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jboolean reset,
+ jint format,
+ jint type,
+ jobject values)
+ {
+ void *ptr4 = NULL;
+
+ if ( disp__glGetHistogram == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr4 = (*env)->GetDirectBufferAddress(env, values);
+ if (ptr4 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 4 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glGetHistogram (
+ (GLenum) target,
+ (GLboolean) reset,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetHistogramParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogramParameterfv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jfloatArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetHistogramParameterfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetHistogramParameterfv (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLfloat *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetHistogramParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogramParameteriv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jintArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetHistogramParameteriv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetHistogramParameteriv (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLint *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMinmax ( GLenum target , GLenum internalformat , GLboolean sink ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMinmax (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jboolean sink)
+ {
+
+ if ( disp__glMinmax == NULL ) return;
+
+ disp__glMinmax (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLboolean) sink
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glResetMinmax ( GLenum target ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glResetMinmax (
+ JNIEnv *env, jobject obj,
+ jint target)
+ {
+
+ if ( disp__glResetMinmax == NULL ) return;
+
+ disp__glResetMinmax (
+ (GLenum) target
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetMinmax ( GLenum target , GLboolean reset , GLenum format , GLenum types , GLvoid * values ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmax__IZII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jboolean reset,
+ jint format,
+ jint types,
+ jbyteArray values)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jbyte *ptr4 = NULL;
+
+ if ( disp__glGetMinmax == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+ }
+ disp__glGetMinmax (
+ (GLenum) target,
+ (GLboolean) reset,
+ (GLenum) format,
+ (GLenum) types,
+ (GLvoid *) ptr4
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmax__IZII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jboolean reset,
+ jint format,
+ jint types,
+ jshortArray values)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jshort *ptr4 = NULL;
+
+ if ( disp__glGetMinmax == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+ }
+ disp__glGetMinmax (
+ (GLenum) target,
+ (GLboolean) reset,
+ (GLenum) format,
+ (GLenum) types,
+ (GLvoid *) ptr4
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmax__IZII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jboolean reset,
+ jint format,
+ jint types,
+ jintArray values)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jint *ptr4 = NULL;
+
+ if ( disp__glGetMinmax == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+ }
+ disp__glGetMinmax (
+ (GLenum) target,
+ (GLboolean) reset,
+ (GLenum) format,
+ (GLenum) types,
+ (GLvoid *) ptr4
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmax__IZII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jboolean reset,
+ jint format,
+ jint types,
+ jfloatArray values)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jfloat *ptr4 = NULL;
+
+ if ( disp__glGetMinmax == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+ }
+ disp__glGetMinmax (
+ (GLenum) target,
+ (GLboolean) reset,
+ (GLenum) format,
+ (GLenum) types,
+ (GLvoid *) ptr4
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmax__IZII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jboolean reset,
+ jint format,
+ jint types,
+ jdoubleArray values)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jdouble *ptr4 = NULL;
+
+ if ( disp__glGetMinmax == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+ }
+ disp__glGetMinmax (
+ (GLenum) target,
+ (GLboolean) reset,
+ (GLenum) format,
+ (GLenum) types,
+ (GLvoid *) ptr4
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmax__IZII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jboolean reset,
+ jint format,
+ jint types,
+ jbooleanArray values)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jboolean *ptr4 = NULL;
+
+ if ( disp__glGetMinmax == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+ }
+ disp__glGetMinmax (
+ (GLenum) target,
+ (GLboolean) reset,
+ (GLenum) format,
+ (GLenum) types,
+ (GLvoid *) ptr4
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmax__IZII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jboolean reset,
+ jint format,
+ jint types,
+ jlongArray values)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jlong *ptr4 = NULL;
+
+ if ( disp__glGetMinmax == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+ }
+ disp__glGetMinmax (
+ (GLenum) target,
+ (GLboolean) reset,
+ (GLenum) format,
+ (GLenum) types,
+ (GLvoid *) ptr4
+ );
+
+ if(values!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmax__IZIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jboolean reset,
+ jint format,
+ jint types,
+ jobject values)
+ {
+ void *ptr4 = NULL;
+
+ if ( disp__glGetMinmax == NULL ) return;
+
+ if(values!=NULL)
+ {
+ ptr4 = (*env)->GetDirectBufferAddress(env, values);
+ if (ptr4 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 4 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glGetMinmax (
+ (GLenum) target,
+ (GLboolean) reset,
+ (GLenum) format,
+ (GLenum) types,
+ (GLvoid *) ptr4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetMinmaxParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmaxParameterfv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jfloatArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetMinmaxParameterfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetMinmaxParameterfv (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLfloat *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetMinmaxParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmaxParameteriv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jintArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetMinmaxParameteriv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetMinmaxParameteriv (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLint *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glConvolutionFilter1D ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * image ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter1D__IIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jbyteArray image)
+ {
+ jbyte *ptr5 = NULL;
+
+ if ( disp__glConvolutionFilter1D == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+ }
+ disp__glConvolutionFilter1D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter1D__IIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jshortArray image)
+ {
+ jshort *ptr5 = NULL;
+
+ if ( disp__glConvolutionFilter1D == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+ }
+ disp__glConvolutionFilter1D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter1D__IIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jintArray image)
+ {
+ jint *ptr5 = NULL;
+
+ if ( disp__glConvolutionFilter1D == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+ }
+ disp__glConvolutionFilter1D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter1D__IIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jfloatArray image)
+ {
+ jfloat *ptr5 = NULL;
+
+ if ( disp__glConvolutionFilter1D == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+ }
+ disp__glConvolutionFilter1D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter1D__IIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jdoubleArray image)
+ {
+ jdouble *ptr5 = NULL;
+
+ if ( disp__glConvolutionFilter1D == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+ }
+ disp__glConvolutionFilter1D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter1D__IIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jbooleanArray image)
+ {
+ jboolean *ptr5 = NULL;
+
+ if ( disp__glConvolutionFilter1D == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+ }
+ disp__glConvolutionFilter1D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter1D__IIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jlongArray image)
+ {
+ jlong *ptr5 = NULL;
+
+ if ( disp__glConvolutionFilter1D == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+ }
+ disp__glConvolutionFilter1D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter1D__IIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jobject image)
+ {
+ void *ptr5 = NULL;
+
+ if ( disp__glConvolutionFilter1D == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr5 = (*env)->GetDirectBufferAddress(env, image);
+ if (ptr5 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 5 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glConvolutionFilter1D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glConvolutionFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * image ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter2D__IIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jbyteArray image)
+ {
+ jbyte *ptr6 = NULL;
+
+ if ( disp__glConvolutionFilter2D == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+ }
+ disp__glConvolutionFilter2D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter2D__IIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jshortArray image)
+ {
+ jshort *ptr6 = NULL;
+
+ if ( disp__glConvolutionFilter2D == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+ }
+ disp__glConvolutionFilter2D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter2D__IIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jintArray image)
+ {
+ jint *ptr6 = NULL;
+
+ if ( disp__glConvolutionFilter2D == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+ }
+ disp__glConvolutionFilter2D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter2D__IIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jfloatArray image)
+ {
+ jfloat *ptr6 = NULL;
+
+ if ( disp__glConvolutionFilter2D == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+ }
+ disp__glConvolutionFilter2D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter2D__IIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jdoubleArray image)
+ {
+ jdouble *ptr6 = NULL;
+
+ if ( disp__glConvolutionFilter2D == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+ }
+ disp__glConvolutionFilter2D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter2D__IIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jbooleanArray image)
+ {
+ jboolean *ptr6 = NULL;
+
+ if ( disp__glConvolutionFilter2D == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+ }
+ disp__glConvolutionFilter2D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter2D__IIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jlongArray image)
+ {
+ jlong *ptr6 = NULL;
+
+ if ( disp__glConvolutionFilter2D == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+ }
+ disp__glConvolutionFilter2D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter2D__IIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jobject image)
+ {
+ void *ptr6 = NULL;
+
+ if ( disp__glConvolutionFilter2D == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr6 = (*env)->GetDirectBufferAddress(env, image);
+ if (ptr6 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 6 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glConvolutionFilter2D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glConvolutionParameterf ( GLenum target , GLenum pname , GLfloat params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionParameterf (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jfloat params)
+ {
+
+ if ( disp__glConvolutionParameterf == NULL ) return;
+
+ disp__glConvolutionParameterf (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLfloat) params
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glConvolutionParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionParameterfv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jfloatArray params)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glConvolutionParameterfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glConvolutionParameterfv (
+ (GLenum) target,
+ (GLenum) pname,
+ (const GLfloat *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glConvolutionParameteri ( GLenum target , GLenum pname , GLint params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionParameteri (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jint params)
+ {
+
+ if ( disp__glConvolutionParameteri == NULL ) return;
+
+ disp__glConvolutionParameteri (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLint) params
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glConvolutionParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionParameteriv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jintArray params)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glConvolutionParameteriv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glConvolutionParameteriv (
+ (GLenum) target,
+ (GLenum) pname,
+ (const GLint *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyConvolutionFilter1D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyConvolutionFilter1D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint x,
+ jint y,
+ jint width)
+ {
+
+ if ( disp__glCopyConvolutionFilter1D == NULL ) return;
+
+ disp__glCopyConvolutionFilter1D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyConvolutionFilter2D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyConvolutionFilter2D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint x,
+ jint y,
+ jint width,
+ jint height)
+ {
+
+ if ( disp__glCopyConvolutionFilter2D == NULL ) return;
+
+ disp__glCopyConvolutionFilter2D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width,
+ (GLsizei) height
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetConvolutionFilter ( GLenum target , GLenum format , GLenum type , GLvoid * image ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionFilter__III_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jbyteArray image)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glGetConvolutionFilter == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+ }
+ disp__glGetConvolutionFilter (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionFilter__III_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jshortArray image)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jshort *ptr3 = NULL;
+
+ if ( disp__glGetConvolutionFilter == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+ }
+ disp__glGetConvolutionFilter (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionFilter__III_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jintArray image)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jint *ptr3 = NULL;
+
+ if ( disp__glGetConvolutionFilter == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+ }
+ disp__glGetConvolutionFilter (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionFilter__III_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jfloatArray image)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glGetConvolutionFilter == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+ }
+ disp__glGetConvolutionFilter (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionFilter__III_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jdoubleArray image)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glGetConvolutionFilter == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+ }
+ disp__glGetConvolutionFilter (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionFilter__III_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jbooleanArray image)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glGetConvolutionFilter == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+ }
+ disp__glGetConvolutionFilter (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionFilter__III_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jlongArray image)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jlong *ptr3 = NULL;
+
+ if ( disp__glGetConvolutionFilter == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+ }
+ disp__glGetConvolutionFilter (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(image!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionFilter__IIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jobject image)
+ {
+ void *ptr3 = NULL;
+
+ if ( disp__glGetConvolutionFilter == NULL ) return;
+
+ if(image!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, image);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glGetConvolutionFilter (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetConvolutionParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionParameterfv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jfloatArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetConvolutionParameterfv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetConvolutionParameterfv (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLfloat *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetConvolutionParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionParameteriv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jintArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetConvolutionParameteriv == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetConvolutionParameteriv (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLint *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSeparableFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * row , const GLvoid * column ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSeparableFilter2D__IIIIII_3B_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jbyteArray row,
+ jbyteArray column)
+ {
+ jbyte *ptr6 = NULL;
+ jbyte *ptr7 = NULL;
+
+ if ( disp__glSeparableFilter2D == NULL ) return;
+
+ if(row!=NULL)
+ {
+ ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, row, 0);
+ }
+ if(column!=NULL)
+ {
+ ptr7 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, column, 0);
+ }
+ disp__glSeparableFilter2D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6,
+ (const GLvoid *) ptr7
+ );
+
+ if(row!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, row, ptr6, JNI_ABORT);
+ }
+ if(column!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, column, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSeparableFilter2D__IIIIII_3S_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jshortArray row,
+ jshortArray column)
+ {
+ jshort *ptr6 = NULL;
+ jshort *ptr7 = NULL;
+
+ if ( disp__glSeparableFilter2D == NULL ) return;
+
+ if(row!=NULL)
+ {
+ ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, row, 0);
+ }
+ if(column!=NULL)
+ {
+ ptr7 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, column, 0);
+ }
+ disp__glSeparableFilter2D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6,
+ (const GLvoid *) ptr7
+ );
+
+ if(row!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, row, ptr6, JNI_ABORT);
+ }
+ if(column!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, column, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSeparableFilter2D__IIIIII_3I_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jintArray row,
+ jintArray column)
+ {
+ jint *ptr6 = NULL;
+ jint *ptr7 = NULL;
+
+ if ( disp__glSeparableFilter2D == NULL ) return;
+
+ if(row!=NULL)
+ {
+ ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, row, 0);
+ }
+ if(column!=NULL)
+ {
+ ptr7 = (jint *) (*env)->GetPrimitiveArrayCritical(env, column, 0);
+ }
+ disp__glSeparableFilter2D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6,
+ (const GLvoid *) ptr7
+ );
+
+ if(row!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, row, ptr6, JNI_ABORT);
+ }
+ if(column!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, column, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSeparableFilter2D__IIIIII_3F_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jfloatArray row,
+ jfloatArray column)
+ {
+ jfloat *ptr6 = NULL;
+ jfloat *ptr7 = NULL;
+
+ if ( disp__glSeparableFilter2D == NULL ) return;
+
+ if(row!=NULL)
+ {
+ ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, row, 0);
+ }
+ if(column!=NULL)
+ {
+ ptr7 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, column, 0);
+ }
+ disp__glSeparableFilter2D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6,
+ (const GLvoid *) ptr7
+ );
+
+ if(row!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, row, ptr6, JNI_ABORT);
+ }
+ if(column!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, column, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSeparableFilter2D__IIIIII_3D_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jdoubleArray row,
+ jdoubleArray column)
+ {
+ jdouble *ptr6 = NULL;
+ jdouble *ptr7 = NULL;
+
+ if ( disp__glSeparableFilter2D == NULL ) return;
+
+ if(row!=NULL)
+ {
+ ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, row, 0);
+ }
+ if(column!=NULL)
+ {
+ ptr7 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, column, 0);
+ }
+ disp__glSeparableFilter2D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6,
+ (const GLvoid *) ptr7
+ );
+
+ if(row!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, row, ptr6, JNI_ABORT);
+ }
+ if(column!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, column, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSeparableFilter2D__IIIIII_3Z_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jbooleanArray row,
+ jbooleanArray column)
+ {
+ jboolean *ptr6 = NULL;
+ jboolean *ptr7 = NULL;
+
+ if ( disp__glSeparableFilter2D == NULL ) return;
+
+ if(row!=NULL)
+ {
+ ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, row, 0);
+ }
+ if(column!=NULL)
+ {
+ ptr7 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, column, 0);
+ }
+ disp__glSeparableFilter2D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6,
+ (const GLvoid *) ptr7
+ );
+
+ if(row!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, row, ptr6, JNI_ABORT);
+ }
+ if(column!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, column, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSeparableFilter2D__IIIIII_3J_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jlongArray row,
+ jlongArray column)
+ {
+ jlong *ptr6 = NULL;
+ jlong *ptr7 = NULL;
+
+ if ( disp__glSeparableFilter2D == NULL ) return;
+
+ if(row!=NULL)
+ {
+ ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, row, 0);
+ }
+ if(column!=NULL)
+ {
+ ptr7 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, column, 0);
+ }
+ disp__glSeparableFilter2D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6,
+ (const GLvoid *) ptr7
+ );
+
+ if(row!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, row, ptr6, JNI_ABORT);
+ }
+ if(column!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, column, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSeparableFilter2D__IIIIIILjava_nio_Buffer_2Ljava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint format,
+ jint type,
+ jobject row,
+ jobject column)
+ {
+ void *ptr6 = NULL;
+ void *ptr7 = NULL;
+
+ if ( disp__glSeparableFilter2D == NULL ) return;
+
+ if(row!=NULL)
+ {
+ ptr6 = (*env)->GetDirectBufferAddress(env, row);
+ if (ptr6 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 6 was not a direct buffer");
+ return ;
+ }
+ }
+ if(column!=NULL)
+ {
+ ptr7 = (*env)->GetDirectBufferAddress(env, column);
+ if (ptr7 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 7 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glSeparableFilter2D (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr6,
+ (const GLvoid *) ptr7
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetSeparableFilter ( GLenum target , GLenum format , GLenum type , GLvoid * row , GLvoid * column , GLvoid * span ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetSeparableFilter__III_3B_3B_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jbyteArray row,
+ jbyteArray column,
+ jbyteArray span)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jbyte *ptr3 = NULL;
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jbyte *ptr4 = NULL;
+ jboolean isCopiedArray5 = JNI_FALSE;
+ jbyte *ptr5 = NULL;
+
+ if ( disp__glGetSeparableFilter == NULL ) return;
+
+ if(row!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+ }
+ if(column!=NULL)
+ {
+ ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+ }
+ if(span!=NULL)
+ {
+ ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+ }
+ disp__glGetSeparableFilter (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3,
+ (GLvoid *) ptr4,
+ (GLvoid *) ptr5
+ );
+
+ if(row!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(column!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(span!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetSeparableFilter__III_3S_3S_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jshortArray row,
+ jshortArray column,
+ jshortArray span)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jshort *ptr3 = NULL;
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jshort *ptr4 = NULL;
+ jboolean isCopiedArray5 = JNI_FALSE;
+ jshort *ptr5 = NULL;
+
+ if ( disp__glGetSeparableFilter == NULL ) return;
+
+ if(row!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+ }
+ if(column!=NULL)
+ {
+ ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+ }
+ if(span!=NULL)
+ {
+ ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+ }
+ disp__glGetSeparableFilter (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3,
+ (GLvoid *) ptr4,
+ (GLvoid *) ptr5
+ );
+
+ if(row!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(column!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(span!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetSeparableFilter__III_3I_3I_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jintArray row,
+ jintArray column,
+ jintArray span)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jint *ptr3 = NULL;
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jint *ptr4 = NULL;
+ jboolean isCopiedArray5 = JNI_FALSE;
+ jint *ptr5 = NULL;
+
+ if ( disp__glGetSeparableFilter == NULL ) return;
+
+ if(row!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+ }
+ if(column!=NULL)
+ {
+ ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+ }
+ if(span!=NULL)
+ {
+ ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+ }
+ disp__glGetSeparableFilter (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3,
+ (GLvoid *) ptr4,
+ (GLvoid *) ptr5
+ );
+
+ if(row!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(column!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(span!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetSeparableFilter__III_3F_3F_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jfloatArray row,
+ jfloatArray column,
+ jfloatArray span)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jfloat *ptr3 = NULL;
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jfloat *ptr4 = NULL;
+ jboolean isCopiedArray5 = JNI_FALSE;
+ jfloat *ptr5 = NULL;
+
+ if ( disp__glGetSeparableFilter == NULL ) return;
+
+ if(row!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+ }
+ if(column!=NULL)
+ {
+ ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+ }
+ if(span!=NULL)
+ {
+ ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+ }
+ disp__glGetSeparableFilter (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3,
+ (GLvoid *) ptr4,
+ (GLvoid *) ptr5
+ );
+
+ if(row!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(column!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(span!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetSeparableFilter__III_3D_3D_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jdoubleArray row,
+ jdoubleArray column,
+ jdoubleArray span)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jdouble *ptr3 = NULL;
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jdouble *ptr4 = NULL;
+ jboolean isCopiedArray5 = JNI_FALSE;
+ jdouble *ptr5 = NULL;
+
+ if ( disp__glGetSeparableFilter == NULL ) return;
+
+ if(row!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+ }
+ if(column!=NULL)
+ {
+ ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+ }
+ if(span!=NULL)
+ {
+ ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+ }
+ disp__glGetSeparableFilter (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3,
+ (GLvoid *) ptr4,
+ (GLvoid *) ptr5
+ );
+
+ if(row!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(column!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(span!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetSeparableFilter__III_3Z_3Z_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jbooleanArray row,
+ jbooleanArray column,
+ jbooleanArray span)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jboolean *ptr3 = NULL;
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jboolean *ptr4 = NULL;
+ jboolean isCopiedArray5 = JNI_FALSE;
+ jboolean *ptr5 = NULL;
+
+ if ( disp__glGetSeparableFilter == NULL ) return;
+
+ if(row!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+ }
+ if(column!=NULL)
+ {
+ ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+ }
+ if(span!=NULL)
+ {
+ ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+ }
+ disp__glGetSeparableFilter (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3,
+ (GLvoid *) ptr4,
+ (GLvoid *) ptr5
+ );
+
+ if(row!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(column!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(span!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetSeparableFilter__III_3J_3J_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jlongArray row,
+ jlongArray column,
+ jlongArray span)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jlong *ptr3 = NULL;
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jlong *ptr4 = NULL;
+ jboolean isCopiedArray5 = JNI_FALSE;
+ jlong *ptr5 = NULL;
+
+ if ( disp__glGetSeparableFilter == NULL ) return;
+
+ if(row!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+ }
+ if(column!=NULL)
+ {
+ ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+ }
+ if(span!=NULL)
+ {
+ ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+ }
+ disp__glGetSeparableFilter (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3,
+ (GLvoid *) ptr4,
+ (GLvoid *) ptr5
+ );
+
+ if(row!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(column!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(span!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetSeparableFilter__IIILjava_nio_Buffer_2Ljava_nio_Buffer_2Ljava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jobject row,
+ jobject column,
+ jobject span)
+ {
+ void *ptr3 = NULL;
+ void *ptr4 = NULL;
+ void *ptr5 = NULL;
+
+ if ( disp__glGetSeparableFilter == NULL ) return;
+
+ if(row!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, row);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ if(column!=NULL)
+ {
+ ptr4 = (*env)->GetDirectBufferAddress(env, column);
+ if (ptr4 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 4 was not a direct buffer");
+ return ;
+ }
+ }
+ if(span!=NULL)
+ {
+ ptr5 = (*env)->GetDirectBufferAddress(env, span);
+ if (ptr5 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 5 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glGetSeparableFilter (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3,
+ (GLvoid *) ptr4,
+ (GLvoid *) ptr5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glActiveTexture ( GLenum texture ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glActiveTexture (
+ JNIEnv *env, jobject obj,
+ jint texture)
+ {
+
+ if ( disp__glActiveTexture == NULL ) return;
+
+ disp__glActiveTexture (
+ (GLenum) texture
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glClientActiveTexture ( GLenum texture ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glClientActiveTexture (
+ JNIEnv *env, jobject obj,
+ jint texture)
+ {
+
+ if ( disp__glClientActiveTexture == NULL ) return;
+
+ disp__glClientActiveTexture (
+ (GLenum) texture
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCompressedTexImage1D ( GLenum target , GLint level , GLenum internalformat , GLsizei width , GLint border , GLsizei imageSize , const GLvoid * data ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage1D__IIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint border,
+ jint imageSize,
+ jbyteArray data)
+ {
+ jbyte *ptr6 = NULL;
+
+ if ( disp__glCompressedTexImage1D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage1D__IIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint border,
+ jint imageSize,
+ jshortArray data)
+ {
+ jshort *ptr6 = NULL;
+
+ if ( disp__glCompressedTexImage1D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage1D__IIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint border,
+ jint imageSize,
+ jintArray data)
+ {
+ jint *ptr6 = NULL;
+
+ if ( disp__glCompressedTexImage1D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage1D__IIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint border,
+ jint imageSize,
+ jfloatArray data)
+ {
+ jfloat *ptr6 = NULL;
+
+ if ( disp__glCompressedTexImage1D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage1D__IIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint border,
+ jint imageSize,
+ jdoubleArray data)
+ {
+ jdouble *ptr6 = NULL;
+
+ if ( disp__glCompressedTexImage1D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage1D__IIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint border,
+ jint imageSize,
+ jbooleanArray data)
+ {
+ jboolean *ptr6 = NULL;
+
+ if ( disp__glCompressedTexImage1D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage1D__IIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint border,
+ jint imageSize,
+ jlongArray data)
+ {
+ jlong *ptr6 = NULL;
+
+ if ( disp__glCompressedTexImage1D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage1D__IIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint border,
+ jint imageSize,
+ jobject data)
+ {
+ void *ptr6 = NULL;
+
+ if ( disp__glCompressedTexImage1D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr6 = (*env)->GetDirectBufferAddress(env, data);
+ if (ptr6 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 6 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glCompressedTexImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr6
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCompressedTexImage2D ( GLenum target , GLint level , GLenum internalformat , GLsizei width , GLsizei height , GLint border , GLsizei imageSize , const GLvoid * data ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage2D__IIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint border,
+ jint imageSize,
+ jbyteArray data)
+ {
+ jbyte *ptr7 = NULL;
+
+ if ( disp__glCompressedTexImage2D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr7 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr7
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage2D__IIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint border,
+ jint imageSize,
+ jshortArray data)
+ {
+ jshort *ptr7 = NULL;
+
+ if ( disp__glCompressedTexImage2D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr7 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr7
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage2D__IIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint border,
+ jint imageSize,
+ jintArray data)
+ {
+ jint *ptr7 = NULL;
+
+ if ( disp__glCompressedTexImage2D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr7 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr7
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage2D__IIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint border,
+ jint imageSize,
+ jfloatArray data)
+ {
+ jfloat *ptr7 = NULL;
+
+ if ( disp__glCompressedTexImage2D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr7 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr7
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage2D__IIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint border,
+ jint imageSize,
+ jdoubleArray data)
+ {
+ jdouble *ptr7 = NULL;
+
+ if ( disp__glCompressedTexImage2D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr7 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr7
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage2D__IIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint border,
+ jint imageSize,
+ jbooleanArray data)
+ {
+ jboolean *ptr7 = NULL;
+
+ if ( disp__glCompressedTexImage2D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr7 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr7
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage2D__IIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint border,
+ jint imageSize,
+ jlongArray data)
+ {
+ jlong *ptr7 = NULL;
+
+ if ( disp__glCompressedTexImage2D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr7 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr7
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint border,
+ jint imageSize,
+ jobject data)
+ {
+ void *ptr7 = NULL;
+
+ if ( disp__glCompressedTexImage2D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr7 = (*env)->GetDirectBufferAddress(env, data);
+ if (ptr7 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 7 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glCompressedTexImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr7
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCompressedTexImage3D ( GLenum target , GLint level , GLenum internalformat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLsizei imageSize , const GLvoid * data ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage3D__IIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint imageSize,
+ jbyteArray data)
+ {
+ jbyte *ptr8 = NULL;
+
+ if ( disp__glCompressedTexImage3D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage3D__IIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint imageSize,
+ jshortArray data)
+ {
+ jshort *ptr8 = NULL;
+
+ if ( disp__glCompressedTexImage3D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage3D__IIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint imageSize,
+ jintArray data)
+ {
+ jint *ptr8 = NULL;
+
+ if ( disp__glCompressedTexImage3D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage3D__IIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint imageSize,
+ jfloatArray data)
+ {
+ jfloat *ptr8 = NULL;
+
+ if ( disp__glCompressedTexImage3D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage3D__IIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint imageSize,
+ jdoubleArray data)
+ {
+ jdouble *ptr8 = NULL;
+
+ if ( disp__glCompressedTexImage3D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage3D__IIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint imageSize,
+ jbooleanArray data)
+ {
+ jboolean *ptr8 = NULL;
+
+ if ( disp__glCompressedTexImage3D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage3D__IIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint imageSize,
+ jlongArray data)
+ {
+ jlong *ptr8 = NULL;
+
+ if ( disp__glCompressedTexImage3D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage3D__IIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalformat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint imageSize,
+ jobject data)
+ {
+ void *ptr8 = NULL;
+
+ if ( disp__glCompressedTexImage3D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr8 = (*env)->GetDirectBufferAddress(env, data);
+ if (ptr8 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 8 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glCompressedTexImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr8
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCompressedTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLsizei width , GLenum format , GLsizei imageSize , const GLvoid * data ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage1D__IIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint width,
+ jint format,
+ jint imageSize,
+ jbyteArray data)
+ {
+ jbyte *ptr6 = NULL;
+
+ if ( disp__glCompressedTexSubImage1D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage1D__IIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint width,
+ jint format,
+ jint imageSize,
+ jshortArray data)
+ {
+ jshort *ptr6 = NULL;
+
+ if ( disp__glCompressedTexSubImage1D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage1D__IIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint width,
+ jint format,
+ jint imageSize,
+ jintArray data)
+ {
+ jint *ptr6 = NULL;
+
+ if ( disp__glCompressedTexSubImage1D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage1D__IIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint width,
+ jint format,
+ jint imageSize,
+ jfloatArray data)
+ {
+ jfloat *ptr6 = NULL;
+
+ if ( disp__glCompressedTexSubImage1D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage1D__IIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint width,
+ jint format,
+ jint imageSize,
+ jdoubleArray data)
+ {
+ jdouble *ptr6 = NULL;
+
+ if ( disp__glCompressedTexSubImage1D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage1D__IIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint width,
+ jint format,
+ jint imageSize,
+ jbooleanArray data)
+ {
+ jboolean *ptr6 = NULL;
+
+ if ( disp__glCompressedTexSubImage1D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage1D__IIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint width,
+ jint format,
+ jint imageSize,
+ jlongArray data)
+ {
+ jlong *ptr6 = NULL;
+
+ if ( disp__glCompressedTexSubImage1D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr6
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage1D__IIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint width,
+ jint format,
+ jint imageSize,
+ jobject data)
+ {
+ void *ptr6 = NULL;
+
+ if ( disp__glCompressedTexSubImage1D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr6 = (*env)->GetDirectBufferAddress(env, data);
+ if (ptr6 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 6 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glCompressedTexSubImage1D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr6
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCompressedTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLsizei width , GLsizei height , GLenum format , GLsizei imageSize , const GLvoid * data ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage2D__IIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint width,
+ jint height,
+ jint format,
+ jint imageSize,
+ jbyteArray data)
+ {
+ jbyte *ptr8 = NULL;
+
+ if ( disp__glCompressedTexSubImage2D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage2D__IIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint width,
+ jint height,
+ jint format,
+ jint imageSize,
+ jshortArray data)
+ {
+ jshort *ptr8 = NULL;
+
+ if ( disp__glCompressedTexSubImage2D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage2D__IIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint width,
+ jint height,
+ jint format,
+ jint imageSize,
+ jintArray data)
+ {
+ jint *ptr8 = NULL;
+
+ if ( disp__glCompressedTexSubImage2D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage2D__IIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint width,
+ jint height,
+ jint format,
+ jint imageSize,
+ jfloatArray data)
+ {
+ jfloat *ptr8 = NULL;
+
+ if ( disp__glCompressedTexSubImage2D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage2D__IIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint width,
+ jint height,
+ jint format,
+ jint imageSize,
+ jdoubleArray data)
+ {
+ jdouble *ptr8 = NULL;
+
+ if ( disp__glCompressedTexSubImage2D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage2D__IIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint width,
+ jint height,
+ jint format,
+ jint imageSize,
+ jbooleanArray data)
+ {
+ jboolean *ptr8 = NULL;
+
+ if ( disp__glCompressedTexSubImage2D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage2D__IIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint width,
+ jint height,
+ jint format,
+ jint imageSize,
+ jlongArray data)
+ {
+ jlong *ptr8 = NULL;
+
+ if ( disp__glCompressedTexSubImage2D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr8 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr8
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint width,
+ jint height,
+ jint format,
+ jint imageSize,
+ jobject data)
+ {
+ void *ptr8 = NULL;
+
+ if ( disp__glCompressedTexSubImage2D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr8 = (*env)->GetDirectBufferAddress(env, data);
+ if (ptr8 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 8 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glCompressedTexSubImage2D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr8
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCompressedTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLsizei imageSize , const GLvoid * data ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage3D__IIIIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint imageSize,
+ jbyteArray data)
+ {
+ jbyte *ptr10 = NULL;
+
+ if ( disp__glCompressedTexSubImage3D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr10 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr10
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage3D__IIIIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint imageSize,
+ jshortArray data)
+ {
+ jshort *ptr10 = NULL;
+
+ if ( disp__glCompressedTexSubImage3D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr10 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr10
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage3D__IIIIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint imageSize,
+ jintArray data)
+ {
+ jint *ptr10 = NULL;
+
+ if ( disp__glCompressedTexSubImage3D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr10 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr10
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage3D__IIIIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint imageSize,
+ jfloatArray data)
+ {
+ jfloat *ptr10 = NULL;
+
+ if ( disp__glCompressedTexSubImage3D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr10 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr10
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage3D__IIIIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint imageSize,
+ jdoubleArray data)
+ {
+ jdouble *ptr10 = NULL;
+
+ if ( disp__glCompressedTexSubImage3D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr10 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr10
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage3D__IIIIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint imageSize,
+ jbooleanArray data)
+ {
+ jboolean *ptr10 = NULL;
+
+ if ( disp__glCompressedTexSubImage3D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr10 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr10
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage3D__IIIIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint imageSize,
+ jlongArray data)
+ {
+ jlong *ptr10 = NULL;
+
+ if ( disp__glCompressedTexSubImage3D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr10 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glCompressedTexSubImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr10
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage3D__IIIIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint imageSize,
+ jobject data)
+ {
+ void *ptr10 = NULL;
+
+ if ( disp__glCompressedTexSubImage3D == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr10 = (*env)->GetDirectBufferAddress(env, data);
+ if (ptr10 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 10 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glCompressedTexSubImage3D (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLsizei) imageSize,
+ (const GLvoid *) ptr10
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetCompressedTexImage ( GLenum target , GLint lod , GLvoid * img ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCompressedTexImage__II_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint lod,
+ jbyteArray img)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glGetCompressedTexImage == NULL ) return;
+
+ if(img!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, img, &isCopiedArray2);
+ }
+ disp__glGetCompressedTexImage (
+ (GLenum) target,
+ (GLint) lod,
+ (GLvoid *) ptr2
+ );
+
+ if(img!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, img, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCompressedTexImage__II_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint lod,
+ jshortArray img)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jshort *ptr2 = NULL;
+
+ if ( disp__glGetCompressedTexImage == NULL ) return;
+
+ if(img!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, img, &isCopiedArray2);
+ }
+ disp__glGetCompressedTexImage (
+ (GLenum) target,
+ (GLint) lod,
+ (GLvoid *) ptr2
+ );
+
+ if(img!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, img, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCompressedTexImage__II_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint lod,
+ jintArray img)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetCompressedTexImage == NULL ) return;
+
+ if(img!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, img, &isCopiedArray2);
+ }
+ disp__glGetCompressedTexImage (
+ (GLenum) target,
+ (GLint) lod,
+ (GLvoid *) ptr2
+ );
+
+ if(img!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, img, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCompressedTexImage__II_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint lod,
+ jfloatArray img)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetCompressedTexImage == NULL ) return;
+
+ if(img!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, img, &isCopiedArray2);
+ }
+ disp__glGetCompressedTexImage (
+ (GLenum) target,
+ (GLint) lod,
+ (GLvoid *) ptr2
+ );
+
+ if(img!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, img, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCompressedTexImage__II_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint lod,
+ jdoubleArray img)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glGetCompressedTexImage == NULL ) return;
+
+ if(img!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, img, &isCopiedArray2);
+ }
+ disp__glGetCompressedTexImage (
+ (GLenum) target,
+ (GLint) lod,
+ (GLvoid *) ptr2
+ );
+
+ if(img!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, img, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCompressedTexImage__II_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint lod,
+ jbooleanArray img)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glGetCompressedTexImage == NULL ) return;
+
+ if(img!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, img, &isCopiedArray2);
+ }
+ disp__glGetCompressedTexImage (
+ (GLenum) target,
+ (GLint) lod,
+ (GLvoid *) ptr2
+ );
+
+ if(img!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, img, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCompressedTexImage__II_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint lod,
+ jlongArray img)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jlong *ptr2 = NULL;
+
+ if ( disp__glGetCompressedTexImage == NULL ) return;
+
+ if(img!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, img, &isCopiedArray2);
+ }
+ disp__glGetCompressedTexImage (
+ (GLenum) target,
+ (GLint) lod,
+ (GLvoid *) ptr2
+ );
+
+ if(img!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, img, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCompressedTexImage__IILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint lod,
+ jobject img)
+ {
+ void *ptr2 = NULL;
+
+ if ( disp__glGetCompressedTexImage == NULL ) return;
+
+ if(img!=NULL)
+ {
+ ptr2 = (*env)->GetDirectBufferAddress(env, img);
+ if (ptr2 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 2 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glGetCompressedTexImage (
+ (GLenum) target,
+ (GLint) lod,
+ (GLvoid *) ptr2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord1d ( GLenum target , GLdouble s ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord1d (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdouble s)
+ {
+
+ if ( disp__glMultiTexCoord1d == NULL ) return;
+
+ disp__glMultiTexCoord1d (
+ (GLenum) target,
+ (GLdouble) s
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord1dv ( GLenum target , const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord1dv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdoubleArray v)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord1dv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord1dv (
+ (GLenum) target,
+ (const GLdouble *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord1f ( GLenum target , GLfloat s ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord1f (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloat s)
+ {
+
+ if ( disp__glMultiTexCoord1f == NULL ) return;
+
+ disp__glMultiTexCoord1f (
+ (GLenum) target,
+ (GLfloat) s
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord1fv ( GLenum target , const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord1fv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloatArray v)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord1fv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord1fv (
+ (GLenum) target,
+ (const GLfloat *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord1i ( GLenum target , GLint s ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord1i (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint s)
+ {
+
+ if ( disp__glMultiTexCoord1i == NULL ) return;
+
+ disp__glMultiTexCoord1i (
+ (GLenum) target,
+ (GLint) s
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord1iv ( GLenum target , const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord1iv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jintArray v)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord1iv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord1iv (
+ (GLenum) target,
+ (const GLint *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord1s ( GLenum target , GLshort s ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord1s (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jshort s)
+ {
+
+ if ( disp__glMultiTexCoord1s == NULL ) return;
+
+ disp__glMultiTexCoord1s (
+ (GLenum) target,
+ (GLshort) s
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord1sv ( GLenum target , const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord1sv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jshortArray v)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord1sv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord1sv (
+ (GLenum) target,
+ (const GLshort *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord2d ( GLenum target , GLdouble s , GLdouble t ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord2d (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdouble s,
+ jdouble t)
+ {
+
+ if ( disp__glMultiTexCoord2d == NULL ) return;
+
+ disp__glMultiTexCoord2d (
+ (GLenum) target,
+ (GLdouble) s,
+ (GLdouble) t
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord2dv ( GLenum target , const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord2dv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdoubleArray v)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord2dv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord2dv (
+ (GLenum) target,
+ (const GLdouble *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord2f ( GLenum target , GLfloat s , GLfloat t ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord2f (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloat s,
+ jfloat t)
+ {
+
+ if ( disp__glMultiTexCoord2f == NULL ) return;
+
+ disp__glMultiTexCoord2f (
+ (GLenum) target,
+ (GLfloat) s,
+ (GLfloat) t
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord2fv ( GLenum target , const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord2fv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloatArray v)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord2fv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord2fv (
+ (GLenum) target,
+ (const GLfloat *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord2i ( GLenum target , GLint s , GLint t ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord2i (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint s,
+ jint t)
+ {
+
+ if ( disp__glMultiTexCoord2i == NULL ) return;
+
+ disp__glMultiTexCoord2i (
+ (GLenum) target,
+ (GLint) s,
+ (GLint) t
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord2iv ( GLenum target , const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord2iv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jintArray v)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord2iv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord2iv (
+ (GLenum) target,
+ (const GLint *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord2s ( GLenum target , GLshort s , GLshort t ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord2s (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jshort s,
+ jshort t)
+ {
+
+ if ( disp__glMultiTexCoord2s == NULL ) return;
+
+ disp__glMultiTexCoord2s (
+ (GLenum) target,
+ (GLshort) s,
+ (GLshort) t
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord2sv ( GLenum target , const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord2sv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jshortArray v)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord2sv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord2sv (
+ (GLenum) target,
+ (const GLshort *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord3d ( GLenum target , GLdouble s , GLdouble t , GLdouble r ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord3d (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdouble s,
+ jdouble t,
+ jdouble r)
+ {
+
+ if ( disp__glMultiTexCoord3d == NULL ) return;
+
+ disp__glMultiTexCoord3d (
+ (GLenum) target,
+ (GLdouble) s,
+ (GLdouble) t,
+ (GLdouble) r
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord3dv ( GLenum target , const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord3dv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdoubleArray v)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord3dv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord3dv (
+ (GLenum) target,
+ (const GLdouble *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord3f ( GLenum target , GLfloat s , GLfloat t , GLfloat r ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord3f (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloat s,
+ jfloat t,
+ jfloat r)
+ {
+
+ if ( disp__glMultiTexCoord3f == NULL ) return;
+
+ disp__glMultiTexCoord3f (
+ (GLenum) target,
+ (GLfloat) s,
+ (GLfloat) t,
+ (GLfloat) r
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord3fv ( GLenum target , const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord3fv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloatArray v)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord3fv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord3fv (
+ (GLenum) target,
+ (const GLfloat *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord3i ( GLenum target , GLint s , GLint t , GLint r ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord3i (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint s,
+ jint t,
+ jint r)
+ {
+
+ if ( disp__glMultiTexCoord3i == NULL ) return;
+
+ disp__glMultiTexCoord3i (
+ (GLenum) target,
+ (GLint) s,
+ (GLint) t,
+ (GLint) r
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord3iv ( GLenum target , const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord3iv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jintArray v)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord3iv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord3iv (
+ (GLenum) target,
+ (const GLint *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord3s ( GLenum target , GLshort s , GLshort t , GLshort r ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord3s (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jshort s,
+ jshort t,
+ jshort r)
+ {
+
+ if ( disp__glMultiTexCoord3s == NULL ) return;
+
+ disp__glMultiTexCoord3s (
+ (GLenum) target,
+ (GLshort) s,
+ (GLshort) t,
+ (GLshort) r
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord3sv ( GLenum target , const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord3sv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jshortArray v)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord3sv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord3sv (
+ (GLenum) target,
+ (const GLshort *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord4d ( GLenum target , GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord4d (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdouble s,
+ jdouble t,
+ jdouble r,
+ jdouble q)
+ {
+
+ if ( disp__glMultiTexCoord4d == NULL ) return;
+
+ disp__glMultiTexCoord4d (
+ (GLenum) target,
+ (GLdouble) s,
+ (GLdouble) t,
+ (GLdouble) r,
+ (GLdouble) q
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord4dv ( GLenum target , const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord4dv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdoubleArray v)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord4dv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord4dv (
+ (GLenum) target,
+ (const GLdouble *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord4f ( GLenum target , GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord4f (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloat s,
+ jfloat t,
+ jfloat r,
+ jfloat q)
+ {
+
+ if ( disp__glMultiTexCoord4f == NULL ) return;
+
+ disp__glMultiTexCoord4f (
+ (GLenum) target,
+ (GLfloat) s,
+ (GLfloat) t,
+ (GLfloat) r,
+ (GLfloat) q
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord4fv ( GLenum target , const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord4fv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloatArray v)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord4fv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord4fv (
+ (GLenum) target,
+ (const GLfloat *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord4i ( GLenum target , GLint s , GLint t , GLint r , GLint q ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord4i (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint s,
+ jint t,
+ jint r,
+ jint q)
+ {
+
+ if ( disp__glMultiTexCoord4i == NULL ) return;
+
+ disp__glMultiTexCoord4i (
+ (GLenum) target,
+ (GLint) s,
+ (GLint) t,
+ (GLint) r,
+ (GLint) q
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord4iv ( GLenum target , const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord4iv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jintArray v)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord4iv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord4iv (
+ (GLenum) target,
+ (const GLint *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord4s ( GLenum target , GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord4s (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jshort s,
+ jshort t,
+ jshort r,
+ jshort q)
+ {
+
+ if ( disp__glMultiTexCoord4s == NULL ) return;
+
+ disp__glMultiTexCoord4s (
+ (GLenum) target,
+ (GLshort) s,
+ (GLshort) t,
+ (GLshort) r,
+ (GLshort) q
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord4sv ( GLenum target , const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord4sv (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jshortArray v)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord4sv == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord4sv (
+ (GLenum) target,
+ (const GLshort *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLoadTransposeMatrixd ( const GLdouble m [ 16 ] ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLoadTransposeMatrixd (
+ JNIEnv *env, jobject obj,
+ jdoubleArray m)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glLoadTransposeMatrixd == NULL ) return;
+
+ if(m!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, m, 0);
+ }
+ disp__glLoadTransposeMatrixd (
+ (const GLdouble *) ptr0
+ );
+
+ if(m!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, m, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLoadTransposeMatrixf ( const GLfloat m [ 16 ] ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLoadTransposeMatrixf (
+ JNIEnv *env, jobject obj,
+ jfloatArray m)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glLoadTransposeMatrixf == NULL ) return;
+
+ if(m!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, m, 0);
+ }
+ disp__glLoadTransposeMatrixf (
+ (const GLfloat *) ptr0
+ );
+
+ if(m!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, m, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultTransposeMatrixd ( const GLdouble m [ 16 ] ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultTransposeMatrixd (
+ JNIEnv *env, jobject obj,
+ jdoubleArray m)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glMultTransposeMatrixd == NULL ) return;
+
+ if(m!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, m, 0);
+ }
+ disp__glMultTransposeMatrixd (
+ (const GLdouble *) ptr0
+ );
+
+ if(m!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, m, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultTransposeMatrixf ( const GLfloat m [ 16 ] ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultTransposeMatrixf (
+ JNIEnv *env, jobject obj,
+ jfloatArray m)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glMultTransposeMatrixf == NULL ) return;
+
+ if(m!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, m, 0);
+ }
+ disp__glMultTransposeMatrixf (
+ (const GLfloat *) ptr0
+ );
+
+ if(m!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, m, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSampleCoverage ( GLclampf value , GLboolean invert ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSampleCoverage (
+ JNIEnv *env, jobject obj,
+ jfloat value,
+ jboolean invert)
+ {
+
+ if ( disp__glSampleCoverage == NULL ) return;
+
+ disp__glSampleCoverage (
+ (GLclampf) value,
+ (GLboolean) invert
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSamplePass ( GLenum pass ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSamplePass (
+ JNIEnv *env, jobject obj,
+ jint pass)
+ {
+
+ if ( disp__glSamplePass == NULL ) return;
+
+ disp__glSamplePass (
+ (GLenum) pass
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glActiveTextureARB ( GLenum texture ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glActiveTextureARB (
+ JNIEnv *env, jobject obj,
+ jint texture)
+ {
+
+ if ( disp__glActiveTextureARB == NULL ) return;
+
+ disp__glActiveTextureARB (
+ (GLenum) texture
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glClientActiveTextureARB ( GLenum texture ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glClientActiveTextureARB (
+ JNIEnv *env, jobject obj,
+ jint texture)
+ {
+
+ if ( disp__glClientActiveTextureARB == NULL ) return;
+
+ disp__glClientActiveTextureARB (
+ (GLenum) texture
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord1dARB ( GLenum target , GLdouble s ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord1dARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdouble s)
+ {
+
+ if ( disp__glMultiTexCoord1dARB == NULL ) return;
+
+ disp__glMultiTexCoord1dARB (
+ (GLenum) target,
+ (GLdouble) s
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord1dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord1dvARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdoubleArray v)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord1dvARB == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord1dvARB (
+ (GLenum) target,
+ (const GLdouble *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord1fARB ( GLenum target , GLfloat s ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord1fARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloat s)
+ {
+
+ if ( disp__glMultiTexCoord1fARB == NULL ) return;
+
+ disp__glMultiTexCoord1fARB (
+ (GLenum) target,
+ (GLfloat) s
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord1fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord1fvARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloatArray v)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord1fvARB == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord1fvARB (
+ (GLenum) target,
+ (const GLfloat *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord1iARB ( GLenum target , GLint s ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord1iARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint s)
+ {
+
+ if ( disp__glMultiTexCoord1iARB == NULL ) return;
+
+ disp__glMultiTexCoord1iARB (
+ (GLenum) target,
+ (GLint) s
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord1ivARB ( GLenum target , const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord1ivARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jintArray v)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord1ivARB == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord1ivARB (
+ (GLenum) target,
+ (const GLint *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord1sARB ( GLenum target , GLshort s ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord1sARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jshort s)
+ {
+
+ if ( disp__glMultiTexCoord1sARB == NULL ) return;
+
+ disp__glMultiTexCoord1sARB (
+ (GLenum) target,
+ (GLshort) s
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord1svARB ( GLenum target , const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord1svARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jshortArray v)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord1svARB == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord1svARB (
+ (GLenum) target,
+ (const GLshort *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord2dARB ( GLenum target , GLdouble s , GLdouble t ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord2dARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdouble s,
+ jdouble t)
+ {
+
+ if ( disp__glMultiTexCoord2dARB == NULL ) return;
+
+ disp__glMultiTexCoord2dARB (
+ (GLenum) target,
+ (GLdouble) s,
+ (GLdouble) t
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord2dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord2dvARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdoubleArray v)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord2dvARB == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord2dvARB (
+ (GLenum) target,
+ (const GLdouble *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord2fARB ( GLenum target , GLfloat s , GLfloat t ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord2fARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloat s,
+ jfloat t)
+ {
+
+ if ( disp__glMultiTexCoord2fARB == NULL ) return;
+
+ disp__glMultiTexCoord2fARB (
+ (GLenum) target,
+ (GLfloat) s,
+ (GLfloat) t
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord2fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord2fvARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloatArray v)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord2fvARB == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord2fvARB (
+ (GLenum) target,
+ (const GLfloat *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord2iARB ( GLenum target , GLint s , GLint t ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord2iARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint s,
+ jint t)
+ {
+
+ if ( disp__glMultiTexCoord2iARB == NULL ) return;
+
+ disp__glMultiTexCoord2iARB (
+ (GLenum) target,
+ (GLint) s,
+ (GLint) t
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord2ivARB ( GLenum target , const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord2ivARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jintArray v)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord2ivARB == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord2ivARB (
+ (GLenum) target,
+ (const GLint *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord2sARB ( GLenum target , GLshort s , GLshort t ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord2sARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jshort s,
+ jshort t)
+ {
+
+ if ( disp__glMultiTexCoord2sARB == NULL ) return;
+
+ disp__glMultiTexCoord2sARB (
+ (GLenum) target,
+ (GLshort) s,
+ (GLshort) t
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord2svARB ( GLenum target , const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord2svARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jshortArray v)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord2svARB == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord2svARB (
+ (GLenum) target,
+ (const GLshort *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord3dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord3dARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdouble s,
+ jdouble t,
+ jdouble r)
+ {
+
+ if ( disp__glMultiTexCoord3dARB == NULL ) return;
+
+ disp__glMultiTexCoord3dARB (
+ (GLenum) target,
+ (GLdouble) s,
+ (GLdouble) t,
+ (GLdouble) r
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord3dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord3dvARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdoubleArray v)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord3dvARB == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord3dvARB (
+ (GLenum) target,
+ (const GLdouble *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord3fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord3fARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloat s,
+ jfloat t,
+ jfloat r)
+ {
+
+ if ( disp__glMultiTexCoord3fARB == NULL ) return;
+
+ disp__glMultiTexCoord3fARB (
+ (GLenum) target,
+ (GLfloat) s,
+ (GLfloat) t,
+ (GLfloat) r
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord3fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord3fvARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloatArray v)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord3fvARB == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord3fvARB (
+ (GLenum) target,
+ (const GLfloat *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord3iARB ( GLenum target , GLint s , GLint t , GLint r ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord3iARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint s,
+ jint t,
+ jint r)
+ {
+
+ if ( disp__glMultiTexCoord3iARB == NULL ) return;
+
+ disp__glMultiTexCoord3iARB (
+ (GLenum) target,
+ (GLint) s,
+ (GLint) t,
+ (GLint) r
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord3ivARB ( GLenum target , const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord3ivARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jintArray v)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord3ivARB == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord3ivARB (
+ (GLenum) target,
+ (const GLint *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord3sARB ( GLenum target , GLshort s , GLshort t , GLshort r ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord3sARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jshort s,
+ jshort t,
+ jshort r)
+ {
+
+ if ( disp__glMultiTexCoord3sARB == NULL ) return;
+
+ disp__glMultiTexCoord3sARB (
+ (GLenum) target,
+ (GLshort) s,
+ (GLshort) t,
+ (GLshort) r
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord3svARB ( GLenum target , const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord3svARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jshortArray v)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord3svARB == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord3svARB (
+ (GLenum) target,
+ (const GLshort *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord4dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord4dARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdouble s,
+ jdouble t,
+ jdouble r,
+ jdouble q)
+ {
+
+ if ( disp__glMultiTexCoord4dARB == NULL ) return;
+
+ disp__glMultiTexCoord4dARB (
+ (GLenum) target,
+ (GLdouble) s,
+ (GLdouble) t,
+ (GLdouble) r,
+ (GLdouble) q
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord4dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord4dvARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jdoubleArray v)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord4dvARB == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord4dvARB (
+ (GLenum) target,
+ (const GLdouble *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord4fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord4fARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloat s,
+ jfloat t,
+ jfloat r,
+ jfloat q)
+ {
+
+ if ( disp__glMultiTexCoord4fARB == NULL ) return;
+
+ disp__glMultiTexCoord4fARB (
+ (GLenum) target,
+ (GLfloat) s,
+ (GLfloat) t,
+ (GLfloat) r,
+ (GLfloat) q
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord4fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord4fvARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jfloatArray v)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord4fvARB == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord4fvARB (
+ (GLenum) target,
+ (const GLfloat *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord4iARB ( GLenum target , GLint s , GLint t , GLint r , GLint q ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord4iARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint s,
+ jint t,
+ jint r,
+ jint q)
+ {
+
+ if ( disp__glMultiTexCoord4iARB == NULL ) return;
+
+ disp__glMultiTexCoord4iARB (
+ (GLenum) target,
+ (GLint) s,
+ (GLint) t,
+ (GLint) r,
+ (GLint) q
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord4ivARB ( GLenum target , const GLint * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord4ivARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jintArray v)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord4ivARB == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord4ivARB (
+ (GLenum) target,
+ (const GLint *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord4sARB ( GLenum target , GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord4sARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jshort s,
+ jshort t,
+ jshort r,
+ jshort q)
+ {
+
+ if ( disp__glMultiTexCoord4sARB == NULL ) return;
+
+ disp__glMultiTexCoord4sARB (
+ (GLenum) target,
+ (GLshort) s,
+ (GLshort) t,
+ (GLshort) r,
+ (GLshort) q
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiTexCoord4svARB ( GLenum target , const GLshort * v ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiTexCoord4svARB (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jshortArray v)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glMultiTexCoord4svARB == NULL ) return;
+
+ if(v!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+ }
+ disp__glMultiTexCoord4svARB (
+ (GLenum) target,
+ (const GLshort *) ptr1
+ );
+
+ if(v!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, v, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBlendColorEXT ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBlendColorEXT (
+ JNIEnv *env, jobject obj,
+ jfloat red,
+ jfloat green,
+ jfloat blue,
+ jfloat alpha)
+ {
+
+ if ( disp__glBlendColorEXT == NULL ) return;
+
+ disp__glBlendColorEXT (
+ (GLclampf) red,
+ (GLclampf) green,
+ (GLclampf) blue,
+ (GLclampf) alpha
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPolygonOffsetEXT ( GLfloat factor , GLfloat bias ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPolygonOffsetEXT (
+ JNIEnv *env, jobject obj,
+ jfloat factor,
+ jfloat bias)
+ {
+
+ if ( disp__glPolygonOffsetEXT == NULL ) return;
+
+ disp__glPolygonOffsetEXT (
+ (GLfloat) factor,
+ (GLfloat) bias
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexImage3DEXT ( GLenum target , GLint level , GLenum internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage3DEXT__IIIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint format,
+ jint type,
+ jbyteArray pixels)
+ {
+ jbyte *ptr9 = NULL;
+
+ if ( disp__glTexImage3DEXT == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr9 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage3DEXT (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr9
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr9, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage3DEXT__IIIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint format,
+ jint type,
+ jshortArray pixels)
+ {
+ jshort *ptr9 = NULL;
+
+ if ( disp__glTexImage3DEXT == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr9 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage3DEXT (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr9
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr9, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage3DEXT__IIIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint format,
+ jint type,
+ jintArray pixels)
+ {
+ jint *ptr9 = NULL;
+
+ if ( disp__glTexImage3DEXT == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr9 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage3DEXT (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr9
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr9, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage3DEXT__IIIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint format,
+ jint type,
+ jfloatArray pixels)
+ {
+ jfloat *ptr9 = NULL;
+
+ if ( disp__glTexImage3DEXT == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr9 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage3DEXT (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr9
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr9, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage3DEXT__IIIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint format,
+ jint type,
+ jdoubleArray pixels)
+ {
+ jdouble *ptr9 = NULL;
+
+ if ( disp__glTexImage3DEXT == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr9 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage3DEXT (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr9
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr9, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage3DEXT__IIIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint format,
+ jint type,
+ jbooleanArray pixels)
+ {
+ jboolean *ptr9 = NULL;
+
+ if ( disp__glTexImage3DEXT == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr9 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage3DEXT (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr9
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr9, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage3DEXT__IIIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint format,
+ jint type,
+ jlongArray pixels)
+ {
+ jlong *ptr9 = NULL;
+
+ if ( disp__glTexImage3DEXT == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr9 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexImage3DEXT (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr9
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr9, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage3DEXT__IIIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint internalFormat,
+ jint width,
+ jint height,
+ jint depth,
+ jint border,
+ jint format,
+ jint type,
+ jobject pixels)
+ {
+ void *ptr9 = NULL;
+
+ if ( disp__glTexImage3DEXT == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr9 = (*env)->GetDirectBufferAddress(env, pixels);
+ if (ptr9 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 9 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glTexImage3DEXT (
+ (GLenum) target,
+ (GLint) level,
+ (GLenum) internalFormat,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLint) border,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr9
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage3DEXT__IIIIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jbyteArray pixels)
+ {
+ jbyte *ptr10 = NULL;
+
+ if ( disp__glTexSubImage3DEXT == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr10 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage3DEXT (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr10
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage3DEXT__IIIIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jshortArray pixels)
+ {
+ jshort *ptr10 = NULL;
+
+ if ( disp__glTexSubImage3DEXT == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr10 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage3DEXT (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr10
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage3DEXT__IIIIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jintArray pixels)
+ {
+ jint *ptr10 = NULL;
+
+ if ( disp__glTexSubImage3DEXT == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr10 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage3DEXT (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr10
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage3DEXT__IIIIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jfloatArray pixels)
+ {
+ jfloat *ptr10 = NULL;
+
+ if ( disp__glTexSubImage3DEXT == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr10 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage3DEXT (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr10
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage3DEXT__IIIIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jdoubleArray pixels)
+ {
+ jdouble *ptr10 = NULL;
+
+ if ( disp__glTexSubImage3DEXT == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr10 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage3DEXT (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr10
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage3DEXT__IIIIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jbooleanArray pixels)
+ {
+ jboolean *ptr10 = NULL;
+
+ if ( disp__glTexSubImage3DEXT == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr10 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage3DEXT (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr10
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage3DEXT__IIIIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jlongArray pixels)
+ {
+ jlong *ptr10 = NULL;
+
+ if ( disp__glTexSubImage3DEXT == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr10 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+ }
+ disp__glTexSubImage3DEXT (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr10
+ );
+
+ if(pixels!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, pixels, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage3DEXT__IIIIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint width,
+ jint height,
+ jint depth,
+ jint format,
+ jint type,
+ jobject pixels)
+ {
+ void *ptr10 = NULL;
+
+ if ( disp__glTexSubImage3DEXT == NULL ) return;
+
+ if(pixels!=NULL)
+ {
+ ptr10 = (*env)->GetDirectBufferAddress(env, pixels);
+ if (ptr10 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 10 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glTexSubImage3DEXT (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLsizei) width,
+ (GLsizei) height,
+ (GLsizei) depth,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr10
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyTexSubImage3DEXT (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint level,
+ jint xoffset,
+ jint yoffset,
+ jint zoffset,
+ jint x,
+ jint y,
+ jint width,
+ jint height)
+ {
+
+ if ( disp__glCopyTexSubImage3DEXT == NULL ) return;
+
+ disp__glCopyTexSubImage3DEXT (
+ (GLenum) target,
+ (GLint) level,
+ (GLint) xoffset,
+ (GLint) yoffset,
+ (GLint) zoffset,
+ (GLint) x,
+ (GLint) y,
+ (GLsizei) width,
+ (GLsizei) height
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGenTexturesEXT ( GLsizei n , GLuint * textures ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGenTexturesEXT (
+ JNIEnv *env, jobject obj,
+ jint n,
+ jintArray textures)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jint *ptr1 = NULL;
+
+ if ( disp__glGenTexturesEXT == NULL ) return;
+
+ if(textures!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, &isCopiedArray1);
+ }
+ disp__glGenTexturesEXT (
+ (GLsizei) n,
+ (GLuint *) ptr1
+ );
+
+ if(textures!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, textures, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDeleteTexturesEXT ( GLsizei n , const GLuint * textures ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDeleteTexturesEXT (
+ JNIEnv *env, jobject obj,
+ jint n,
+ jintArray textures)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glDeleteTexturesEXT == NULL ) return;
+
+ if(textures!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, 0);
+ }
+ disp__glDeleteTexturesEXT (
+ (GLsizei) n,
+ (const GLuint *) ptr1
+ );
+
+ if(textures!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, textures, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBindTextureEXT ( GLenum target , GLuint texture ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBindTextureEXT (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint texture)
+ {
+
+ if ( disp__glBindTextureEXT == NULL ) return;
+
+ disp__glBindTextureEXT (
+ (GLenum) target,
+ (GLuint) texture
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPrioritizeTexturesEXT ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPrioritizeTexturesEXT (
+ JNIEnv *env, jobject obj,
+ jint n,
+ jintArray textures,
+ jfloatArray priorities)
+ {
+ jint *ptr1 = NULL;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glPrioritizeTexturesEXT == NULL ) return;
+
+ if(textures!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, 0);
+ }
+ if(priorities!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, priorities, 0);
+ }
+ disp__glPrioritizeTexturesEXT (
+ (GLsizei) n,
+ (const GLuint *) ptr1,
+ (const GLclampf *) ptr2
+ );
+
+ if(textures!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, textures, ptr1, JNI_ABORT);
+ }
+ if(priorities!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, priorities, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLboolean glAreTexturesResidentEXT ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ * </pre>
+ */
+ JNIEXPORT jboolean JNICALL
+ Java_gl4java_GLFunc14JauJNI_glAreTexturesResidentEXT (
+ JNIEnv *env, jobject obj,
+ jint n,
+ jintArray textures,
+ jbooleanArray residences)
+ {
+ jboolean ret;
+
+ jint *ptr1 = NULL;
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glAreTexturesResidentEXT == NULL ) return 0;
+
+ if(textures!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, 0);
+ }
+ if(residences!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, residences, &isCopiedArray2);
+ }
+ ret = (jboolean) disp__glAreTexturesResidentEXT (
+ (GLsizei) n,
+ (const GLuint *) ptr1,
+ (GLboolean *) ptr2
+ );
+
+ if(textures!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, textures, ptr1, JNI_ABORT);
+ }
+ if(residences!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, residences, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLboolean glIsTextureEXT ( GLuint texture ) ;
+ * </pre>
+ */
+ JNIEXPORT jboolean JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIsTextureEXT (
+ JNIEnv *env, jobject obj,
+ jint texture)
+ {
+ jboolean ret;
+
+
+ if ( disp__glIsTextureEXT == NULL ) return 0;
+
+ ret = (jboolean) disp__glIsTextureEXT (
+ (GLuint) texture
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointerEXT__IIII_3B (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jbyteArray ptr)
+ {
+ jbyte *ptr4 = NULL;
+
+ if ( disp__glVertexPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glVertexPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointerEXT__IIII_3S (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jshortArray ptr)
+ {
+ jshort *ptr4 = NULL;
+
+ if ( disp__glVertexPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glVertexPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointerEXT__IIII_3I (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jintArray ptr)
+ {
+ jint *ptr4 = NULL;
+
+ if ( disp__glVertexPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glVertexPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointerEXT__IIII_3F (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jfloatArray ptr)
+ {
+ jfloat *ptr4 = NULL;
+
+ if ( disp__glVertexPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glVertexPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointerEXT__IIII_3D (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jdoubleArray ptr)
+ {
+ jdouble *ptr4 = NULL;
+
+ if ( disp__glVertexPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glVertexPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointerEXT__IIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jbooleanArray ptr)
+ {
+ jboolean *ptr4 = NULL;
+
+ if ( disp__glVertexPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glVertexPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointerEXT__IIII_3J (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jlongArray ptr)
+ {
+ jlong *ptr4 = NULL;
+
+ if ( disp__glVertexPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glVertexPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointerEXT__IIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jobject ptr)
+ {
+ void *ptr4 = NULL;
+
+ if ( disp__glVertexPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (*env)->GetDirectBufferAddress(env, ptr);
+ if (ptr4 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 4 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glVertexPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormalPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointerEXT__III_3B (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jint count,
+ jbyteArray ptr)
+ {
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glNormalPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glNormalPointerEXT (
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointerEXT__III_3S (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jint count,
+ jshortArray ptr)
+ {
+ jshort *ptr3 = NULL;
+
+ if ( disp__glNormalPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glNormalPointerEXT (
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointerEXT__III_3I (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jint count,
+ jintArray ptr)
+ {
+ jint *ptr3 = NULL;
+
+ if ( disp__glNormalPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glNormalPointerEXT (
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointerEXT__III_3F (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jint count,
+ jfloatArray ptr)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glNormalPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glNormalPointerEXT (
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointerEXT__III_3D (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jint count,
+ jdoubleArray ptr)
+ {
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glNormalPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glNormalPointerEXT (
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointerEXT__III_3Z (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jint count,
+ jbooleanArray ptr)
+ {
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glNormalPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glNormalPointerEXT (
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointerEXT__III_3J (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jint count,
+ jlongArray ptr)
+ {
+ jlong *ptr3 = NULL;
+
+ if ( disp__glNormalPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glNormalPointerEXT (
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointerEXT__IIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jint count,
+ jobject ptr)
+ {
+ void *ptr3 = NULL;
+
+ if ( disp__glNormalPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, ptr);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glNormalPointerEXT (
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointerEXT__IIII_3B (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jbyteArray ptr)
+ {
+ jbyte *ptr4 = NULL;
+
+ if ( disp__glColorPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glColorPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointerEXT__IIII_3S (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jshortArray ptr)
+ {
+ jshort *ptr4 = NULL;
+
+ if ( disp__glColorPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glColorPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointerEXT__IIII_3I (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jintArray ptr)
+ {
+ jint *ptr4 = NULL;
+
+ if ( disp__glColorPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glColorPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointerEXT__IIII_3F (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jfloatArray ptr)
+ {
+ jfloat *ptr4 = NULL;
+
+ if ( disp__glColorPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glColorPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointerEXT__IIII_3D (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jdoubleArray ptr)
+ {
+ jdouble *ptr4 = NULL;
+
+ if ( disp__glColorPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glColorPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointerEXT__IIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jbooleanArray ptr)
+ {
+ jboolean *ptr4 = NULL;
+
+ if ( disp__glColorPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glColorPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointerEXT__IIII_3J (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jlongArray ptr)
+ {
+ jlong *ptr4 = NULL;
+
+ if ( disp__glColorPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glColorPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointerEXT__IIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jobject ptr)
+ {
+ void *ptr4 = NULL;
+
+ if ( disp__glColorPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (*env)->GetDirectBufferAddress(env, ptr);
+ if (ptr4 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 4 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glColorPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glIndexPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointerEXT__III_3B (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jint count,
+ jbyteArray ptr)
+ {
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glIndexPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glIndexPointerEXT (
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointerEXT__III_3S (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jint count,
+ jshortArray ptr)
+ {
+ jshort *ptr3 = NULL;
+
+ if ( disp__glIndexPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glIndexPointerEXT (
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointerEXT__III_3I (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jint count,
+ jintArray ptr)
+ {
+ jint *ptr3 = NULL;
+
+ if ( disp__glIndexPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glIndexPointerEXT (
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointerEXT__III_3F (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jint count,
+ jfloatArray ptr)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glIndexPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glIndexPointerEXT (
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointerEXT__III_3D (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jint count,
+ jdoubleArray ptr)
+ {
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glIndexPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glIndexPointerEXT (
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointerEXT__III_3Z (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jint count,
+ jbooleanArray ptr)
+ {
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glIndexPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glIndexPointerEXT (
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointerEXT__III_3J (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jint count,
+ jlongArray ptr)
+ {
+ jlong *ptr3 = NULL;
+
+ if ( disp__glIndexPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glIndexPointerEXT (
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr3
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointerEXT__IIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint type,
+ jint stride,
+ jint count,
+ jobject ptr)
+ {
+ void *ptr3 = NULL;
+
+ if ( disp__glIndexPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, ptr);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glIndexPointerEXT (
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoordPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointerEXT__IIII_3B (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jbyteArray ptr)
+ {
+ jbyte *ptr4 = NULL;
+
+ if ( disp__glTexCoordPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glTexCoordPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointerEXT__IIII_3S (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jshortArray ptr)
+ {
+ jshort *ptr4 = NULL;
+
+ if ( disp__glTexCoordPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glTexCoordPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointerEXT__IIII_3I (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jintArray ptr)
+ {
+ jint *ptr4 = NULL;
+
+ if ( disp__glTexCoordPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glTexCoordPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointerEXT__IIII_3F (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jfloatArray ptr)
+ {
+ jfloat *ptr4 = NULL;
+
+ if ( disp__glTexCoordPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glTexCoordPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointerEXT__IIII_3D (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jdoubleArray ptr)
+ {
+ jdouble *ptr4 = NULL;
+
+ if ( disp__glTexCoordPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glTexCoordPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointerEXT__IIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jbooleanArray ptr)
+ {
+ jboolean *ptr4 = NULL;
+
+ if ( disp__glTexCoordPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glTexCoordPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointerEXT__IIII_3J (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jlongArray ptr)
+ {
+ jlong *ptr4 = NULL;
+
+ if ( disp__glTexCoordPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glTexCoordPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointerEXT__IIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint size,
+ jint type,
+ jint stride,
+ jint count,
+ jobject ptr)
+ {
+ void *ptr4 = NULL;
+
+ if ( disp__glTexCoordPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr4 = (*env)->GetDirectBufferAddress(env, ptr);
+ if (ptr4 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 4 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glTexCoordPointerEXT (
+ (GLint) size,
+ (GLenum) type,
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLvoid *) ptr4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEdgeFlagPointerEXT ( GLsizei stride , GLsizei count , const GLboolean * ptr ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEdgeFlagPointerEXT (
+ JNIEnv *env, jobject obj,
+ jint stride,
+ jint count,
+ jbooleanArray ptr)
+ {
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glEdgeFlagPointerEXT == NULL ) return;
+
+ if(ptr!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+ }
+ disp__glEdgeFlagPointerEXT (
+ (GLsizei) stride,
+ (GLsizei) count,
+ (const GLboolean *) ptr2
+ );
+
+ if(ptr!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, ptr, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetPointervEXT ( GLenum pname , GLvoid * * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPointervEXT__I_3_3B (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jbyteArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jbyte *ptr1 = NULL;
+
+ if ( disp__glGetPointervEXT == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetPointervEXT (
+ (GLenum) pname,
+ (GLvoid **) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPointervEXT__I_3_3S (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jshortArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jshort *ptr1 = NULL;
+
+ if ( disp__glGetPointervEXT == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetPointervEXT (
+ (GLenum) pname,
+ (GLvoid **) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPointervEXT__I_3_3I (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jintArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jint *ptr1 = NULL;
+
+ if ( disp__glGetPointervEXT == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetPointervEXT (
+ (GLenum) pname,
+ (GLvoid **) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPointervEXT__I_3_3F (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jfloatArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glGetPointervEXT == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetPointervEXT (
+ (GLenum) pname,
+ (GLvoid **) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPointervEXT__I_3_3D (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jdoubleArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glGetPointervEXT == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetPointervEXT (
+ (GLenum) pname,
+ (GLvoid **) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPointervEXT__I_3_3Z (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jbooleanArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jboolean *ptr1 = NULL;
+
+ if ( disp__glGetPointervEXT == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetPointervEXT (
+ (GLenum) pname,
+ (GLvoid **) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPointervEXT__I_3_3J (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jlongArray params)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jlong *ptr1 = NULL;
+
+ if ( disp__glGetPointervEXT == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+ }
+ disp__glGetPointervEXT (
+ (GLenum) pname,
+ (GLvoid **) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glArrayElementEXT ( GLint i ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glArrayElementEXT (
+ JNIEnv *env, jobject obj,
+ jint i)
+ {
+
+ if ( disp__glArrayElementEXT == NULL ) return;
+
+ disp__glArrayElementEXT (
+ (GLint) i
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDrawArraysEXT ( GLenum mode , GLint first , GLsizei count ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawArraysEXT (
+ JNIEnv *env, jobject obj,
+ jint mode,
+ jint first,
+ jint count)
+ {
+
+ if ( disp__glDrawArraysEXT == NULL ) return;
+
+ disp__glDrawArraysEXT (
+ (GLenum) mode,
+ (GLint) first,
+ (GLsizei) count
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBlendEquationEXT ( GLenum mode ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBlendEquationEXT (
+ JNIEnv *env, jobject obj,
+ jint mode)
+ {
+
+ if ( disp__glBlendEquationEXT == NULL ) return;
+
+ disp__glBlendEquationEXT (
+ (GLenum) mode
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPointParameterfEXT ( GLenum pname , GLfloat param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPointParameterfEXT (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jfloat param)
+ {
+
+ if ( disp__glPointParameterfEXT == NULL ) return;
+
+ disp__glPointParameterfEXT (
+ (GLenum) pname,
+ (GLfloat) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPointParameterfvEXT ( GLenum pname , const GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPointParameterfvEXT (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jfloatArray params)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glPointParameterfvEXT == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glPointParameterfvEXT (
+ (GLenum) pname,
+ (const GLfloat *) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPointParameterfSGIS ( GLenum pname , GLfloat param ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPointParameterfSGIS (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jfloat param)
+ {
+
+ if ( disp__glPointParameterfSGIS == NULL ) return;
+
+ disp__glPointParameterfSGIS (
+ (GLenum) pname,
+ (GLfloat) param
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPointParameterfvSGIS ( GLenum pname , const GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPointParameterfvSGIS (
+ JNIEnv *env, jobject obj,
+ jint pname,
+ jfloatArray params)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glPointParameterfvSGIS == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+ }
+ disp__glPointParameterfvSGIS (
+ (GLenum) pname,
+ (const GLfloat *) ptr1
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorTableEXT ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableEXT__IIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jbyteArray table)
+ {
+ jbyte *ptr5 = NULL;
+
+ if ( disp__glColorTableEXT == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+ }
+ disp__glColorTableEXT (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableEXT__IIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jshortArray table)
+ {
+ jshort *ptr5 = NULL;
+
+ if ( disp__glColorTableEXT == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+ }
+ disp__glColorTableEXT (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableEXT__IIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jintArray table)
+ {
+ jint *ptr5 = NULL;
+
+ if ( disp__glColorTableEXT == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+ }
+ disp__glColorTableEXT (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableEXT__IIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jfloatArray table)
+ {
+ jfloat *ptr5 = NULL;
+
+ if ( disp__glColorTableEXT == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+ }
+ disp__glColorTableEXT (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableEXT__IIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jdoubleArray table)
+ {
+ jdouble *ptr5 = NULL;
+
+ if ( disp__glColorTableEXT == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+ }
+ disp__glColorTableEXT (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableEXT__IIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jbooleanArray table)
+ {
+ jboolean *ptr5 = NULL;
+
+ if ( disp__glColorTableEXT == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+ }
+ disp__glColorTableEXT (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableEXT__IIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jlongArray table)
+ {
+ jlong *ptr5 = NULL;
+
+ if ( disp__glColorTableEXT == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+ }
+ disp__glColorTableEXT (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableEXT__IIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint internalformat,
+ jint width,
+ jint format,
+ jint type,
+ jobject table)
+ {
+ void *ptr5 = NULL;
+
+ if ( disp__glColorTableEXT == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr5 = (*env)->GetDirectBufferAddress(env, table);
+ if (ptr5 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 5 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glColorTableEXT (
+ (GLenum) target,
+ (GLenum) internalformat,
+ (GLsizei) width,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorSubTableEXT ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorSubTableEXT__IIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint start,
+ jint count,
+ jint format,
+ jint type,
+ jbyteArray data)
+ {
+ jbyte *ptr5 = NULL;
+
+ if ( disp__glColorSubTableEXT == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glColorSubTableEXT (
+ (GLenum) target,
+ (GLsizei) start,
+ (GLsizei) count,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorSubTableEXT__IIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint start,
+ jint count,
+ jint format,
+ jint type,
+ jshortArray data)
+ {
+ jshort *ptr5 = NULL;
+
+ if ( disp__glColorSubTableEXT == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glColorSubTableEXT (
+ (GLenum) target,
+ (GLsizei) start,
+ (GLsizei) count,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorSubTableEXT__IIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint start,
+ jint count,
+ jint format,
+ jint type,
+ jintArray data)
+ {
+ jint *ptr5 = NULL;
+
+ if ( disp__glColorSubTableEXT == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glColorSubTableEXT (
+ (GLenum) target,
+ (GLsizei) start,
+ (GLsizei) count,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorSubTableEXT__IIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint start,
+ jint count,
+ jint format,
+ jint type,
+ jfloatArray data)
+ {
+ jfloat *ptr5 = NULL;
+
+ if ( disp__glColorSubTableEXT == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glColorSubTableEXT (
+ (GLenum) target,
+ (GLsizei) start,
+ (GLsizei) count,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorSubTableEXT__IIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint start,
+ jint count,
+ jint format,
+ jint type,
+ jdoubleArray data)
+ {
+ jdouble *ptr5 = NULL;
+
+ if ( disp__glColorSubTableEXT == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glColorSubTableEXT (
+ (GLenum) target,
+ (GLsizei) start,
+ (GLsizei) count,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorSubTableEXT__IIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint start,
+ jint count,
+ jint format,
+ jint type,
+ jbooleanArray data)
+ {
+ jboolean *ptr5 = NULL;
+
+ if ( disp__glColorSubTableEXT == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glColorSubTableEXT (
+ (GLenum) target,
+ (GLsizei) start,
+ (GLsizei) count,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorSubTableEXT__IIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint start,
+ jint count,
+ jint format,
+ jint type,
+ jlongArray data)
+ {
+ jlong *ptr5 = NULL;
+
+ if ( disp__glColorSubTableEXT == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+ }
+ disp__glColorSubTableEXT (
+ (GLenum) target,
+ (GLsizei) start,
+ (GLsizei) count,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ if(data!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, data, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorSubTableEXT__IIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint start,
+ jint count,
+ jint format,
+ jint type,
+ jobject data)
+ {
+ void *ptr5 = NULL;
+
+ if ( disp__glColorSubTableEXT == NULL ) return;
+
+ if(data!=NULL)
+ {
+ ptr5 = (*env)->GetDirectBufferAddress(env, data);
+ if (ptr5 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 5 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glColorSubTableEXT (
+ (GLenum) target,
+ (GLsizei) start,
+ (GLsizei) count,
+ (GLenum) format,
+ (GLenum) type,
+ (const GLvoid *) ptr5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetColorTableEXT ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableEXT__III_3B (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jbyteArray table)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glGetColorTableEXT == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+ }
+ disp__glGetColorTableEXT (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableEXT__III_3S (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jshortArray table)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jshort *ptr3 = NULL;
+
+ if ( disp__glGetColorTableEXT == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+ }
+ disp__glGetColorTableEXT (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableEXT__III_3I (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jintArray table)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jint *ptr3 = NULL;
+
+ if ( disp__glGetColorTableEXT == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+ }
+ disp__glGetColorTableEXT (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableEXT__III_3F (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jfloatArray table)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glGetColorTableEXT == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+ }
+ disp__glGetColorTableEXT (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableEXT__III_3D (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jdoubleArray table)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glGetColorTableEXT == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+ }
+ disp__glGetColorTableEXT (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableEXT__III_3Z (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jbooleanArray table)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glGetColorTableEXT == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+ }
+ disp__glGetColorTableEXT (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableEXT__III_3J (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jlongArray table)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jlong *ptr3 = NULL;
+
+ if ( disp__glGetColorTableEXT == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+ }
+ disp__glGetColorTableEXT (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ if(table!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableEXT__IIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint format,
+ jint type,
+ jobject table)
+ {
+ void *ptr3 = NULL;
+
+ if ( disp__glGetColorTableEXT == NULL ) return;
+
+ if(table!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, table);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glGetColorTableEXT (
+ (GLenum) target,
+ (GLenum) format,
+ (GLenum) type,
+ (GLvoid *) ptr3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetColorTableParameterfvEXT ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableParameterfvEXT (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jfloatArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetColorTableParameterfvEXT == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetColorTableParameterfvEXT (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLfloat *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetColorTableParameterivEXT ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableParameterivEXT (
+ JNIEnv *env, jobject obj,
+ jint target,
+ jint pname,
+ jintArray params)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetColorTableParameterivEXT == NULL ) return;
+
+ if(params!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+ }
+ disp__glGetColorTableParameterivEXT (
+ (GLenum) target,
+ (GLenum) pname,
+ (GLint *) ptr2
+ );
+
+ if(params!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLockArraysEXT ( GLint first , GLsizei count ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLockArraysEXT (
+ JNIEnv *env, jobject obj,
+ jint first,
+ jint count)
+ {
+
+ if ( disp__glLockArraysEXT == NULL ) return;
+
+ disp__glLockArraysEXT (
+ (GLint) first,
+ (GLsizei) count
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glUnlockArraysEXT ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glUnlockArraysEXT (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glUnlockArraysEXT == NULL ) return;
+
+ disp__glUnlockArraysEXT (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLoadTransposeMatrixfARB ( const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLoadTransposeMatrixfARB (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glLoadTransposeMatrixfARB == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glLoadTransposeMatrixfARB (
+ (const GLfloat *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLoadTransposeMatrixdARB ( const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLoadTransposeMatrixdARB (
+ JNIEnv *env, jobject obj,
+ jdoubleArray arg0)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glLoadTransposeMatrixdARB == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glLoadTransposeMatrixdARB (
+ (const GLdouble *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultTransposeMatrixfARB ( const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultTransposeMatrixfARB (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glMultTransposeMatrixfARB == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glMultTransposeMatrixfARB (
+ (const GLfloat *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultTransposeMatrixdARB ( const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultTransposeMatrixdARB (
+ JNIEnv *env, jobject obj,
+ jdoubleArray arg0)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glMultTransposeMatrixdARB == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glMultTransposeMatrixdARB (
+ (const GLdouble *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSampleCoverageARB ( GLclampf , GLboolean ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSampleCoverageARB (
+ JNIEnv *env, jobject obj,
+ jfloat arg0,
+ jboolean arg1)
+ {
+
+ if ( disp__glSampleCoverageARB == NULL ) return;
+
+ disp__glSampleCoverageARB (
+ (GLclampf) arg0,
+ (GLboolean) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCompressedTexImage3DARB ( GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLsizei , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage3DARB__IIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jbyteArray arg8)
+ {
+ jbyte *ptr8 = NULL;
+
+ if ( disp__glCompressedTexImage3DARB == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glCompressedTexImage3DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLint) arg6,
+ (GLsizei) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage3DARB__IIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jshortArray arg8)
+ {
+ jshort *ptr8 = NULL;
+
+ if ( disp__glCompressedTexImage3DARB == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glCompressedTexImage3DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLint) arg6,
+ (GLsizei) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage3DARB__IIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jintArray arg8)
+ {
+ jint *ptr8 = NULL;
+
+ if ( disp__glCompressedTexImage3DARB == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glCompressedTexImage3DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLint) arg6,
+ (GLsizei) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage3DARB__IIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jfloatArray arg8)
+ {
+ jfloat *ptr8 = NULL;
+
+ if ( disp__glCompressedTexImage3DARB == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glCompressedTexImage3DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLint) arg6,
+ (GLsizei) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage3DARB__IIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jdoubleArray arg8)
+ {
+ jdouble *ptr8 = NULL;
+
+ if ( disp__glCompressedTexImage3DARB == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glCompressedTexImage3DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLint) arg6,
+ (GLsizei) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage3DARB__IIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jbooleanArray arg8)
+ {
+ jboolean *ptr8 = NULL;
+
+ if ( disp__glCompressedTexImage3DARB == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glCompressedTexImage3DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLint) arg6,
+ (GLsizei) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage3DARB__IIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jlongArray arg8)
+ {
+ jlong *ptr8 = NULL;
+
+ if ( disp__glCompressedTexImage3DARB == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glCompressedTexImage3DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLint) arg6,
+ (GLsizei) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage3DARB__IIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jobject arg8)
+ {
+ void *ptr8 = NULL;
+
+ if ( disp__glCompressedTexImage3DARB == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (*env)->GetDirectBufferAddress(env, arg8);
+ if (ptr8 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 8 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glCompressedTexImage3DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLint) arg6,
+ (GLsizei) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCompressedTexImage2DARB ( GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLsizei , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage2DARB__IIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jbyteArray arg7)
+ {
+ jbyte *ptr7 = NULL;
+
+ if ( disp__glCompressedTexImage2DARB == NULL ) return;
+
+ if(arg7!=NULL)
+ {
+ ptr7 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg7, 0);
+ }
+ disp__glCompressedTexImage2DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLint) arg5,
+ (GLsizei) arg6,
+ (const GLvoid *) ptr7
+ );
+
+ if(arg7!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg7, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage2DARB__IIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jshortArray arg7)
+ {
+ jshort *ptr7 = NULL;
+
+ if ( disp__glCompressedTexImage2DARB == NULL ) return;
+
+ if(arg7!=NULL)
+ {
+ ptr7 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg7, 0);
+ }
+ disp__glCompressedTexImage2DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLint) arg5,
+ (GLsizei) arg6,
+ (const GLvoid *) ptr7
+ );
+
+ if(arg7!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg7, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage2DARB__IIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jintArray arg7)
+ {
+ jint *ptr7 = NULL;
+
+ if ( disp__glCompressedTexImage2DARB == NULL ) return;
+
+ if(arg7!=NULL)
+ {
+ ptr7 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg7, 0);
+ }
+ disp__glCompressedTexImage2DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLint) arg5,
+ (GLsizei) arg6,
+ (const GLvoid *) ptr7
+ );
+
+ if(arg7!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg7, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage2DARB__IIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jfloatArray arg7)
+ {
+ jfloat *ptr7 = NULL;
+
+ if ( disp__glCompressedTexImage2DARB == NULL ) return;
+
+ if(arg7!=NULL)
+ {
+ ptr7 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg7, 0);
+ }
+ disp__glCompressedTexImage2DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLint) arg5,
+ (GLsizei) arg6,
+ (const GLvoid *) ptr7
+ );
+
+ if(arg7!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg7, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage2DARB__IIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jdoubleArray arg7)
+ {
+ jdouble *ptr7 = NULL;
+
+ if ( disp__glCompressedTexImage2DARB == NULL ) return;
+
+ if(arg7!=NULL)
+ {
+ ptr7 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg7, 0);
+ }
+ disp__glCompressedTexImage2DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLint) arg5,
+ (GLsizei) arg6,
+ (const GLvoid *) ptr7
+ );
+
+ if(arg7!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg7, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage2DARB__IIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jbooleanArray arg7)
+ {
+ jboolean *ptr7 = NULL;
+
+ if ( disp__glCompressedTexImage2DARB == NULL ) return;
+
+ if(arg7!=NULL)
+ {
+ ptr7 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg7, 0);
+ }
+ disp__glCompressedTexImage2DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLint) arg5,
+ (GLsizei) arg6,
+ (const GLvoid *) ptr7
+ );
+
+ if(arg7!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg7, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage2DARB__IIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jlongArray arg7)
+ {
+ jlong *ptr7 = NULL;
+
+ if ( disp__glCompressedTexImage2DARB == NULL ) return;
+
+ if(arg7!=NULL)
+ {
+ ptr7 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg7, 0);
+ }
+ disp__glCompressedTexImage2DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLint) arg5,
+ (GLsizei) arg6,
+ (const GLvoid *) ptr7
+ );
+
+ if(arg7!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg7, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage2DARB__IIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jobject arg7)
+ {
+ void *ptr7 = NULL;
+
+ if ( disp__glCompressedTexImage2DARB == NULL ) return;
+
+ if(arg7!=NULL)
+ {
+ ptr7 = (*env)->GetDirectBufferAddress(env, arg7);
+ if (ptr7 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 7 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glCompressedTexImage2DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLint) arg5,
+ (GLsizei) arg6,
+ (const GLvoid *) ptr7
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCompressedTexImage1DARB ( GLenum , GLint , GLenum , GLsizei , GLint , GLsizei , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage1DARB__IIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jbyteArray arg6)
+ {
+ jbyte *ptr6 = NULL;
+
+ if ( disp__glCompressedTexImage1DARB == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glCompressedTexImage1DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage1DARB__IIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jshortArray arg6)
+ {
+ jshort *ptr6 = NULL;
+
+ if ( disp__glCompressedTexImage1DARB == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glCompressedTexImage1DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage1DARB__IIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jintArray arg6)
+ {
+ jint *ptr6 = NULL;
+
+ if ( disp__glCompressedTexImage1DARB == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glCompressedTexImage1DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage1DARB__IIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jfloatArray arg6)
+ {
+ jfloat *ptr6 = NULL;
+
+ if ( disp__glCompressedTexImage1DARB == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glCompressedTexImage1DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage1DARB__IIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jdoubleArray arg6)
+ {
+ jdouble *ptr6 = NULL;
+
+ if ( disp__glCompressedTexImage1DARB == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glCompressedTexImage1DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage1DARB__IIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jbooleanArray arg6)
+ {
+ jboolean *ptr6 = NULL;
+
+ if ( disp__glCompressedTexImage1DARB == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glCompressedTexImage1DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage1DARB__IIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jlongArray arg6)
+ {
+ jlong *ptr6 = NULL;
+
+ if ( disp__glCompressedTexImage1DARB == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glCompressedTexImage1DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexImage1DARB__IIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jobject arg6)
+ {
+ void *ptr6 = NULL;
+
+ if ( disp__glCompressedTexImage1DARB == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (*env)->GetDirectBufferAddress(env, arg6);
+ if (ptr6 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 6 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glCompressedTexImage1DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCompressedTexSubImage3DARB ( GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage3DARB__IIIIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jbyteArray arg10)
+ {
+ jbyte *ptr10 = NULL;
+
+ if ( disp__glCompressedTexSubImage3DARB == NULL ) return;
+
+ if(arg10!=NULL)
+ {
+ ptr10 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg10, 0);
+ }
+ disp__glCompressedTexSubImage3DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (GLsizei) arg6,
+ (GLsizei) arg7,
+ (GLenum) arg8,
+ (GLsizei) arg9,
+ (const GLvoid *) ptr10
+ );
+
+ if(arg10!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg10, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage3DARB__IIIIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jshortArray arg10)
+ {
+ jshort *ptr10 = NULL;
+
+ if ( disp__glCompressedTexSubImage3DARB == NULL ) return;
+
+ if(arg10!=NULL)
+ {
+ ptr10 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg10, 0);
+ }
+ disp__glCompressedTexSubImage3DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (GLsizei) arg6,
+ (GLsizei) arg7,
+ (GLenum) arg8,
+ (GLsizei) arg9,
+ (const GLvoid *) ptr10
+ );
+
+ if(arg10!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg10, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage3DARB__IIIIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jintArray arg10)
+ {
+ jint *ptr10 = NULL;
+
+ if ( disp__glCompressedTexSubImage3DARB == NULL ) return;
+
+ if(arg10!=NULL)
+ {
+ ptr10 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg10, 0);
+ }
+ disp__glCompressedTexSubImage3DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (GLsizei) arg6,
+ (GLsizei) arg7,
+ (GLenum) arg8,
+ (GLsizei) arg9,
+ (const GLvoid *) ptr10
+ );
+
+ if(arg10!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg10, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage3DARB__IIIIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jfloatArray arg10)
+ {
+ jfloat *ptr10 = NULL;
+
+ if ( disp__glCompressedTexSubImage3DARB == NULL ) return;
+
+ if(arg10!=NULL)
+ {
+ ptr10 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg10, 0);
+ }
+ disp__glCompressedTexSubImage3DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (GLsizei) arg6,
+ (GLsizei) arg7,
+ (GLenum) arg8,
+ (GLsizei) arg9,
+ (const GLvoid *) ptr10
+ );
+
+ if(arg10!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg10, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage3DARB__IIIIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jdoubleArray arg10)
+ {
+ jdouble *ptr10 = NULL;
+
+ if ( disp__glCompressedTexSubImage3DARB == NULL ) return;
+
+ if(arg10!=NULL)
+ {
+ ptr10 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg10, 0);
+ }
+ disp__glCompressedTexSubImage3DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (GLsizei) arg6,
+ (GLsizei) arg7,
+ (GLenum) arg8,
+ (GLsizei) arg9,
+ (const GLvoid *) ptr10
+ );
+
+ if(arg10!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg10, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage3DARB__IIIIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jbooleanArray arg10)
+ {
+ jboolean *ptr10 = NULL;
+
+ if ( disp__glCompressedTexSubImage3DARB == NULL ) return;
+
+ if(arg10!=NULL)
+ {
+ ptr10 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg10, 0);
+ }
+ disp__glCompressedTexSubImage3DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (GLsizei) arg6,
+ (GLsizei) arg7,
+ (GLenum) arg8,
+ (GLsizei) arg9,
+ (const GLvoid *) ptr10
+ );
+
+ if(arg10!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg10, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage3DARB__IIIIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jlongArray arg10)
+ {
+ jlong *ptr10 = NULL;
+
+ if ( disp__glCompressedTexSubImage3DARB == NULL ) return;
+
+ if(arg10!=NULL)
+ {
+ ptr10 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg10, 0);
+ }
+ disp__glCompressedTexSubImage3DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (GLsizei) arg6,
+ (GLsizei) arg7,
+ (GLenum) arg8,
+ (GLsizei) arg9,
+ (const GLvoid *) ptr10
+ );
+
+ if(arg10!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg10, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage3DARB__IIIIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jobject arg10)
+ {
+ void *ptr10 = NULL;
+
+ if ( disp__glCompressedTexSubImage3DARB == NULL ) return;
+
+ if(arg10!=NULL)
+ {
+ ptr10 = (*env)->GetDirectBufferAddress(env, arg10);
+ if (ptr10 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 10 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glCompressedTexSubImage3DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (GLsizei) arg6,
+ (GLsizei) arg7,
+ (GLenum) arg8,
+ (GLsizei) arg9,
+ (const GLvoid *) ptr10
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCompressedTexSubImage2DARB ( GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage2DARB__IIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jbyteArray arg8)
+ {
+ jbyte *ptr8 = NULL;
+
+ if ( disp__glCompressedTexSubImage2DARB == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glCompressedTexSubImage2DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLenum) arg6,
+ (GLsizei) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage2DARB__IIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jshortArray arg8)
+ {
+ jshort *ptr8 = NULL;
+
+ if ( disp__glCompressedTexSubImage2DARB == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glCompressedTexSubImage2DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLenum) arg6,
+ (GLsizei) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage2DARB__IIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jintArray arg8)
+ {
+ jint *ptr8 = NULL;
+
+ if ( disp__glCompressedTexSubImage2DARB == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glCompressedTexSubImage2DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLenum) arg6,
+ (GLsizei) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage2DARB__IIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jfloatArray arg8)
+ {
+ jfloat *ptr8 = NULL;
+
+ if ( disp__glCompressedTexSubImage2DARB == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glCompressedTexSubImage2DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLenum) arg6,
+ (GLsizei) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage2DARB__IIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jdoubleArray arg8)
+ {
+ jdouble *ptr8 = NULL;
+
+ if ( disp__glCompressedTexSubImage2DARB == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glCompressedTexSubImage2DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLenum) arg6,
+ (GLsizei) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage2DARB__IIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jbooleanArray arg8)
+ {
+ jboolean *ptr8 = NULL;
+
+ if ( disp__glCompressedTexSubImage2DARB == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glCompressedTexSubImage2DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLenum) arg6,
+ (GLsizei) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage2DARB__IIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jlongArray arg8)
+ {
+ jlong *ptr8 = NULL;
+
+ if ( disp__glCompressedTexSubImage2DARB == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glCompressedTexSubImage2DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLenum) arg6,
+ (GLsizei) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage2DARB__IIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jobject arg8)
+ {
+ void *ptr8 = NULL;
+
+ if ( disp__glCompressedTexSubImage2DARB == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (*env)->GetDirectBufferAddress(env, arg8);
+ if (ptr8 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 8 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glCompressedTexSubImage2DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLenum) arg6,
+ (GLsizei) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCompressedTexSubImage1DARB ( GLenum , GLint , GLint , GLsizei , GLenum , GLsizei , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage1DARB__IIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jbyteArray arg6)
+ {
+ jbyte *ptr6 = NULL;
+
+ if ( disp__glCompressedTexSubImage1DARB == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glCompressedTexSubImage1DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLsizei) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage1DARB__IIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jshortArray arg6)
+ {
+ jshort *ptr6 = NULL;
+
+ if ( disp__glCompressedTexSubImage1DARB == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glCompressedTexSubImage1DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLsizei) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage1DARB__IIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jintArray arg6)
+ {
+ jint *ptr6 = NULL;
+
+ if ( disp__glCompressedTexSubImage1DARB == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glCompressedTexSubImage1DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLsizei) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage1DARB__IIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jfloatArray arg6)
+ {
+ jfloat *ptr6 = NULL;
+
+ if ( disp__glCompressedTexSubImage1DARB == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glCompressedTexSubImage1DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLsizei) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage1DARB__IIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jdoubleArray arg6)
+ {
+ jdouble *ptr6 = NULL;
+
+ if ( disp__glCompressedTexSubImage1DARB == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glCompressedTexSubImage1DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLsizei) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage1DARB__IIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jbooleanArray arg6)
+ {
+ jboolean *ptr6 = NULL;
+
+ if ( disp__glCompressedTexSubImage1DARB == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glCompressedTexSubImage1DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLsizei) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage1DARB__IIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jlongArray arg6)
+ {
+ jlong *ptr6 = NULL;
+
+ if ( disp__glCompressedTexSubImage1DARB == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glCompressedTexSubImage1DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLsizei) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCompressedTexSubImage1DARB__IIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jobject arg6)
+ {
+ void *ptr6 = NULL;
+
+ if ( disp__glCompressedTexSubImage1DARB == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (*env)->GetDirectBufferAddress(env, arg6);
+ if (ptr6 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 6 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glCompressedTexSubImage1DARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLsizei) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetCompressedTexImageARB ( GLenum , GLint , void * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCompressedTexImageARB__II_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbyteArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glGetCompressedTexImageARB == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetCompressedTexImageARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCompressedTexImageARB__II_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jshort *ptr2 = NULL;
+
+ if ( disp__glGetCompressedTexImageARB == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetCompressedTexImageARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCompressedTexImageARB__II_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetCompressedTexImageARB == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetCompressedTexImageARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCompressedTexImageARB__II_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetCompressedTexImageARB == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetCompressedTexImageARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCompressedTexImageARB__II_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glGetCompressedTexImageARB == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetCompressedTexImageARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCompressedTexImageARB__II_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glGetCompressedTexImageARB == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetCompressedTexImageARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCompressedTexImageARB__II_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jlongArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jlong *ptr2 = NULL;
+
+ if ( disp__glGetCompressedTexImageARB == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetCompressedTexImageARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCompressedTexImageARB__IILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jobject arg2)
+ {
+ void *ptr2 = NULL;
+
+ if ( disp__glGetCompressedTexImageARB == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (*env)->GetDirectBufferAddress(env, arg2);
+ if (ptr2 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 2 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glGetCompressedTexImageARB (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (void *) ptr2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glWeightbvARB ( GLint , const GLbyte * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glWeightbvARB (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbyteArray arg1)
+ {
+ jbyte *ptr1 = NULL;
+
+ if ( disp__glWeightbvARB == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glWeightbvARB (
+ (GLint) arg0,
+ (const GLbyte *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glWeightsvARB ( GLint , const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glWeightsvARB (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glWeightsvARB == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glWeightsvARB (
+ (GLint) arg0,
+ (const GLshort *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glWeightivARB ( GLint , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glWeightivARB (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glWeightivARB == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glWeightivARB (
+ (GLint) arg0,
+ (const GLint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glWeightfvARB ( GLint , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glWeightfvARB (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glWeightfvARB == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glWeightfvARB (
+ (GLint) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glWeightdvARB ( GLint , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glWeightdvARB (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdoubleArray arg1)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glWeightdvARB == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glWeightdvARB (
+ (GLint) arg0,
+ (const GLdouble *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glWeightubvARB ( GLint , const GLubyte * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glWeightubvARB (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbyteArray arg1)
+ {
+ jbyte *ptr1 = NULL;
+
+ if ( disp__glWeightubvARB == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glWeightubvARB (
+ (GLint) arg0,
+ (const GLubyte *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glWeightusvARB ( GLint , const GLushort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glWeightusvARB (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glWeightusvARB == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glWeightusvARB (
+ (GLint) arg0,
+ (const GLushort *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glWeightuivARB ( GLint , const GLuint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glWeightuivARB (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glWeightuivARB == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glWeightuivARB (
+ (GLint) arg0,
+ (const GLuint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glWeightPointerARB ( GLint , GLenum , GLsizei , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glWeightPointerARB__III_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbyteArray arg3)
+ {
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glWeightPointerARB == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glWeightPointerARB (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glWeightPointerARB__III_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jshortArray arg3)
+ {
+ jshort *ptr3 = NULL;
+
+ if ( disp__glWeightPointerARB == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glWeightPointerARB (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glWeightPointerARB__III_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jintArray arg3)
+ {
+ jint *ptr3 = NULL;
+
+ if ( disp__glWeightPointerARB == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glWeightPointerARB (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glWeightPointerARB__III_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glWeightPointerARB == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glWeightPointerARB (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glWeightPointerARB__III_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jdoubleArray arg3)
+ {
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glWeightPointerARB == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glWeightPointerARB (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glWeightPointerARB__III_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbooleanArray arg3)
+ {
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glWeightPointerARB == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glWeightPointerARB (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glWeightPointerARB__III_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jlongArray arg3)
+ {
+ jlong *ptr3 = NULL;
+
+ if ( disp__glWeightPointerARB == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glWeightPointerARB (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glWeightPointerARB__IIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jobject arg3)
+ {
+ void *ptr3 = NULL;
+
+ if ( disp__glWeightPointerARB == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, arg3);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glWeightPointerARB (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexBlendARB ( GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexBlendARB (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glVertexBlendARB == NULL ) return;
+
+ disp__glVertexBlendARB (
+ (GLint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCurrentPaletteMatrixARB ( GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCurrentPaletteMatrixARB (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glCurrentPaletteMatrixARB == NULL ) return;
+
+ disp__glCurrentPaletteMatrixARB (
+ (GLint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMatrixIndexubvARB ( GLint , const GLubyte * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMatrixIndexubvARB (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbyteArray arg1)
+ {
+ jbyte *ptr1 = NULL;
+
+ if ( disp__glMatrixIndexubvARB == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glMatrixIndexubvARB (
+ (GLint) arg0,
+ (const GLubyte *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMatrixIndexusvARB ( GLint , const GLushort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMatrixIndexusvARB (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glMatrixIndexusvARB == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glMatrixIndexusvARB (
+ (GLint) arg0,
+ (const GLushort *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMatrixIndexuivARB ( GLint , const GLuint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMatrixIndexuivARB (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glMatrixIndexuivARB == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glMatrixIndexuivARB (
+ (GLint) arg0,
+ (const GLuint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMatrixIndexPointerARB ( GLint , GLenum , GLsizei , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMatrixIndexPointerARB__III_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbyteArray arg3)
+ {
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glMatrixIndexPointerARB == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMatrixIndexPointerARB (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMatrixIndexPointerARB__III_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jshortArray arg3)
+ {
+ jshort *ptr3 = NULL;
+
+ if ( disp__glMatrixIndexPointerARB == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMatrixIndexPointerARB (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMatrixIndexPointerARB__III_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jintArray arg3)
+ {
+ jint *ptr3 = NULL;
+
+ if ( disp__glMatrixIndexPointerARB == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMatrixIndexPointerARB (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMatrixIndexPointerARB__III_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glMatrixIndexPointerARB == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMatrixIndexPointerARB (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMatrixIndexPointerARB__III_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jdoubleArray arg3)
+ {
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glMatrixIndexPointerARB == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMatrixIndexPointerARB (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMatrixIndexPointerARB__III_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbooleanArray arg3)
+ {
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glMatrixIndexPointerARB == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMatrixIndexPointerARB (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMatrixIndexPointerARB__III_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jlongArray arg3)
+ {
+ jlong *ptr3 = NULL;
+
+ if ( disp__glMatrixIndexPointerARB == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMatrixIndexPointerARB (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMatrixIndexPointerARB__IIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jobject arg3)
+ {
+ void *ptr3 = NULL;
+
+ if ( disp__glMatrixIndexPointerARB == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, arg3);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glMatrixIndexPointerARB (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetTexFilterFuncSGIS ( GLenum , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexFilterFuncSGIS (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetTexFilterFuncSGIS == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetTexFilterFuncSGIS (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexFilterFuncSGIS ( GLenum , GLenum , GLsizei , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexFilterFuncSGIS (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glTexFilterFuncSGIS == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glTexFilterFuncSGIS (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLfloat *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexSubImage1DEXT ( GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage1DEXT__IIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jbyteArray arg6)
+ {
+ jbyte *ptr6 = NULL;
+
+ if ( disp__glTexSubImage1DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glTexSubImage1DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage1DEXT__IIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jshortArray arg6)
+ {
+ jshort *ptr6 = NULL;
+
+ if ( disp__glTexSubImage1DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glTexSubImage1DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage1DEXT__IIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jintArray arg6)
+ {
+ jint *ptr6 = NULL;
+
+ if ( disp__glTexSubImage1DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glTexSubImage1DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage1DEXT__IIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jfloatArray arg6)
+ {
+ jfloat *ptr6 = NULL;
+
+ if ( disp__glTexSubImage1DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glTexSubImage1DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage1DEXT__IIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jdoubleArray arg6)
+ {
+ jdouble *ptr6 = NULL;
+
+ if ( disp__glTexSubImage1DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glTexSubImage1DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage1DEXT__IIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jbooleanArray arg6)
+ {
+ jboolean *ptr6 = NULL;
+
+ if ( disp__glTexSubImage1DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glTexSubImage1DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage1DEXT__IIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jlongArray arg6)
+ {
+ jlong *ptr6 = NULL;
+
+ if ( disp__glTexSubImage1DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glTexSubImage1DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage1DEXT__IIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jobject arg6)
+ {
+ void *ptr6 = NULL;
+
+ if ( disp__glTexSubImage1DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (*env)->GetDirectBufferAddress(env, arg6);
+ if (ptr6 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 6 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glTexSubImage1DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexSubImage2DEXT ( GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage2DEXT__IIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jbyteArray arg8)
+ {
+ jbyte *ptr8 = NULL;
+
+ if ( disp__glTexSubImage2DEXT == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glTexSubImage2DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLenum) arg6,
+ (GLenum) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage2DEXT__IIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jshortArray arg8)
+ {
+ jshort *ptr8 = NULL;
+
+ if ( disp__glTexSubImage2DEXT == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glTexSubImage2DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLenum) arg6,
+ (GLenum) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage2DEXT__IIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jintArray arg8)
+ {
+ jint *ptr8 = NULL;
+
+ if ( disp__glTexSubImage2DEXT == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glTexSubImage2DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLenum) arg6,
+ (GLenum) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage2DEXT__IIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jfloatArray arg8)
+ {
+ jfloat *ptr8 = NULL;
+
+ if ( disp__glTexSubImage2DEXT == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glTexSubImage2DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLenum) arg6,
+ (GLenum) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage2DEXT__IIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jdoubleArray arg8)
+ {
+ jdouble *ptr8 = NULL;
+
+ if ( disp__glTexSubImage2DEXT == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glTexSubImage2DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLenum) arg6,
+ (GLenum) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage2DEXT__IIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jbooleanArray arg8)
+ {
+ jboolean *ptr8 = NULL;
+
+ if ( disp__glTexSubImage2DEXT == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glTexSubImage2DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLenum) arg6,
+ (GLenum) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage2DEXT__IIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jlongArray arg8)
+ {
+ jlong *ptr8 = NULL;
+
+ if ( disp__glTexSubImage2DEXT == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glTexSubImage2DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLenum) arg6,
+ (GLenum) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage2DEXT__IIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jobject arg8)
+ {
+ void *ptr8 = NULL;
+
+ if ( disp__glTexSubImage2DEXT == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (*env)->GetDirectBufferAddress(env, arg8);
+ if (ptr8 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 8 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glTexSubImage2DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLenum) arg6,
+ (GLenum) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyTexImage1DEXT ( GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyTexImage1DEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6)
+ {
+
+ if ( disp__glCopyTexImage1DEXT == NULL ) return;
+
+ disp__glCopyTexImage1DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (GLint) arg6
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyTexImage2DEXT ( GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLsizei , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyTexImage2DEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7)
+ {
+
+ if ( disp__glCopyTexImage2DEXT == NULL ) return;
+
+ disp__glCopyTexImage2DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5,
+ (GLsizei) arg6,
+ (GLint) arg7
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyTexSubImage1DEXT ( GLenum , GLint , GLint , GLint , GLint , GLsizei ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyTexSubImage1DEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5)
+ {
+
+ if ( disp__glCopyTexSubImage1DEXT == NULL ) return;
+
+ disp__glCopyTexSubImage1DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLsizei) arg5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyTexSubImage2DEXT ( GLenum , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyTexSubImage2DEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7)
+ {
+
+ if ( disp__glCopyTexSubImage2DEXT == NULL ) return;
+
+ disp__glCopyTexSubImage2DEXT (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLint) arg5,
+ (GLsizei) arg6,
+ (GLsizei) arg7
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetHistogramEXT ( GLenum , GLboolean , GLenum , GLenum , GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogramEXT__IZII_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jboolean arg1,
+ jint arg2,
+ jint arg3,
+ jbyteArray arg4)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jbyte *ptr4 = NULL;
+
+ if ( disp__glGetHistogramEXT == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ disp__glGetHistogramEXT (
+ (GLenum) arg0,
+ (GLboolean) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogramEXT__IZII_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jboolean arg1,
+ jint arg2,
+ jint arg3,
+ jshortArray arg4)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jshort *ptr4 = NULL;
+
+ if ( disp__glGetHistogramEXT == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ disp__glGetHistogramEXT (
+ (GLenum) arg0,
+ (GLboolean) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogramEXT__IZII_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jboolean arg1,
+ jint arg2,
+ jint arg3,
+ jintArray arg4)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jint *ptr4 = NULL;
+
+ if ( disp__glGetHistogramEXT == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ disp__glGetHistogramEXT (
+ (GLenum) arg0,
+ (GLboolean) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogramEXT__IZII_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jboolean arg1,
+ jint arg2,
+ jint arg3,
+ jfloatArray arg4)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jfloat *ptr4 = NULL;
+
+ if ( disp__glGetHistogramEXT == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ disp__glGetHistogramEXT (
+ (GLenum) arg0,
+ (GLboolean) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogramEXT__IZII_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jboolean arg1,
+ jint arg2,
+ jint arg3,
+ jdoubleArray arg4)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jdouble *ptr4 = NULL;
+
+ if ( disp__glGetHistogramEXT == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ disp__glGetHistogramEXT (
+ (GLenum) arg0,
+ (GLboolean) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogramEXT__IZII_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jboolean arg1,
+ jint arg2,
+ jint arg3,
+ jbooleanArray arg4)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jboolean *ptr4 = NULL;
+
+ if ( disp__glGetHistogramEXT == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ disp__glGetHistogramEXT (
+ (GLenum) arg0,
+ (GLboolean) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogramEXT__IZII_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jboolean arg1,
+ jint arg2,
+ jint arg3,
+ jlongArray arg4)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jlong *ptr4 = NULL;
+
+ if ( disp__glGetHistogramEXT == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ disp__glGetHistogramEXT (
+ (GLenum) arg0,
+ (GLboolean) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogramEXT__IZIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jboolean arg1,
+ jint arg2,
+ jint arg3,
+ jobject arg4)
+ {
+ void *ptr4 = NULL;
+
+ if ( disp__glGetHistogramEXT == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (*env)->GetDirectBufferAddress(env, arg4);
+ if (ptr4 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 4 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glGetHistogramEXT (
+ (GLenum) arg0,
+ (GLboolean) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLvoid *) ptr4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetHistogramParameterfvEXT ( GLenum , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogramParameterfvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetHistogramParameterfvEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetHistogramParameterfvEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetHistogramParameterivEXT ( GLenum , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetHistogramParameterivEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetHistogramParameterivEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetHistogramParameterivEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetMinmaxEXT ( GLenum , GLboolean , GLenum , GLenum , GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmaxEXT__IZII_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jboolean arg1,
+ jint arg2,
+ jint arg3,
+ jbyteArray arg4)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jbyte *ptr4 = NULL;
+
+ if ( disp__glGetMinmaxEXT == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ disp__glGetMinmaxEXT (
+ (GLenum) arg0,
+ (GLboolean) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmaxEXT__IZII_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jboolean arg1,
+ jint arg2,
+ jint arg3,
+ jshortArray arg4)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jshort *ptr4 = NULL;
+
+ if ( disp__glGetMinmaxEXT == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ disp__glGetMinmaxEXT (
+ (GLenum) arg0,
+ (GLboolean) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmaxEXT__IZII_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jboolean arg1,
+ jint arg2,
+ jint arg3,
+ jintArray arg4)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jint *ptr4 = NULL;
+
+ if ( disp__glGetMinmaxEXT == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ disp__glGetMinmaxEXT (
+ (GLenum) arg0,
+ (GLboolean) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmaxEXT__IZII_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jboolean arg1,
+ jint arg2,
+ jint arg3,
+ jfloatArray arg4)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jfloat *ptr4 = NULL;
+
+ if ( disp__glGetMinmaxEXT == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ disp__glGetMinmaxEXT (
+ (GLenum) arg0,
+ (GLboolean) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmaxEXT__IZII_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jboolean arg1,
+ jint arg2,
+ jint arg3,
+ jdoubleArray arg4)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jdouble *ptr4 = NULL;
+
+ if ( disp__glGetMinmaxEXT == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ disp__glGetMinmaxEXT (
+ (GLenum) arg0,
+ (GLboolean) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmaxEXT__IZII_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jboolean arg1,
+ jint arg2,
+ jint arg3,
+ jbooleanArray arg4)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jboolean *ptr4 = NULL;
+
+ if ( disp__glGetMinmaxEXT == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ disp__glGetMinmaxEXT (
+ (GLenum) arg0,
+ (GLboolean) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmaxEXT__IZII_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jboolean arg1,
+ jint arg2,
+ jint arg3,
+ jlongArray arg4)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jlong *ptr4 = NULL;
+
+ if ( disp__glGetMinmaxEXT == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ disp__glGetMinmaxEXT (
+ (GLenum) arg0,
+ (GLboolean) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmaxEXT__IZIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jboolean arg1,
+ jint arg2,
+ jint arg3,
+ jobject arg4)
+ {
+ void *ptr4 = NULL;
+
+ if ( disp__glGetMinmaxEXT == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (*env)->GetDirectBufferAddress(env, arg4);
+ if (ptr4 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 4 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glGetMinmaxEXT (
+ (GLenum) arg0,
+ (GLboolean) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLvoid *) ptr4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetMinmaxParameterfvEXT ( GLenum , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmaxParameterfvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetMinmaxParameterfvEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetMinmaxParameterfvEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetMinmaxParameterivEXT ( GLenum , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMinmaxParameterivEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetMinmaxParameterivEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetMinmaxParameterivEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glHistogramEXT ( GLenum , GLsizei , GLenum , GLboolean ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glHistogramEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jboolean arg3)
+ {
+
+ if ( disp__glHistogramEXT == NULL ) return;
+
+ disp__glHistogramEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (GLenum) arg2,
+ (GLboolean) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMinmaxEXT ( GLenum , GLenum , GLboolean ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMinmaxEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jboolean arg2)
+ {
+
+ if ( disp__glMinmaxEXT == NULL ) return;
+
+ disp__glMinmaxEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLboolean) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glResetHistogramEXT ( GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glResetHistogramEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glResetHistogramEXT == NULL ) return;
+
+ disp__glResetHistogramEXT (
+ (GLenum) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glResetMinmaxEXT ( GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glResetMinmaxEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glResetMinmaxEXT == NULL ) return;
+
+ disp__glResetMinmaxEXT (
+ (GLenum) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glConvolutionFilter1DEXT ( GLenum , GLenum , GLsizei , GLenum , GLenum , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter1DEXT__IIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jbyteArray arg5)
+ {
+ jbyte *ptr5 = NULL;
+
+ if ( disp__glConvolutionFilter1DEXT == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glConvolutionFilter1DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter1DEXT__IIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jshortArray arg5)
+ {
+ jshort *ptr5 = NULL;
+
+ if ( disp__glConvolutionFilter1DEXT == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glConvolutionFilter1DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter1DEXT__IIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jintArray arg5)
+ {
+ jint *ptr5 = NULL;
+
+ if ( disp__glConvolutionFilter1DEXT == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glConvolutionFilter1DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter1DEXT__IIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jfloatArray arg5)
+ {
+ jfloat *ptr5 = NULL;
+
+ if ( disp__glConvolutionFilter1DEXT == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glConvolutionFilter1DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter1DEXT__IIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jdoubleArray arg5)
+ {
+ jdouble *ptr5 = NULL;
+
+ if ( disp__glConvolutionFilter1DEXT == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glConvolutionFilter1DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter1DEXT__IIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jbooleanArray arg5)
+ {
+ jboolean *ptr5 = NULL;
+
+ if ( disp__glConvolutionFilter1DEXT == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glConvolutionFilter1DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter1DEXT__IIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jlongArray arg5)
+ {
+ jlong *ptr5 = NULL;
+
+ if ( disp__glConvolutionFilter1DEXT == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glConvolutionFilter1DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter1DEXT__IIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jobject arg5)
+ {
+ void *ptr5 = NULL;
+
+ if ( disp__glConvolutionFilter1DEXT == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (*env)->GetDirectBufferAddress(env, arg5);
+ if (ptr5 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 5 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glConvolutionFilter1DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glConvolutionFilter2DEXT ( GLenum , GLenum , GLsizei , GLsizei , GLenum , GLenum , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter2DEXT__IIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jbyteArray arg6)
+ {
+ jbyte *ptr6 = NULL;
+
+ if ( disp__glConvolutionFilter2DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glConvolutionFilter2DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter2DEXT__IIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jshortArray arg6)
+ {
+ jshort *ptr6 = NULL;
+
+ if ( disp__glConvolutionFilter2DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glConvolutionFilter2DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter2DEXT__IIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jintArray arg6)
+ {
+ jint *ptr6 = NULL;
+
+ if ( disp__glConvolutionFilter2DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glConvolutionFilter2DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter2DEXT__IIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jfloatArray arg6)
+ {
+ jfloat *ptr6 = NULL;
+
+ if ( disp__glConvolutionFilter2DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glConvolutionFilter2DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter2DEXT__IIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jdoubleArray arg6)
+ {
+ jdouble *ptr6 = NULL;
+
+ if ( disp__glConvolutionFilter2DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glConvolutionFilter2DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter2DEXT__IIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jbooleanArray arg6)
+ {
+ jboolean *ptr6 = NULL;
+
+ if ( disp__glConvolutionFilter2DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glConvolutionFilter2DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter2DEXT__IIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jlongArray arg6)
+ {
+ jlong *ptr6 = NULL;
+
+ if ( disp__glConvolutionFilter2DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ disp__glConvolutionFilter2DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionFilter2DEXT__IIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jobject arg6)
+ {
+ void *ptr6 = NULL;
+
+ if ( disp__glConvolutionFilter2DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (*env)->GetDirectBufferAddress(env, arg6);
+ if (ptr6 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 6 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glConvolutionFilter2DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glConvolutionParameterfEXT ( GLenum , GLenum , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionParameterfEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloat arg2)
+ {
+
+ if ( disp__glConvolutionParameterfEXT == NULL ) return;
+
+ disp__glConvolutionParameterfEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLfloat) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glConvolutionParameterfvEXT ( GLenum , GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionParameterfvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glConvolutionParameterfvEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glConvolutionParameterfvEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glConvolutionParameteriEXT ( GLenum , GLenum , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionParameteriEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2)
+ {
+
+ if ( disp__glConvolutionParameteriEXT == NULL ) return;
+
+ disp__glConvolutionParameteriEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glConvolutionParameterivEXT ( GLenum , GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glConvolutionParameterivEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glConvolutionParameterivEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glConvolutionParameterivEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (const GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyConvolutionFilter1DEXT ( GLenum , GLenum , GLint , GLint , GLsizei ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyConvolutionFilter1DEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4)
+ {
+
+ if ( disp__glCopyConvolutionFilter1DEXT == NULL ) return;
+
+ disp__glCopyConvolutionFilter1DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyConvolutionFilter2DEXT ( GLenum , GLenum , GLint , GLint , GLsizei , GLsizei ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyConvolutionFilter2DEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5)
+ {
+
+ if ( disp__glCopyConvolutionFilter2DEXT == NULL ) return;
+
+ disp__glCopyConvolutionFilter2DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetConvolutionFilterEXT ( GLenum , GLenum , GLenum , GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionFilterEXT__III_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbyteArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glGetConvolutionFilterEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetConvolutionFilterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionFilterEXT__III_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jshortArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jshort *ptr3 = NULL;
+
+ if ( disp__glGetConvolutionFilterEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetConvolutionFilterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionFilterEXT__III_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jintArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jint *ptr3 = NULL;
+
+ if ( disp__glGetConvolutionFilterEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetConvolutionFilterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionFilterEXT__III_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glGetConvolutionFilterEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetConvolutionFilterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionFilterEXT__III_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jdoubleArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glGetConvolutionFilterEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetConvolutionFilterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionFilterEXT__III_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbooleanArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glGetConvolutionFilterEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetConvolutionFilterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionFilterEXT__III_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jlongArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jlong *ptr3 = NULL;
+
+ if ( disp__glGetConvolutionFilterEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetConvolutionFilterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionFilterEXT__IIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jobject arg3)
+ {
+ void *ptr3 = NULL;
+
+ if ( disp__glGetConvolutionFilterEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, arg3);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glGetConvolutionFilterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetConvolutionParameterfvEXT ( GLenum , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionParameterfvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetConvolutionParameterfvEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetConvolutionParameterfvEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetConvolutionParameterivEXT ( GLenum , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetConvolutionParameterivEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetConvolutionParameterivEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetConvolutionParameterivEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetSeparableFilterEXT ( GLenum , GLenum , GLenum , GLvoid * , GLvoid * , GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetSeparableFilterEXT__III_3B_3B_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbyteArray arg3,
+ jbyteArray arg4,
+ jbyteArray arg5)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jbyte *ptr3 = NULL;
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jbyte *ptr4 = NULL;
+ jboolean isCopiedArray5 = JNI_FALSE;
+ jbyte *ptr5 = NULL;
+
+ if ( disp__glGetSeparableFilterEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ if(arg4!=NULL)
+ {
+ ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ if(arg5!=NULL)
+ {
+ ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg5, &isCopiedArray5);
+ }
+ disp__glGetSeparableFilterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3,
+ (GLvoid *) ptr4,
+ (GLvoid *) ptr5
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetSeparableFilterEXT__III_3S_3S_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jshortArray arg3,
+ jshortArray arg4,
+ jshortArray arg5)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jshort *ptr3 = NULL;
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jshort *ptr4 = NULL;
+ jboolean isCopiedArray5 = JNI_FALSE;
+ jshort *ptr5 = NULL;
+
+ if ( disp__glGetSeparableFilterEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ if(arg4!=NULL)
+ {
+ ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ if(arg5!=NULL)
+ {
+ ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg5, &isCopiedArray5);
+ }
+ disp__glGetSeparableFilterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3,
+ (GLvoid *) ptr4,
+ (GLvoid *) ptr5
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetSeparableFilterEXT__III_3I_3I_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jintArray arg3,
+ jintArray arg4,
+ jintArray arg5)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jint *ptr3 = NULL;
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jint *ptr4 = NULL;
+ jboolean isCopiedArray5 = JNI_FALSE;
+ jint *ptr5 = NULL;
+
+ if ( disp__glGetSeparableFilterEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ if(arg4!=NULL)
+ {
+ ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ if(arg5!=NULL)
+ {
+ ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg5, &isCopiedArray5);
+ }
+ disp__glGetSeparableFilterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3,
+ (GLvoid *) ptr4,
+ (GLvoid *) ptr5
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetSeparableFilterEXT__III_3F_3F_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3,
+ jfloatArray arg4,
+ jfloatArray arg5)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jfloat *ptr3 = NULL;
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jfloat *ptr4 = NULL;
+ jboolean isCopiedArray5 = JNI_FALSE;
+ jfloat *ptr5 = NULL;
+
+ if ( disp__glGetSeparableFilterEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ if(arg4!=NULL)
+ {
+ ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ if(arg5!=NULL)
+ {
+ ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg5, &isCopiedArray5);
+ }
+ disp__glGetSeparableFilterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3,
+ (GLvoid *) ptr4,
+ (GLvoid *) ptr5
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetSeparableFilterEXT__III_3D_3D_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jdoubleArray arg3,
+ jdoubleArray arg4,
+ jdoubleArray arg5)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jdouble *ptr3 = NULL;
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jdouble *ptr4 = NULL;
+ jboolean isCopiedArray5 = JNI_FALSE;
+ jdouble *ptr5 = NULL;
+
+ if ( disp__glGetSeparableFilterEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ if(arg4!=NULL)
+ {
+ ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ if(arg5!=NULL)
+ {
+ ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg5, &isCopiedArray5);
+ }
+ disp__glGetSeparableFilterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3,
+ (GLvoid *) ptr4,
+ (GLvoid *) ptr5
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetSeparableFilterEXT__III_3Z_3Z_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbooleanArray arg3,
+ jbooleanArray arg4,
+ jbooleanArray arg5)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jboolean *ptr3 = NULL;
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jboolean *ptr4 = NULL;
+ jboolean isCopiedArray5 = JNI_FALSE;
+ jboolean *ptr5 = NULL;
+
+ if ( disp__glGetSeparableFilterEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ if(arg4!=NULL)
+ {
+ ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ if(arg5!=NULL)
+ {
+ ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg5, &isCopiedArray5);
+ }
+ disp__glGetSeparableFilterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3,
+ (GLvoid *) ptr4,
+ (GLvoid *) ptr5
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetSeparableFilterEXT__III_3J_3J_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jlongArray arg3,
+ jlongArray arg4,
+ jlongArray arg5)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jlong *ptr3 = NULL;
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jlong *ptr4 = NULL;
+ jboolean isCopiedArray5 = JNI_FALSE;
+ jlong *ptr5 = NULL;
+
+ if ( disp__glGetSeparableFilterEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ if(arg4!=NULL)
+ {
+ ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ if(arg5!=NULL)
+ {
+ ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg5, &isCopiedArray5);
+ }
+ disp__glGetSeparableFilterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3,
+ (GLvoid *) ptr4,
+ (GLvoid *) ptr5
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetSeparableFilterEXT__IIILjava_nio_Buffer_2Ljava_nio_Buffer_2Ljava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jobject arg3,
+ jobject arg4,
+ jobject arg5)
+ {
+ void *ptr3 = NULL;
+ void *ptr4 = NULL;
+ void *ptr5 = NULL;
+
+ if ( disp__glGetSeparableFilterEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, arg3);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ if(arg4!=NULL)
+ {
+ ptr4 = (*env)->GetDirectBufferAddress(env, arg4);
+ if (ptr4 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 4 was not a direct buffer");
+ return ;
+ }
+ }
+ if(arg5!=NULL)
+ {
+ ptr5 = (*env)->GetDirectBufferAddress(env, arg5);
+ if (ptr5 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 5 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glGetSeparableFilterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3,
+ (GLvoid *) ptr4,
+ (GLvoid *) ptr5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSeparableFilter2DEXT ( GLenum , GLenum , GLsizei , GLsizei , GLenum , GLenum , const GLvoid * , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSeparableFilter2DEXT__IIIIII_3B_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jbyteArray arg6,
+ jbyteArray arg7)
+ {
+ jbyte *ptr6 = NULL;
+ jbyte *ptr7 = NULL;
+
+ if ( disp__glSeparableFilter2DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ if(arg7!=NULL)
+ {
+ ptr7 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg7, 0);
+ }
+ disp__glSeparableFilter2DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6,
+ (const GLvoid *) ptr7
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ if(arg7!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg7, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSeparableFilter2DEXT__IIIIII_3S_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jshortArray arg6,
+ jshortArray arg7)
+ {
+ jshort *ptr6 = NULL;
+ jshort *ptr7 = NULL;
+
+ if ( disp__glSeparableFilter2DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ if(arg7!=NULL)
+ {
+ ptr7 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg7, 0);
+ }
+ disp__glSeparableFilter2DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6,
+ (const GLvoid *) ptr7
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ if(arg7!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg7, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSeparableFilter2DEXT__IIIIII_3I_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jintArray arg6,
+ jintArray arg7)
+ {
+ jint *ptr6 = NULL;
+ jint *ptr7 = NULL;
+
+ if ( disp__glSeparableFilter2DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ if(arg7!=NULL)
+ {
+ ptr7 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg7, 0);
+ }
+ disp__glSeparableFilter2DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6,
+ (const GLvoid *) ptr7
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ if(arg7!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg7, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSeparableFilter2DEXT__IIIIII_3F_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jfloatArray arg6,
+ jfloatArray arg7)
+ {
+ jfloat *ptr6 = NULL;
+ jfloat *ptr7 = NULL;
+
+ if ( disp__glSeparableFilter2DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ if(arg7!=NULL)
+ {
+ ptr7 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg7, 0);
+ }
+ disp__glSeparableFilter2DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6,
+ (const GLvoid *) ptr7
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ if(arg7!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg7, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSeparableFilter2DEXT__IIIIII_3D_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jdoubleArray arg6,
+ jdoubleArray arg7)
+ {
+ jdouble *ptr6 = NULL;
+ jdouble *ptr7 = NULL;
+
+ if ( disp__glSeparableFilter2DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ if(arg7!=NULL)
+ {
+ ptr7 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg7, 0);
+ }
+ disp__glSeparableFilter2DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6,
+ (const GLvoid *) ptr7
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ if(arg7!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg7, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSeparableFilter2DEXT__IIIIII_3Z_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jbooleanArray arg6,
+ jbooleanArray arg7)
+ {
+ jboolean *ptr6 = NULL;
+ jboolean *ptr7 = NULL;
+
+ if ( disp__glSeparableFilter2DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ if(arg7!=NULL)
+ {
+ ptr7 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg7, 0);
+ }
+ disp__glSeparableFilter2DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6,
+ (const GLvoid *) ptr7
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ if(arg7!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg7, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSeparableFilter2DEXT__IIIIII_3J_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jlongArray arg6,
+ jlongArray arg7)
+ {
+ jlong *ptr6 = NULL;
+ jlong *ptr7 = NULL;
+
+ if ( disp__glSeparableFilter2DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg6, 0);
+ }
+ if(arg7!=NULL)
+ {
+ ptr7 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg7, 0);
+ }
+ disp__glSeparableFilter2DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6,
+ (const GLvoid *) ptr7
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, JNI_ABORT);
+ }
+ if(arg7!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg7, ptr7, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSeparableFilter2DEXT__IIIIIILjava_nio_Buffer_2Ljava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jobject arg6,
+ jobject arg7)
+ {
+ void *ptr6 = NULL;
+ void *ptr7 = NULL;
+
+ if ( disp__glSeparableFilter2DEXT == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (*env)->GetDirectBufferAddress(env, arg6);
+ if (ptr6 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 6 was not a direct buffer");
+ return ;
+ }
+ }
+ if(arg7!=NULL)
+ {
+ ptr7 = (*env)->GetDirectBufferAddress(env, arg7);
+ if (ptr7 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 7 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glSeparableFilter2DEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (const GLvoid *) ptr6,
+ (const GLvoid *) ptr7
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorTableSGI ( GLenum , GLenum , GLsizei , GLenum , GLenum , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableSGI__IIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jbyteArray arg5)
+ {
+ jbyte *ptr5 = NULL;
+
+ if ( disp__glColorTableSGI == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glColorTableSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableSGI__IIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jshortArray arg5)
+ {
+ jshort *ptr5 = NULL;
+
+ if ( disp__glColorTableSGI == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glColorTableSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableSGI__IIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jintArray arg5)
+ {
+ jint *ptr5 = NULL;
+
+ if ( disp__glColorTableSGI == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glColorTableSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableSGI__IIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jfloatArray arg5)
+ {
+ jfloat *ptr5 = NULL;
+
+ if ( disp__glColorTableSGI == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glColorTableSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableSGI__IIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jdoubleArray arg5)
+ {
+ jdouble *ptr5 = NULL;
+
+ if ( disp__glColorTableSGI == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glColorTableSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableSGI__IIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jbooleanArray arg5)
+ {
+ jboolean *ptr5 = NULL;
+
+ if ( disp__glColorTableSGI == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glColorTableSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableSGI__IIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jlongArray arg5)
+ {
+ jlong *ptr5 = NULL;
+
+ if ( disp__glColorTableSGI == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glColorTableSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableSGI__IIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jobject arg5)
+ {
+ void *ptr5 = NULL;
+
+ if ( disp__glColorTableSGI == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (*env)->GetDirectBufferAddress(env, arg5);
+ if (ptr5 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 5 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glColorTableSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorTableParameterfvSGI ( GLenum , GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableParameterfvSGI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glColorTableParameterfvSGI == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glColorTableParameterfvSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorTableParameterivSGI ( GLenum , GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorTableParameterivSGI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glColorTableParameterivSGI == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glColorTableParameterivSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (const GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyColorTableSGI ( GLenum , GLenum , GLint , GLint , GLsizei ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyColorTableSGI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4)
+ {
+
+ if ( disp__glCopyColorTableSGI == NULL ) return;
+
+ disp__glCopyColorTableSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetColorTableSGI ( GLenum , GLenum , GLenum , GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableSGI__III_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbyteArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glGetColorTableSGI == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetColorTableSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableSGI__III_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jshortArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jshort *ptr3 = NULL;
+
+ if ( disp__glGetColorTableSGI == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetColorTableSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableSGI__III_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jintArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jint *ptr3 = NULL;
+
+ if ( disp__glGetColorTableSGI == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetColorTableSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableSGI__III_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glGetColorTableSGI == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetColorTableSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableSGI__III_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jdoubleArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glGetColorTableSGI == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetColorTableSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableSGI__III_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbooleanArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glGetColorTableSGI == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetColorTableSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableSGI__III_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jlongArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jlong *ptr3 = NULL;
+
+ if ( disp__glGetColorTableSGI == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetColorTableSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableSGI__IIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jobject arg3)
+ {
+ void *ptr3 = NULL;
+
+ if ( disp__glGetColorTableSGI == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, arg3);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glGetColorTableSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLvoid *) ptr3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetColorTableParameterfvSGI ( GLenum , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableParameterfvSGI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetColorTableParameterfvSGI == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetColorTableParameterfvSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetColorTableParameterivSGI ( GLenum , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetColorTableParameterivSGI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetColorTableParameterivSGI == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetColorTableParameterivSGI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPixelTexGenSGIX ( GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPixelTexGenSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glPixelTexGenSGIX == NULL ) return;
+
+ disp__glPixelTexGenSGIX (
+ (GLenum) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPixelTexGenParameteriSGIS ( GLenum , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPixelTexGenParameteriSGIS (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+
+ if ( disp__glPixelTexGenParameteriSGIS == NULL ) return;
+
+ disp__glPixelTexGenParameteriSGIS (
+ (GLenum) arg0,
+ (GLint) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPixelTexGenParameterivSGIS ( GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPixelTexGenParameterivSGIS (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glPixelTexGenParameterivSGIS == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glPixelTexGenParameterivSGIS (
+ (GLenum) arg0,
+ (const GLint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPixelTexGenParameterfSGIS ( GLenum , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPixelTexGenParameterfSGIS (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1)
+ {
+
+ if ( disp__glPixelTexGenParameterfSGIS == NULL ) return;
+
+ disp__glPixelTexGenParameterfSGIS (
+ (GLenum) arg0,
+ (GLfloat) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPixelTexGenParameterfvSGIS ( GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPixelTexGenParameterfvSGIS (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glPixelTexGenParameterfvSGIS == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glPixelTexGenParameterfvSGIS (
+ (GLenum) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetPixelTexGenParameterivSGIS ( GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPixelTexGenParameterivSGIS (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jint *ptr1 = NULL;
+
+ if ( disp__glGetPixelTexGenParameterivSGIS == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, &isCopiedArray1);
+ }
+ disp__glGetPixelTexGenParameterivSGIS (
+ (GLenum) arg0,
+ (GLint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetPixelTexGenParameterfvSGIS ( GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetPixelTexGenParameterfvSGIS (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glGetPixelTexGenParameterfvSGIS == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, &isCopiedArray1);
+ }
+ disp__glGetPixelTexGenParameterfvSGIS (
+ (GLenum) arg0,
+ (GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexImage4DSGIS ( GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage4DSGIS__IIIIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jbyteArray arg10)
+ {
+ jbyte *ptr10 = NULL;
+
+ if ( disp__glTexImage4DSGIS == NULL ) return;
+
+ if(arg10!=NULL)
+ {
+ ptr10 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg10, 0);
+ }
+ disp__glTexImage4DSGIS (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLsizei) arg6,
+ (GLint) arg7,
+ (GLenum) arg8,
+ (GLenum) arg9,
+ (const GLvoid *) ptr10
+ );
+
+ if(arg10!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg10, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage4DSGIS__IIIIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jshortArray arg10)
+ {
+ jshort *ptr10 = NULL;
+
+ if ( disp__glTexImage4DSGIS == NULL ) return;
+
+ if(arg10!=NULL)
+ {
+ ptr10 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg10, 0);
+ }
+ disp__glTexImage4DSGIS (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLsizei) arg6,
+ (GLint) arg7,
+ (GLenum) arg8,
+ (GLenum) arg9,
+ (const GLvoid *) ptr10
+ );
+
+ if(arg10!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg10, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage4DSGIS__IIIIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jintArray arg10)
+ {
+ jint *ptr10 = NULL;
+
+ if ( disp__glTexImage4DSGIS == NULL ) return;
+
+ if(arg10!=NULL)
+ {
+ ptr10 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg10, 0);
+ }
+ disp__glTexImage4DSGIS (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLsizei) arg6,
+ (GLint) arg7,
+ (GLenum) arg8,
+ (GLenum) arg9,
+ (const GLvoid *) ptr10
+ );
+
+ if(arg10!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg10, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage4DSGIS__IIIIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jfloatArray arg10)
+ {
+ jfloat *ptr10 = NULL;
+
+ if ( disp__glTexImage4DSGIS == NULL ) return;
+
+ if(arg10!=NULL)
+ {
+ ptr10 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg10, 0);
+ }
+ disp__glTexImage4DSGIS (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLsizei) arg6,
+ (GLint) arg7,
+ (GLenum) arg8,
+ (GLenum) arg9,
+ (const GLvoid *) ptr10
+ );
+
+ if(arg10!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg10, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage4DSGIS__IIIIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jdoubleArray arg10)
+ {
+ jdouble *ptr10 = NULL;
+
+ if ( disp__glTexImage4DSGIS == NULL ) return;
+
+ if(arg10!=NULL)
+ {
+ ptr10 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg10, 0);
+ }
+ disp__glTexImage4DSGIS (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLsizei) arg6,
+ (GLint) arg7,
+ (GLenum) arg8,
+ (GLenum) arg9,
+ (const GLvoid *) ptr10
+ );
+
+ if(arg10!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg10, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage4DSGIS__IIIIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jbooleanArray arg10)
+ {
+ jboolean *ptr10 = NULL;
+
+ if ( disp__glTexImage4DSGIS == NULL ) return;
+
+ if(arg10!=NULL)
+ {
+ ptr10 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg10, 0);
+ }
+ disp__glTexImage4DSGIS (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLsizei) arg6,
+ (GLint) arg7,
+ (GLenum) arg8,
+ (GLenum) arg9,
+ (const GLvoid *) ptr10
+ );
+
+ if(arg10!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg10, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage4DSGIS__IIIIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jlongArray arg10)
+ {
+ jlong *ptr10 = NULL;
+
+ if ( disp__glTexImage4DSGIS == NULL ) return;
+
+ if(arg10!=NULL)
+ {
+ ptr10 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg10, 0);
+ }
+ disp__glTexImage4DSGIS (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLsizei) arg6,
+ (GLint) arg7,
+ (GLenum) arg8,
+ (GLenum) arg9,
+ (const GLvoid *) ptr10
+ );
+
+ if(arg10!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg10, ptr10, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexImage4DSGIS__IIIIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jobject arg10)
+ {
+ void *ptr10 = NULL;
+
+ if ( disp__glTexImage4DSGIS == NULL ) return;
+
+ if(arg10!=NULL)
+ {
+ ptr10 = (*env)->GetDirectBufferAddress(env, arg10);
+ if (ptr10 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 10 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glTexImage4DSGIS (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLsizei) arg5,
+ (GLsizei) arg6,
+ (GLint) arg7,
+ (GLenum) arg8,
+ (GLenum) arg9,
+ (const GLvoid *) ptr10
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexSubImage4DSGIS ( GLenum , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage4DSGIS__IIIIIIIIIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jint arg10,
+ jint arg11,
+ jbyteArray arg12)
+ {
+ jbyte *ptr12 = NULL;
+
+ if ( disp__glTexSubImage4DSGIS == NULL ) return;
+
+ if(arg12!=NULL)
+ {
+ ptr12 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg12, 0);
+ }
+ disp__glTexSubImage4DSGIS (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLint) arg5,
+ (GLsizei) arg6,
+ (GLsizei) arg7,
+ (GLsizei) arg8,
+ (GLsizei) arg9,
+ (GLenum) arg10,
+ (GLenum) arg11,
+ (const GLvoid *) ptr12
+ );
+
+ if(arg12!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg12, ptr12, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage4DSGIS__IIIIIIIIIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jint arg10,
+ jint arg11,
+ jshortArray arg12)
+ {
+ jshort *ptr12 = NULL;
+
+ if ( disp__glTexSubImage4DSGIS == NULL ) return;
+
+ if(arg12!=NULL)
+ {
+ ptr12 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg12, 0);
+ }
+ disp__glTexSubImage4DSGIS (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLint) arg5,
+ (GLsizei) arg6,
+ (GLsizei) arg7,
+ (GLsizei) arg8,
+ (GLsizei) arg9,
+ (GLenum) arg10,
+ (GLenum) arg11,
+ (const GLvoid *) ptr12
+ );
+
+ if(arg12!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg12, ptr12, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage4DSGIS__IIIIIIIIIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jint arg10,
+ jint arg11,
+ jintArray arg12)
+ {
+ jint *ptr12 = NULL;
+
+ if ( disp__glTexSubImage4DSGIS == NULL ) return;
+
+ if(arg12!=NULL)
+ {
+ ptr12 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg12, 0);
+ }
+ disp__glTexSubImage4DSGIS (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLint) arg5,
+ (GLsizei) arg6,
+ (GLsizei) arg7,
+ (GLsizei) arg8,
+ (GLsizei) arg9,
+ (GLenum) arg10,
+ (GLenum) arg11,
+ (const GLvoid *) ptr12
+ );
+
+ if(arg12!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg12, ptr12, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage4DSGIS__IIIIIIIIIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jint arg10,
+ jint arg11,
+ jfloatArray arg12)
+ {
+ jfloat *ptr12 = NULL;
+
+ if ( disp__glTexSubImage4DSGIS == NULL ) return;
+
+ if(arg12!=NULL)
+ {
+ ptr12 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg12, 0);
+ }
+ disp__glTexSubImage4DSGIS (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLint) arg5,
+ (GLsizei) arg6,
+ (GLsizei) arg7,
+ (GLsizei) arg8,
+ (GLsizei) arg9,
+ (GLenum) arg10,
+ (GLenum) arg11,
+ (const GLvoid *) ptr12
+ );
+
+ if(arg12!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg12, ptr12, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage4DSGIS__IIIIIIIIIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jint arg10,
+ jint arg11,
+ jdoubleArray arg12)
+ {
+ jdouble *ptr12 = NULL;
+
+ if ( disp__glTexSubImage4DSGIS == NULL ) return;
+
+ if(arg12!=NULL)
+ {
+ ptr12 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg12, 0);
+ }
+ disp__glTexSubImage4DSGIS (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLint) arg5,
+ (GLsizei) arg6,
+ (GLsizei) arg7,
+ (GLsizei) arg8,
+ (GLsizei) arg9,
+ (GLenum) arg10,
+ (GLenum) arg11,
+ (const GLvoid *) ptr12
+ );
+
+ if(arg12!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg12, ptr12, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage4DSGIS__IIIIIIIIIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jint arg10,
+ jint arg11,
+ jbooleanArray arg12)
+ {
+ jboolean *ptr12 = NULL;
+
+ if ( disp__glTexSubImage4DSGIS == NULL ) return;
+
+ if(arg12!=NULL)
+ {
+ ptr12 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg12, 0);
+ }
+ disp__glTexSubImage4DSGIS (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLint) arg5,
+ (GLsizei) arg6,
+ (GLsizei) arg7,
+ (GLsizei) arg8,
+ (GLsizei) arg9,
+ (GLenum) arg10,
+ (GLenum) arg11,
+ (const GLvoid *) ptr12
+ );
+
+ if(arg12!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg12, ptr12, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage4DSGIS__IIIIIIIIIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jint arg10,
+ jint arg11,
+ jlongArray arg12)
+ {
+ jlong *ptr12 = NULL;
+
+ if ( disp__glTexSubImage4DSGIS == NULL ) return;
+
+ if(arg12!=NULL)
+ {
+ ptr12 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg12, 0);
+ }
+ disp__glTexSubImage4DSGIS (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLint) arg5,
+ (GLsizei) arg6,
+ (GLsizei) arg7,
+ (GLsizei) arg8,
+ (GLsizei) arg9,
+ (GLenum) arg10,
+ (GLenum) arg11,
+ (const GLvoid *) ptr12
+ );
+
+ if(arg12!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg12, ptr12, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexSubImage4DSGIS__IIIIIIIIIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jint arg10,
+ jint arg11,
+ jobject arg12)
+ {
+ void *ptr12 = NULL;
+
+ if ( disp__glTexSubImage4DSGIS == NULL ) return;
+
+ if(arg12!=NULL)
+ {
+ ptr12 = (*env)->GetDirectBufferAddress(env, arg12);
+ if (ptr12 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 12 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glTexSubImage4DSGIS (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLint) arg5,
+ (GLsizei) arg6,
+ (GLsizei) arg7,
+ (GLsizei) arg8,
+ (GLsizei) arg9,
+ (GLenum) arg10,
+ (GLenum) arg11,
+ (const GLvoid *) ptr12
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDetailTexFuncSGIS ( GLenum , GLsizei , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDetailTexFuncSGIS (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glDetailTexFuncSGIS == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glDetailTexFuncSGIS (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetDetailTexFuncSGIS ( GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetDetailTexFuncSGIS (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glGetDetailTexFuncSGIS == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, &isCopiedArray1);
+ }
+ disp__glGetDetailTexFuncSGIS (
+ (GLenum) arg0,
+ (GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSharpenTexFuncSGIS ( GLenum , GLsizei , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSharpenTexFuncSGIS (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glSharpenTexFuncSGIS == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glSharpenTexFuncSGIS (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetSharpenTexFuncSGIS ( GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetSharpenTexFuncSGIS (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glGetSharpenTexFuncSGIS == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, &isCopiedArray1);
+ }
+ disp__glGetSharpenTexFuncSGIS (
+ (GLenum) arg0,
+ (GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSampleMaskSGIS ( GLclampf , GLboolean ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSampleMaskSGIS (
+ JNIEnv *env, jobject obj,
+ jfloat arg0,
+ jboolean arg1)
+ {
+
+ if ( disp__glSampleMaskSGIS == NULL ) return;
+
+ disp__glSampleMaskSGIS (
+ (GLclampf) arg0,
+ (GLboolean) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSamplePatternSGIS ( GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSamplePatternSGIS (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glSamplePatternSGIS == NULL ) return;
+
+ disp__glSamplePatternSGIS (
+ (GLenum) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSpriteParameterfSGIX ( GLenum , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSpriteParameterfSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1)
+ {
+
+ if ( disp__glSpriteParameterfSGIX == NULL ) return;
+
+ disp__glSpriteParameterfSGIX (
+ (GLenum) arg0,
+ (GLfloat) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSpriteParameterfvSGIX ( GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSpriteParameterfvSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glSpriteParameterfvSGIX == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glSpriteParameterfvSGIX (
+ (GLenum) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSpriteParameteriSGIX ( GLenum , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSpriteParameteriSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+
+ if ( disp__glSpriteParameteriSGIX == NULL ) return;
+
+ disp__glSpriteParameteriSGIX (
+ (GLenum) arg0,
+ (GLint) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSpriteParameterivSGIX ( GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSpriteParameterivSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glSpriteParameterivSGIX == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glSpriteParameterivSGIX (
+ (GLenum) arg0,
+ (const GLint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPointParameterfARB ( GLenum , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPointParameterfARB (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1)
+ {
+
+ if ( disp__glPointParameterfARB == NULL ) return;
+
+ disp__glPointParameterfARB (
+ (GLenum) arg0,
+ (GLfloat) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPointParameterfvARB ( GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPointParameterfvARB (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glPointParameterfvARB == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glPointParameterfvARB (
+ (GLenum) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLint glGetInstrumentsSGIX ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetInstrumentsSGIX (
+ JNIEnv *env, jobject obj)
+ {
+ jint ret;
+
+
+ if ( disp__glGetInstrumentsSGIX == NULL ) return 0;
+
+ ret = (jint) disp__glGetInstrumentsSGIX (
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glInstrumentsBufferSGIX ( GLsizei , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glInstrumentsBufferSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jint *ptr1 = NULL;
+
+ if ( disp__glInstrumentsBufferSGIX == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, &isCopiedArray1);
+ }
+ disp__glInstrumentsBufferSGIX (
+ (GLsizei) arg0,
+ (GLint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLint glPollInstrumentsSGIX ( GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPollInstrumentsSGIX (
+ JNIEnv *env, jobject obj,
+ jintArray arg0)
+ {
+ jint ret;
+
+ jboolean isCopiedArray0 = JNI_FALSE;
+ jint *ptr0 = NULL;
+
+ if ( disp__glPollInstrumentsSGIX == NULL ) return 0;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, &isCopiedArray0);
+ }
+ ret = (jint) disp__glPollInstrumentsSGIX (
+ (GLint *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, (isCopiedArray0 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReadInstrumentsSGIX ( GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReadInstrumentsSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glReadInstrumentsSGIX == NULL ) return;
+
+ disp__glReadInstrumentsSGIX (
+ (GLint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glStartInstrumentsSGIX ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glStartInstrumentsSGIX (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glStartInstrumentsSGIX == NULL ) return;
+
+ disp__glStartInstrumentsSGIX (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glStopInstrumentsSGIX ( GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glStopInstrumentsSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glStopInstrumentsSGIX == NULL ) return;
+
+ disp__glStopInstrumentsSGIX (
+ (GLint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFrameZoomSGIX ( GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFrameZoomSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glFrameZoomSGIX == NULL ) return;
+
+ disp__glFrameZoomSGIX (
+ (GLint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTagSampleBufferSGIX ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTagSampleBufferSGIX (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glTagSampleBufferSGIX == NULL ) return;
+
+ disp__glTagSampleBufferSGIX (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDeformationMap3dSGIX ( GLenum , GLdouble , GLdouble , GLint , GLint , GLdouble , GLdouble , GLint , GLint , GLdouble , GLdouble , GLint , GLint , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDeformationMap3dSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdouble arg1,
+ jdouble arg2,
+ jint arg3,
+ jint arg4,
+ jdouble arg5,
+ jdouble arg6,
+ jint arg7,
+ jint arg8,
+ jdouble arg9,
+ jdouble arg10,
+ jint arg11,
+ jint arg12,
+ jdoubleArray arg13)
+ {
+ jdouble *ptr13 = NULL;
+
+ if ( disp__glDeformationMap3dSGIX == NULL ) return;
+
+ if(arg13!=NULL)
+ {
+ ptr13 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg13, 0);
+ }
+ disp__glDeformationMap3dSGIX (
+ (GLenum) arg0,
+ (GLdouble) arg1,
+ (GLdouble) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLdouble) arg5,
+ (GLdouble) arg6,
+ (GLint) arg7,
+ (GLint) arg8,
+ (GLdouble) arg9,
+ (GLdouble) arg10,
+ (GLint) arg11,
+ (GLint) arg12,
+ (const GLdouble *) ptr13
+ );
+
+ if(arg13!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg13, ptr13, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDeformationMap3fSGIX ( GLenum , GLfloat , GLfloat , GLint , GLint , GLfloat , GLfloat , GLint , GLint , GLfloat , GLfloat , GLint , GLint , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDeformationMap3fSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jint arg3,
+ jint arg4,
+ jfloat arg5,
+ jfloat arg6,
+ jint arg7,
+ jint arg8,
+ jfloat arg9,
+ jfloat arg10,
+ jint arg11,
+ jint arg12,
+ jfloatArray arg13)
+ {
+ jfloat *ptr13 = NULL;
+
+ if ( disp__glDeformationMap3fSGIX == NULL ) return;
+
+ if(arg13!=NULL)
+ {
+ ptr13 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg13, 0);
+ }
+ disp__glDeformationMap3fSGIX (
+ (GLenum) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLint) arg3,
+ (GLint) arg4,
+ (GLfloat) arg5,
+ (GLfloat) arg6,
+ (GLint) arg7,
+ (GLint) arg8,
+ (GLfloat) arg9,
+ (GLfloat) arg10,
+ (GLint) arg11,
+ (GLint) arg12,
+ (const GLfloat *) ptr13
+ );
+
+ if(arg13!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg13, ptr13, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDeformSGIX ( GLbitfield ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDeformSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glDeformSGIX == NULL ) return;
+
+ disp__glDeformSGIX (
+ (GLbitfield) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLoadIdentityDeformationMapSGIX ( GLbitfield ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLoadIdentityDeformationMapSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glLoadIdentityDeformationMapSGIX == NULL ) return;
+
+ disp__glLoadIdentityDeformationMapSGIX (
+ (GLbitfield) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReferencePlaneSGIX ( const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReferencePlaneSGIX (
+ JNIEnv *env, jobject obj,
+ jdoubleArray arg0)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glReferencePlaneSGIX == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glReferencePlaneSGIX (
+ (const GLdouble *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFlushRasterSGIX ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFlushRasterSGIX (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glFlushRasterSGIX == NULL ) return;
+
+ disp__glFlushRasterSGIX (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFogFuncSGIS ( GLsizei , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogFuncSGIS (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glFogFuncSGIS == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glFogFuncSGIS (
+ (GLsizei) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetFogFuncSGIS ( GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetFogFuncSGIS (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0)
+ {
+ jboolean isCopiedArray0 = JNI_FALSE;
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glGetFogFuncSGIS == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, &isCopiedArray0);
+ }
+ disp__glGetFogFuncSGIS (
+ (GLfloat *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, (isCopiedArray0 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glImageTransformParameteriHP ( GLenum , GLenum , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glImageTransformParameteriHP (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2)
+ {
+
+ if ( disp__glImageTransformParameteriHP == NULL ) return;
+
+ disp__glImageTransformParameteriHP (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glImageTransformParameterfHP ( GLenum , GLenum , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glImageTransformParameterfHP (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloat arg2)
+ {
+
+ if ( disp__glImageTransformParameterfHP == NULL ) return;
+
+ disp__glImageTransformParameterfHP (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLfloat) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glImageTransformParameterivHP ( GLenum , GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glImageTransformParameterivHP (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glImageTransformParameterivHP == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glImageTransformParameterivHP (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (const GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glImageTransformParameterfvHP ( GLenum , GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glImageTransformParameterfvHP (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glImageTransformParameterfvHP == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glImageTransformParameterfvHP (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetImageTransformParameterivHP ( GLenum , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetImageTransformParameterivHP (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetImageTransformParameterivHP == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetImageTransformParameterivHP (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetImageTransformParameterfvHP ( GLenum , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetImageTransformParameterfvHP (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetImageTransformParameterfvHP == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetImageTransformParameterfvHP (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCopyColorSubTableEXT ( GLenum , GLsizei , GLint , GLint , GLsizei ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCopyColorSubTableEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4)
+ {
+
+ if ( disp__glCopyColorSubTableEXT == NULL ) return;
+
+ disp__glCopyColorSubTableEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLsizei) arg4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glHintPGI ( GLenum , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glHintPGI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+
+ if ( disp__glHintPGI == NULL ) return;
+
+ disp__glHintPGI (
+ (GLenum) arg0,
+ (GLint) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetListParameterfvSGIX ( GLuint , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetListParameterfvSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetListParameterfvSGIX == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetListParameterfvSGIX (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetListParameterivSGIX ( GLuint , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetListParameterivSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetListParameterivSGIX == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetListParameterivSGIX (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glListParameterfSGIX ( GLuint , GLenum , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glListParameterfSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloat arg2)
+ {
+
+ if ( disp__glListParameterfSGIX == NULL ) return;
+
+ disp__glListParameterfSGIX (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLfloat) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glListParameterfvSGIX ( GLuint , GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glListParameterfvSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glListParameterfvSGIX == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glListParameterfvSGIX (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glListParameteriSGIX ( GLuint , GLenum , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glListParameteriSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2)
+ {
+
+ if ( disp__glListParameteriSGIX == NULL ) return;
+
+ disp__glListParameteriSGIX (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glListParameterivSGIX ( GLuint , GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glListParameterivSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glListParameterivSGIX == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glListParameterivSGIX (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glIndexMaterialEXT ( GLenum , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexMaterialEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+
+ if ( disp__glIndexMaterialEXT == NULL ) return;
+
+ disp__glIndexMaterialEXT (
+ (GLenum) arg0,
+ (GLenum) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glIndexFuncEXT ( GLenum , GLclampf ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexFuncEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1)
+ {
+
+ if ( disp__glIndexFuncEXT == NULL ) return;
+
+ disp__glIndexFuncEXT (
+ (GLenum) arg0,
+ (GLclampf) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCullParameterdvEXT ( GLenum , GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCullParameterdvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdoubleArray arg1)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glCullParameterdvEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg1, &isCopiedArray1);
+ }
+ disp__glCullParameterdvEXT (
+ (GLenum) arg0,
+ (GLdouble *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCullParameterfvEXT ( GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCullParameterfvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glCullParameterfvEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, &isCopiedArray1);
+ }
+ disp__glCullParameterfvEXT (
+ (GLenum) arg0,
+ (GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFragmentColorMaterialSGIX ( GLenum , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFragmentColorMaterialSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+
+ if ( disp__glFragmentColorMaterialSGIX == NULL ) return;
+
+ disp__glFragmentColorMaterialSGIX (
+ (GLenum) arg0,
+ (GLenum) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFragmentLightfSGIX ( GLenum , GLenum , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFragmentLightfSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloat arg2)
+ {
+
+ if ( disp__glFragmentLightfSGIX == NULL ) return;
+
+ disp__glFragmentLightfSGIX (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLfloat) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFragmentLightfvSGIX ( GLenum , GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFragmentLightfvSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glFragmentLightfvSGIX == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFragmentLightfvSGIX (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFragmentLightiSGIX ( GLenum , GLenum , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFragmentLightiSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2)
+ {
+
+ if ( disp__glFragmentLightiSGIX == NULL ) return;
+
+ disp__glFragmentLightiSGIX (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFragmentLightivSGIX ( GLenum , GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFragmentLightivSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glFragmentLightivSGIX == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFragmentLightivSGIX (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (const GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFragmentLightModelfSGIX ( GLenum , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFragmentLightModelfSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1)
+ {
+
+ if ( disp__glFragmentLightModelfSGIX == NULL ) return;
+
+ disp__glFragmentLightModelfSGIX (
+ (GLenum) arg0,
+ (GLfloat) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFragmentLightModelfvSGIX ( GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFragmentLightModelfvSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glFragmentLightModelfvSGIX == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glFragmentLightModelfvSGIX (
+ (GLenum) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFragmentLightModeliSGIX ( GLenum , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFragmentLightModeliSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+
+ if ( disp__glFragmentLightModeliSGIX == NULL ) return;
+
+ disp__glFragmentLightModeliSGIX (
+ (GLenum) arg0,
+ (GLint) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFragmentLightModelivSGIX ( GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFragmentLightModelivSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glFragmentLightModelivSGIX == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glFragmentLightModelivSGIX (
+ (GLenum) arg0,
+ (const GLint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFragmentMaterialfSGIX ( GLenum , GLenum , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFragmentMaterialfSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloat arg2)
+ {
+
+ if ( disp__glFragmentMaterialfSGIX == NULL ) return;
+
+ disp__glFragmentMaterialfSGIX (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLfloat) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFragmentMaterialfvSGIX ( GLenum , GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFragmentMaterialfvSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glFragmentMaterialfvSGIX == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFragmentMaterialfvSGIX (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFragmentMaterialiSGIX ( GLenum , GLenum , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFragmentMaterialiSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2)
+ {
+
+ if ( disp__glFragmentMaterialiSGIX == NULL ) return;
+
+ disp__glFragmentMaterialiSGIX (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFragmentMaterialivSGIX ( GLenum , GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFragmentMaterialivSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glFragmentMaterialivSGIX == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFragmentMaterialivSGIX (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (const GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetFragmentLightfvSGIX ( GLenum , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetFragmentLightfvSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetFragmentLightfvSGIX == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetFragmentLightfvSGIX (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetFragmentLightivSGIX ( GLenum , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetFragmentLightivSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetFragmentLightivSGIX == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetFragmentLightivSGIX (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetFragmentMaterialfvSGIX ( GLenum , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetFragmentMaterialfvSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetFragmentMaterialfvSGIX == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetFragmentMaterialfvSGIX (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetFragmentMaterialivSGIX ( GLenum , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetFragmentMaterialivSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetFragmentMaterialivSGIX == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetFragmentMaterialivSGIX (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLightEnviSGIX ( GLenum , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLightEnviSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+
+ if ( disp__glLightEnviSGIX == NULL ) return;
+
+ disp__glLightEnviSGIX (
+ (GLenum) arg0,
+ (GLint) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDrawRangeElementsEXT ( GLenum , GLuint , GLuint , GLsizei , GLenum , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawRangeElementsEXT__IIIII_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jbyteArray arg5)
+ {
+ jbyte *ptr5 = NULL;
+
+ if ( disp__glDrawRangeElementsEXT == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glDrawRangeElementsEXT (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawRangeElementsEXT__IIIII_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jshortArray arg5)
+ {
+ jshort *ptr5 = NULL;
+
+ if ( disp__glDrawRangeElementsEXT == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glDrawRangeElementsEXT (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawRangeElementsEXT__IIIII_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jintArray arg5)
+ {
+ jint *ptr5 = NULL;
+
+ if ( disp__glDrawRangeElementsEXT == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glDrawRangeElementsEXT (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawRangeElementsEXT__IIIII_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jfloatArray arg5)
+ {
+ jfloat *ptr5 = NULL;
+
+ if ( disp__glDrawRangeElementsEXT == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glDrawRangeElementsEXT (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawRangeElementsEXT__IIIII_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jdoubleArray arg5)
+ {
+ jdouble *ptr5 = NULL;
+
+ if ( disp__glDrawRangeElementsEXT == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glDrawRangeElementsEXT (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawRangeElementsEXT__IIIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jbooleanArray arg5)
+ {
+ jboolean *ptr5 = NULL;
+
+ if ( disp__glDrawRangeElementsEXT == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glDrawRangeElementsEXT (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawRangeElementsEXT__IIIII_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jlongArray arg5)
+ {
+ jlong *ptr5 = NULL;
+
+ if ( disp__glDrawRangeElementsEXT == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg5, 0);
+ }
+ disp__glDrawRangeElementsEXT (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ if(arg5!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg5, ptr5, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDrawRangeElementsEXT__IIIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jobject arg5)
+ {
+ void *ptr5 = NULL;
+
+ if ( disp__glDrawRangeElementsEXT == NULL ) return;
+
+ if(arg5!=NULL)
+ {
+ ptr5 = (*env)->GetDirectBufferAddress(env, arg5);
+ if (ptr5 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 5 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glDrawRangeElementsEXT (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (GLsizei) arg3,
+ (GLenum) arg4,
+ (const GLvoid *) ptr5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glApplyTextureEXT ( GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glApplyTextureEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glApplyTextureEXT == NULL ) return;
+
+ disp__glApplyTextureEXT (
+ (GLenum) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTextureLightEXT ( GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTextureLightEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glTextureLightEXT == NULL ) return;
+
+ disp__glTextureLightEXT (
+ (GLenum) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTextureMaterialEXT ( GLenum , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTextureMaterialEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+
+ if ( disp__glTextureMaterialEXT == NULL ) return;
+
+ disp__glTextureMaterialEXT (
+ (GLenum) arg0,
+ (GLenum) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glAsyncMarkerSGIX ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glAsyncMarkerSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glAsyncMarkerSGIX == NULL ) return;
+
+ disp__glAsyncMarkerSGIX (
+ (GLuint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLint glFinishAsyncSGIX ( GLuint * ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFinishAsyncSGIX (
+ JNIEnv *env, jobject obj,
+ jintArray arg0)
+ {
+ jint ret;
+
+ jboolean isCopiedArray0 = JNI_FALSE;
+ jint *ptr0 = NULL;
+
+ if ( disp__glFinishAsyncSGIX == NULL ) return 0;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, &isCopiedArray0);
+ }
+ ret = (jint) disp__glFinishAsyncSGIX (
+ (GLuint *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, (isCopiedArray0 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLint glPollAsyncSGIX ( GLuint * ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPollAsyncSGIX (
+ JNIEnv *env, jobject obj,
+ jintArray arg0)
+ {
+ jint ret;
+
+ jboolean isCopiedArray0 = JNI_FALSE;
+ jint *ptr0 = NULL;
+
+ if ( disp__glPollAsyncSGIX == NULL ) return 0;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, &isCopiedArray0);
+ }
+ ret = (jint) disp__glPollAsyncSGIX (
+ (GLuint *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, (isCopiedArray0 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLuint glGenAsyncMarkersSGIX ( GLsizei ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGenAsyncMarkersSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+ jint ret;
+
+
+ if ( disp__glGenAsyncMarkersSGIX == NULL ) return 0;
+
+ ret = (jint) disp__glGenAsyncMarkersSGIX (
+ (GLsizei) arg0
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDeleteAsyncMarkersSGIX ( GLuint , GLsizei ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDeleteAsyncMarkersSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+
+ if ( disp__glDeleteAsyncMarkersSGIX == NULL ) return;
+
+ disp__glDeleteAsyncMarkersSGIX (
+ (GLuint) arg0,
+ (GLsizei) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLboolean glIsAsyncMarkerSGIX ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT jboolean JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIsAsyncMarkerSGIX (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+ jboolean ret;
+
+
+ if ( disp__glIsAsyncMarkerSGIX == NULL ) return 0;
+
+ ret = (jboolean) disp__glIsAsyncMarkerSGIX (
+ (GLuint) arg0
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexPointervINTEL ( GLint , GLenum , const GLvoid * * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointervINTEL__II_3_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbyteArray arg2)
+ {
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glVertexPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointervINTEL__II_3_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glVertexPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointervINTEL__II_3_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glVertexPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointervINTEL__II_3_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glVertexPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointervINTEL__II_3_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glVertexPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointervINTEL__II_3_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2)
+ {
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glVertexPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointervINTEL__II_3_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jlongArray arg2)
+ {
+ jlong *ptr2 = NULL;
+
+ if ( disp__glVertexPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormalPointervINTEL ( GLenum , const GLvoid * * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointervINTEL__I_3_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbyteArray arg1)
+ {
+ jbyte *ptr1 = NULL;
+
+ if ( disp__glNormalPointervINTEL == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glNormalPointervINTEL (
+ (GLenum) arg0,
+ (const GLvoid **) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointervINTEL__I_3_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glNormalPointervINTEL == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glNormalPointervINTEL (
+ (GLenum) arg0,
+ (const GLvoid **) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointervINTEL__I_3_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glNormalPointervINTEL == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glNormalPointervINTEL (
+ (GLenum) arg0,
+ (const GLvoid **) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointervINTEL__I_3_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glNormalPointervINTEL == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glNormalPointervINTEL (
+ (GLenum) arg0,
+ (const GLvoid **) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointervINTEL__I_3_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdoubleArray arg1)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glNormalPointervINTEL == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glNormalPointervINTEL (
+ (GLenum) arg0,
+ (const GLvoid **) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointervINTEL__I_3_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbooleanArray arg1)
+ {
+ jboolean *ptr1 = NULL;
+
+ if ( disp__glNormalPointervINTEL == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glNormalPointervINTEL (
+ (GLenum) arg0,
+ (const GLvoid **) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointervINTEL__I_3_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jlongArray arg1)
+ {
+ jlong *ptr1 = NULL;
+
+ if ( disp__glNormalPointervINTEL == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glNormalPointervINTEL (
+ (GLenum) arg0,
+ (const GLvoid **) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorPointervINTEL ( GLint , GLenum , const GLvoid * * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointervINTEL__II_3_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbyteArray arg2)
+ {
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glColorPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glColorPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointervINTEL__II_3_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glColorPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glColorPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointervINTEL__II_3_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glColorPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glColorPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointervINTEL__II_3_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glColorPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glColorPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointervINTEL__II_3_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glColorPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glColorPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointervINTEL__II_3_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2)
+ {
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glColorPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glColorPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointervINTEL__II_3_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jlongArray arg2)
+ {
+ jlong *ptr2 = NULL;
+
+ if ( disp__glColorPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glColorPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoordPointervINTEL ( GLint , GLenum , const GLvoid * * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointervINTEL__II_3_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbyteArray arg2)
+ {
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glTexCoordPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glTexCoordPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointervINTEL__II_3_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glTexCoordPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glTexCoordPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointervINTEL__II_3_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glTexCoordPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glTexCoordPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointervINTEL__II_3_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glTexCoordPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glTexCoordPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointervINTEL__II_3_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glTexCoordPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glTexCoordPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointervINTEL__II_3_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2)
+ {
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glTexCoordPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glTexCoordPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointervINTEL__II_3_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jlongArray arg2)
+ {
+ jlong *ptr2 = NULL;
+
+ if ( disp__glTexCoordPointervINTEL == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glTexCoordPointervINTEL (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPixelTransformParameteriEXT ( GLenum , GLenum , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPixelTransformParameteriEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2)
+ {
+
+ if ( disp__glPixelTransformParameteriEXT == NULL ) return;
+
+ disp__glPixelTransformParameteriEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPixelTransformParameterfEXT ( GLenum , GLenum , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPixelTransformParameterfEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloat arg2)
+ {
+
+ if ( disp__glPixelTransformParameterfEXT == NULL ) return;
+
+ disp__glPixelTransformParameterfEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLfloat) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPixelTransformParameterivEXT ( GLenum , GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPixelTransformParameterivEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glPixelTransformParameterivEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glPixelTransformParameterivEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (const GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPixelTransformParameterfvEXT ( GLenum , GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPixelTransformParameterfvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glPixelTransformParameterfvEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glPixelTransformParameterfvEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColor3bEXT ( GLbyte , GLbyte , GLbyte ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColor3bEXT (
+ JNIEnv *env, jobject obj,
+ jbyte arg0,
+ jbyte arg1,
+ jbyte arg2)
+ {
+
+ if ( disp__glSecondaryColor3bEXT == NULL ) return;
+
+ disp__glSecondaryColor3bEXT (
+ (GLbyte) arg0,
+ (GLbyte) arg1,
+ (GLbyte) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColor3bvEXT ( const GLbyte * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColor3bvEXT (
+ JNIEnv *env, jobject obj,
+ jbyteArray arg0)
+ {
+ jbyte *ptr0 = NULL;
+
+ if ( disp__glSecondaryColor3bvEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glSecondaryColor3bvEXT (
+ (const GLbyte *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColor3dEXT ( GLdouble , GLdouble , GLdouble ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColor3dEXT (
+ JNIEnv *env, jobject obj,
+ jdouble arg0,
+ jdouble arg1,
+ jdouble arg2)
+ {
+
+ if ( disp__glSecondaryColor3dEXT == NULL ) return;
+
+ disp__glSecondaryColor3dEXT (
+ (GLdouble) arg0,
+ (GLdouble) arg1,
+ (GLdouble) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColor3dvEXT ( const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColor3dvEXT (
+ JNIEnv *env, jobject obj,
+ jdoubleArray arg0)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glSecondaryColor3dvEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glSecondaryColor3dvEXT (
+ (const GLdouble *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColor3fEXT ( GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColor3fEXT (
+ JNIEnv *env, jobject obj,
+ jfloat arg0,
+ jfloat arg1,
+ jfloat arg2)
+ {
+
+ if ( disp__glSecondaryColor3fEXT == NULL ) return;
+
+ disp__glSecondaryColor3fEXT (
+ (GLfloat) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColor3fvEXT ( const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColor3fvEXT (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glSecondaryColor3fvEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glSecondaryColor3fvEXT (
+ (const GLfloat *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColor3iEXT ( GLint , GLint , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColor3iEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2)
+ {
+
+ if ( disp__glSecondaryColor3iEXT == NULL ) return;
+
+ disp__glSecondaryColor3iEXT (
+ (GLint) arg0,
+ (GLint) arg1,
+ (GLint) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColor3ivEXT ( const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColor3ivEXT (
+ JNIEnv *env, jobject obj,
+ jintArray arg0)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glSecondaryColor3ivEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glSecondaryColor3ivEXT (
+ (const GLint *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColor3sEXT ( GLshort , GLshort , GLshort ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColor3sEXT (
+ JNIEnv *env, jobject obj,
+ jshort arg0,
+ jshort arg1,
+ jshort arg2)
+ {
+
+ if ( disp__glSecondaryColor3sEXT == NULL ) return;
+
+ disp__glSecondaryColor3sEXT (
+ (GLshort) arg0,
+ (GLshort) arg1,
+ (GLshort) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColor3svEXT ( const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColor3svEXT (
+ JNIEnv *env, jobject obj,
+ jshortArray arg0)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glSecondaryColor3svEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glSecondaryColor3svEXT (
+ (const GLshort *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColor3ubEXT ( GLubyte , GLubyte , GLubyte ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColor3ubEXT (
+ JNIEnv *env, jobject obj,
+ jbyte arg0,
+ jbyte arg1,
+ jbyte arg2)
+ {
+
+ if ( disp__glSecondaryColor3ubEXT == NULL ) return;
+
+ disp__glSecondaryColor3ubEXT (
+ (GLubyte) arg0,
+ (GLubyte) arg1,
+ (GLubyte) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColor3ubvEXT ( const GLubyte * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColor3ubvEXT (
+ JNIEnv *env, jobject obj,
+ jbyteArray arg0)
+ {
+ jbyte *ptr0 = NULL;
+
+ if ( disp__glSecondaryColor3ubvEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glSecondaryColor3ubvEXT (
+ (const GLubyte *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColor3uiEXT ( GLuint , GLuint , GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColor3uiEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2)
+ {
+
+ if ( disp__glSecondaryColor3uiEXT == NULL ) return;
+
+ disp__glSecondaryColor3uiEXT (
+ (GLuint) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColor3uivEXT ( const GLuint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColor3uivEXT (
+ JNIEnv *env, jobject obj,
+ jintArray arg0)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glSecondaryColor3uivEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glSecondaryColor3uivEXT (
+ (const GLuint *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColor3usEXT ( GLushort , GLushort , GLushort ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColor3usEXT (
+ JNIEnv *env, jobject obj,
+ jshort arg0,
+ jshort arg1,
+ jshort arg2)
+ {
+
+ if ( disp__glSecondaryColor3usEXT == NULL ) return;
+
+ disp__glSecondaryColor3usEXT (
+ (GLushort) arg0,
+ (GLushort) arg1,
+ (GLushort) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColor3usvEXT ( const GLushort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColor3usvEXT (
+ JNIEnv *env, jobject obj,
+ jshortArray arg0)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glSecondaryColor3usvEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glSecondaryColor3usvEXT (
+ (const GLushort *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColorPointerEXT ( GLint , GLenum , GLsizei , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColorPointerEXT__III_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbyteArray arg3)
+ {
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glSecondaryColorPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glSecondaryColorPointerEXT (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColorPointerEXT__III_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jshortArray arg3)
+ {
+ jshort *ptr3 = NULL;
+
+ if ( disp__glSecondaryColorPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glSecondaryColorPointerEXT (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColorPointerEXT__III_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jintArray arg3)
+ {
+ jint *ptr3 = NULL;
+
+ if ( disp__glSecondaryColorPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glSecondaryColorPointerEXT (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColorPointerEXT__III_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glSecondaryColorPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glSecondaryColorPointerEXT (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColorPointerEXT__III_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jdoubleArray arg3)
+ {
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glSecondaryColorPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glSecondaryColorPointerEXT (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColorPointerEXT__III_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbooleanArray arg3)
+ {
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glSecondaryColorPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glSecondaryColorPointerEXT (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColorPointerEXT__III_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jlongArray arg3)
+ {
+ jlong *ptr3 = NULL;
+
+ if ( disp__glSecondaryColorPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glSecondaryColorPointerEXT (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColorPointerEXT__IIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jobject arg3)
+ {
+ void *ptr3 = NULL;
+
+ if ( disp__glSecondaryColorPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, arg3);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glSecondaryColorPointerEXT (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTextureNormalEXT ( GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTextureNormalEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glTextureNormalEXT == NULL ) return;
+
+ disp__glTextureNormalEXT (
+ (GLenum) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiDrawArraysEXT ( GLenum , GLint * , GLsizei * , GLsizei ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiDrawArraysEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1,
+ jintArray arg2,
+ jint arg3)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jint *ptr1 = NULL;
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glMultiDrawArraysEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, &isCopiedArray1);
+ }
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glMultiDrawArraysEXT (
+ (GLenum) arg0,
+ (GLint *) ptr1,
+ (GLsizei *) ptr2,
+ (GLsizei) arg3
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiDrawElementsEXT ( GLenum , const GLsizei * , GLenum , const GLvoid * * , GLsizei ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiDrawElementsEXT__I_3II_3_3BI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1,
+ jint arg2,
+ jbyteArray arg3,
+ jint arg4)
+ {
+ jint *ptr1 = NULL;
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glMultiDrawElementsEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMultiDrawElementsEXT (
+ (GLenum) arg0,
+ (const GLsizei *) ptr1,
+ (GLenum) arg2,
+ (const GLvoid **) ptr3,
+ (GLsizei) arg4
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiDrawElementsEXT__I_3II_3_3SI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1,
+ jint arg2,
+ jshortArray arg3,
+ jint arg4)
+ {
+ jint *ptr1 = NULL;
+ jshort *ptr3 = NULL;
+
+ if ( disp__glMultiDrawElementsEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMultiDrawElementsEXT (
+ (GLenum) arg0,
+ (const GLsizei *) ptr1,
+ (GLenum) arg2,
+ (const GLvoid **) ptr3,
+ (GLsizei) arg4
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiDrawElementsEXT__I_3II_3_3II (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1,
+ jint arg2,
+ jintArray arg3,
+ jint arg4)
+ {
+ jint *ptr1 = NULL;
+ jint *ptr3 = NULL;
+
+ if ( disp__glMultiDrawElementsEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMultiDrawElementsEXT (
+ (GLenum) arg0,
+ (const GLsizei *) ptr1,
+ (GLenum) arg2,
+ (const GLvoid **) ptr3,
+ (GLsizei) arg4
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiDrawElementsEXT__I_3II_3_3FI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1,
+ jint arg2,
+ jfloatArray arg3,
+ jint arg4)
+ {
+ jint *ptr1 = NULL;
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glMultiDrawElementsEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMultiDrawElementsEXT (
+ (GLenum) arg0,
+ (const GLsizei *) ptr1,
+ (GLenum) arg2,
+ (const GLvoid **) ptr3,
+ (GLsizei) arg4
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiDrawElementsEXT__I_3II_3_3DI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1,
+ jint arg2,
+ jdoubleArray arg3,
+ jint arg4)
+ {
+ jint *ptr1 = NULL;
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glMultiDrawElementsEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMultiDrawElementsEXT (
+ (GLenum) arg0,
+ (const GLsizei *) ptr1,
+ (GLenum) arg2,
+ (const GLvoid **) ptr3,
+ (GLsizei) arg4
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiDrawElementsEXT__I_3II_3_3ZI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1,
+ jint arg2,
+ jbooleanArray arg3,
+ jint arg4)
+ {
+ jint *ptr1 = NULL;
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glMultiDrawElementsEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMultiDrawElementsEXT (
+ (GLenum) arg0,
+ (const GLsizei *) ptr1,
+ (GLenum) arg2,
+ (const GLvoid **) ptr3,
+ (GLsizei) arg4
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiDrawElementsEXT__I_3II_3_3JI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1,
+ jint arg2,
+ jlongArray arg3,
+ jint arg4)
+ {
+ jint *ptr1 = NULL;
+ jlong *ptr3 = NULL;
+
+ if ( disp__glMultiDrawElementsEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMultiDrawElementsEXT (
+ (GLenum) arg0,
+ (const GLsizei *) ptr1,
+ (GLenum) arg2,
+ (const GLvoid **) ptr3,
+ (GLsizei) arg4
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFogCoordfEXT ( GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoordfEXT (
+ JNIEnv *env, jobject obj,
+ jfloat arg0)
+ {
+
+ if ( disp__glFogCoordfEXT == NULL ) return;
+
+ disp__glFogCoordfEXT (
+ (GLfloat) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFogCoordfvEXT ( const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoordfvEXT (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glFogCoordfvEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glFogCoordfvEXT (
+ (const GLfloat *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFogCoorddEXT ( GLdouble ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoorddEXT (
+ JNIEnv *env, jobject obj,
+ jdouble arg0)
+ {
+
+ if ( disp__glFogCoorddEXT == NULL ) return;
+
+ disp__glFogCoorddEXT (
+ (GLdouble) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFogCoorddvEXT ( const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoorddvEXT (
+ JNIEnv *env, jobject obj,
+ jdoubleArray arg0)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glFogCoorddvEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glFogCoorddvEXT (
+ (const GLdouble *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFogCoordPointerEXT ( GLenum , GLsizei , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoordPointerEXT__II_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbyteArray arg2)
+ {
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glFogCoordPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFogCoordPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoordPointerEXT__II_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glFogCoordPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFogCoordPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoordPointerEXT__II_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glFogCoordPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFogCoordPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoordPointerEXT__II_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glFogCoordPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFogCoordPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoordPointerEXT__II_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glFogCoordPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFogCoordPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoordPointerEXT__II_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2)
+ {
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glFogCoordPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFogCoordPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoordPointerEXT__II_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jlongArray arg2)
+ {
+ jlong *ptr2 = NULL;
+
+ if ( disp__glFogCoordPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFogCoordPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoordPointerEXT__IILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jobject arg2)
+ {
+ void *ptr2 = NULL;
+
+ if ( disp__glFogCoordPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (*env)->GetDirectBufferAddress(env, arg2);
+ if (ptr2 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 2 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glFogCoordPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTangent3bEXT ( GLbyte , GLbyte , GLbyte ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangent3bEXT (
+ JNIEnv *env, jobject obj,
+ jbyte arg0,
+ jbyte arg1,
+ jbyte arg2)
+ {
+
+ if ( disp__glTangent3bEXT == NULL ) return;
+
+ disp__glTangent3bEXT (
+ (GLbyte) arg0,
+ (GLbyte) arg1,
+ (GLbyte) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTangent3bvEXT ( const GLbyte * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangent3bvEXT (
+ JNIEnv *env, jobject obj,
+ jbyteArray arg0)
+ {
+ jbyte *ptr0 = NULL;
+
+ if ( disp__glTangent3bvEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glTangent3bvEXT (
+ (const GLbyte *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTangent3dEXT ( GLdouble , GLdouble , GLdouble ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangent3dEXT (
+ JNIEnv *env, jobject obj,
+ jdouble arg0,
+ jdouble arg1,
+ jdouble arg2)
+ {
+
+ if ( disp__glTangent3dEXT == NULL ) return;
+
+ disp__glTangent3dEXT (
+ (GLdouble) arg0,
+ (GLdouble) arg1,
+ (GLdouble) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTangent3dvEXT ( const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangent3dvEXT (
+ JNIEnv *env, jobject obj,
+ jdoubleArray arg0)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glTangent3dvEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glTangent3dvEXT (
+ (const GLdouble *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTangent3fEXT ( GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangent3fEXT (
+ JNIEnv *env, jobject obj,
+ jfloat arg0,
+ jfloat arg1,
+ jfloat arg2)
+ {
+
+ if ( disp__glTangent3fEXT == NULL ) return;
+
+ disp__glTangent3fEXT (
+ (GLfloat) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTangent3fvEXT ( const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangent3fvEXT (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glTangent3fvEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glTangent3fvEXT (
+ (const GLfloat *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTangent3iEXT ( GLint , GLint , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangent3iEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2)
+ {
+
+ if ( disp__glTangent3iEXT == NULL ) return;
+
+ disp__glTangent3iEXT (
+ (GLint) arg0,
+ (GLint) arg1,
+ (GLint) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTangent3ivEXT ( const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangent3ivEXT (
+ JNIEnv *env, jobject obj,
+ jintArray arg0)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glTangent3ivEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glTangent3ivEXT (
+ (const GLint *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTangent3sEXT ( GLshort , GLshort , GLshort ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangent3sEXT (
+ JNIEnv *env, jobject obj,
+ jshort arg0,
+ jshort arg1,
+ jshort arg2)
+ {
+
+ if ( disp__glTangent3sEXT == NULL ) return;
+
+ disp__glTangent3sEXT (
+ (GLshort) arg0,
+ (GLshort) arg1,
+ (GLshort) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTangent3svEXT ( const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangent3svEXT (
+ JNIEnv *env, jobject obj,
+ jshortArray arg0)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glTangent3svEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glTangent3svEXT (
+ (const GLshort *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBinormal3bEXT ( GLbyte , GLbyte , GLbyte ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormal3bEXT (
+ JNIEnv *env, jobject obj,
+ jbyte arg0,
+ jbyte arg1,
+ jbyte arg2)
+ {
+
+ if ( disp__glBinormal3bEXT == NULL ) return;
+
+ disp__glBinormal3bEXT (
+ (GLbyte) arg0,
+ (GLbyte) arg1,
+ (GLbyte) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBinormal3bvEXT ( const GLbyte * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormal3bvEXT (
+ JNIEnv *env, jobject obj,
+ jbyteArray arg0)
+ {
+ jbyte *ptr0 = NULL;
+
+ if ( disp__glBinormal3bvEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glBinormal3bvEXT (
+ (const GLbyte *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBinormal3dEXT ( GLdouble , GLdouble , GLdouble ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormal3dEXT (
+ JNIEnv *env, jobject obj,
+ jdouble arg0,
+ jdouble arg1,
+ jdouble arg2)
+ {
+
+ if ( disp__glBinormal3dEXT == NULL ) return;
+
+ disp__glBinormal3dEXT (
+ (GLdouble) arg0,
+ (GLdouble) arg1,
+ (GLdouble) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBinormal3dvEXT ( const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormal3dvEXT (
+ JNIEnv *env, jobject obj,
+ jdoubleArray arg0)
+ {
+ jdouble *ptr0 = NULL;
+
+ if ( disp__glBinormal3dvEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glBinormal3dvEXT (
+ (const GLdouble *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBinormal3fEXT ( GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormal3fEXT (
+ JNIEnv *env, jobject obj,
+ jfloat arg0,
+ jfloat arg1,
+ jfloat arg2)
+ {
+
+ if ( disp__glBinormal3fEXT == NULL ) return;
+
+ disp__glBinormal3fEXT (
+ (GLfloat) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBinormal3fvEXT ( const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormal3fvEXT (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glBinormal3fvEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glBinormal3fvEXT (
+ (const GLfloat *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBinormal3iEXT ( GLint , GLint , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormal3iEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2)
+ {
+
+ if ( disp__glBinormal3iEXT == NULL ) return;
+
+ disp__glBinormal3iEXT (
+ (GLint) arg0,
+ (GLint) arg1,
+ (GLint) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBinormal3ivEXT ( const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormal3ivEXT (
+ JNIEnv *env, jobject obj,
+ jintArray arg0)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glBinormal3ivEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glBinormal3ivEXT (
+ (const GLint *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBinormal3sEXT ( GLshort , GLshort , GLshort ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormal3sEXT (
+ JNIEnv *env, jobject obj,
+ jshort arg0,
+ jshort arg1,
+ jshort arg2)
+ {
+
+ if ( disp__glBinormal3sEXT == NULL ) return;
+
+ disp__glBinormal3sEXT (
+ (GLshort) arg0,
+ (GLshort) arg1,
+ (GLshort) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBinormal3svEXT ( const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormal3svEXT (
+ JNIEnv *env, jobject obj,
+ jshortArray arg0)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glBinormal3svEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glBinormal3svEXT (
+ (const GLshort *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTangentPointerEXT ( GLenum , GLsizei , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangentPointerEXT__II_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbyteArray arg2)
+ {
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glTangentPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glTangentPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangentPointerEXT__II_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glTangentPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glTangentPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangentPointerEXT__II_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glTangentPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glTangentPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangentPointerEXT__II_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glTangentPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glTangentPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangentPointerEXT__II_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glTangentPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glTangentPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangentPointerEXT__II_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2)
+ {
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glTangentPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glTangentPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangentPointerEXT__II_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jlongArray arg2)
+ {
+ jlong *ptr2 = NULL;
+
+ if ( disp__glTangentPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glTangentPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTangentPointerEXT__IILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jobject arg2)
+ {
+ void *ptr2 = NULL;
+
+ if ( disp__glTangentPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (*env)->GetDirectBufferAddress(env, arg2);
+ if (ptr2 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 2 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glTangentPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBinormalPointerEXT ( GLenum , GLsizei , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormalPointerEXT__II_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbyteArray arg2)
+ {
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glBinormalPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glBinormalPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormalPointerEXT__II_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glBinormalPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glBinormalPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormalPointerEXT__II_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glBinormalPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glBinormalPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormalPointerEXT__II_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glBinormalPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glBinormalPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormalPointerEXT__II_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glBinormalPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glBinormalPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormalPointerEXT__II_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2)
+ {
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glBinormalPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glBinormalPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormalPointerEXT__II_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jlongArray arg2)
+ {
+ jlong *ptr2 = NULL;
+
+ if ( disp__glBinormalPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glBinormalPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBinormalPointerEXT__IILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jobject arg2)
+ {
+ void *ptr2 = NULL;
+
+ if ( disp__glBinormalPointerEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (*env)->GetDirectBufferAddress(env, arg2);
+ if (ptr2 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 2 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glBinormalPointerEXT (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid *) ptr2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFinishTextureSUNX ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFinishTextureSUNX (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glFinishTextureSUNX == NULL ) return;
+
+ disp__glFinishTextureSUNX (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGlobalAlphaFactorbSUN ( GLbyte ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGlobalAlphaFactorbSUN (
+ JNIEnv *env, jobject obj,
+ jbyte arg0)
+ {
+
+ if ( disp__glGlobalAlphaFactorbSUN == NULL ) return;
+
+ disp__glGlobalAlphaFactorbSUN (
+ (GLbyte) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGlobalAlphaFactorsSUN ( GLshort ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGlobalAlphaFactorsSUN (
+ JNIEnv *env, jobject obj,
+ jshort arg0)
+ {
+
+ if ( disp__glGlobalAlphaFactorsSUN == NULL ) return;
+
+ disp__glGlobalAlphaFactorsSUN (
+ (GLshort) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGlobalAlphaFactoriSUN ( GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGlobalAlphaFactoriSUN (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glGlobalAlphaFactoriSUN == NULL ) return;
+
+ disp__glGlobalAlphaFactoriSUN (
+ (GLint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGlobalAlphaFactorfSUN ( GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGlobalAlphaFactorfSUN (
+ JNIEnv *env, jobject obj,
+ jfloat arg0)
+ {
+
+ if ( disp__glGlobalAlphaFactorfSUN == NULL ) return;
+
+ disp__glGlobalAlphaFactorfSUN (
+ (GLfloat) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGlobalAlphaFactordSUN ( GLdouble ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGlobalAlphaFactordSUN (
+ JNIEnv *env, jobject obj,
+ jdouble arg0)
+ {
+
+ if ( disp__glGlobalAlphaFactordSUN == NULL ) return;
+
+ disp__glGlobalAlphaFactordSUN (
+ (GLdouble) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGlobalAlphaFactorubSUN ( GLubyte ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGlobalAlphaFactorubSUN (
+ JNIEnv *env, jobject obj,
+ jbyte arg0)
+ {
+
+ if ( disp__glGlobalAlphaFactorubSUN == NULL ) return;
+
+ disp__glGlobalAlphaFactorubSUN (
+ (GLubyte) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGlobalAlphaFactorusSUN ( GLushort ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGlobalAlphaFactorusSUN (
+ JNIEnv *env, jobject obj,
+ jshort arg0)
+ {
+
+ if ( disp__glGlobalAlphaFactorusSUN == NULL ) return;
+
+ disp__glGlobalAlphaFactorusSUN (
+ (GLushort) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGlobalAlphaFactoruiSUN ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGlobalAlphaFactoruiSUN (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glGlobalAlphaFactoruiSUN == NULL ) return;
+
+ disp__glGlobalAlphaFactoruiSUN (
+ (GLuint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuiSUN ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuiSUN (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glReplacementCodeuiSUN == NULL ) return;
+
+ disp__glReplacementCodeuiSUN (
+ (GLuint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeusSUN ( GLushort ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeusSUN (
+ JNIEnv *env, jobject obj,
+ jshort arg0)
+ {
+
+ if ( disp__glReplacementCodeusSUN == NULL ) return;
+
+ disp__glReplacementCodeusSUN (
+ (GLushort) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeubSUN ( GLubyte ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeubSUN (
+ JNIEnv *env, jobject obj,
+ jbyte arg0)
+ {
+
+ if ( disp__glReplacementCodeubSUN == NULL ) return;
+
+ disp__glReplacementCodeubSUN (
+ (GLubyte) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuivSUN ( const GLuint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuivSUN (
+ JNIEnv *env, jobject obj,
+ jintArray arg0)
+ {
+ jint *ptr0 = NULL;
+
+ if ( disp__glReplacementCodeuivSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glReplacementCodeuivSUN (
+ (const GLuint *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeusvSUN ( const GLushort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeusvSUN (
+ JNIEnv *env, jobject obj,
+ jshortArray arg0)
+ {
+ jshort *ptr0 = NULL;
+
+ if ( disp__glReplacementCodeusvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glReplacementCodeusvSUN (
+ (const GLushort *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeubvSUN ( const GLubyte * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeubvSUN (
+ JNIEnv *env, jobject obj,
+ jbyteArray arg0)
+ {
+ jbyte *ptr0 = NULL;
+
+ if ( disp__glReplacementCodeubvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glReplacementCodeubvSUN (
+ (const GLubyte *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodePointerSUN ( GLenum , GLsizei , const GLvoid * * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodePointerSUN__II_3_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbyteArray arg2)
+ {
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glReplacementCodePointerSUN == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glReplacementCodePointerSUN (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodePointerSUN__II_3_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glReplacementCodePointerSUN == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glReplacementCodePointerSUN (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodePointerSUN__II_3_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glReplacementCodePointerSUN == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glReplacementCodePointerSUN (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodePointerSUN__II_3_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glReplacementCodePointerSUN == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glReplacementCodePointerSUN (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodePointerSUN__II_3_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glReplacementCodePointerSUN == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glReplacementCodePointerSUN (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodePointerSUN__II_3_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2)
+ {
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glReplacementCodePointerSUN == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glReplacementCodePointerSUN (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodePointerSUN__II_3_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jlongArray arg2)
+ {
+ jlong *ptr2 = NULL;
+
+ if ( disp__glReplacementCodePointerSUN == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glReplacementCodePointerSUN (
+ (GLenum) arg0,
+ (GLsizei) arg1,
+ (const GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4ubVertex2fSUN ( GLubyte , GLubyte , GLubyte , GLubyte , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4ubVertex2fSUN (
+ JNIEnv *env, jobject obj,
+ jbyte arg0,
+ jbyte arg1,
+ jbyte arg2,
+ jbyte arg3,
+ jfloat arg4,
+ jfloat arg5)
+ {
+
+ if ( disp__glColor4ubVertex2fSUN == NULL ) return;
+
+ disp__glColor4ubVertex2fSUN (
+ (GLubyte) arg0,
+ (GLubyte) arg1,
+ (GLubyte) arg2,
+ (GLubyte) arg3,
+ (GLfloat) arg4,
+ (GLfloat) arg5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4ubVertex2fvSUN ( const GLubyte * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4ubVertex2fvSUN (
+ JNIEnv *env, jobject obj,
+ jbyteArray arg0,
+ jfloatArray arg1)
+ {
+ jbyte *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glColor4ubVertex2fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glColor4ubVertex2fvSUN (
+ (const GLubyte *) ptr0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4ubVertex3fSUN ( GLubyte , GLubyte , GLubyte , GLubyte , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4ubVertex3fSUN (
+ JNIEnv *env, jobject obj,
+ jbyte arg0,
+ jbyte arg1,
+ jbyte arg2,
+ jbyte arg3,
+ jfloat arg4,
+ jfloat arg5,
+ jfloat arg6)
+ {
+
+ if ( disp__glColor4ubVertex3fSUN == NULL ) return;
+
+ disp__glColor4ubVertex3fSUN (
+ (GLubyte) arg0,
+ (GLubyte) arg1,
+ (GLubyte) arg2,
+ (GLubyte) arg3,
+ (GLfloat) arg4,
+ (GLfloat) arg5,
+ (GLfloat) arg6
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4ubVertex3fvSUN ( const GLubyte * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4ubVertex3fvSUN (
+ JNIEnv *env, jobject obj,
+ jbyteArray arg0,
+ jfloatArray arg1)
+ {
+ jbyte *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glColor4ubVertex3fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glColor4ubVertex3fvSUN (
+ (const GLubyte *) ptr0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3fVertex3fSUN ( GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3fVertex3fSUN (
+ JNIEnv *env, jobject obj,
+ jfloat arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4,
+ jfloat arg5)
+ {
+
+ if ( disp__glColor3fVertex3fSUN == NULL ) return;
+
+ disp__glColor3fVertex3fSUN (
+ (GLfloat) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4,
+ (GLfloat) arg5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor3fVertex3fvSUN ( const GLfloat * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor3fVertex3fvSUN (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glColor3fVertex3fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glColor3fVertex3fvSUN (
+ (const GLfloat *) ptr0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormal3fVertex3fSUN ( GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormal3fVertex3fSUN (
+ JNIEnv *env, jobject obj,
+ jfloat arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4,
+ jfloat arg5)
+ {
+
+ if ( disp__glNormal3fVertex3fSUN == NULL ) return;
+
+ disp__glNormal3fVertex3fSUN (
+ (GLfloat) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4,
+ (GLfloat) arg5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormal3fVertex3fvSUN ( const GLfloat * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormal3fVertex3fvSUN (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glNormal3fVertex3fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glNormal3fVertex3fvSUN (
+ (const GLfloat *) ptr0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4fNormal3fVertex3fSUN ( GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4fNormal3fVertex3fSUN (
+ JNIEnv *env, jobject obj,
+ jfloat arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4,
+ jfloat arg5,
+ jfloat arg6,
+ jfloat arg7,
+ jfloat arg8,
+ jfloat arg9)
+ {
+
+ if ( disp__glColor4fNormal3fVertex3fSUN == NULL ) return;
+
+ disp__glColor4fNormal3fVertex3fSUN (
+ (GLfloat) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4,
+ (GLfloat) arg5,
+ (GLfloat) arg6,
+ (GLfloat) arg7,
+ (GLfloat) arg8,
+ (GLfloat) arg9
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColor4fNormal3fVertex3fvSUN ( const GLfloat * , const GLfloat * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColor4fNormal3fVertex3fvSUN (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0,
+ jfloatArray arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glColor4fNormal3fVertex3fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glColor4fNormal3fVertex3fvSUN (
+ (const GLfloat *) ptr0,
+ (const GLfloat *) ptr1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2fVertex3fSUN ( GLfloat , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2fVertex3fSUN (
+ JNIEnv *env, jobject obj,
+ jfloat arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4)
+ {
+
+ if ( disp__glTexCoord2fVertex3fSUN == NULL ) return;
+
+ disp__glTexCoord2fVertex3fSUN (
+ (GLfloat) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2fVertex3fvSUN ( const GLfloat * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2fVertex3fvSUN (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glTexCoord2fVertex3fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glTexCoord2fVertex3fvSUN (
+ (const GLfloat *) ptr0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord4fVertex4fSUN ( GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord4fVertex4fSUN (
+ JNIEnv *env, jobject obj,
+ jfloat arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4,
+ jfloat arg5,
+ jfloat arg6,
+ jfloat arg7)
+ {
+
+ if ( disp__glTexCoord4fVertex4fSUN == NULL ) return;
+
+ disp__glTexCoord4fVertex4fSUN (
+ (GLfloat) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4,
+ (GLfloat) arg5,
+ (GLfloat) arg6,
+ (GLfloat) arg7
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord4fVertex4fvSUN ( const GLfloat * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord4fVertex4fvSUN (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glTexCoord4fVertex4fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glTexCoord4fVertex4fvSUN (
+ (const GLfloat *) ptr0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2fColor4ubVertex3fSUN ( GLfloat , GLfloat , GLubyte , GLubyte , GLubyte , GLubyte , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2fColor4ubVertex3fSUN (
+ JNIEnv *env, jobject obj,
+ jfloat arg0,
+ jfloat arg1,
+ jbyte arg2,
+ jbyte arg3,
+ jbyte arg4,
+ jbyte arg5,
+ jfloat arg6,
+ jfloat arg7,
+ jfloat arg8)
+ {
+
+ if ( disp__glTexCoord2fColor4ubVertex3fSUN == NULL ) return;
+
+ disp__glTexCoord2fColor4ubVertex3fSUN (
+ (GLfloat) arg0,
+ (GLfloat) arg1,
+ (GLubyte) arg2,
+ (GLubyte) arg3,
+ (GLubyte) arg4,
+ (GLubyte) arg5,
+ (GLfloat) arg6,
+ (GLfloat) arg7,
+ (GLfloat) arg8
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2fColor4ubVertex3fvSUN ( const GLfloat * , const GLubyte * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2fColor4ubVertex3fvSUN (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0,
+ jbyteArray arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr0 = NULL;
+ jbyte *ptr1 = NULL;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glTexCoord2fColor4ubVertex3fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glTexCoord2fColor4ubVertex3fvSUN (
+ (const GLfloat *) ptr0,
+ (const GLubyte *) ptr1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2fColor3fVertex3fSUN ( GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2fColor3fVertex3fSUN (
+ JNIEnv *env, jobject obj,
+ jfloat arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4,
+ jfloat arg5,
+ jfloat arg6,
+ jfloat arg7)
+ {
+
+ if ( disp__glTexCoord2fColor3fVertex3fSUN == NULL ) return;
+
+ disp__glTexCoord2fColor3fVertex3fSUN (
+ (GLfloat) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4,
+ (GLfloat) arg5,
+ (GLfloat) arg6,
+ (GLfloat) arg7
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2fColor3fVertex3fvSUN ( const GLfloat * , const GLfloat * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2fColor3fVertex3fvSUN (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0,
+ jfloatArray arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glTexCoord2fColor3fVertex3fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glTexCoord2fColor3fVertex3fvSUN (
+ (const GLfloat *) ptr0,
+ (const GLfloat *) ptr1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2fNormal3fVertex3fSUN ( GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2fNormal3fVertex3fSUN (
+ JNIEnv *env, jobject obj,
+ jfloat arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4,
+ jfloat arg5,
+ jfloat arg6,
+ jfloat arg7)
+ {
+
+ if ( disp__glTexCoord2fNormal3fVertex3fSUN == NULL ) return;
+
+ disp__glTexCoord2fNormal3fVertex3fSUN (
+ (GLfloat) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4,
+ (GLfloat) arg5,
+ (GLfloat) arg6,
+ (GLfloat) arg7
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2fNormal3fVertex3fvSUN ( const GLfloat * , const GLfloat * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2fNormal3fVertex3fvSUN (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0,
+ jfloatArray arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glTexCoord2fNormal3fVertex3fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glTexCoord2fNormal3fVertex3fvSUN (
+ (const GLfloat *) ptr0,
+ (const GLfloat *) ptr1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2fColor4fNormal3fVertex3fSUN ( GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2fColor4fNormal3fVertex3fSUN (
+ JNIEnv *env, jobject obj,
+ jfloat arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4,
+ jfloat arg5,
+ jfloat arg6,
+ jfloat arg7,
+ jfloat arg8,
+ jfloat arg9,
+ jfloat arg10,
+ jfloat arg11)
+ {
+
+ if ( disp__glTexCoord2fColor4fNormal3fVertex3fSUN == NULL ) return;
+
+ disp__glTexCoord2fColor4fNormal3fVertex3fSUN (
+ (GLfloat) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4,
+ (GLfloat) arg5,
+ (GLfloat) arg6,
+ (GLfloat) arg7,
+ (GLfloat) arg8,
+ (GLfloat) arg9,
+ (GLfloat) arg10,
+ (GLfloat) arg11
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord2fColor4fNormal3fVertex3fvSUN ( const GLfloat * , const GLfloat * , const GLfloat * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord2fColor4fNormal3fVertex3fvSUN (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0,
+ jfloatArray arg1,
+ jfloatArray arg2,
+ jfloatArray arg3)
+ {
+ jfloat *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+ jfloat *ptr2 = NULL;
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glTexCoord2fColor4fNormal3fVertex3fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glTexCoord2fColor4fNormal3fVertex3fvSUN (
+ (const GLfloat *) ptr0,
+ (const GLfloat *) ptr1,
+ (const GLfloat *) ptr2,
+ (const GLfloat *) ptr3
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord4fColor4fNormal3fVertex4fSUN ( GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord4fColor4fNormal3fVertex4fSUN (
+ JNIEnv *env, jobject obj,
+ jfloat arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4,
+ jfloat arg5,
+ jfloat arg6,
+ jfloat arg7,
+ jfloat arg8,
+ jfloat arg9,
+ jfloat arg10,
+ jfloat arg11,
+ jfloat arg12,
+ jfloat arg13,
+ jfloat arg14)
+ {
+
+ if ( disp__glTexCoord4fColor4fNormal3fVertex4fSUN == NULL ) return;
+
+ disp__glTexCoord4fColor4fNormal3fVertex4fSUN (
+ (GLfloat) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4,
+ (GLfloat) arg5,
+ (GLfloat) arg6,
+ (GLfloat) arg7,
+ (GLfloat) arg8,
+ (GLfloat) arg9,
+ (GLfloat) arg10,
+ (GLfloat) arg11,
+ (GLfloat) arg12,
+ (GLfloat) arg13,
+ (GLfloat) arg14
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoord4fColor4fNormal3fVertex4fvSUN ( const GLfloat * , const GLfloat * , const GLfloat * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoord4fColor4fNormal3fVertex4fvSUN (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0,
+ jfloatArray arg1,
+ jfloatArray arg2,
+ jfloatArray arg3)
+ {
+ jfloat *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+ jfloat *ptr2 = NULL;
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glTexCoord4fColor4fNormal3fVertex4fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glTexCoord4fColor4fNormal3fVertex4fvSUN (
+ (const GLfloat *) ptr0,
+ (const GLfloat *) ptr1,
+ (const GLfloat *) ptr2,
+ (const GLfloat *) ptr3
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuiVertex3fSUN ( GLenum , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuiVertex3fSUN (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3)
+ {
+
+ if ( disp__glReplacementCodeuiVertex3fSUN == NULL ) return;
+
+ disp__glReplacementCodeuiVertex3fSUN (
+ (GLenum) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuiVertex3fvSUN ( const GLenum * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuiVertex3fvSUN (
+ JNIEnv *env, jobject obj,
+ jintArray arg0,
+ jfloatArray arg1)
+ {
+ jint *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glReplacementCodeuiVertex3fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glReplacementCodeuiVertex3fvSUN (
+ (const GLenum *) ptr0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuiColor4ubVertex3fSUN ( GLenum , GLubyte , GLubyte , GLubyte , GLubyte , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuiColor4ubVertex3fSUN (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbyte arg1,
+ jbyte arg2,
+ jbyte arg3,
+ jbyte arg4,
+ jfloat arg5,
+ jfloat arg6,
+ jfloat arg7)
+ {
+
+ if ( disp__glReplacementCodeuiColor4ubVertex3fSUN == NULL ) return;
+
+ disp__glReplacementCodeuiColor4ubVertex3fSUN (
+ (GLenum) arg0,
+ (GLubyte) arg1,
+ (GLubyte) arg2,
+ (GLubyte) arg3,
+ (GLubyte) arg4,
+ (GLfloat) arg5,
+ (GLfloat) arg6,
+ (GLfloat) arg7
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuiColor4ubVertex3fvSUN ( const GLenum * , const GLubyte * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuiColor4ubVertex3fvSUN (
+ JNIEnv *env, jobject obj,
+ jintArray arg0,
+ jbyteArray arg1,
+ jfloatArray arg2)
+ {
+ jint *ptr0 = NULL;
+ jbyte *ptr1 = NULL;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glReplacementCodeuiColor4ubVertex3fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glReplacementCodeuiColor4ubVertex3fvSUN (
+ (const GLenum *) ptr0,
+ (const GLubyte *) ptr1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuiColor3fVertex3fSUN ( GLenum , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuiColor3fVertex3fSUN (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4,
+ jfloat arg5,
+ jfloat arg6)
+ {
+
+ if ( disp__glReplacementCodeuiColor3fVertex3fSUN == NULL ) return;
+
+ disp__glReplacementCodeuiColor3fVertex3fSUN (
+ (GLenum) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4,
+ (GLfloat) arg5,
+ (GLfloat) arg6
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuiColor3fVertex3fvSUN ( const GLenum * , const GLfloat * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuiColor3fVertex3fvSUN (
+ JNIEnv *env, jobject obj,
+ jintArray arg0,
+ jfloatArray arg1,
+ jfloatArray arg2)
+ {
+ jint *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glReplacementCodeuiColor3fVertex3fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glReplacementCodeuiColor3fVertex3fvSUN (
+ (const GLenum *) ptr0,
+ (const GLfloat *) ptr1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuiNormal3fVertex3fSUN ( GLenum , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuiNormal3fVertex3fSUN (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4,
+ jfloat arg5,
+ jfloat arg6)
+ {
+
+ if ( disp__glReplacementCodeuiNormal3fVertex3fSUN == NULL ) return;
+
+ disp__glReplacementCodeuiNormal3fVertex3fSUN (
+ (GLenum) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4,
+ (GLfloat) arg5,
+ (GLfloat) arg6
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuiNormal3fVertex3fvSUN ( const GLenum * , const GLfloat * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuiNormal3fVertex3fvSUN (
+ JNIEnv *env, jobject obj,
+ jintArray arg0,
+ jfloatArray arg1,
+ jfloatArray arg2)
+ {
+ jint *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glReplacementCodeuiNormal3fVertex3fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glReplacementCodeuiNormal3fVertex3fvSUN (
+ (const GLenum *) ptr0,
+ (const GLfloat *) ptr1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuiColor4fNormal3fVertex3fSUN ( GLenum , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuiColor4fNormal3fVertex3fSUN (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4,
+ jfloat arg5,
+ jfloat arg6,
+ jfloat arg7,
+ jfloat arg8,
+ jfloat arg9,
+ jfloat arg10)
+ {
+
+ if ( disp__glReplacementCodeuiColor4fNormal3fVertex3fSUN == NULL ) return;
+
+ disp__glReplacementCodeuiColor4fNormal3fVertex3fSUN (
+ (GLenum) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4,
+ (GLfloat) arg5,
+ (GLfloat) arg6,
+ (GLfloat) arg7,
+ (GLfloat) arg8,
+ (GLfloat) arg9,
+ (GLfloat) arg10
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuiColor4fNormal3fVertex3fvSUN ( const GLenum * , const GLfloat * , const GLfloat * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuiColor4fNormal3fVertex3fvSUN (
+ JNIEnv *env, jobject obj,
+ jintArray arg0,
+ jfloatArray arg1,
+ jfloatArray arg2,
+ jfloatArray arg3)
+ {
+ jint *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+ jfloat *ptr2 = NULL;
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glReplacementCodeuiColor4fNormal3fVertex3fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glReplacementCodeuiColor4fNormal3fVertex3fvSUN (
+ (const GLenum *) ptr0,
+ (const GLfloat *) ptr1,
+ (const GLfloat *) ptr2,
+ (const GLfloat *) ptr3
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuiTexCoord2fVertex3fSUN ( GLenum , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuiTexCoord2fVertex3fSUN (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4,
+ jfloat arg5)
+ {
+
+ if ( disp__glReplacementCodeuiTexCoord2fVertex3fSUN == NULL ) return;
+
+ disp__glReplacementCodeuiTexCoord2fVertex3fSUN (
+ (GLenum) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4,
+ (GLfloat) arg5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuiTexCoord2fVertex3fvSUN ( const GLenum * , const GLfloat * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuiTexCoord2fVertex3fvSUN (
+ JNIEnv *env, jobject obj,
+ jintArray arg0,
+ jfloatArray arg1,
+ jfloatArray arg2)
+ {
+ jint *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glReplacementCodeuiTexCoord2fVertex3fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glReplacementCodeuiTexCoord2fVertex3fvSUN (
+ (const GLenum *) ptr0,
+ (const GLfloat *) ptr1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN ( GLenum , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4,
+ jfloat arg5,
+ jfloat arg6,
+ jfloat arg7,
+ jfloat arg8)
+ {
+
+ if ( disp__glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN == NULL ) return;
+
+ disp__glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (
+ (GLenum) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4,
+ (GLfloat) arg5,
+ (GLfloat) arg6,
+ (GLfloat) arg7,
+ (GLfloat) arg8
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN ( const GLenum * , const GLfloat * , const GLfloat * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (
+ JNIEnv *env, jobject obj,
+ jintArray arg0,
+ jfloatArray arg1,
+ jfloatArray arg2,
+ jfloatArray arg3)
+ {
+ jint *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+ jfloat *ptr2 = NULL;
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (
+ (const GLenum *) ptr0,
+ (const GLfloat *) ptr1,
+ (const GLfloat *) ptr2,
+ (const GLfloat *) ptr3
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN ( GLenum , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4,
+ jfloat arg5,
+ jfloat arg6,
+ jfloat arg7,
+ jfloat arg8,
+ jfloat arg9,
+ jfloat arg10,
+ jfloat arg11,
+ jfloat arg12)
+ {
+
+ if ( disp__glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN == NULL ) return;
+
+ disp__glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (
+ (GLenum) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4,
+ (GLfloat) arg5,
+ (GLfloat) arg6,
+ (GLfloat) arg7,
+ (GLfloat) arg8,
+ (GLfloat) arg9,
+ (GLfloat) arg10,
+ (GLfloat) arg11,
+ (GLfloat) arg12
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN ( const GLenum * , const GLfloat * , const GLfloat * , const GLfloat * , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (
+ JNIEnv *env, jobject obj,
+ jintArray arg0,
+ jfloatArray arg1,
+ jfloatArray arg2,
+ jfloatArray arg3,
+ jfloatArray arg4)
+ {
+ jint *ptr0 = NULL;
+ jfloat *ptr1 = NULL;
+ jfloat *ptr2 = NULL;
+ jfloat *ptr3 = NULL;
+ jfloat *ptr4 = NULL;
+
+ if ( disp__glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ if(arg4!=NULL)
+ {
+ ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg4, 0);
+ }
+ disp__glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (
+ (const GLenum *) ptr0,
+ (const GLfloat *) ptr1,
+ (const GLfloat *) ptr2,
+ (const GLfloat *) ptr3,
+ (const GLfloat *) ptr4
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBlendFuncSeparateEXT ( GLenum , GLenum , GLenum , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBlendFuncSeparateEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3)
+ {
+
+ if ( disp__glBlendFuncSeparateEXT == NULL ) return;
+
+ disp__glBlendFuncSeparateEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBlendFuncSeparateINGR ( GLenum , GLenum , GLenum , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBlendFuncSeparateINGR (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3)
+ {
+
+ if ( disp__glBlendFuncSeparateINGR == NULL ) return;
+
+ disp__glBlendFuncSeparateINGR (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexWeightfEXT ( GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexWeightfEXT (
+ JNIEnv *env, jobject obj,
+ jfloat arg0)
+ {
+
+ if ( disp__glVertexWeightfEXT == NULL ) return;
+
+ disp__glVertexWeightfEXT (
+ (GLfloat) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexWeightfvEXT ( const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexWeightfvEXT (
+ JNIEnv *env, jobject obj,
+ jfloatArray arg0)
+ {
+ jfloat *ptr0 = NULL;
+
+ if ( disp__glVertexWeightfvEXT == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ disp__glVertexWeightfvEXT (
+ (const GLfloat *) ptr0
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexWeightPointerEXT ( GLsizei , GLenum , GLsizei , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexWeightPointerEXT__III_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbyteArray arg3)
+ {
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glVertexWeightPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVertexWeightPointerEXT (
+ (GLsizei) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexWeightPointerEXT__III_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jshortArray arg3)
+ {
+ jshort *ptr3 = NULL;
+
+ if ( disp__glVertexWeightPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVertexWeightPointerEXT (
+ (GLsizei) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexWeightPointerEXT__III_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jintArray arg3)
+ {
+ jint *ptr3 = NULL;
+
+ if ( disp__glVertexWeightPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVertexWeightPointerEXT (
+ (GLsizei) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexWeightPointerEXT__III_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glVertexWeightPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVertexWeightPointerEXT (
+ (GLsizei) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexWeightPointerEXT__III_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jdoubleArray arg3)
+ {
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glVertexWeightPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVertexWeightPointerEXT (
+ (GLsizei) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexWeightPointerEXT__III_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbooleanArray arg3)
+ {
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glVertexWeightPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVertexWeightPointerEXT (
+ (GLsizei) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexWeightPointerEXT__III_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jlongArray arg3)
+ {
+ jlong *ptr3 = NULL;
+
+ if ( disp__glVertexWeightPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVertexWeightPointerEXT (
+ (GLsizei) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexWeightPointerEXT__IIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jobject arg3)
+ {
+ void *ptr3 = NULL;
+
+ if ( disp__glVertexWeightPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, arg3);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glVertexWeightPointerEXT (
+ (GLsizei) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFlushVertexArrayRangeNV ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFlushVertexArrayRangeNV (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glFlushVertexArrayRangeNV == NULL ) return;
+
+ disp__glFlushVertexArrayRangeNV (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexArrayRangeNV ( GLsizei , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexArrayRangeNV__I_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbyteArray arg1)
+ {
+ jbyte *ptr1 = NULL;
+
+ if ( disp__glVertexArrayRangeNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexArrayRangeNV (
+ (GLsizei) arg0,
+ (const GLvoid *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexArrayRangeNV__I_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glVertexArrayRangeNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexArrayRangeNV (
+ (GLsizei) arg0,
+ (const GLvoid *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexArrayRangeNV__I_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glVertexArrayRangeNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexArrayRangeNV (
+ (GLsizei) arg0,
+ (const GLvoid *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexArrayRangeNV__I_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glVertexArrayRangeNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexArrayRangeNV (
+ (GLsizei) arg0,
+ (const GLvoid *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexArrayRangeNV__I_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdoubleArray arg1)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glVertexArrayRangeNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexArrayRangeNV (
+ (GLsizei) arg0,
+ (const GLvoid *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexArrayRangeNV__I_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbooleanArray arg1)
+ {
+ jboolean *ptr1 = NULL;
+
+ if ( disp__glVertexArrayRangeNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexArrayRangeNV (
+ (GLsizei) arg0,
+ (const GLvoid *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexArrayRangeNV__I_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jlongArray arg1)
+ {
+ jlong *ptr1 = NULL;
+
+ if ( disp__glVertexArrayRangeNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexArrayRangeNV (
+ (GLsizei) arg0,
+ (const GLvoid *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexArrayRangeNV__ILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jobject arg1)
+ {
+ void *ptr1 = NULL;
+
+ if ( disp__glVertexArrayRangeNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (*env)->GetDirectBufferAddress(env, arg1);
+ if (ptr1 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 1 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glVertexArrayRangeNV (
+ (GLsizei) arg0,
+ (const GLvoid *) ptr1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCombinerParameterfvNV ( GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCombinerParameterfvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glCombinerParameterfvNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glCombinerParameterfvNV (
+ (GLenum) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCombinerParameterfNV ( GLenum , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCombinerParameterfNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1)
+ {
+
+ if ( disp__glCombinerParameterfNV == NULL ) return;
+
+ disp__glCombinerParameterfNV (
+ (GLenum) arg0,
+ (GLfloat) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCombinerParameterivNV ( GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCombinerParameterivNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glCombinerParameterivNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glCombinerParameterivNV (
+ (GLenum) arg0,
+ (const GLint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCombinerParameteriNV ( GLenum , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCombinerParameteriNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+
+ if ( disp__glCombinerParameteriNV == NULL ) return;
+
+ disp__glCombinerParameteriNV (
+ (GLenum) arg0,
+ (GLint) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCombinerInputNV ( GLenum , GLenum , GLenum , GLenum , GLenum , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCombinerInputNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5)
+ {
+
+ if ( disp__glCombinerInputNV == NULL ) return;
+
+ disp__glCombinerInputNV (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCombinerOutputNV ( GLenum , GLenum , GLenum , GLenum , GLenum , GLenum , GLenum , GLboolean , GLboolean , GLboolean ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCombinerOutputNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jboolean arg7,
+ jboolean arg8,
+ jboolean arg9)
+ {
+
+ if ( disp__glCombinerOutputNV == NULL ) return;
+
+ disp__glCombinerOutputNV (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5,
+ (GLenum) arg6,
+ (GLboolean) arg7,
+ (GLboolean) arg8,
+ (GLboolean) arg9
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFinalCombinerInputNV ( GLenum , GLenum , GLenum , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFinalCombinerInputNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3)
+ {
+
+ if ( disp__glFinalCombinerInputNV == NULL ) return;
+
+ disp__glFinalCombinerInputNV (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetCombinerInputParameterfvNV ( GLenum , GLenum , GLenum , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCombinerInputParameterfvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jfloatArray arg4)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jfloat *ptr4 = NULL;
+
+ if ( disp__glGetCombinerInputParameterfvNV == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ disp__glGetCombinerInputParameterfvNV (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLfloat *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetCombinerInputParameterivNV ( GLenum , GLenum , GLenum , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCombinerInputParameterivNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jintArray arg4)
+ {
+ jboolean isCopiedArray4 = JNI_FALSE;
+ jint *ptr4 = NULL;
+
+ if ( disp__glGetCombinerInputParameterivNV == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg4, &isCopiedArray4);
+ }
+ disp__glGetCombinerInputParameterivNV (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLint *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetCombinerOutputParameterfvNV ( GLenum , GLenum , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCombinerOutputParameterfvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glGetCombinerOutputParameterfvNV == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetCombinerOutputParameterfvNV (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLfloat *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetCombinerOutputParameterivNV ( GLenum , GLenum , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCombinerOutputParameterivNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jintArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jint *ptr3 = NULL;
+
+ if ( disp__glGetCombinerOutputParameterivNV == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetCombinerOutputParameterivNV (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLint *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetFinalCombinerInputParameterfvNV ( GLenum , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetFinalCombinerInputParameterfvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetFinalCombinerInputParameterfvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetFinalCombinerInputParameterfvNV (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetFinalCombinerInputParameterivNV ( GLenum , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetFinalCombinerInputParameterivNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetFinalCombinerInputParameterivNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetFinalCombinerInputParameterivNV (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiModeDrawArraysIBM ( GLenum , const GLint * , const GLsizei * , GLsizei , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiModeDrawArraysIBM (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1,
+ jintArray arg2,
+ jint arg3,
+ jint arg4)
+ {
+ jint *ptr1 = NULL;
+ jint *ptr2 = NULL;
+
+ if ( disp__glMultiModeDrawArraysIBM == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glMultiModeDrawArraysIBM (
+ (GLenum) arg0,
+ (const GLint *) ptr1,
+ (const GLsizei *) ptr2,
+ (GLsizei) arg3,
+ (GLint) arg4
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMultiModeDrawElementsIBM ( const GLenum * , const GLsizei * , GLenum , const GLvoid * * , GLsizei , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiModeDrawElementsIBM___3I_3II_3_3BII (
+ JNIEnv *env, jobject obj,
+ jintArray arg0,
+ jintArray arg1,
+ jint arg2,
+ jbyteArray arg3,
+ jint arg4,
+ jint arg5)
+ {
+ jint *ptr0 = NULL;
+ jint *ptr1 = NULL;
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glMultiModeDrawElementsIBM == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMultiModeDrawElementsIBM (
+ (const GLenum *) ptr0,
+ (const GLsizei *) ptr1,
+ (GLenum) arg2,
+ (const GLvoid **) ptr3,
+ (GLsizei) arg4,
+ (GLint) arg5
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiModeDrawElementsIBM___3I_3II_3_3SII (
+ JNIEnv *env, jobject obj,
+ jintArray arg0,
+ jintArray arg1,
+ jint arg2,
+ jshortArray arg3,
+ jint arg4,
+ jint arg5)
+ {
+ jint *ptr0 = NULL;
+ jint *ptr1 = NULL;
+ jshort *ptr3 = NULL;
+
+ if ( disp__glMultiModeDrawElementsIBM == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMultiModeDrawElementsIBM (
+ (const GLenum *) ptr0,
+ (const GLsizei *) ptr1,
+ (GLenum) arg2,
+ (const GLvoid **) ptr3,
+ (GLsizei) arg4,
+ (GLint) arg5
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiModeDrawElementsIBM___3I_3II_3_3III (
+ JNIEnv *env, jobject obj,
+ jintArray arg0,
+ jintArray arg1,
+ jint arg2,
+ jintArray arg3,
+ jint arg4,
+ jint arg5)
+ {
+ jint *ptr0 = NULL;
+ jint *ptr1 = NULL;
+ jint *ptr3 = NULL;
+
+ if ( disp__glMultiModeDrawElementsIBM == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMultiModeDrawElementsIBM (
+ (const GLenum *) ptr0,
+ (const GLsizei *) ptr1,
+ (GLenum) arg2,
+ (const GLvoid **) ptr3,
+ (GLsizei) arg4,
+ (GLint) arg5
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiModeDrawElementsIBM___3I_3II_3_3FII (
+ JNIEnv *env, jobject obj,
+ jintArray arg0,
+ jintArray arg1,
+ jint arg2,
+ jfloatArray arg3,
+ jint arg4,
+ jint arg5)
+ {
+ jint *ptr0 = NULL;
+ jint *ptr1 = NULL;
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glMultiModeDrawElementsIBM == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMultiModeDrawElementsIBM (
+ (const GLenum *) ptr0,
+ (const GLsizei *) ptr1,
+ (GLenum) arg2,
+ (const GLvoid **) ptr3,
+ (GLsizei) arg4,
+ (GLint) arg5
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiModeDrawElementsIBM___3I_3II_3_3DII (
+ JNIEnv *env, jobject obj,
+ jintArray arg0,
+ jintArray arg1,
+ jint arg2,
+ jdoubleArray arg3,
+ jint arg4,
+ jint arg5)
+ {
+ jint *ptr0 = NULL;
+ jint *ptr1 = NULL;
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glMultiModeDrawElementsIBM == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMultiModeDrawElementsIBM (
+ (const GLenum *) ptr0,
+ (const GLsizei *) ptr1,
+ (GLenum) arg2,
+ (const GLvoid **) ptr3,
+ (GLsizei) arg4,
+ (GLint) arg5
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiModeDrawElementsIBM___3I_3II_3_3ZII (
+ JNIEnv *env, jobject obj,
+ jintArray arg0,
+ jintArray arg1,
+ jint arg2,
+ jbooleanArray arg3,
+ jint arg4,
+ jint arg5)
+ {
+ jint *ptr0 = NULL;
+ jint *ptr1 = NULL;
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glMultiModeDrawElementsIBM == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMultiModeDrawElementsIBM (
+ (const GLenum *) ptr0,
+ (const GLsizei *) ptr1,
+ (GLenum) arg2,
+ (const GLvoid **) ptr3,
+ (GLsizei) arg4,
+ (GLint) arg5
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMultiModeDrawElementsIBM___3I_3II_3_3JII (
+ JNIEnv *env, jobject obj,
+ jintArray arg0,
+ jintArray arg1,
+ jint arg2,
+ jlongArray arg3,
+ jint arg4,
+ jint arg5)
+ {
+ jint *ptr0 = NULL;
+ jint *ptr1 = NULL;
+ jlong *ptr3 = NULL;
+
+ if ( disp__glMultiModeDrawElementsIBM == NULL ) return;
+
+ if(arg0!=NULL)
+ {
+ ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg0, 0);
+ }
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg3!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glMultiModeDrawElementsIBM (
+ (const GLenum *) ptr0,
+ (const GLsizei *) ptr1,
+ (GLenum) arg2,
+ (const GLvoid **) ptr3,
+ (GLsizei) arg4,
+ (GLint) arg5
+ );
+
+ if(arg0!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg0, ptr0, JNI_ABORT);
+ }
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorPointerListIBM ( GLint , GLenum , GLint , const GLvoid * * , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointerListIBM__III_3_3BI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbyteArray arg3,
+ jint arg4)
+ {
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glColorPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glColorPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointerListIBM__III_3_3SI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jshortArray arg3,
+ jint arg4)
+ {
+ jshort *ptr3 = NULL;
+
+ if ( disp__glColorPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glColorPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointerListIBM__III_3_3II (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jintArray arg3,
+ jint arg4)
+ {
+ jint *ptr3 = NULL;
+
+ if ( disp__glColorPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glColorPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointerListIBM__III_3_3FI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3,
+ jint arg4)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glColorPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glColorPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointerListIBM__III_3_3DI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jdoubleArray arg3,
+ jint arg4)
+ {
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glColorPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glColorPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointerListIBM__III_3_3ZI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbooleanArray arg3,
+ jint arg4)
+ {
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glColorPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glColorPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorPointerListIBM__III_3_3JI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jlongArray arg3,
+ jint arg4)
+ {
+ jlong *ptr3 = NULL;
+
+ if ( disp__glColorPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glColorPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSecondaryColorPointerListIBM ( GLint , GLenum , GLint , const GLvoid * * , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColorPointerListIBM__III_3_3BI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbyteArray arg3,
+ jint arg4)
+ {
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glSecondaryColorPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glSecondaryColorPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColorPointerListIBM__III_3_3SI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jshortArray arg3,
+ jint arg4)
+ {
+ jshort *ptr3 = NULL;
+
+ if ( disp__glSecondaryColorPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glSecondaryColorPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColorPointerListIBM__III_3_3II (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jintArray arg3,
+ jint arg4)
+ {
+ jint *ptr3 = NULL;
+
+ if ( disp__glSecondaryColorPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glSecondaryColorPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColorPointerListIBM__III_3_3FI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3,
+ jint arg4)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glSecondaryColorPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glSecondaryColorPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColorPointerListIBM__III_3_3DI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jdoubleArray arg3,
+ jint arg4)
+ {
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glSecondaryColorPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glSecondaryColorPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColorPointerListIBM__III_3_3ZI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbooleanArray arg3,
+ jint arg4)
+ {
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glSecondaryColorPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glSecondaryColorPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSecondaryColorPointerListIBM__III_3_3JI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jlongArray arg3,
+ jint arg4)
+ {
+ jlong *ptr3 = NULL;
+
+ if ( disp__glSecondaryColorPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glSecondaryColorPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEdgeFlagPointerListIBM ( GLint , const GLboolean * * , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEdgeFlagPointerListIBM (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbooleanArray arg1,
+ jint arg2)
+ {
+ jboolean *ptr1 = NULL;
+
+ if ( disp__glEdgeFlagPointerListIBM == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glEdgeFlagPointerListIBM (
+ (GLint) arg0,
+ (const GLboolean **) ptr1,
+ (GLint) arg2
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFogCoordPointerListIBM ( GLenum , GLint , const GLvoid * * , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoordPointerListIBM__II_3_3BI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbyteArray arg2,
+ jint arg3)
+ {
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glFogCoordPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFogCoordPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoordPointerListIBM__II_3_3SI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2,
+ jint arg3)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glFogCoordPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFogCoordPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoordPointerListIBM__II_3_3II (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2,
+ jint arg3)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glFogCoordPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFogCoordPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoordPointerListIBM__II_3_3FI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2,
+ jint arg3)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glFogCoordPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFogCoordPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoordPointerListIBM__II_3_3DI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2,
+ jint arg3)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glFogCoordPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFogCoordPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoordPointerListIBM__II_3_3ZI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2,
+ jint arg3)
+ {
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glFogCoordPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFogCoordPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFogCoordPointerListIBM__II_3_3JI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jlongArray arg2,
+ jint arg3)
+ {
+ jlong *ptr2 = NULL;
+
+ if ( disp__glFogCoordPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glFogCoordPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glIndexPointerListIBM ( GLenum , GLint , const GLvoid * * , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointerListIBM__II_3_3BI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbyteArray arg2,
+ jint arg3)
+ {
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glIndexPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glIndexPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointerListIBM__II_3_3SI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2,
+ jint arg3)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glIndexPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glIndexPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointerListIBM__II_3_3II (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2,
+ jint arg3)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glIndexPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glIndexPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointerListIBM__II_3_3FI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2,
+ jint arg3)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glIndexPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glIndexPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointerListIBM__II_3_3DI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2,
+ jint arg3)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glIndexPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glIndexPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointerListIBM__II_3_3ZI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2,
+ jint arg3)
+ {
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glIndexPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glIndexPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIndexPointerListIBM__II_3_3JI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jlongArray arg2,
+ jint arg3)
+ {
+ jlong *ptr2 = NULL;
+
+ if ( disp__glIndexPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glIndexPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormalPointerListIBM ( GLenum , GLint , const GLvoid * * , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointerListIBM__II_3_3BI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbyteArray arg2,
+ jint arg3)
+ {
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glNormalPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glNormalPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointerListIBM__II_3_3SI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2,
+ jint arg3)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glNormalPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glNormalPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointerListIBM__II_3_3II (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2,
+ jint arg3)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glNormalPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glNormalPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointerListIBM__II_3_3FI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2,
+ jint arg3)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glNormalPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glNormalPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointerListIBM__II_3_3DI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2,
+ jint arg3)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glNormalPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glNormalPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointerListIBM__II_3_3ZI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2,
+ jint arg3)
+ {
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glNormalPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glNormalPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalPointerListIBM__II_3_3JI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jlongArray arg2,
+ jint arg3)
+ {
+ jlong *ptr2 = NULL;
+
+ if ( disp__glNormalPointerListIBM == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glNormalPointerListIBM (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (const GLvoid **) ptr2,
+ (GLint) arg3
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexCoordPointerListIBM ( GLint , GLenum , GLint , const GLvoid * * , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointerListIBM__III_3_3BI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbyteArray arg3,
+ jint arg4)
+ {
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glTexCoordPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glTexCoordPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointerListIBM__III_3_3SI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jshortArray arg3,
+ jint arg4)
+ {
+ jshort *ptr3 = NULL;
+
+ if ( disp__glTexCoordPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glTexCoordPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointerListIBM__III_3_3II (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jintArray arg3,
+ jint arg4)
+ {
+ jint *ptr3 = NULL;
+
+ if ( disp__glTexCoordPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glTexCoordPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointerListIBM__III_3_3FI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3,
+ jint arg4)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glTexCoordPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glTexCoordPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointerListIBM__III_3_3DI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jdoubleArray arg3,
+ jint arg4)
+ {
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glTexCoordPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glTexCoordPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointerListIBM__III_3_3ZI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbooleanArray arg3,
+ jint arg4)
+ {
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glTexCoordPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glTexCoordPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexCoordPointerListIBM__III_3_3JI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jlongArray arg3,
+ jint arg4)
+ {
+ jlong *ptr3 = NULL;
+
+ if ( disp__glTexCoordPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glTexCoordPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexPointerListIBM ( GLint , GLenum , GLint , const GLvoid * * , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointerListIBM__III_3_3BI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbyteArray arg3,
+ jint arg4)
+ {
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glVertexPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVertexPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointerListIBM__III_3_3SI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jshortArray arg3,
+ jint arg4)
+ {
+ jshort *ptr3 = NULL;
+
+ if ( disp__glVertexPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVertexPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointerListIBM__III_3_3II (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jintArray arg3,
+ jint arg4)
+ {
+ jint *ptr3 = NULL;
+
+ if ( disp__glVertexPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVertexPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointerListIBM__III_3_3FI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3,
+ jint arg4)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glVertexPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVertexPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointerListIBM__III_3_3DI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jdoubleArray arg3,
+ jint arg4)
+ {
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glVertexPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVertexPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointerListIBM__III_3_3ZI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbooleanArray arg3,
+ jint arg4)
+ {
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glVertexPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVertexPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexPointerListIBM__III_3_3JI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jlongArray arg3,
+ jint arg4)
+ {
+ jlong *ptr3 = NULL;
+
+ if ( disp__glVertexPointerListIBM == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVertexPointerListIBM (
+ (GLint) arg0,
+ (GLenum) arg1,
+ (GLint) arg2,
+ (const GLvoid **) ptr3,
+ (GLint) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTbufferMask3DFX ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTbufferMask3DFX (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glTbufferMask3DFX == NULL ) return;
+
+ disp__glTbufferMask3DFX (
+ (GLuint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSampleMaskEXT ( GLclampf , GLboolean ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSampleMaskEXT (
+ JNIEnv *env, jobject obj,
+ jfloat arg0,
+ jboolean arg1)
+ {
+
+ if ( disp__glSampleMaskEXT == NULL ) return;
+
+ disp__glSampleMaskEXT (
+ (GLclampf) arg0,
+ (GLboolean) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSamplePatternEXT ( GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSamplePatternEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glSamplePatternEXT == NULL ) return;
+
+ disp__glSamplePatternEXT (
+ (GLenum) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTextureColorMaskSGIS ( GLboolean , GLboolean , GLboolean , GLboolean ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTextureColorMaskSGIS (
+ JNIEnv *env, jobject obj,
+ jboolean arg0,
+ jboolean arg1,
+ jboolean arg2,
+ jboolean arg3)
+ {
+
+ if ( disp__glTextureColorMaskSGIS == NULL ) return;
+
+ disp__glTextureColorMaskSGIS (
+ (GLboolean) arg0,
+ (GLboolean) arg1,
+ (GLboolean) arg2,
+ (GLboolean) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glIglooInterfaceSGIX ( GLenum , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIglooInterfaceSGIX__I_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbyteArray arg1)
+ {
+ jbyte *ptr1 = NULL;
+
+ if ( disp__glIglooInterfaceSGIX == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glIglooInterfaceSGIX (
+ (GLenum) arg0,
+ (const GLvoid *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIglooInterfaceSGIX__I_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glIglooInterfaceSGIX == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glIglooInterfaceSGIX (
+ (GLenum) arg0,
+ (const GLvoid *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIglooInterfaceSGIX__I_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glIglooInterfaceSGIX == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glIglooInterfaceSGIX (
+ (GLenum) arg0,
+ (const GLvoid *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIglooInterfaceSGIX__I_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glIglooInterfaceSGIX == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glIglooInterfaceSGIX (
+ (GLenum) arg0,
+ (const GLvoid *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIglooInterfaceSGIX__I_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdoubleArray arg1)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glIglooInterfaceSGIX == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glIglooInterfaceSGIX (
+ (GLenum) arg0,
+ (const GLvoid *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIglooInterfaceSGIX__I_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbooleanArray arg1)
+ {
+ jboolean *ptr1 = NULL;
+
+ if ( disp__glIglooInterfaceSGIX == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glIglooInterfaceSGIX (
+ (GLenum) arg0,
+ (const GLvoid *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIglooInterfaceSGIX__I_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jlongArray arg1)
+ {
+ jlong *ptr1 = NULL;
+
+ if ( disp__glIglooInterfaceSGIX == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glIglooInterfaceSGIX (
+ (GLenum) arg0,
+ (const GLvoid *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIglooInterfaceSGIX__ILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jobject arg1)
+ {
+ void *ptr1 = NULL;
+
+ if ( disp__glIglooInterfaceSGIX == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (*env)->GetDirectBufferAddress(env, arg1);
+ if (ptr1 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 1 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glIglooInterfaceSGIX (
+ (GLenum) arg0,
+ (const GLvoid *) ptr1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGenFencesNV ( GLsizei , GLuint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGenFencesNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jint *ptr1 = NULL;
+
+ if ( disp__glGenFencesNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, &isCopiedArray1);
+ }
+ disp__glGenFencesNV (
+ (GLsizei) arg0,
+ (GLuint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDeleteFencesNV ( GLsizei , const GLuint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDeleteFencesNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glDeleteFencesNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glDeleteFencesNV (
+ (GLsizei) arg0,
+ (const GLuint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSetFenceNV ( GLuint , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetFenceNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+
+ if ( disp__glSetFenceNV == NULL ) return;
+
+ disp__glSetFenceNV (
+ (GLuint) arg0,
+ (GLenum) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLboolean glTestFenceNV ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT jboolean JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTestFenceNV (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+ jboolean ret;
+
+
+ if ( disp__glTestFenceNV == NULL ) return 0;
+
+ ret = (jboolean) disp__glTestFenceNV (
+ (GLuint) arg0
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glFinishFenceNV ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glFinishFenceNV (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glFinishFenceNV == NULL ) return;
+
+ disp__glFinishFenceNV (
+ (GLuint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLboolean glIsFenceNV ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT jboolean JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIsFenceNV (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+ jboolean ret;
+
+
+ if ( disp__glIsFenceNV == NULL ) return 0;
+
+ ret = (jboolean) disp__glIsFenceNV (
+ (GLuint) arg0
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetFenceivNV ( GLuint , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetFenceivNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetFenceivNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetFenceivNV (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMapControlPointsNV ( GLenum , GLuint , GLenum , GLsizei , GLsizei , GLint , GLint , GLboolean , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMapControlPointsNV__IIIIIIIZ_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jboolean arg7,
+ jbyteArray arg8)
+ {
+ jbyte *ptr8 = NULL;
+
+ if ( disp__glMapControlPointsNV == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glMapControlPointsNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLint) arg5,
+ (GLint) arg6,
+ (GLboolean) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMapControlPointsNV__IIIIIIIZ_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jboolean arg7,
+ jshortArray arg8)
+ {
+ jshort *ptr8 = NULL;
+
+ if ( disp__glMapControlPointsNV == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glMapControlPointsNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLint) arg5,
+ (GLint) arg6,
+ (GLboolean) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMapControlPointsNV__IIIIIIIZ_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jboolean arg7,
+ jintArray arg8)
+ {
+ jint *ptr8 = NULL;
+
+ if ( disp__glMapControlPointsNV == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glMapControlPointsNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLint) arg5,
+ (GLint) arg6,
+ (GLboolean) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMapControlPointsNV__IIIIIIIZ_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jboolean arg7,
+ jfloatArray arg8)
+ {
+ jfloat *ptr8 = NULL;
+
+ if ( disp__glMapControlPointsNV == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glMapControlPointsNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLint) arg5,
+ (GLint) arg6,
+ (GLboolean) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMapControlPointsNV__IIIIIIIZ_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jboolean arg7,
+ jdoubleArray arg8)
+ {
+ jdouble *ptr8 = NULL;
+
+ if ( disp__glMapControlPointsNV == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glMapControlPointsNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLint) arg5,
+ (GLint) arg6,
+ (GLboolean) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMapControlPointsNV__IIIIIIIZ_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jboolean arg7,
+ jbooleanArray arg8)
+ {
+ jboolean *ptr8 = NULL;
+
+ if ( disp__glMapControlPointsNV == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glMapControlPointsNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLint) arg5,
+ (GLint) arg6,
+ (GLboolean) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMapControlPointsNV__IIIIIIIZ_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jboolean arg7,
+ jlongArray arg8)
+ {
+ jlong *ptr8 = NULL;
+
+ if ( disp__glMapControlPointsNV == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg8, 0);
+ }
+ disp__glMapControlPointsNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLint) arg5,
+ (GLint) arg6,
+ (GLboolean) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ if(arg8!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg8, ptr8, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMapControlPointsNV__IIIIIIIZLjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jboolean arg7,
+ jobject arg8)
+ {
+ void *ptr8 = NULL;
+
+ if ( disp__glMapControlPointsNV == NULL ) return;
+
+ if(arg8!=NULL)
+ {
+ ptr8 = (*env)->GetDirectBufferAddress(env, arg8);
+ if (ptr8 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 8 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glMapControlPointsNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLint) arg5,
+ (GLint) arg6,
+ (GLboolean) arg7,
+ (const GLvoid *) ptr8
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMapParameterivNV ( GLenum , GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMapParameterivNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glMapParameterivNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glMapParameterivNV (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (const GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glMapParameterfvNV ( GLenum , GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glMapParameterfvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glMapParameterfvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glMapParameterfvNV (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetMapControlPointsNV ( GLenum , GLuint , GLenum , GLsizei , GLsizei , GLboolean , GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMapControlPointsNV__IIIIIZ_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jboolean arg5,
+ jbyteArray arg6)
+ {
+ jboolean isCopiedArray6 = JNI_FALSE;
+ jbyte *ptr6 = NULL;
+
+ if ( disp__glGetMapControlPointsNV == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg6, &isCopiedArray6);
+ }
+ disp__glGetMapControlPointsNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLboolean) arg5,
+ (GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMapControlPointsNV__IIIIIZ_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jboolean arg5,
+ jshortArray arg6)
+ {
+ jboolean isCopiedArray6 = JNI_FALSE;
+ jshort *ptr6 = NULL;
+
+ if ( disp__glGetMapControlPointsNV == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg6, &isCopiedArray6);
+ }
+ disp__glGetMapControlPointsNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLboolean) arg5,
+ (GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMapControlPointsNV__IIIIIZ_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jboolean arg5,
+ jintArray arg6)
+ {
+ jboolean isCopiedArray6 = JNI_FALSE;
+ jint *ptr6 = NULL;
+
+ if ( disp__glGetMapControlPointsNV == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg6, &isCopiedArray6);
+ }
+ disp__glGetMapControlPointsNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLboolean) arg5,
+ (GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMapControlPointsNV__IIIIIZ_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jboolean arg5,
+ jfloatArray arg6)
+ {
+ jboolean isCopiedArray6 = JNI_FALSE;
+ jfloat *ptr6 = NULL;
+
+ if ( disp__glGetMapControlPointsNV == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg6, &isCopiedArray6);
+ }
+ disp__glGetMapControlPointsNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLboolean) arg5,
+ (GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMapControlPointsNV__IIIIIZ_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jboolean arg5,
+ jdoubleArray arg6)
+ {
+ jboolean isCopiedArray6 = JNI_FALSE;
+ jdouble *ptr6 = NULL;
+
+ if ( disp__glGetMapControlPointsNV == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg6, &isCopiedArray6);
+ }
+ disp__glGetMapControlPointsNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLboolean) arg5,
+ (GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMapControlPointsNV__IIIIIZ_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jboolean arg5,
+ jbooleanArray arg6)
+ {
+ jboolean isCopiedArray6 = JNI_FALSE;
+ jboolean *ptr6 = NULL;
+
+ if ( disp__glGetMapControlPointsNV == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg6, &isCopiedArray6);
+ }
+ disp__glGetMapControlPointsNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLboolean) arg5,
+ (GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMapControlPointsNV__IIIIIZ_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jboolean arg5,
+ jlongArray arg6)
+ {
+ jboolean isCopiedArray6 = JNI_FALSE;
+ jlong *ptr6 = NULL;
+
+ if ( disp__glGetMapControlPointsNV == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg6, &isCopiedArray6);
+ }
+ disp__glGetMapControlPointsNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLboolean) arg5,
+ (GLvoid *) ptr6
+ );
+
+ if(arg6!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg6, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMapControlPointsNV__IIIIIZLjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jboolean arg5,
+ jobject arg6)
+ {
+ void *ptr6 = NULL;
+
+ if ( disp__glGetMapControlPointsNV == NULL ) return;
+
+ if(arg6!=NULL)
+ {
+ ptr6 = (*env)->GetDirectBufferAddress(env, arg6);
+ if (ptr6 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 6 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glGetMapControlPointsNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLsizei) arg4,
+ (GLboolean) arg5,
+ (GLvoid *) ptr6
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetMapParameterivNV ( GLenum , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMapParameterivNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetMapParameterivNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetMapParameterivNV (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetMapParameterfvNV ( GLenum , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMapParameterfvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetMapParameterfvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetMapParameterfvNV (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetMapAttribParameterivNV ( GLenum , GLuint , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMapAttribParameterivNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jintArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jint *ptr3 = NULL;
+
+ if ( disp__glGetMapAttribParameterivNV == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetMapAttribParameterivNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLint *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetMapAttribParameterfvNV ( GLenum , GLuint , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetMapAttribParameterfvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glGetMapAttribParameterfvNV == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetMapAttribParameterfvNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLfloat *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEvalMapsNV ( GLenum , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEvalMapsNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+
+ if ( disp__glEvalMapsNV == NULL ) return;
+
+ disp__glEvalMapsNV (
+ (GLenum) arg0,
+ (GLenum) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glCombinerStageParameterfvNV ( GLenum , GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glCombinerStageParameterfvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glCombinerStageParameterfvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glCombinerStageParameterfvNV (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetCombinerStageParameterfvNV ( GLenum , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetCombinerStageParameterfvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetCombinerStageParameterfvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetCombinerStageParameterfvNV (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBindProgramNV ( GLenum , GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBindProgramNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+
+ if ( disp__glBindProgramNV == NULL ) return;
+
+ disp__glBindProgramNV (
+ (GLenum) arg0,
+ (GLuint) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDeleteProgramsNV ( GLsizei , const GLuint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDeleteProgramsNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glDeleteProgramsNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glDeleteProgramsNV (
+ (GLsizei) arg0,
+ (const GLuint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glExecuteProgramNV ( GLenum , GLuint , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glExecuteProgramNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glExecuteProgramNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glExecuteProgramNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGenProgramsNV ( GLsizei , GLuint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGenProgramsNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jint *ptr1 = NULL;
+
+ if ( disp__glGenProgramsNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, &isCopiedArray1);
+ }
+ disp__glGenProgramsNV (
+ (GLsizei) arg0,
+ (GLuint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLboolean glAreProgramsResidentNV ( GLsizei , const GLuint * , GLboolean * ) ;
+ * </pre>
+ */
+ JNIEXPORT jboolean JNICALL
+ Java_gl4java_GLFunc14JauJNI_glAreProgramsResidentNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1,
+ jbooleanArray arg2)
+ {
+ jboolean ret;
+
+ jint *ptr1 = NULL;
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glAreProgramsResidentNV == NULL ) return 0;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ ret = (jboolean) disp__glAreProgramsResidentNV (
+ (GLsizei) arg0,
+ (const GLuint *) ptr1,
+ (GLboolean *) ptr2
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glRequestResidentProgramsNV ( GLsizei , const GLuint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glRequestResidentProgramsNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glRequestResidentProgramsNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glRequestResidentProgramsNV (
+ (GLsizei) arg0,
+ (const GLuint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetProgramParameterfvNV ( GLenum , GLuint , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetProgramParameterfvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glGetProgramParameterfvNV == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetProgramParameterfvNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLfloat *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetProgramParameterdvNV ( GLenum , GLuint , GLenum , GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetProgramParameterdvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jdoubleArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glGetProgramParameterdvNV == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetProgramParameterdvNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLdouble *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetProgramivNV ( GLuint , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetProgramivNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetProgramivNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetProgramivNV (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetProgramStringNV ( GLuint , GLenum , GLubyte * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetProgramStringNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbyteArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glGetProgramStringNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetProgramStringNV (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLubyte *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetTrackMatrixivNV ( GLenum , GLuint , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTrackMatrixivNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jintArray arg3)
+ {
+ jboolean isCopiedArray3 = JNI_FALSE;
+ jint *ptr3 = NULL;
+
+ if ( disp__glGetTrackMatrixivNV == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, &isCopiedArray3);
+ }
+ disp__glGetTrackMatrixivNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLint *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetVertexAttribdvNV ( GLuint , GLenum , GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVertexAttribdvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glGetVertexAttribdvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVertexAttribdvNV (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLdouble *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetVertexAttribfvNV ( GLuint , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVertexAttribfvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetVertexAttribfvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVertexAttribfvNV (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetVertexAttribivNV ( GLuint , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVertexAttribivNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetVertexAttribivNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVertexAttribivNV (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetVertexAttribPointervNV ( GLuint , GLenum , GLvoid * * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVertexAttribPointervNV__II_3_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbyteArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glGetVertexAttribPointervNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVertexAttribPointervNV (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVertexAttribPointervNV__II_3_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jshort *ptr2 = NULL;
+
+ if ( disp__glGetVertexAttribPointervNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVertexAttribPointervNV (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVertexAttribPointervNV__II_3_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetVertexAttribPointervNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVertexAttribPointervNV (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVertexAttribPointervNV__II_3_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetVertexAttribPointervNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVertexAttribPointervNV (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVertexAttribPointervNV__II_3_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glGetVertexAttribPointervNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVertexAttribPointervNV (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVertexAttribPointervNV__II_3_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glGetVertexAttribPointervNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVertexAttribPointervNV (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVertexAttribPointervNV__II_3_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jlongArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jlong *ptr2 = NULL;
+
+ if ( disp__glGetVertexAttribPointervNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVertexAttribPointervNV (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLboolean glIsProgramNV ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT jboolean JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIsProgramNV (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+ jboolean ret;
+
+
+ if ( disp__glIsProgramNV == NULL ) return 0;
+
+ ret = (jboolean) disp__glIsProgramNV (
+ (GLuint) arg0
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glLoadProgramNV ( GLenum , GLuint , GLsizei , const GLubyte * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glLoadProgramNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbyteArray arg3)
+ {
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glLoadProgramNV == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glLoadProgramNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLsizei) arg2,
+ (const GLubyte *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glProgramParameter4fNV ( GLenum , GLuint , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glProgramParameter4fNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4,
+ jfloat arg5)
+ {
+
+ if ( disp__glProgramParameter4fNV == NULL ) return;
+
+ disp__glProgramParameter4fNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4,
+ (GLfloat) arg5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glProgramParameter4dNV ( GLenum , GLuint , GLdouble , GLdouble , GLdouble , GLdouble ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glProgramParameter4dNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdouble arg2,
+ jdouble arg3,
+ jdouble arg4,
+ jdouble arg5)
+ {
+
+ if ( disp__glProgramParameter4dNV == NULL ) return;
+
+ disp__glProgramParameter4dNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLdouble) arg2,
+ (GLdouble) arg3,
+ (GLdouble) arg4,
+ (GLdouble) arg5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glProgramParameter4dvNV ( GLenum , GLuint , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glProgramParameter4dvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glProgramParameter4dvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glProgramParameter4dvNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (const GLdouble *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glProgramParameter4fvNV ( GLenum , GLuint , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glProgramParameter4fvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glProgramParameter4fvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glProgramParameter4fvNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glProgramParameters4dvNV ( GLenum , GLuint , GLuint , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glProgramParameters4dvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jdoubleArray arg3)
+ {
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glProgramParameters4dvNV == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glProgramParameters4dvNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (const GLdouble *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glProgramParameters4fvNV ( GLenum , GLuint , GLuint , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glProgramParameters4fvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glProgramParameters4fvNV == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glProgramParameters4fvNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (const GLfloat *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTrackMatrixNV ( GLenum , GLuint , GLenum , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTrackMatrixNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3)
+ {
+
+ if ( disp__glTrackMatrixNV == NULL ) return;
+
+ disp__glTrackMatrixNV (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttribPointerNV ( GLuint , GLint , GLenum , GLsizei , const GLvoid * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribPointerNV__IIII_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jbyteArray arg4)
+ {
+ jbyte *ptr4 = NULL;
+
+ if ( disp__glVertexAttribPointerNV == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg4, 0);
+ }
+ disp__glVertexAttribPointerNV (
+ (GLuint) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (const GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribPointerNV__IIII_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jshortArray arg4)
+ {
+ jshort *ptr4 = NULL;
+
+ if ( disp__glVertexAttribPointerNV == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg4, 0);
+ }
+ disp__glVertexAttribPointerNV (
+ (GLuint) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (const GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribPointerNV__IIII_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jintArray arg4)
+ {
+ jint *ptr4 = NULL;
+
+ if ( disp__glVertexAttribPointerNV == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg4, 0);
+ }
+ disp__glVertexAttribPointerNV (
+ (GLuint) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (const GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribPointerNV__IIII_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jfloatArray arg4)
+ {
+ jfloat *ptr4 = NULL;
+
+ if ( disp__glVertexAttribPointerNV == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg4, 0);
+ }
+ disp__glVertexAttribPointerNV (
+ (GLuint) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (const GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribPointerNV__IIII_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jdoubleArray arg4)
+ {
+ jdouble *ptr4 = NULL;
+
+ if ( disp__glVertexAttribPointerNV == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg4, 0);
+ }
+ disp__glVertexAttribPointerNV (
+ (GLuint) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (const GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribPointerNV__IIII_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jbooleanArray arg4)
+ {
+ jboolean *ptr4 = NULL;
+
+ if ( disp__glVertexAttribPointerNV == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg4, 0);
+ }
+ disp__glVertexAttribPointerNV (
+ (GLuint) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (const GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribPointerNV__IIII_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jlongArray arg4)
+ {
+ jlong *ptr4 = NULL;
+
+ if ( disp__glVertexAttribPointerNV == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg4, 0);
+ }
+ disp__glVertexAttribPointerNV (
+ (GLuint) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (const GLvoid *) ptr4
+ );
+
+ if(arg4!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg4, ptr4, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribPointerNV__IIIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jobject arg4)
+ {
+ void *ptr4 = NULL;
+
+ if ( disp__glVertexAttribPointerNV == NULL ) return;
+
+ if(arg4!=NULL)
+ {
+ ptr4 = (*env)->GetDirectBufferAddress(env, arg4);
+ if (ptr4 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 4 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glVertexAttribPointerNV (
+ (GLuint) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (const GLvoid *) ptr4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib1sNV ( GLuint , GLshort ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib1sNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshort arg1)
+ {
+
+ if ( disp__glVertexAttrib1sNV == NULL ) return;
+
+ disp__glVertexAttrib1sNV (
+ (GLuint) arg0,
+ (GLshort) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib1fNV ( GLuint , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib1fNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1)
+ {
+
+ if ( disp__glVertexAttrib1fNV == NULL ) return;
+
+ disp__glVertexAttrib1fNV (
+ (GLuint) arg0,
+ (GLfloat) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib1dNV ( GLuint , GLdouble ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib1dNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdouble arg1)
+ {
+
+ if ( disp__glVertexAttrib1dNV == NULL ) return;
+
+ disp__glVertexAttrib1dNV (
+ (GLuint) arg0,
+ (GLdouble) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib2sNV ( GLuint , GLshort , GLshort ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib2sNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshort arg1,
+ jshort arg2)
+ {
+
+ if ( disp__glVertexAttrib2sNV == NULL ) return;
+
+ disp__glVertexAttrib2sNV (
+ (GLuint) arg0,
+ (GLshort) arg1,
+ (GLshort) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib2fNV ( GLuint , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib2fNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1,
+ jfloat arg2)
+ {
+
+ if ( disp__glVertexAttrib2fNV == NULL ) return;
+
+ disp__glVertexAttrib2fNV (
+ (GLuint) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib2dNV ( GLuint , GLdouble , GLdouble ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib2dNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdouble arg1,
+ jdouble arg2)
+ {
+
+ if ( disp__glVertexAttrib2dNV == NULL ) return;
+
+ disp__glVertexAttrib2dNV (
+ (GLuint) arg0,
+ (GLdouble) arg1,
+ (GLdouble) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib3sNV ( GLuint , GLshort , GLshort , GLshort ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib3sNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshort arg1,
+ jshort arg2,
+ jshort arg3)
+ {
+
+ if ( disp__glVertexAttrib3sNV == NULL ) return;
+
+ disp__glVertexAttrib3sNV (
+ (GLuint) arg0,
+ (GLshort) arg1,
+ (GLshort) arg2,
+ (GLshort) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib3fNV ( GLuint , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib3fNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3)
+ {
+
+ if ( disp__glVertexAttrib3fNV == NULL ) return;
+
+ disp__glVertexAttrib3fNV (
+ (GLuint) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib3dNV ( GLuint , GLdouble , GLdouble , GLdouble ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib3dNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdouble arg1,
+ jdouble arg2,
+ jdouble arg3)
+ {
+
+ if ( disp__glVertexAttrib3dNV == NULL ) return;
+
+ disp__glVertexAttrib3dNV (
+ (GLuint) arg0,
+ (GLdouble) arg1,
+ (GLdouble) arg2,
+ (GLdouble) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib4sNV ( GLuint , GLshort , GLshort , GLshort , GLshort ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib4sNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshort arg1,
+ jshort arg2,
+ jshort arg3,
+ jshort arg4)
+ {
+
+ if ( disp__glVertexAttrib4sNV == NULL ) return;
+
+ disp__glVertexAttrib4sNV (
+ (GLuint) arg0,
+ (GLshort) arg1,
+ (GLshort) arg2,
+ (GLshort) arg3,
+ (GLshort) arg4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib4fNV ( GLuint , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib4fNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4)
+ {
+
+ if ( disp__glVertexAttrib4fNV == NULL ) return;
+
+ disp__glVertexAttrib4fNV (
+ (GLuint) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib4dNV ( GLuint , GLdouble , GLdouble , GLdouble , GLdouble ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib4dNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdouble arg1,
+ jdouble arg2,
+ jdouble arg3,
+ jdouble arg4)
+ {
+
+ if ( disp__glVertexAttrib4dNV == NULL ) return;
+
+ disp__glVertexAttrib4dNV (
+ (GLuint) arg0,
+ (GLdouble) arg1,
+ (GLdouble) arg2,
+ (GLdouble) arg3,
+ (GLdouble) arg4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib4ubNV ( GLuint , GLubyte , GLubyte , GLubyte , GLubyte ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib4ubNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbyte arg1,
+ jbyte arg2,
+ jbyte arg3,
+ jbyte arg4)
+ {
+
+ if ( disp__glVertexAttrib4ubNV == NULL ) return;
+
+ disp__glVertexAttrib4ubNV (
+ (GLuint) arg0,
+ (GLubyte) arg1,
+ (GLubyte) arg2,
+ (GLubyte) arg3,
+ (GLubyte) arg4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib1svNV ( GLuint , const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib1svNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glVertexAttrib1svNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexAttrib1svNV (
+ (GLuint) arg0,
+ (const GLshort *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib1fvNV ( GLuint , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib1fvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glVertexAttrib1fvNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexAttrib1fvNV (
+ (GLuint) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib1dvNV ( GLuint , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib1dvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdoubleArray arg1)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glVertexAttrib1dvNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexAttrib1dvNV (
+ (GLuint) arg0,
+ (const GLdouble *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib2svNV ( GLuint , const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib2svNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glVertexAttrib2svNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexAttrib2svNV (
+ (GLuint) arg0,
+ (const GLshort *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib2fvNV ( GLuint , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib2fvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glVertexAttrib2fvNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexAttrib2fvNV (
+ (GLuint) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib2dvNV ( GLuint , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib2dvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdoubleArray arg1)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glVertexAttrib2dvNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexAttrib2dvNV (
+ (GLuint) arg0,
+ (const GLdouble *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib3svNV ( GLuint , const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib3svNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glVertexAttrib3svNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexAttrib3svNV (
+ (GLuint) arg0,
+ (const GLshort *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib3fvNV ( GLuint , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib3fvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glVertexAttrib3fvNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexAttrib3fvNV (
+ (GLuint) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib3dvNV ( GLuint , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib3dvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdoubleArray arg1)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glVertexAttrib3dvNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexAttrib3dvNV (
+ (GLuint) arg0,
+ (const GLdouble *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib4svNV ( GLuint , const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib4svNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glVertexAttrib4svNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexAttrib4svNV (
+ (GLuint) arg0,
+ (const GLshort *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib4fvNV ( GLuint , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib4fvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glVertexAttrib4fvNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexAttrib4fvNV (
+ (GLuint) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib4dvNV ( GLuint , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib4dvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdoubleArray arg1)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glVertexAttrib4dvNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexAttrib4dvNV (
+ (GLuint) arg0,
+ (const GLdouble *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttrib4ubvNV ( GLuint , const GLubyte * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttrib4ubvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbyteArray arg1)
+ {
+ jbyte *ptr1 = NULL;
+
+ if ( disp__glVertexAttrib4ubvNV == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexAttrib4ubvNV (
+ (GLuint) arg0,
+ (const GLubyte *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttribs1svNV ( GLuint , GLsizei , const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribs1svNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glVertexAttribs1svNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexAttribs1svNV (
+ (GLuint) arg0,
+ (GLsizei) arg1,
+ (const GLshort *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttribs1fvNV ( GLuint , GLsizei , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribs1fvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glVertexAttribs1fvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexAttribs1fvNV (
+ (GLuint) arg0,
+ (GLsizei) arg1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttribs1dvNV ( GLuint , GLsizei , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribs1dvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glVertexAttribs1dvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexAttribs1dvNV (
+ (GLuint) arg0,
+ (GLsizei) arg1,
+ (const GLdouble *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttribs2svNV ( GLuint , GLsizei , const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribs2svNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glVertexAttribs2svNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexAttribs2svNV (
+ (GLuint) arg0,
+ (GLsizei) arg1,
+ (const GLshort *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttribs2fvNV ( GLuint , GLsizei , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribs2fvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glVertexAttribs2fvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexAttribs2fvNV (
+ (GLuint) arg0,
+ (GLsizei) arg1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttribs2dvNV ( GLuint , GLsizei , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribs2dvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glVertexAttribs2dvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexAttribs2dvNV (
+ (GLuint) arg0,
+ (GLsizei) arg1,
+ (const GLdouble *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttribs3svNV ( GLuint , GLsizei , const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribs3svNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glVertexAttribs3svNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexAttribs3svNV (
+ (GLuint) arg0,
+ (GLsizei) arg1,
+ (const GLshort *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttribs3fvNV ( GLuint , GLsizei , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribs3fvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glVertexAttribs3fvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexAttribs3fvNV (
+ (GLuint) arg0,
+ (GLsizei) arg1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttribs3dvNV ( GLuint , GLsizei , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribs3dvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glVertexAttribs3dvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexAttribs3dvNV (
+ (GLuint) arg0,
+ (GLsizei) arg1,
+ (const GLdouble *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttribs4svNV ( GLuint , GLsizei , const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribs4svNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glVertexAttribs4svNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexAttribs4svNV (
+ (GLuint) arg0,
+ (GLsizei) arg1,
+ (const GLshort *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttribs4fvNV ( GLuint , GLsizei , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribs4fvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glVertexAttribs4fvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexAttribs4fvNV (
+ (GLuint) arg0,
+ (GLsizei) arg1,
+ (const GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttribs4dvNV ( GLuint , GLsizei , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribs4dvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glVertexAttribs4dvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexAttribs4dvNV (
+ (GLuint) arg0,
+ (GLsizei) arg1,
+ (const GLdouble *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexAttribs4ubvNV ( GLuint , GLsizei , const GLubyte * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexAttribs4ubvNV (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbyteArray arg2)
+ {
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glVertexAttribs4ubvNV == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glVertexAttribs4ubvNV (
+ (GLuint) arg0,
+ (GLsizei) arg1,
+ (const GLubyte *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexBumpParameterivATI ( GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexBumpParameterivATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glTexBumpParameterivATI == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glTexBumpParameterivATI (
+ (GLenum) arg0,
+ (const GLint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glTexBumpParameterfvATI ( GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glTexBumpParameterfvATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glTexBumpParameterfvATI == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glTexBumpParameterfvATI (
+ (GLenum) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetTexBumpParameterivATI ( GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexBumpParameterivATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jint *ptr1 = NULL;
+
+ if ( disp__glGetTexBumpParameterivATI == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, &isCopiedArray1);
+ }
+ disp__glGetTexBumpParameterivATI (
+ (GLenum) arg0,
+ (GLint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetTexBumpParameterfvATI ( GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetTexBumpParameterfvATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jboolean isCopiedArray1 = JNI_FALSE;
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glGetTexBumpParameterfvATI == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, &isCopiedArray1);
+ }
+ disp__glGetTexBumpParameterfvATI (
+ (GLenum) arg0,
+ (GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLuint glGenFragmentShadersATI ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGenFragmentShadersATI (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+ jint ret;
+
+
+ if ( disp__glGenFragmentShadersATI == NULL ) return 0;
+
+ ret = (jint) disp__glGenFragmentShadersATI (
+ (GLuint) arg0
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBindFragmentShaderATI ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBindFragmentShaderATI (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glBindFragmentShaderATI == NULL ) return;
+
+ disp__glBindFragmentShaderATI (
+ (GLuint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDeleteFragmentShaderATI ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDeleteFragmentShaderATI (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glDeleteFragmentShaderATI == NULL ) return;
+
+ disp__glDeleteFragmentShaderATI (
+ (GLuint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBeginFragmentShaderATI ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBeginFragmentShaderATI (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glBeginFragmentShaderATI == NULL ) return;
+
+ disp__glBeginFragmentShaderATI (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEndFragmentShaderATI ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEndFragmentShaderATI (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glEndFragmentShaderATI == NULL ) return;
+
+ disp__glEndFragmentShaderATI (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPassTexCoordATI ( GLuint , GLuint , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPassTexCoordATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2)
+ {
+
+ if ( disp__glPassTexCoordATI == NULL ) return;
+
+ disp__glPassTexCoordATI (
+ (GLuint) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSampleMapATI ( GLuint , GLuint , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSampleMapATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2)
+ {
+
+ if ( disp__glSampleMapATI == NULL ) return;
+
+ disp__glSampleMapATI (
+ (GLuint) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorFragmentOp1ATI ( GLenum , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorFragmentOp1ATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6)
+ {
+
+ if ( disp__glColorFragmentOp1ATI == NULL ) return;
+
+ disp__glColorFragmentOp1ATI (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (GLuint) arg3,
+ (GLuint) arg4,
+ (GLuint) arg5,
+ (GLuint) arg6
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorFragmentOp2ATI ( GLenum , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorFragmentOp2ATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9)
+ {
+
+ if ( disp__glColorFragmentOp2ATI == NULL ) return;
+
+ disp__glColorFragmentOp2ATI (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (GLuint) arg3,
+ (GLuint) arg4,
+ (GLuint) arg5,
+ (GLuint) arg6,
+ (GLuint) arg7,
+ (GLuint) arg8,
+ (GLuint) arg9
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glColorFragmentOp3ATI ( GLenum , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glColorFragmentOp3ATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jint arg10,
+ jint arg11,
+ jint arg12)
+ {
+
+ if ( disp__glColorFragmentOp3ATI == NULL ) return;
+
+ disp__glColorFragmentOp3ATI (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (GLuint) arg3,
+ (GLuint) arg4,
+ (GLuint) arg5,
+ (GLuint) arg6,
+ (GLuint) arg7,
+ (GLuint) arg8,
+ (GLuint) arg9,
+ (GLuint) arg10,
+ (GLuint) arg11,
+ (GLuint) arg12
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glAlphaFragmentOp1ATI ( GLenum , GLuint , GLuint , GLuint , GLuint , GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glAlphaFragmentOp1ATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5)
+ {
+
+ if ( disp__glAlphaFragmentOp1ATI == NULL ) return;
+
+ disp__glAlphaFragmentOp1ATI (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (GLuint) arg3,
+ (GLuint) arg4,
+ (GLuint) arg5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glAlphaFragmentOp2ATI ( GLenum , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glAlphaFragmentOp2ATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8)
+ {
+
+ if ( disp__glAlphaFragmentOp2ATI == NULL ) return;
+
+ disp__glAlphaFragmentOp2ATI (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (GLuint) arg3,
+ (GLuint) arg4,
+ (GLuint) arg5,
+ (GLuint) arg6,
+ (GLuint) arg7,
+ (GLuint) arg8
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glAlphaFragmentOp3ATI ( GLenum , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint , GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glAlphaFragmentOp3ATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5,
+ jint arg6,
+ jint arg7,
+ jint arg8,
+ jint arg9,
+ jint arg10,
+ jint arg11)
+ {
+
+ if ( disp__glAlphaFragmentOp3ATI == NULL ) return;
+
+ disp__glAlphaFragmentOp3ATI (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (GLuint) arg3,
+ (GLuint) arg4,
+ (GLuint) arg5,
+ (GLuint) arg6,
+ (GLuint) arg7,
+ (GLuint) arg8,
+ (GLuint) arg9,
+ (GLuint) arg10,
+ (GLuint) arg11
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSetFragmentShaderConstantATI ( GLuint , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetFragmentShaderConstantATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glSetFragmentShaderConstantATI == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glSetFragmentShaderConstantATI (
+ (GLuint) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPNTrianglesiATI ( GLenum , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPNTrianglesiATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+
+ if ( disp__glPNTrianglesiATI == NULL ) return;
+
+ disp__glPNTrianglesiATI (
+ (GLenum) arg0,
+ (GLint) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glPNTrianglesfATI ( GLenum , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glPNTrianglesfATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1)
+ {
+
+ if ( disp__glPNTrianglesfATI == NULL ) return;
+
+ disp__glPNTrianglesfATI (
+ (GLenum) arg0,
+ (GLfloat) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLuint glNewObjectBufferATI ( GLsizei , const GLvoid * , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNewObjectBufferATI__I_3BI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbyteArray arg1,
+ jint arg2)
+ {
+ jint ret;
+
+ jbyte *ptr1 = NULL;
+
+ if ( disp__glNewObjectBufferATI == NULL ) return 0;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ ret = (jint) disp__glNewObjectBufferATI (
+ (GLsizei) arg0,
+ (const GLvoid *) ptr1,
+ (GLenum) arg2
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNewObjectBufferATI__I_3SI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1,
+ jint arg2)
+ {
+ jint ret;
+
+ jshort *ptr1 = NULL;
+
+ if ( disp__glNewObjectBufferATI == NULL ) return 0;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ ret = (jint) disp__glNewObjectBufferATI (
+ (GLsizei) arg0,
+ (const GLvoid *) ptr1,
+ (GLenum) arg2
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNewObjectBufferATI__I_3II (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1,
+ jint arg2)
+ {
+ jint ret;
+
+ jint *ptr1 = NULL;
+
+ if ( disp__glNewObjectBufferATI == NULL ) return 0;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ ret = (jint) disp__glNewObjectBufferATI (
+ (GLsizei) arg0,
+ (const GLvoid *) ptr1,
+ (GLenum) arg2
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNewObjectBufferATI__I_3FI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1,
+ jint arg2)
+ {
+ jint ret;
+
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glNewObjectBufferATI == NULL ) return 0;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ ret = (jint) disp__glNewObjectBufferATI (
+ (GLsizei) arg0,
+ (const GLvoid *) ptr1,
+ (GLenum) arg2
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNewObjectBufferATI__I_3DI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdoubleArray arg1,
+ jint arg2)
+ {
+ jint ret;
+
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glNewObjectBufferATI == NULL ) return 0;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ ret = (jint) disp__glNewObjectBufferATI (
+ (GLsizei) arg0,
+ (const GLvoid *) ptr1,
+ (GLenum) arg2
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNewObjectBufferATI__I_3ZI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbooleanArray arg1,
+ jint arg2)
+ {
+ jint ret;
+
+ jboolean *ptr1 = NULL;
+
+ if ( disp__glNewObjectBufferATI == NULL ) return 0;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ ret = (jint) disp__glNewObjectBufferATI (
+ (GLsizei) arg0,
+ (const GLvoid *) ptr1,
+ (GLenum) arg2
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNewObjectBufferATI__I_3JI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jlongArray arg1,
+ jint arg2)
+ {
+ jint ret;
+
+ jlong *ptr1 = NULL;
+
+ if ( disp__glNewObjectBufferATI == NULL ) return 0;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ ret = (jint) disp__glNewObjectBufferATI (
+ (GLsizei) arg0,
+ (const GLvoid *) ptr1,
+ (GLenum) arg2
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ return ret;
+ }
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNewObjectBufferATI__ILjava_nio_Buffer_2I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jobject arg1,
+ jint arg2)
+ {
+ jint ret;
+
+ void *ptr1 = NULL;
+
+ if ( disp__glNewObjectBufferATI == NULL ) return 0;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (*env)->GetDirectBufferAddress(env, arg1);
+ if (ptr1 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 1 was not a direct buffer");
+ return 0;
+ }
+ }
+ ret = (jint) disp__glNewObjectBufferATI (
+ (GLsizei) arg0,
+ (const GLvoid *) ptr1,
+ (GLenum) arg2
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLboolean glIsObjectBufferATI ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT jboolean JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIsObjectBufferATI (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+ jboolean ret;
+
+
+ if ( disp__glIsObjectBufferATI == NULL ) return 0;
+
+ ret = (jboolean) disp__glIsObjectBufferATI (
+ (GLuint) arg0
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glUpdateObjectBufferATI ( GLuint , GLuint , GLsizei , const GLvoid * , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glUpdateObjectBufferATI__III_3BI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbyteArray arg3,
+ jint arg4)
+ {
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glUpdateObjectBufferATI == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glUpdateObjectBufferATI (
+ (GLuint) arg0,
+ (GLuint) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3,
+ (GLenum) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glUpdateObjectBufferATI__III_3SI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jshortArray arg3,
+ jint arg4)
+ {
+ jshort *ptr3 = NULL;
+
+ if ( disp__glUpdateObjectBufferATI == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glUpdateObjectBufferATI (
+ (GLuint) arg0,
+ (GLuint) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3,
+ (GLenum) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glUpdateObjectBufferATI__III_3II (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jintArray arg3,
+ jint arg4)
+ {
+ jint *ptr3 = NULL;
+
+ if ( disp__glUpdateObjectBufferATI == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glUpdateObjectBufferATI (
+ (GLuint) arg0,
+ (GLuint) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3,
+ (GLenum) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glUpdateObjectBufferATI__III_3FI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3,
+ jint arg4)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glUpdateObjectBufferATI == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glUpdateObjectBufferATI (
+ (GLuint) arg0,
+ (GLuint) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3,
+ (GLenum) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glUpdateObjectBufferATI__III_3DI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jdoubleArray arg3,
+ jint arg4)
+ {
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glUpdateObjectBufferATI == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glUpdateObjectBufferATI (
+ (GLuint) arg0,
+ (GLuint) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3,
+ (GLenum) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glUpdateObjectBufferATI__III_3ZI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbooleanArray arg3,
+ jint arg4)
+ {
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glUpdateObjectBufferATI == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glUpdateObjectBufferATI (
+ (GLuint) arg0,
+ (GLuint) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3,
+ (GLenum) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glUpdateObjectBufferATI__III_3JI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jlongArray arg3,
+ jint arg4)
+ {
+ jlong *ptr3 = NULL;
+
+ if ( disp__glUpdateObjectBufferATI == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glUpdateObjectBufferATI (
+ (GLuint) arg0,
+ (GLuint) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3,
+ (GLenum) arg4
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glUpdateObjectBufferATI__IIILjava_nio_Buffer_2I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jobject arg3,
+ jint arg4)
+ {
+ void *ptr3 = NULL;
+
+ if ( disp__glUpdateObjectBufferATI == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, arg3);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glUpdateObjectBufferATI (
+ (GLuint) arg0,
+ (GLuint) arg1,
+ (GLsizei) arg2,
+ (const GLvoid *) ptr3,
+ (GLenum) arg4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetObjectBufferfvATI ( GLuint , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetObjectBufferfvATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetObjectBufferfvATI == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetObjectBufferfvATI (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetObjectBufferivATI ( GLuint , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetObjectBufferivATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetObjectBufferivATI == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetObjectBufferivATI (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDeleteObjectBufferATI ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDeleteObjectBufferATI (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glDeleteObjectBufferATI == NULL ) return;
+
+ disp__glDeleteObjectBufferATI (
+ (GLuint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glArrayObjectATI ( GLenum , GLint , GLenum , GLsizei , GLuint , GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glArrayObjectATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5)
+ {
+
+ if ( disp__glArrayObjectATI == NULL ) return;
+
+ disp__glArrayObjectATI (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLenum) arg2,
+ (GLsizei) arg3,
+ (GLuint) arg4,
+ (GLuint) arg5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetArrayObjectfvATI ( GLenum , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetArrayObjectfvATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetArrayObjectfvATI == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetArrayObjectfvATI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetArrayObjectivATI ( GLenum , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetArrayObjectivATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetArrayObjectivATI == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetArrayObjectivATI (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVariantArrayObjectATI ( GLuint , GLenum , GLsizei , GLuint , GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVariantArrayObjectATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4)
+ {
+
+ if ( disp__glVariantArrayObjectATI == NULL ) return;
+
+ disp__glVariantArrayObjectATI (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLsizei) arg2,
+ (GLuint) arg3,
+ (GLuint) arg4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetVariantArrayObjectfvATI ( GLuint , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVariantArrayObjectfvATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetVariantArrayObjectfvATI == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVariantArrayObjectfvATI (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetVariantArrayObjectivATI ( GLuint , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVariantArrayObjectivATI (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetVariantArrayObjectivATI == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVariantArrayObjectivATI (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBeginVertexShaderEXT ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBeginVertexShaderEXT (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glBeginVertexShaderEXT == NULL ) return;
+
+ disp__glBeginVertexShaderEXT (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEndVertexShaderEXT ( void ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEndVertexShaderEXT (
+ JNIEnv *env, jobject obj)
+ {
+
+ if ( disp__glEndVertexShaderEXT == NULL ) return;
+
+ disp__glEndVertexShaderEXT (
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glBindVertexShaderEXT ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBindVertexShaderEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glBindVertexShaderEXT == NULL ) return;
+
+ disp__glBindVertexShaderEXT (
+ (GLuint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLuint glGenVertexShadersEXT ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGenVertexShadersEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+ jint ret;
+
+
+ if ( disp__glGenVertexShadersEXT == NULL ) return 0;
+
+ ret = (jint) disp__glGenVertexShadersEXT (
+ (GLuint) arg0
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDeleteVertexShaderEXT ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDeleteVertexShaderEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glDeleteVertexShaderEXT == NULL ) return;
+
+ disp__glDeleteVertexShaderEXT (
+ (GLuint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glShaderOp1EXT ( GLenum , GLuint , GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glShaderOp1EXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2)
+ {
+
+ if ( disp__glShaderOp1EXT == NULL ) return;
+
+ disp__glShaderOp1EXT (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glShaderOp2EXT ( GLenum , GLuint , GLuint , GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glShaderOp2EXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3)
+ {
+
+ if ( disp__glShaderOp2EXT == NULL ) return;
+
+ disp__glShaderOp2EXT (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (GLuint) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glShaderOp3EXT ( GLenum , GLuint , GLuint , GLuint , GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glShaderOp3EXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4)
+ {
+
+ if ( disp__glShaderOp3EXT == NULL ) return;
+
+ disp__glShaderOp3EXT (
+ (GLenum) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2,
+ (GLuint) arg3,
+ (GLuint) arg4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSwizzleEXT ( GLuint , GLuint , GLenum , GLenum , GLenum , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSwizzleEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5)
+ {
+
+ if ( disp__glSwizzleEXT == NULL ) return;
+
+ disp__glSwizzleEXT (
+ (GLuint) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glWriteMaskEXT ( GLuint , GLuint , GLenum , GLenum , GLenum , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glWriteMaskEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4,
+ jint arg5)
+ {
+
+ if ( disp__glWriteMaskEXT == NULL ) return;
+
+ disp__glWriteMaskEXT (
+ (GLuint) arg0,
+ (GLuint) arg1,
+ (GLenum) arg2,
+ (GLenum) arg3,
+ (GLenum) arg4,
+ (GLenum) arg5
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glInsertComponentEXT ( GLuint , GLuint , GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glInsertComponentEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2)
+ {
+
+ if ( disp__glInsertComponentEXT == NULL ) return;
+
+ disp__glInsertComponentEXT (
+ (GLuint) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glExtractComponentEXT ( GLuint , GLuint , GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glExtractComponentEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2)
+ {
+
+ if ( disp__glExtractComponentEXT == NULL ) return;
+
+ disp__glExtractComponentEXT (
+ (GLuint) arg0,
+ (GLuint) arg1,
+ (GLuint) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLuint glGenSymbolsEXT ( GLenum , GLenum , GLenum , GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGenSymbolsEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3)
+ {
+ jint ret;
+
+
+ if ( disp__glGenSymbolsEXT == NULL ) return 0;
+
+ ret = (jint) disp__glGenSymbolsEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2,
+ (GLuint) arg3
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSetInvariantEXT ( GLuint , GLenum , const void * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetInvariantEXT__II_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbyteArray arg2)
+ {
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glSetInvariantEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glSetInvariantEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetInvariantEXT__II_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glSetInvariantEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glSetInvariantEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetInvariantEXT__II_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glSetInvariantEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glSetInvariantEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetInvariantEXT__II_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glSetInvariantEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glSetInvariantEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetInvariantEXT__II_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glSetInvariantEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glSetInvariantEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetInvariantEXT__II_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2)
+ {
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glSetInvariantEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glSetInvariantEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetInvariantEXT__II_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jlongArray arg2)
+ {
+ jlong *ptr2 = NULL;
+
+ if ( disp__glSetInvariantEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glSetInvariantEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetInvariantEXT__IILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jobject arg2)
+ {
+ void *ptr2 = NULL;
+
+ if ( disp__glSetInvariantEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (*env)->GetDirectBufferAddress(env, arg2);
+ if (ptr2 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 2 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glSetInvariantEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const void *) ptr2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glSetLocalConstantEXT ( GLuint , GLenum , const void * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetLocalConstantEXT__II_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbyteArray arg2)
+ {
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glSetLocalConstantEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glSetLocalConstantEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetLocalConstantEXT__II_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2)
+ {
+ jshort *ptr2 = NULL;
+
+ if ( disp__glSetLocalConstantEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glSetLocalConstantEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetLocalConstantEXT__II_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jint *ptr2 = NULL;
+
+ if ( disp__glSetLocalConstantEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glSetLocalConstantEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetLocalConstantEXT__II_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glSetLocalConstantEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glSetLocalConstantEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetLocalConstantEXT__II_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glSetLocalConstantEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glSetLocalConstantEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetLocalConstantEXT__II_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2)
+ {
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glSetLocalConstantEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glSetLocalConstantEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetLocalConstantEXT__II_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jlongArray arg2)
+ {
+ jlong *ptr2 = NULL;
+
+ if ( disp__glSetLocalConstantEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg2, 0);
+ }
+ disp__glSetLocalConstantEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const void *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glSetLocalConstantEXT__IILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jobject arg2)
+ {
+ void *ptr2 = NULL;
+
+ if ( disp__glSetLocalConstantEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (*env)->GetDirectBufferAddress(env, arg2);
+ if (ptr2 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 2 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glSetLocalConstantEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (const void *) ptr2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVariantbvEXT ( GLuint , const GLbyte * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVariantbvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbyteArray arg1)
+ {
+ jbyte *ptr1 = NULL;
+
+ if ( disp__glVariantbvEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVariantbvEXT (
+ (GLuint) arg0,
+ (const GLbyte *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVariantsvEXT ( GLuint , const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVariantsvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glVariantsvEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVariantsvEXT (
+ (GLuint) arg0,
+ (const GLshort *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVariantivEXT ( GLuint , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVariantivEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glVariantivEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVariantivEXT (
+ (GLuint) arg0,
+ (const GLint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVariantfvEXT ( GLuint , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVariantfvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glVariantfvEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVariantfvEXT (
+ (GLuint) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVariantdvEXT ( GLuint , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVariantdvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdoubleArray arg1)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glVariantdvEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVariantdvEXT (
+ (GLuint) arg0,
+ (const GLdouble *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVariantubvEXT ( GLuint , const GLubyte * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVariantubvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbyteArray arg1)
+ {
+ jbyte *ptr1 = NULL;
+
+ if ( disp__glVariantubvEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVariantubvEXT (
+ (GLuint) arg0,
+ (const GLubyte *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVariantusvEXT ( GLuint , const GLushort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVariantusvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glVariantusvEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVariantusvEXT (
+ (GLuint) arg0,
+ (const GLushort *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVariantuivEXT ( GLuint , const GLuint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVariantuivEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glVariantuivEXT == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVariantuivEXT (
+ (GLuint) arg0,
+ (const GLuint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVariantPointerEXT ( GLuint , GLenum , GLuint , const void * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVariantPointerEXT__III_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbyteArray arg3)
+ {
+ jbyte *ptr3 = NULL;
+
+ if ( disp__glVariantPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVariantPointerEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLuint) arg2,
+ (const void *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVariantPointerEXT__III_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jshortArray arg3)
+ {
+ jshort *ptr3 = NULL;
+
+ if ( disp__glVariantPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVariantPointerEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLuint) arg2,
+ (const void *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVariantPointerEXT__III_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jintArray arg3)
+ {
+ jint *ptr3 = NULL;
+
+ if ( disp__glVariantPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVariantPointerEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLuint) arg2,
+ (const void *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVariantPointerEXT__III_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jfloatArray arg3)
+ {
+ jfloat *ptr3 = NULL;
+
+ if ( disp__glVariantPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVariantPointerEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLuint) arg2,
+ (const void *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVariantPointerEXT__III_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jdoubleArray arg3)
+ {
+ jdouble *ptr3 = NULL;
+
+ if ( disp__glVariantPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVariantPointerEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLuint) arg2,
+ (const void *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVariantPointerEXT__III_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jbooleanArray arg3)
+ {
+ jboolean *ptr3 = NULL;
+
+ if ( disp__glVariantPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVariantPointerEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLuint) arg2,
+ (const void *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVariantPointerEXT__III_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jlongArray arg3)
+ {
+ jlong *ptr3 = NULL;
+
+ if ( disp__glVariantPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg3, 0);
+ }
+ disp__glVariantPointerEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLuint) arg2,
+ (const void *) ptr3
+ );
+
+ if(arg3!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg3, ptr3, JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVariantPointerEXT__IIILjava_nio_Buffer_2 (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jobject arg3)
+ {
+ void *ptr3 = NULL;
+
+ if ( disp__glVariantPointerEXT == NULL ) return;
+
+ if(arg3!=NULL)
+ {
+ ptr3 = (*env)->GetDirectBufferAddress(env, arg3);
+ if (ptr3 == NULL) {
+ (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"),
+ "Argument 3 was not a direct buffer");
+ return ;
+ }
+ }
+ disp__glVariantPointerEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLuint) arg2,
+ (const void *) ptr3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glEnableVariantClientStateEXT ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glEnableVariantClientStateEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glEnableVariantClientStateEXT == NULL ) return;
+
+ disp__glEnableVariantClientStateEXT (
+ (GLuint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glDisableVariantClientStateEXT ( GLuint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glDisableVariantClientStateEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glDisableVariantClientStateEXT == NULL ) return;
+
+ disp__glDisableVariantClientStateEXT (
+ (GLuint) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLuint glBindLightParameterEXT ( GLenum , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBindLightParameterEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+ jint ret;
+
+
+ if ( disp__glBindLightParameterEXT == NULL ) return 0;
+
+ ret = (jint) disp__glBindLightParameterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLuint glBindMaterialParameterEXT ( GLenum , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBindMaterialParameterEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+ jint ret;
+
+
+ if ( disp__glBindMaterialParameterEXT == NULL ) return 0;
+
+ ret = (jint) disp__glBindMaterialParameterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLuint glBindTexGenParameterEXT ( GLenum , GLenum , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBindTexGenParameterEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2)
+ {
+ jint ret;
+
+
+ if ( disp__glBindTexGenParameterEXT == NULL ) return 0;
+
+ ret = (jint) disp__glBindTexGenParameterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1,
+ (GLenum) arg2
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLuint glBindTextureUnitParameterEXT ( GLenum , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBindTextureUnitParameterEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+ jint ret;
+
+
+ if ( disp__glBindTextureUnitParameterEXT == NULL ) return 0;
+
+ ret = (jint) disp__glBindTextureUnitParameterEXT (
+ (GLenum) arg0,
+ (GLenum) arg1
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLuint glBindParameterEXT ( GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT jint JNICALL
+ Java_gl4java_GLFunc14JauJNI_glBindParameterEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+ jint ret;
+
+
+ if ( disp__glBindParameterEXT == NULL ) return 0;
+
+ ret = (jint) disp__glBindParameterEXT (
+ (GLenum) arg0
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern GLboolean glIsVariantEnabledEXT ( GLuint , GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT jboolean JNICALL
+ Java_gl4java_GLFunc14JauJNI_glIsVariantEnabledEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+ jboolean ret;
+
+
+ if ( disp__glIsVariantEnabledEXT == NULL ) return 0;
+
+ ret = (jboolean) disp__glIsVariantEnabledEXT (
+ (GLuint) arg0,
+ (GLenum) arg1
+ );
+
+ return ret;
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetVariantBooleanvEXT ( GLuint , GLenum , GLboolean * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVariantBooleanvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glGetVariantBooleanvEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVariantBooleanvEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLboolean *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetVariantIntegervEXT ( GLuint , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVariantIntegervEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetVariantIntegervEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVariantIntegervEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetVariantFloatvEXT ( GLuint , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVariantFloatvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetVariantFloatvEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVariantFloatvEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetVariantPointervEXT ( GLuint , GLenum , GLvoid * * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVariantPointervEXT__II_3_3B (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbyteArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jbyte *ptr2 = NULL;
+
+ if ( disp__glGetVariantPointervEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVariantPointervEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVariantPointervEXT__II_3_3S (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jshortArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jshort *ptr2 = NULL;
+
+ if ( disp__glGetVariantPointervEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVariantPointervEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVariantPointervEXT__II_3_3I (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetVariantPointervEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVariantPointervEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVariantPointervEXT__II_3_3F (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetVariantPointervEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVariantPointervEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVariantPointervEXT__II_3_3D (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jdoubleArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jdouble *ptr2 = NULL;
+
+ if ( disp__glGetVariantPointervEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVariantPointervEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVariantPointervEXT__II_3_3Z (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glGetVariantPointervEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVariantPointervEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetVariantPointervEXT__II_3_3J (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jlongArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jlong *ptr2 = NULL;
+
+ if ( disp__glGetVariantPointervEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetVariantPointervEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLvoid **) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetInvariantBooleanvEXT ( GLuint , GLenum , GLboolean * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetInvariantBooleanvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glGetInvariantBooleanvEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetInvariantBooleanvEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLboolean *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetInvariantIntegervEXT ( GLuint , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetInvariantIntegervEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetInvariantIntegervEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetInvariantIntegervEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetInvariantFloatvEXT ( GLuint , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetInvariantFloatvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetInvariantFloatvEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetInvariantFloatvEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetLocalConstantBooleanvEXT ( GLuint , GLenum , GLboolean * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetLocalConstantBooleanvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jbooleanArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jboolean *ptr2 = NULL;
+
+ if ( disp__glGetLocalConstantBooleanvEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetLocalConstantBooleanvEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLboolean *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetLocalConstantIntegervEXT ( GLuint , GLenum , GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetLocalConstantIntegervEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jintArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jint *ptr2 = NULL;
+
+ if ( disp__glGetLocalConstantIntegervEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetLocalConstantIntegervEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLint *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glGetLocalConstantFloatvEXT ( GLuint , GLenum , GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glGetLocalConstantFloatvEXT (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jfloatArray arg2)
+ {
+ jboolean isCopiedArray2 = JNI_FALSE;
+ jfloat *ptr2 = NULL;
+
+ if ( disp__glGetLocalConstantFloatvEXT == NULL ) return;
+
+ if(arg2!=NULL)
+ {
+ ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg2, &isCopiedArray2);
+ }
+ disp__glGetLocalConstantFloatvEXT (
+ (GLuint) arg0,
+ (GLenum) arg1,
+ (GLfloat *) ptr2
+ );
+
+ if(arg2!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg2, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream1s ( GLenum , GLshort ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream1s (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshort arg1)
+ {
+
+ if ( disp__glVertexStream1s == NULL ) return;
+
+ disp__glVertexStream1s (
+ (GLenum) arg0,
+ (GLshort) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream1sv ( GLenum , const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream1sv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glVertexStream1sv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexStream1sv (
+ (GLenum) arg0,
+ (const GLshort *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream1i ( GLenum , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream1i (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+
+ if ( disp__glVertexStream1i == NULL ) return;
+
+ disp__glVertexStream1i (
+ (GLenum) arg0,
+ (GLint) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream1iv ( GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream1iv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glVertexStream1iv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexStream1iv (
+ (GLenum) arg0,
+ (const GLint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream1f ( GLenum , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream1f (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1)
+ {
+
+ if ( disp__glVertexStream1f == NULL ) return;
+
+ disp__glVertexStream1f (
+ (GLenum) arg0,
+ (GLfloat) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream1fv ( GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream1fv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glVertexStream1fv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexStream1fv (
+ (GLenum) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream1d ( GLenum , GLdouble ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream1d (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdouble arg1)
+ {
+
+ if ( disp__glVertexStream1d == NULL ) return;
+
+ disp__glVertexStream1d (
+ (GLenum) arg0,
+ (GLdouble) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream1dv ( GLenum , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream1dv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdoubleArray arg1)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glVertexStream1dv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexStream1dv (
+ (GLenum) arg0,
+ (const GLdouble *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream2s ( GLenum , GLshort , GLshort ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream2s (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshort arg1,
+ jshort arg2)
+ {
+
+ if ( disp__glVertexStream2s == NULL ) return;
+
+ disp__glVertexStream2s (
+ (GLenum) arg0,
+ (GLshort) arg1,
+ (GLshort) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream2sv ( GLenum , const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream2sv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glVertexStream2sv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexStream2sv (
+ (GLenum) arg0,
+ (const GLshort *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream2i ( GLenum , GLint , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream2i (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2)
+ {
+
+ if ( disp__glVertexStream2i == NULL ) return;
+
+ disp__glVertexStream2i (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream2iv ( GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream2iv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glVertexStream2iv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexStream2iv (
+ (GLenum) arg0,
+ (const GLint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream2f ( GLenum , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream2f (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1,
+ jfloat arg2)
+ {
+
+ if ( disp__glVertexStream2f == NULL ) return;
+
+ disp__glVertexStream2f (
+ (GLenum) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream2fv ( GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream2fv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glVertexStream2fv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexStream2fv (
+ (GLenum) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream2d ( GLenum , GLdouble , GLdouble ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream2d (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdouble arg1,
+ jdouble arg2)
+ {
+
+ if ( disp__glVertexStream2d == NULL ) return;
+
+ disp__glVertexStream2d (
+ (GLenum) arg0,
+ (GLdouble) arg1,
+ (GLdouble) arg2
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream2dv ( GLenum , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream2dv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdoubleArray arg1)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glVertexStream2dv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexStream2dv (
+ (GLenum) arg0,
+ (const GLdouble *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream3s ( GLenum , GLshort , GLshort , GLshort ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream3s (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshort arg1,
+ jshort arg2,
+ jshort arg3)
+ {
+
+ if ( disp__glVertexStream3s == NULL ) return;
+
+ disp__glVertexStream3s (
+ (GLenum) arg0,
+ (GLshort) arg1,
+ (GLshort) arg2,
+ (GLshort) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream3sv ( GLenum , const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream3sv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glVertexStream3sv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexStream3sv (
+ (GLenum) arg0,
+ (const GLshort *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream3i ( GLenum , GLint , GLint , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream3i (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3)
+ {
+
+ if ( disp__glVertexStream3i == NULL ) return;
+
+ disp__glVertexStream3i (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream3iv ( GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream3iv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glVertexStream3iv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexStream3iv (
+ (GLenum) arg0,
+ (const GLint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream3f ( GLenum , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream3f (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3)
+ {
+
+ if ( disp__glVertexStream3f == NULL ) return;
+
+ disp__glVertexStream3f (
+ (GLenum) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream3fv ( GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream3fv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glVertexStream3fv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexStream3fv (
+ (GLenum) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream3d ( GLenum , GLdouble , GLdouble , GLdouble ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream3d (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdouble arg1,
+ jdouble arg2,
+ jdouble arg3)
+ {
+
+ if ( disp__glVertexStream3d == NULL ) return;
+
+ disp__glVertexStream3d (
+ (GLenum) arg0,
+ (GLdouble) arg1,
+ (GLdouble) arg2,
+ (GLdouble) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream3dv ( GLenum , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream3dv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdoubleArray arg1)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glVertexStream3dv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexStream3dv (
+ (GLenum) arg0,
+ (const GLdouble *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream4s ( GLenum , GLshort , GLshort , GLshort , GLshort ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream4s (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshort arg1,
+ jshort arg2,
+ jshort arg3,
+ jshort arg4)
+ {
+
+ if ( disp__glVertexStream4s == NULL ) return;
+
+ disp__glVertexStream4s (
+ (GLenum) arg0,
+ (GLshort) arg1,
+ (GLshort) arg2,
+ (GLshort) arg3,
+ (GLshort) arg4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream4sv ( GLenum , const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream4sv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glVertexStream4sv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexStream4sv (
+ (GLenum) arg0,
+ (const GLshort *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream4i ( GLenum , GLint , GLint , GLint , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream4i (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3,
+ jint arg4)
+ {
+
+ if ( disp__glVertexStream4i == NULL ) return;
+
+ disp__glVertexStream4i (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3,
+ (GLint) arg4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream4iv ( GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream4iv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glVertexStream4iv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexStream4iv (
+ (GLenum) arg0,
+ (const GLint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream4f ( GLenum , GLfloat , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream4f (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3,
+ jfloat arg4)
+ {
+
+ if ( disp__glVertexStream4f == NULL ) return;
+
+ disp__glVertexStream4f (
+ (GLenum) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3,
+ (GLfloat) arg4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream4fv ( GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream4fv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glVertexStream4fv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexStream4fv (
+ (GLenum) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream4d ( GLenum , GLdouble , GLdouble , GLdouble , GLdouble ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream4d (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdouble arg1,
+ jdouble arg2,
+ jdouble arg3,
+ jdouble arg4)
+ {
+
+ if ( disp__glVertexStream4d == NULL ) return;
+
+ disp__glVertexStream4d (
+ (GLenum) arg0,
+ (GLdouble) arg1,
+ (GLdouble) arg2,
+ (GLdouble) arg3,
+ (GLdouble) arg4
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexStream4dv ( GLenum , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexStream4dv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdoubleArray arg1)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glVertexStream4dv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glVertexStream4dv (
+ (GLenum) arg0,
+ (const GLdouble *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormalStream3b ( GLenum , GLbyte , GLbyte , GLbyte ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalStream3b (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbyte arg1,
+ jbyte arg2,
+ jbyte arg3)
+ {
+
+ if ( disp__glNormalStream3b == NULL ) return;
+
+ disp__glNormalStream3b (
+ (GLenum) arg0,
+ (GLbyte) arg1,
+ (GLbyte) arg2,
+ (GLbyte) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormalStream3bv ( GLenum , const GLbyte * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalStream3bv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jbyteArray arg1)
+ {
+ jbyte *ptr1 = NULL;
+
+ if ( disp__glNormalStream3bv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glNormalStream3bv (
+ (GLenum) arg0,
+ (const GLbyte *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormalStream3s ( GLenum , GLshort , GLshort , GLshort ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalStream3s (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshort arg1,
+ jshort arg2,
+ jshort arg3)
+ {
+
+ if ( disp__glNormalStream3s == NULL ) return;
+
+ disp__glNormalStream3s (
+ (GLenum) arg0,
+ (GLshort) arg1,
+ (GLshort) arg2,
+ (GLshort) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormalStream3sv ( GLenum , const GLshort * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalStream3sv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jshortArray arg1)
+ {
+ jshort *ptr1 = NULL;
+
+ if ( disp__glNormalStream3sv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glNormalStream3sv (
+ (GLenum) arg0,
+ (const GLshort *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormalStream3i ( GLenum , GLint , GLint , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalStream3i (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1,
+ jint arg2,
+ jint arg3)
+ {
+
+ if ( disp__glNormalStream3i == NULL ) return;
+
+ disp__glNormalStream3i (
+ (GLenum) arg0,
+ (GLint) arg1,
+ (GLint) arg2,
+ (GLint) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormalStream3iv ( GLenum , const GLint * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalStream3iv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jintArray arg1)
+ {
+ jint *ptr1 = NULL;
+
+ if ( disp__glNormalStream3iv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glNormalStream3iv (
+ (GLenum) arg0,
+ (const GLint *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormalStream3f ( GLenum , GLfloat , GLfloat , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalStream3f (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1,
+ jfloat arg2,
+ jfloat arg3)
+ {
+
+ if ( disp__glNormalStream3f == NULL ) return;
+
+ disp__glNormalStream3f (
+ (GLenum) arg0,
+ (GLfloat) arg1,
+ (GLfloat) arg2,
+ (GLfloat) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormalStream3fv ( GLenum , const GLfloat * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalStream3fv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloatArray arg1)
+ {
+ jfloat *ptr1 = NULL;
+
+ if ( disp__glNormalStream3fv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glNormalStream3fv (
+ (GLenum) arg0,
+ (const GLfloat *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormalStream3d ( GLenum , GLdouble , GLdouble , GLdouble ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalStream3d (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdouble arg1,
+ jdouble arg2,
+ jdouble arg3)
+ {
+
+ if ( disp__glNormalStream3d == NULL ) return;
+
+ disp__glNormalStream3d (
+ (GLenum) arg0,
+ (GLdouble) arg1,
+ (GLdouble) arg2,
+ (GLdouble) arg3
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glNormalStream3dv ( GLenum , const GLdouble * ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glNormalStream3dv (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jdoubleArray arg1)
+ {
+ jdouble *ptr1 = NULL;
+
+ if ( disp__glNormalStream3dv == NULL ) return;
+
+ if(arg1!=NULL)
+ {
+ ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, arg1, 0);
+ }
+ disp__glNormalStream3dv (
+ (GLenum) arg0,
+ (const GLdouble *) ptr1
+ );
+
+ if(arg1!=NULL)
+ {
+ (*env)->ReleasePrimitiveArrayCritical(env, arg1, ptr1, JNI_ABORT);
+ }
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glClientActiveVertexStream ( GLenum ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glClientActiveVertexStream (
+ JNIEnv *env, jobject obj,
+ jint arg0)
+ {
+
+ if ( disp__glClientActiveVertexStream == NULL ) return;
+
+ disp__glClientActiveVertexStream (
+ (GLenum) arg0
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexBlendEnvi ( GLenum , GLint ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexBlendEnvi (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jint arg1)
+ {
+
+ if ( disp__glVertexBlendEnvi == NULL ) return;
+
+ disp__glVertexBlendEnvi (
+ (GLenum) arg0,
+ (GLint) arg1
+ );
+
+ }
+
+/**
+ * Original Function-Prototype :
+ * <pre>
+ extern void glVertexBlendEnvf ( GLenum , GLfloat ) ;
+ * </pre>
+ */
+ JNIEXPORT void JNICALL
+ Java_gl4java_GLFunc14JauJNI_glVertexBlendEnvf (
+ JNIEnv *env, jobject obj,
+ jint arg0,
+ jfloat arg1)
+ {
+
+ if ( disp__glVertexBlendEnvf == NULL ) return;
+
+ disp__glVertexBlendEnvf (
+ (GLenum) arg0,
+ (GLfloat) arg1
+ );
+
+ }
+
+/* C2J Parser Version 3.0: Java program parsed successfully. */
diff --git a/CNativeCode/OpenGL_funcs14.c.skel b/CNativeCode/OpenGL_funcs14.c.skel
new file mode 100644
index 0000000..4038cb5
--- /dev/null
+++ b/CNativeCode/OpenGL_funcs14.c.skel
@@ -0,0 +1,44 @@
+/*
+ * Leo Chan -- 1995
+ * [email protected]
+ *
+ * This mammoth C file takes care of all the native implementation for the
+ * bulk of OpenGL commands
+ * ---------------
+ *
+ * Sven Goethel
+ *
+ * September 1997
+ */
+
+/*
+ * need to include the JAVA internal header files for macros and function
+ * prototypes required to maipulated JAVA data structures and functions
+ *
+ * StubPreamble.h includes the structure and macro definitions neede to
+ * convert JAVA data structures into C data structures.
+ *
+ */
+
+#include "OpenGL_misc.h"
+
+/*
+ * the next thing to include are special headers that were created by
+ * JAVAH. They include the C structure definitions for the JAVA classes
+ */
+#include "gl4java_GLFunc14JauJNI.h"
+
+/*--------------------------------------------------------------------------
+ * here on in is just regular apple pie C
+ */
+
+#ifndef LIBAPIENTRY
+ #define LIBAPIENTRY
+#endif
+#ifndef LIBAPI
+ #define LIBAPI
+#endif
+
+#ifndef CALLBACK
+ #define CALLBACK
+#endif
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-01 05:59:27 +0000