From 4c7204560056fe3bb0289c64020cbb9df17a757b Mon Sep 17 00:00:00 2001 From: Sven Gothel Date: Sat, 13 Apr 2002 04:31:11 +0000 Subject: Merged the Tesselation patch by Pepijn Van Eeckhoudt . I have added minor cleanups .. to it. --- CNativeCode/OpenGLU_JauJNI_funcs.c | 3799 ++++++++++++++++++------------------ 1 file changed, 1876 insertions(+), 1923 deletions(-) (limited to 'CNativeCode/OpenGLU_JauJNI_funcs.c') diff --git a/CNativeCode/OpenGLU_JauJNI_funcs.c b/CNativeCode/OpenGLU_JauJNI_funcs.c index 89418db..9bc474c 100644 --- a/CNativeCode/OpenGLU_JauJNI_funcs.c +++ b/CNativeCode/OpenGLU_JauJNI_funcs.c @@ -33,7 +33,7 @@ * herein lies the native JAVA methods for the OpenGL functions. */ -static const char _glu_n_a_string[] = "GLU-String not avaiable !"; +static const char _glu_n_a_string[] = "GLU-String not available !"; JNIEXPORT jstring JNICALL Java_gl4java_GLUFuncJauJNI_gluErrorString ( JNIEnv *env, jobject obj, @@ -68,7 +68,7 @@ Java_gl4java_GLUFuncJauJNI_gluGetString ( JNIEnv *env, jobject obj, } static const char * _glu_lib_vendor_="Jausoft - Sven Goethel Software Development"; -static const char * _glu_lib_version_="2.8.1.0"; +static const char * _glu_lib_version_="2.8.3.0"; JNIEXPORT jstring JNICALL Java_gl4java_GLUFuncJauJNI_getNativeVendor ( JNIEnv *env, jobject obj ) @@ -300,29 +300,24 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) 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_GLUFuncJauJNI ! - */ +#include "MemoryManager.h" /** * Original Function-Prototype : * 
 
-   extern void gluBeginCurve ( GLUnurbs * nurb ) ;
+   extern void gluTessBeginContour ( GLUtesselator * tess ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluBeginCurve ( + Java_gl4java_GLUFuncJauJNI_gluTessBeginContour ( JNIEnv *env, jobject obj, - jlong nurb) + jlong tess) { - if ( disp__gluBeginCurve == NULL ) return; - - disp__gluBeginCurve ( - (GLUnurbs *) (PointerHolder) nurb + if ( disp__gluTessBeginContour == NULL ) return; + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessBeginContour ( + (GLUtesselator *) (PointerHolder) tess ); } @@ -330,1073 +325,1133 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) /** * Original Function-Prototype : * 
 
-   extern void gluBeginPolygon ( GLUtesselator * tess ) ;
+   extern void gluTessBeginPolygon ( GLUtesselator * tess , GLvoid * data ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluBeginPolygon ( + Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3B ( JNIEnv *env, jobject obj, - jlong tess) + jlong tess, + jbyteArray data) { + jboolean isCopiedArray1 = JNI_FALSE; + jbyte *ptr1 = NULL; - if ( disp__gluBeginPolygon == NULL ) return; + if ( disp__gluTessBeginPolygon == NULL ) return; - disp__gluBeginPolygon ( - (GLUtesselator *) (PointerHolder) tess + if(data!=NULL) + { + ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray1); + } + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessBeginPolygon ( + (GLUtesselator *) (PointerHolder) tess, + (GLvoid *) ptr1 ); + if(data!=NULL) + { + (*env)->ReleasePrimitiveArrayCritical(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); + } } - -/** - * Original Function-Prototype : - * 
 
-   extern void gluBeginSurface ( GLUnurbs * nurb ) ;
- *
- */ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluBeginSurface ( + Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3S ( JNIEnv *env, jobject obj, - jlong nurb) + jlong tess, + jshortArray data) { + jboolean isCopiedArray1 = JNI_FALSE; + jshort *ptr1 = NULL; - if ( disp__gluBeginSurface == NULL ) return; + if ( disp__gluTessBeginPolygon == NULL ) return; - disp__gluBeginSurface ( - (GLUnurbs *) (PointerHolder) nurb + if(data!=NULL) + { + ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray1); + } + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessBeginPolygon ( + (GLUtesselator *) (PointerHolder) tess, + (GLvoid *) ptr1 ); + if(data!=NULL) + { + (*env)->ReleasePrimitiveArrayCritical(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); + } } - -/** - * Original Function-Prototype : - * 
 
-   extern void gluBeginTrim ( GLUnurbs * nurb ) ;
- *
- */ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluBeginTrim ( + Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3I ( JNIEnv *env, jobject obj, - jlong nurb) + jlong tess, + jintArray data) { + jboolean isCopiedArray1 = JNI_FALSE; + jint *ptr1 = NULL; - if ( disp__gluBeginTrim == NULL ) return; + if ( disp__gluTessBeginPolygon == NULL ) return; - disp__gluBeginTrim ( - (GLUnurbs *) (PointerHolder) nurb + if(data!=NULL) + { + ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray1); + } + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessBeginPolygon ( + (GLUtesselator *) (PointerHolder) tess, + (GLvoid *) ptr1 ); + if(data!=NULL) + { + (*env)->ReleasePrimitiveArrayCritical(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); + } } - -/** - * Original Function-Prototype : - * 
 
-   extern GLint gluBuild1DMipmapLevels ( GLenum target , GLint internalFormat , GLsizei width , GLenum format , GLenum type , GLint level , GLint base , GLint max , const void * data ) ;
- *
- */ - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3B ( + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3F ( JNIEnv *env, jobject obj, - jint target, - jint internalFormat, - jint width, - jint format, - jint type, - jint level, - jint base, - jint max, - jbyteArray data) + jlong tess, + jfloatArray data) { - jint ret; - - jbyte *ptr8 = NULL; + jboolean isCopiedArray1 = JNI_FALSE; + jfloat *ptr1 = NULL; - if ( disp__gluBuild1DMipmapLevels == NULL ) return 0; + if ( disp__gluTessBeginPolygon == NULL ) return; if(data!=NULL) { - ptr8 = (*env)->GetByteArrayElements(env, data, 0); + ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray1); } - ret = (jint) disp__gluBuild1DMipmapLevels ( - (GLenum) target, - (GLint) internalFormat, - (GLsizei) width, - (GLenum) format, - (GLenum) type, - (GLint) level, - (GLint) base, - (GLint) max, - (const void *) ptr8 + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessBeginPolygon ( + (GLUtesselator *) (PointerHolder) tess, + (GLvoid *) ptr1 ); if(data!=NULL) { - (*env)->ReleaseByteArrayElements(env, data, ptr8, JNI_ABORT); + (*env)->ReleasePrimitiveArrayCritical(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); } - return ret; } - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3S ( + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3D ( JNIEnv *env, jobject obj, - jint target, - jint internalFormat, - jint width, - jint format, - jint type, - jint level, - jint base, - jint max, - jshortArray data) + jlong tess, + jdoubleArray data) { - jint ret; - - jshort *ptr8 = NULL; + jboolean isCopiedArray1 = JNI_FALSE; + jdouble *ptr1 = NULL; - if ( disp__gluBuild1DMipmapLevels == NULL ) return 0; + if ( disp__gluTessBeginPolygon == NULL ) return; if(data!=NULL) { - ptr8 = (*env)->GetShortArrayElements(env, data, 0); + ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray1); } - ret = (jint) disp__gluBuild1DMipmapLevels ( - (GLenum) target, - (GLint) internalFormat, - (GLsizei) width, - (GLenum) format, - (GLenum) type, - (GLint) level, - (GLint) base, - (GLint) max, - (const void *) ptr8 + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessBeginPolygon ( + (GLUtesselator *) (PointerHolder) tess, + (GLvoid *) ptr1 ); if(data!=NULL) { - (*env)->ReleaseShortArrayElements(env, data, ptr8, JNI_ABORT); + (*env)->ReleasePrimitiveArrayCritical(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); } - return ret; } - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3I ( + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3Z ( JNIEnv *env, jobject obj, - jint target, - jint internalFormat, - jint width, - jint format, - jint type, - jint level, - jint base, - jint max, - jintArray data) + jlong tess, + jbooleanArray data) { - jint ret; - - jint *ptr8 = NULL; + jboolean isCopiedArray1 = JNI_FALSE; + jboolean *ptr1 = NULL; - if ( disp__gluBuild1DMipmapLevels == NULL ) return 0; + if ( disp__gluTessBeginPolygon == NULL ) return; if(data!=NULL) { - ptr8 = (*env)->GetIntArrayElements(env, data, 0); + ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray1); } - ret = (jint) disp__gluBuild1DMipmapLevels ( - (GLenum) target, - (GLint) internalFormat, - (GLsizei) width, - (GLenum) format, - (GLenum) type, - (GLint) level, - (GLint) base, - (GLint) max, - (const void *) ptr8 + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessBeginPolygon ( + (GLUtesselator *) (PointerHolder) tess, + (GLvoid *) ptr1 ); if(data!=NULL) { - (*env)->ReleaseIntArrayElements(env, data, ptr8, JNI_ABORT); + (*env)->ReleasePrimitiveArrayCritical(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); } - return ret; } - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3F ( + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3J ( JNIEnv *env, jobject obj, - jint target, - jint internalFormat, - jint width, - jint format, - jint type, - jint level, - jint base, - jint max, - jfloatArray data) + jlong tess, + jlongArray data) { - jint ret; - - jfloat *ptr8 = NULL; + jboolean isCopiedArray1 = JNI_FALSE; + jlong *ptr1 = NULL; - if ( disp__gluBuild1DMipmapLevels == NULL ) return 0; + if ( disp__gluTessBeginPolygon == NULL ) return; if(data!=NULL) { - ptr8 = (*env)->GetFloatArrayElements(env, data, 0); + ptr1 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray1); } - ret = (jint) disp__gluBuild1DMipmapLevels ( - (GLenum) target, - (GLint) internalFormat, - (GLsizei) width, - (GLenum) format, - (GLenum) type, - (GLint) level, - (GLint) base, - (GLint) max, - (const void *) ptr8 + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessBeginPolygon ( + (GLUtesselator *) (PointerHolder) tess, + (GLvoid *) ptr1 ); if(data!=NULL) { - (*env)->ReleaseFloatArrayElements(env, data, ptr8, JNI_ABORT); + (*env)->ReleasePrimitiveArrayCritical(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); } - return ret; } - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3D ( + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessEndContour ( GLUtesselator * tess ) ;
+ *
+ */ + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluTessEndContour ( JNIEnv *env, jobject obj, - jint target, - jint internalFormat, - jint width, - jint format, - jint type, - jint level, - jint base, - jint max, - jdoubleArray data) + jlong tess) { - jint ret; - - jdouble *ptr8 = NULL; - - if ( disp__gluBuild1DMipmapLevels == NULL ) return 0; - if(data!=NULL) - { - ptr8 = (*env)->GetDoubleArrayElements(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 ( disp__gluTessEndContour == NULL ) return; + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessEndContour ( + (GLUtesselator *) (PointerHolder) tess ); - if(data!=NULL) - { - (*env)->ReleaseDoubleArrayElements(env, data, ptr8, JNI_ABORT); - } - return ret; } - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3Z ( + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessEndPolygon ( GLUtesselator * tess ) ;
+ *
+ */ + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluTessEndPolygon ( JNIEnv *env, jobject obj, - jint target, - jint internalFormat, - jint width, - jint format, - jint type, - jint level, - jint base, - jint max, - jbooleanArray data) + jlong tess) { - jint ret; - - jboolean *ptr8 = NULL; - - if ( disp__gluBuild1DMipmapLevels == NULL ) return 0; - if(data!=NULL) - { - ptr8 = (*env)->GetBooleanArrayElements(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 ( disp__gluTessEndPolygon == NULL ) return; + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessEndPolygon ( + (GLUtesselator *) (PointerHolder) tess ); + FreeArrays(env, MEMM_TESSELATOR); - if(data!=NULL) - { - (*env)->ReleaseBooleanArrayElements(env, data, ptr8, JNI_ABORT); - } - return ret; } - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3J ( + +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessNormal ( GLUtesselator * tess , GLdouble valueX , GLdouble valueY , GLdouble valueZ ) ;
+ *
+ */ + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluTessNormal ( JNIEnv *env, jobject obj, - jint target, - jint internalFormat, - jint width, - jint format, - jint type, - jint level, - jint base, - jint max, - jlongArray data) + jlong tess, + jdouble valueX, + jdouble valueY, + jdouble valueZ) { - jint ret; - jlong *ptr8 = NULL; + if ( disp__gluTessNormal == NULL ) return; + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessNormal ( + (GLUtesselator *) (PointerHolder) tess, + (GLdouble) valueX, + (GLdouble) valueY, + (GLdouble) valueZ + ); - if ( disp__gluBuild1DMipmapLevels == NULL ) return 0; + } - if(data!=NULL) - { - ptr8 = (*env)->GetLongArrayElements(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 +/** + * Original Function-Prototype : + * 
 
+   extern void gluTessProperty ( GLUtesselator * tess , GLenum which , GLdouble data ) ;
+ *
+ */ + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluTessProperty ( + JNIEnv *env, jobject obj, + jlong tess, + jint which, + jdouble data) + { + + if ( disp__gluTessProperty == NULL ) return; + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessProperty ( + (GLUtesselator *) (PointerHolder) tess, + (GLenum) which, + (GLdouble) data ); - if(data!=NULL) - { - (*env)->ReleaseLongArrayElements(env, data, ptr8, JNI_ABORT); - } - return ret; } /** * Original Function-Prototype : * 
 
-   extern GLint gluBuild1DMipmaps ( GLenum target , GLint internalFormat , GLsizei width , GLenum format , GLenum type , const void * data ) ;
+   extern void gluTessVertex ( GLUtesselator * tess , GLdouble * location , GLvoid * data ) ;
  *
*/ - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3B ( + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3B ( JNIEnv *env, jobject obj, - jint target, - jint internalFormat, - jint width, - jint format, - jint type, + jlong tess, + jdoubleArray location, jbyteArray data) { - jint ret; - - jbyte *ptr5 = NULL; + jdouble *ptr1 = NULL; + jbyte *ptr2 = NULL; - if ( disp__gluBuild1DMipmaps == NULL ) return 0; + if ( disp__gluTessVertex == NULL ) return; - if(data!=NULL) + if(location!=NULL) { - ptr5 = (*env)->GetByteArrayElements(env, data, 0); + ptr1 = (jdouble *) (*env)->GetDoubleArrayElements(env, location, 0); + RegisterArray(env, location, ptr1, T_DOUBLE_ARRAY, MEMM_TESSELATOR); } - ret = (jint) disp__gluBuild1DMipmaps ( - (GLenum) target, - (GLint) internalFormat, - (GLsizei) width, - (GLenum) format, - (GLenum) type, - (const void *) ptr5 - ); - if(data!=NULL) { - (*env)->ReleaseByteArrayElements(env, data, ptr5, JNI_ABORT); + ptr2 = (jbyte *) (*env)->GetByteArrayElements(env, data, 0); + RegisterArray(env, data, ptr2, T_BYTE_ARRAY, MEMM_TESSELATOR); } - return ret; + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessVertex ( + (GLUtesselator *) (PointerHolder) tess, + (GLdouble *) ptr1, + (GLvoid *) ptr2 + ); } - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3S ( + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3S ( JNIEnv *env, jobject obj, - jint target, - jint internalFormat, - jint width, - jint format, - jint type, + jlong tess, + jdoubleArray location, jshortArray data) { - jint ret; - - jshort *ptr5 = NULL; + jdouble *ptr1 = NULL; + jshort *ptr2 = NULL; - if ( disp__gluBuild1DMipmaps == NULL ) return 0; + if ( disp__gluTessVertex == NULL ) return; - if(data!=NULL) + if(location!=NULL) { - ptr5 = (*env)->GetShortArrayElements(env, data, 0); + ptr1 = (jdouble *) (*env)->GetDoubleArrayElements(env, location, 0); + RegisterArray(env, location, ptr1, T_DOUBLE_ARRAY, MEMM_TESSELATOR); } - ret = (jint) disp__gluBuild1DMipmaps ( - (GLenum) target, - (GLint) internalFormat, - (GLsizei) width, - (GLenum) format, - (GLenum) type, - (const void *) ptr5 - ); - if(data!=NULL) { - (*env)->ReleaseShortArrayElements(env, data, ptr5, JNI_ABORT); + ptr2 = (jshort *) (*env)->GetShortArrayElements(env, data, 0); + RegisterArray(env, data, ptr2, T_SHORT_ARRAY, MEMM_TESSELATOR); } - return ret; + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessVertex ( + (GLUtesselator *) (PointerHolder) tess, + (GLdouble *) ptr1, + (GLvoid *) ptr2 + ); } - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3I ( + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3I ( JNIEnv *env, jobject obj, - jint target, - jint internalFormat, - jint width, - jint format, - jint type, + jlong tess, + jdoubleArray location, jintArray data) { - jint ret; - - jint *ptr5 = NULL; + jdouble *ptr1 = NULL; + jint *ptr2 = NULL; - if ( disp__gluBuild1DMipmaps == NULL ) return 0; + if ( disp__gluTessVertex == NULL ) return; + if(location!=NULL) + { + ptr1 = (jdouble *) (*env)->GetDoubleArrayElements(env, location, 0); + RegisterArray(env, location, ptr1, T_DOUBLE_ARRAY, MEMM_TESSELATOR); + } if(data!=NULL) { - ptr5 = (*env)->GetIntArrayElements(env, data, 0); + ptr2 = (jint *) (*env)->GetIntArrayElements(env, data, 0); + RegisterArray(env, data, ptr2, T_INT_ARRAY, MEMM_TESSELATOR); } - ret = (jint) disp__gluBuild1DMipmaps ( - (GLenum) target, - (GLint) internalFormat, - (GLsizei) width, - (GLenum) format, - (GLenum) type, - (const void *) ptr5 + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessVertex ( + (GLUtesselator *) (PointerHolder) tess, + (GLdouble *) ptr1, + (GLvoid *) ptr2 ); + } + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3F ( + JNIEnv *env, jobject obj, + jlong tess, + jdoubleArray location, + jfloatArray data) + { + jdouble *ptr1 = NULL; + jfloat *ptr2 = NULL; + + if ( disp__gluTessVertex == NULL ) return; + if(location!=NULL) + { + ptr1 = (jdouble *) (*env)->GetDoubleArrayElements(env, location, 0); + RegisterArray(env, location, ptr1, T_DOUBLE_ARRAY, MEMM_TESSELATOR); + } if(data!=NULL) { - (*env)->ReleaseIntArrayElements(env, data, ptr5, JNI_ABORT); + ptr2 = (jfloat *) (*env)->GetFloatArrayElements(env, data, 0); + RegisterArray(env, data, ptr2, T_FLOAT_ARRAY, MEMM_TESSELATOR); } - return ret; + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessVertex ( + (GLUtesselator *) (PointerHolder) tess, + (GLdouble *) ptr1, + (GLvoid *) ptr2 + ); } - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3F ( + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3D ( JNIEnv *env, jobject obj, - jint target, - jint internalFormat, - jint width, - jint format, - jint type, - jfloatArray data) + jlong tess, + jdoubleArray location, + jdoubleArray data) { - jint ret; + jdouble *ptr1 = NULL; + jdouble *ptr2 = NULL; - jfloat *ptr5 = NULL; + if ( disp__gluTessVertex == NULL ) return; - if ( disp__gluBuild1DMipmaps == NULL ) return 0; + if(location!=NULL) + { + ptr1 = (jdouble *) (*env)->GetDoubleArrayElements(env, location, 0); + RegisterArray(env, location, ptr1, T_DOUBLE_ARRAY, MEMM_TESSELATOR); + } + if(data!=NULL) + { + ptr2 = (jdouble *) (*env)->GetDoubleArrayElements(env, data, 0); + RegisterArray(env, data, ptr2, T_DOUBLE_ARRAY, MEMM_TESSELATOR); + } + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessVertex ( + (GLUtesselator *) (PointerHolder) tess, + (GLdouble *) ptr1, + (GLvoid *) ptr2 + ); + } + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3Z ( + JNIEnv *env, jobject obj, + jlong tess, + jdoubleArray location, + jbooleanArray data) + { + jdouble *ptr1 = NULL; + jboolean *ptr2 = NULL; + + if ( disp__gluTessVertex == NULL ) return; + if(location!=NULL) + { + ptr1 = (jdouble *) (*env)->GetDoubleArrayElements(env, location, 0); + RegisterArray(env, location, ptr1, T_DOUBLE_ARRAY, MEMM_TESSELATOR); + } if(data!=NULL) { - ptr5 = (*env)->GetFloatArrayElements(env, data, 0); + ptr2 = (jboolean *) (*env)->GetBooleanArrayElements(env, data, 0); + RegisterArray(env, data, ptr2, T_BOOLEAN_ARRAY, MEMM_TESSELATOR); } - ret = (jint) disp__gluBuild1DMipmaps ( - (GLenum) target, - (GLint) internalFormat, - (GLsizei) width, - (GLenum) format, - (GLenum) type, - (const void *) ptr5 + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessVertex ( + (GLUtesselator *) (PointerHolder) tess, + (GLdouble *) ptr1, + (GLvoid *) ptr2 ); + } + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3J ( + JNIEnv *env, jobject obj, + jlong tess, + jdoubleArray location, + jlongArray data) + { + jdouble *ptr1 = NULL; + jlong *ptr2 = NULL; + + if ( disp__gluTessVertex == NULL ) return; + if(location!=NULL) + { + ptr1 = (jdouble *) (*env)->GetDoubleArrayElements(env, location, 0); + RegisterArray(env, location, ptr1, T_DOUBLE_ARRAY, MEMM_TESSELATOR); + } if(data!=NULL) { - (*env)->ReleaseFloatArrayElements(env, data, ptr5, JNI_ABORT); + ptr2 = (jlong *) (*env)->GetLongArrayElements(env, data, 0); + RegisterArray(env, data, ptr2, T_LONG_ARRAY, MEMM_TESSELATOR); } - return ret; + SetCurrentCallbackObject((void *) (PointerHolder) tess); + disp__gluTessVertex ( + (GLUtesselator *) (PointerHolder) tess, + (GLdouble *) ptr1, + (GLvoid *) ptr2 + ); + } +/** + * C2J Parser Version 3.0 + * Jausoft - Sven Goethel Software Development + * Reading from file: glu-proto-auto.orig.h . . . + * Destination-Class: gl4java_GLUFuncJauJNI ! + */ + +/** + * Original Function-Prototype : + * 
 
+   extern void gluBeginCurve ( GLUnurbs * nurb ) ;
+ *
+ */ + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluBeginCurve ( + JNIEnv *env, jobject obj, + jlong nurb) + { + + if ( disp__gluBeginCurve == NULL ) return; + + disp__gluBeginCurve ( + (GLUnurbs *) (PointerHolder) nurb + ); + + } + +/** + * Original Function-Prototype : + * 
 
+   extern void gluBeginPolygon ( GLUtesselator * tess ) ;
+ *
+ */ + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluBeginPolygon ( + JNIEnv *env, jobject obj, + jlong tess) + { + + if ( disp__gluBeginPolygon == NULL ) return; + + disp__gluBeginPolygon ( + (GLUtesselator *) (PointerHolder) tess + ); + + } + +/** + * Original Function-Prototype : + * 
 
+   extern void gluBeginSurface ( GLUnurbs * nurb ) ;
+ *
+ */ + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluBeginSurface ( + JNIEnv *env, jobject obj, + jlong nurb) + { + + if ( disp__gluBeginSurface == NULL ) return; + + disp__gluBeginSurface ( + (GLUnurbs *) (PointerHolder) nurb + ); + + } + +/** + * Original Function-Prototype : + * 
 
+   extern void gluBeginTrim ( GLUnurbs * nurb ) ;
+ *
+ */ + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluBeginTrim ( + JNIEnv *env, jobject obj, + jlong nurb) + { + + if ( disp__gluBeginTrim == NULL ) return; + + disp__gluBeginTrim ( + (GLUnurbs *) (PointerHolder) nurb + ); + } + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluBuild1DMipmapLevels ( GLenum target , GLint internalFormat , GLsizei width , GLenum format , GLenum type , GLint level , GLint base , GLint max , const void * data ) ;
+ *
+ */ JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3D ( + Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3B ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, jint format, jint type, - jdoubleArray data) + jint level, + jint base, + jint max, + jbyteArray data) { jint ret; - jdouble *ptr5 = NULL; + jbyte *ptr8 = NULL; - if ( disp__gluBuild1DMipmaps == NULL ) return 0; + if ( disp__gluBuild1DMipmapLevels == NULL ) return 0; if(data!=NULL) { - ptr5 = (*env)->GetDoubleArrayElements(env, data, 0); + ptr8 = (*env)->GetByteArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild1DMipmaps ( + ret = (jint) disp__gluBuild1DMipmapLevels ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLenum) format, (GLenum) type, - (const void *) ptr5 + (GLint) level, + (GLint) base, + (GLint) max, + (const void *) ptr8 ); if(data!=NULL) { - (*env)->ReleaseDoubleArrayElements(env, data, ptr5, JNI_ABORT); + (*env)->ReleaseByteArrayElements(env, data, ptr8, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3Z ( + Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3S ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, jint format, jint type, - jbooleanArray data) + jint level, + jint base, + jint max, + jshortArray data) { jint ret; - jboolean *ptr5 = NULL; + jshort *ptr8 = NULL; - if ( disp__gluBuild1DMipmaps == NULL ) return 0; + if ( disp__gluBuild1DMipmapLevels == NULL ) return 0; if(data!=NULL) { - ptr5 = (*env)->GetBooleanArrayElements(env, data, 0); + ptr8 = (*env)->GetShortArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild1DMipmaps ( + ret = (jint) disp__gluBuild1DMipmapLevels ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLenum) format, (GLenum) type, - (const void *) ptr5 + (GLint) level, + (GLint) base, + (GLint) max, + (const void *) ptr8 ); if(data!=NULL) { - (*env)->ReleaseBooleanArrayElements(env, data, ptr5, JNI_ABORT); + (*env)->ReleaseShortArrayElements(env, data, ptr8, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3J ( + Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3I ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, jint format, jint type, - jlongArray data) + jint level, + jint base, + jint max, + jintArray data) { jint ret; - jlong *ptr5 = NULL; + jint *ptr8 = NULL; - if ( disp__gluBuild1DMipmaps == NULL ) return 0; + if ( disp__gluBuild1DMipmapLevels == NULL ) return 0; if(data!=NULL) { - ptr5 = (*env)->GetLongArrayElements(env, data, 0); + ptr8 = (*env)->GetIntArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild1DMipmaps ( + ret = (jint) disp__gluBuild1DMipmapLevels ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLenum) format, (GLenum) type, - (const void *) ptr5 + (GLint) level, + (GLint) base, + (GLint) max, + (const void *) ptr8 ); if(data!=NULL) { - (*env)->ReleaseLongArrayElements(env, data, ptr5, JNI_ABORT); + (*env)->ReleaseIntArrayElements(env, data, ptr8, JNI_ABORT); } return ret; } - -/** - * Original Function-Prototype : - * 
 
-   extern GLint gluBuild2DMipmapLevels ( GLenum target , GLint internalFormat , GLsizei width , GLsizei height , GLenum format , GLenum type , GLint level , GLint base , GLint max , const void * data ) ;
- *
- */ JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3B ( + Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3F ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, - jint height, jint format, jint type, jint level, jint base, jint max, - jbyteArray data) + jfloatArray data) { jint ret; - jbyte *ptr9 = NULL; + jfloat *ptr8 = NULL; - if ( disp__gluBuild2DMipmapLevels == NULL ) return 0; + if ( disp__gluBuild1DMipmapLevels == NULL ) return 0; if(data!=NULL) { - ptr9 = (*env)->GetByteArrayElements(env, data, 0); + ptr8 = (*env)->GetFloatArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild2DMipmapLevels ( + ret = (jint) disp__gluBuild1DMipmapLevels ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, - (GLsizei) height, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, - (const void *) ptr9 + (const void *) ptr8 ); if(data!=NULL) { - (*env)->ReleaseByteArrayElements(env, data, ptr9, JNI_ABORT); + (*env)->ReleaseFloatArrayElements(env, data, ptr8, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3S ( + Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3D ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, - jint height, jint format, jint type, jint level, jint base, jint max, - jshortArray data) + jdoubleArray data) { jint ret; - jshort *ptr9 = NULL; + jdouble *ptr8 = NULL; - if ( disp__gluBuild2DMipmapLevels == NULL ) return 0; + if ( disp__gluBuild1DMipmapLevels == NULL ) return 0; if(data!=NULL) { - ptr9 = (*env)->GetShortArrayElements(env, data, 0); + ptr8 = (*env)->GetDoubleArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild2DMipmapLevels ( + ret = (jint) disp__gluBuild1DMipmapLevels ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, - (GLsizei) height, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, - (const void *) ptr9 + (const void *) ptr8 ); if(data!=NULL) { - (*env)->ReleaseShortArrayElements(env, data, ptr9, JNI_ABORT); + (*env)->ReleaseDoubleArrayElements(env, data, ptr8, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3I ( + Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3Z ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, - jint height, jint format, jint type, jint level, jint base, jint max, - jintArray data) + jbooleanArray data) { jint ret; - jint *ptr9 = NULL; + jboolean *ptr8 = NULL; - if ( disp__gluBuild2DMipmapLevels == NULL ) return 0; + if ( disp__gluBuild1DMipmapLevels == NULL ) return 0; if(data!=NULL) { - ptr9 = (*env)->GetIntArrayElements(env, data, 0); + ptr8 = (*env)->GetBooleanArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild2DMipmapLevels ( + ret = (jint) disp__gluBuild1DMipmapLevels ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, - (GLsizei) height, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, - (const void *) ptr9 + (const void *) ptr8 ); if(data!=NULL) { - (*env)->ReleaseIntArrayElements(env, data, ptr9, JNI_ABORT); + (*env)->ReleaseBooleanArrayElements(env, data, ptr8, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3F ( + Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3J ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, - jint height, jint format, jint type, jint level, jint base, jint max, - jfloatArray data) + jlongArray data) { jint ret; - jfloat *ptr9 = NULL; + jlong *ptr8 = NULL; - if ( disp__gluBuild2DMipmapLevels == NULL ) return 0; + if ( disp__gluBuild1DMipmapLevels == NULL ) return 0; if(data!=NULL) { - ptr9 = (*env)->GetFloatArrayElements(env, data, 0); + ptr8 = (*env)->GetLongArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild2DMipmapLevels ( + ret = (jint) disp__gluBuild1DMipmapLevels ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, - (GLsizei) height, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, - (const void *) ptr9 + (const void *) ptr8 ); if(data!=NULL) { - (*env)->ReleaseFloatArrayElements(env, data, ptr9, JNI_ABORT); + (*env)->ReleaseLongArrayElements(env, data, ptr8, JNI_ABORT); } return ret; } + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluBuild1DMipmaps ( GLenum target , GLint internalFormat , GLsizei width , GLenum format , GLenum type , const void * data ) ;
+ *
+ */ JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3D ( + Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3B ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, - jint height, jint format, jint type, - jint level, - jint base, - jint max, - jdoubleArray data) + jbyteArray data) { jint ret; - jdouble *ptr9 = NULL; + jbyte *ptr5 = NULL; - if ( disp__gluBuild2DMipmapLevels == NULL ) return 0; + if ( disp__gluBuild1DMipmaps == NULL ) return 0; if(data!=NULL) { - ptr9 = (*env)->GetDoubleArrayElements(env, data, 0); + ptr5 = (*env)->GetByteArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild2DMipmapLevels ( + ret = (jint) disp__gluBuild1DMipmaps ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, - (GLsizei) height, (GLenum) format, (GLenum) type, - (GLint) level, - (GLint) base, - (GLint) max, - (const void *) ptr9 + (const void *) ptr5 ); if(data!=NULL) { - (*env)->ReleaseDoubleArrayElements(env, data, ptr9, JNI_ABORT); + (*env)->ReleaseByteArrayElements(env, data, ptr5, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3Z ( + Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3S ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, - jint height, jint format, jint type, - jint level, - jint base, - jint max, - jbooleanArray data) + jshortArray data) { jint ret; - jboolean *ptr9 = NULL; + jshort *ptr5 = NULL; - if ( disp__gluBuild2DMipmapLevels == NULL ) return 0; + if ( disp__gluBuild1DMipmaps == NULL ) return 0; if(data!=NULL) { - ptr9 = (*env)->GetBooleanArrayElements(env, data, 0); + ptr5 = (*env)->GetShortArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild2DMipmapLevels ( + ret = (jint) disp__gluBuild1DMipmaps ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, - (GLsizei) height, (GLenum) format, (GLenum) type, - (GLint) level, - (GLint) base, - (GLint) max, - (const void *) ptr9 + (const void *) ptr5 ); if(data!=NULL) { - (*env)->ReleaseBooleanArrayElements(env, data, ptr9, JNI_ABORT); + (*env)->ReleaseShortArrayElements(env, data, ptr5, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3J ( + Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3I ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, - jint height, jint format, jint type, - jint level, - jint base, - jint max, - jlongArray data) + jintArray data) { jint ret; - jlong *ptr9 = NULL; + jint *ptr5 = NULL; - if ( disp__gluBuild2DMipmapLevels == NULL ) return 0; + if ( disp__gluBuild1DMipmaps == NULL ) return 0; if(data!=NULL) { - ptr9 = (*env)->GetLongArrayElements(env, data, 0); + ptr5 = (*env)->GetIntArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild2DMipmapLevels ( + ret = (jint) disp__gluBuild1DMipmaps ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, - (GLsizei) height, (GLenum) format, (GLenum) type, - (GLint) level, - (GLint) base, - (GLint) max, - (const void *) ptr9 + (const void *) ptr5 ); if(data!=NULL) { - (*env)->ReleaseLongArrayElements(env, data, ptr9, JNI_ABORT); + (*env)->ReleaseIntArrayElements(env, data, ptr5, JNI_ABORT); } return ret; } - -/** - * Original Function-Prototype : - * 
 
-   extern GLint gluBuild2DMipmaps ( GLenum target , GLint internalFormat , GLsizei width , GLsizei height , GLenum format , GLenum type , const void * data ) ;
- *
- */ JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3B ( + Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3F ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, - jint height, jint format, jint type, - jbyteArray data) + jfloatArray data) { jint ret; - jbyte *ptr6 = NULL; + jfloat *ptr5 = NULL; - if ( disp__gluBuild2DMipmaps == NULL ) return 0; + if ( disp__gluBuild1DMipmaps == NULL ) return 0; if(data!=NULL) { - ptr6 = (*env)->GetByteArrayElements(env, data, 0); + ptr5 = (*env)->GetFloatArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild2DMipmaps ( + ret = (jint) disp__gluBuild1DMipmaps ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, - (GLsizei) height, (GLenum) format, (GLenum) type, - (const void *) ptr6 + (const void *) ptr5 ); if(data!=NULL) { - (*env)->ReleaseByteArrayElements(env, data, ptr6, JNI_ABORT); + (*env)->ReleaseFloatArrayElements(env, data, ptr5, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3S ( + Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3D ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, - jint height, jint format, jint type, - jshortArray data) + jdoubleArray data) { jint ret; - jshort *ptr6 = NULL; + jdouble *ptr5 = NULL; - if ( disp__gluBuild2DMipmaps == NULL ) return 0; + if ( disp__gluBuild1DMipmaps == NULL ) return 0; if(data!=NULL) { - ptr6 = (*env)->GetShortArrayElements(env, data, 0); + ptr5 = (*env)->GetDoubleArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild2DMipmaps ( + ret = (jint) disp__gluBuild1DMipmaps ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, - (GLsizei) height, (GLenum) format, (GLenum) type, - (const void *) ptr6 + (const void *) ptr5 ); if(data!=NULL) { - (*env)->ReleaseShortArrayElements(env, data, ptr6, JNI_ABORT); + (*env)->ReleaseDoubleArrayElements(env, data, ptr5, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3I ( + Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3Z ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, - jint height, jint format, jint type, - jintArray data) + jbooleanArray data) { jint ret; - jint *ptr6 = NULL; + jboolean *ptr5 = NULL; - if ( disp__gluBuild2DMipmaps == NULL ) return 0; + if ( disp__gluBuild1DMipmaps == NULL ) return 0; if(data!=NULL) { - ptr6 = (*env)->GetIntArrayElements(env, data, 0); + ptr5 = (*env)->GetBooleanArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild2DMipmaps ( + ret = (jint) disp__gluBuild1DMipmaps ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, - (GLsizei) height, (GLenum) format, (GLenum) type, - (const void *) ptr6 + (const void *) ptr5 ); if(data!=NULL) { - (*env)->ReleaseIntArrayElements(env, data, ptr6, JNI_ABORT); + (*env)->ReleaseBooleanArrayElements(env, data, ptr5, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3F ( + Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3J ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, - jint height, jint format, jint type, - jfloatArray data) + jlongArray data) { jint ret; - jfloat *ptr6 = NULL; + jlong *ptr5 = NULL; - if ( disp__gluBuild2DMipmaps == NULL ) return 0; + if ( disp__gluBuild1DMipmaps == NULL ) return 0; if(data!=NULL) { - ptr6 = (*env)->GetFloatArrayElements(env, data, 0); + ptr5 = (*env)->GetLongArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild2DMipmaps ( + ret = (jint) disp__gluBuild1DMipmaps ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, - (GLsizei) height, (GLenum) format, (GLenum) type, - (const void *) ptr6 + (const void *) ptr5 ); if(data!=NULL) { - (*env)->ReleaseFloatArrayElements(env, data, ptr6, JNI_ABORT); + (*env)->ReleaseLongArrayElements(env, data, ptr5, JNI_ABORT); } return ret; } + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluBuild2DMipmapLevels ( GLenum target , GLint internalFormat , GLsizei width , GLsizei height , GLenum format , GLenum type , GLint level , GLint base , GLint max , const void * data ) ;
+ *
+ */ JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3D ( + Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3B ( JNIEnv *env, jobject obj, jint target, jint internalFormat, @@ -1404,36 +1459,42 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) jint height, jint format, jint type, - jdoubleArray data) + jint level, + jint base, + jint max, + jbyteArray data) { jint ret; - jdouble *ptr6 = NULL; + jbyte *ptr9 = NULL; - if ( disp__gluBuild2DMipmaps == NULL ) return 0; + if ( disp__gluBuild2DMipmapLevels == NULL ) return 0; if(data!=NULL) { - ptr6 = (*env)->GetDoubleArrayElements(env, data, 0); + ptr9 = (*env)->GetByteArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild2DMipmaps ( + ret = (jint) disp__gluBuild2DMipmapLevels ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLenum) format, (GLenum) type, - (const void *) ptr6 + (GLint) level, + (GLint) base, + (GLint) max, + (const void *) ptr9 ); if(data!=NULL) { - (*env)->ReleaseDoubleArrayElements(env, data, ptr6, JNI_ABORT); + (*env)->ReleaseByteArrayElements(env, data, ptr9, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3Z ( + Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3S ( JNIEnv *env, jobject obj, jint target, jint internalFormat, @@ -1441,36 +1502,42 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) jint height, jint format, jint type, - jbooleanArray data) + jint level, + jint base, + jint max, + jshortArray data) { jint ret; - jboolean *ptr6 = NULL; + jshort *ptr9 = NULL; - if ( disp__gluBuild2DMipmaps == NULL ) return 0; + if ( disp__gluBuild2DMipmapLevels == NULL ) return 0; if(data!=NULL) { - ptr6 = (*env)->GetBooleanArrayElements(env, data, 0); + ptr9 = (*env)->GetShortArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild2DMipmaps ( + ret = (jint) disp__gluBuild2DMipmapLevels ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLenum) format, (GLenum) type, - (const void *) ptr6 + (GLint) level, + (GLint) base, + (GLint) max, + (const void *) ptr9 ); if(data!=NULL) { - (*env)->ReleaseBooleanArrayElements(env, data, ptr6, JNI_ABORT); + (*env)->ReleaseShortArrayElements(env, data, ptr9, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3J ( + Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3I ( JNIEnv *env, jobject obj, jint target, jint internalFormat, @@ -1478,521 +1545,487 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) jint height, jint format, jint type, - jlongArray data) + jint level, + jint base, + jint max, + jintArray data) { jint ret; - jlong *ptr6 = NULL; + jint *ptr9 = NULL; - if ( disp__gluBuild2DMipmaps == NULL ) return 0; + if ( disp__gluBuild2DMipmapLevels == NULL ) return 0; if(data!=NULL) { - ptr6 = (*env)->GetLongArrayElements(env, data, 0); + ptr9 = (*env)->GetIntArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild2DMipmaps ( + ret = (jint) disp__gluBuild2DMipmapLevels ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLenum) format, (GLenum) type, - (const void *) ptr6 + (GLint) level, + (GLint) base, + (GLint) max, + (const void *) ptr9 ); if(data!=NULL) { - (*env)->ReleaseLongArrayElements(env, data, ptr6, JNI_ABORT); + (*env)->ReleaseIntArrayElements(env, data, ptr9, JNI_ABORT); } return ret; } - -/** - * Original Function-Prototype : - * 
 
-   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 ) ;
- *
- */ JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3B ( + Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_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, - jbyteArray data) + jfloatArray data) { jint ret; - jbyte *ptr10 = NULL; + jfloat *ptr9 = NULL; - if ( disp__gluBuild3DMipmapLevels == NULL ) return 0; + if ( disp__gluBuild2DMipmapLevels == NULL ) return 0; if(data!=NULL) { - ptr10 = (*env)->GetByteArrayElements(env, data, 0); + ptr9 = (*env)->GetFloatArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild3DMipmapLevels ( + ret = (jint) disp__gluBuild2DMipmapLevels ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, - (GLsizei) depth, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, - (const void *) ptr10 + (const void *) ptr9 ); if(data!=NULL) { - (*env)->ReleaseByteArrayElements(env, data, ptr10, JNI_ABORT); + (*env)->ReleaseFloatArrayElements(env, data, ptr9, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3S ( + Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_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, - jshortArray data) + jdoubleArray data) { jint ret; - jshort *ptr10 = NULL; + jdouble *ptr9 = NULL; - if ( disp__gluBuild3DMipmapLevels == NULL ) return 0; + if ( disp__gluBuild2DMipmapLevels == NULL ) return 0; if(data!=NULL) { - ptr10 = (*env)->GetShortArrayElements(env, data, 0); + ptr9 = (*env)->GetDoubleArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild3DMipmapLevels ( + ret = (jint) disp__gluBuild2DMipmapLevels ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, - (GLsizei) depth, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, - (const void *) ptr10 + (const void *) ptr9 ); if(data!=NULL) { - (*env)->ReleaseShortArrayElements(env, data, ptr10, JNI_ABORT); + (*env)->ReleaseDoubleArrayElements(env, data, ptr9, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3I ( + Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_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, - jintArray data) + jbooleanArray data) { jint ret; - jint *ptr10 = NULL; + jboolean *ptr9 = NULL; - if ( disp__gluBuild3DMipmapLevels == NULL ) return 0; + if ( disp__gluBuild2DMipmapLevels == NULL ) return 0; if(data!=NULL) { - ptr10 = (*env)->GetIntArrayElements(env, data, 0); + ptr9 = (*env)->GetBooleanArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild3DMipmapLevels ( + ret = (jint) disp__gluBuild2DMipmapLevels ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, - (GLsizei) depth, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, - (const void *) ptr10 + (const void *) ptr9 ); if(data!=NULL) { - (*env)->ReleaseIntArrayElements(env, data, ptr10, JNI_ABORT); + (*env)->ReleaseBooleanArrayElements(env, data, ptr9, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3F ( + Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_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, - jfloatArray data) + jlongArray data) { jint ret; - jfloat *ptr10 = NULL; + jlong *ptr9 = NULL; - if ( disp__gluBuild3DMipmapLevels == NULL ) return 0; + if ( disp__gluBuild2DMipmapLevels == NULL ) return 0; if(data!=NULL) { - ptr10 = (*env)->GetFloatArrayElements(env, data, 0); + ptr9 = (*env)->GetLongArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild3DMipmapLevels ( + ret = (jint) disp__gluBuild2DMipmapLevels ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, - (GLsizei) depth, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, - (const void *) ptr10 + (const void *) ptr9 ); if(data!=NULL) { - (*env)->ReleaseFloatArrayElements(env, data, ptr10, JNI_ABORT); + (*env)->ReleaseLongArrayElements(env, data, ptr9, JNI_ABORT); } return ret; } + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluBuild2DMipmaps ( GLenum target , GLint internalFormat , GLsizei width , GLsizei height , GLenum format , GLenum type , const void * data ) ;
+ *
+ */ JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3D ( + Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_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, - jdoubleArray data) + jbyteArray data) { jint ret; - jdouble *ptr10 = NULL; + jbyte *ptr6 = NULL; - if ( disp__gluBuild3DMipmapLevels == NULL ) return 0; + if ( disp__gluBuild2DMipmaps == NULL ) return 0; if(data!=NULL) { - ptr10 = (*env)->GetDoubleArrayElements(env, data, 0); + ptr6 = (*env)->GetByteArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild3DMipmapLevels ( + ret = (jint) disp__gluBuild2DMipmaps ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, - (GLsizei) depth, (GLenum) format, (GLenum) type, - (GLint) level, - (GLint) base, - (GLint) max, - (const void *) ptr10 + (const void *) ptr6 ); if(data!=NULL) { - (*env)->ReleaseDoubleArrayElements(env, data, ptr10, JNI_ABORT); + (*env)->ReleaseByteArrayElements(env, data, ptr6, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3Z ( + Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_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, - jbooleanArray data) + jshortArray data) { jint ret; - jboolean *ptr10 = NULL; + jshort *ptr6 = NULL; - if ( disp__gluBuild3DMipmapLevels == NULL ) return 0; + if ( disp__gluBuild2DMipmaps == NULL ) return 0; if(data!=NULL) { - ptr10 = (*env)->GetBooleanArrayElements(env, data, 0); + ptr6 = (*env)->GetShortArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild3DMipmapLevels ( + ret = (jint) disp__gluBuild2DMipmaps ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, - (GLsizei) depth, (GLenum) format, (GLenum) type, - (GLint) level, - (GLint) base, - (GLint) max, - (const void *) ptr10 + (const void *) ptr6 ); if(data!=NULL) { - (*env)->ReleaseBooleanArrayElements(env, data, ptr10, JNI_ABORT); + (*env)->ReleaseShortArrayElements(env, data, ptr6, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3J ( + Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_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, - jlongArray data) + jintArray data) { jint ret; - jlong *ptr10 = NULL; + jint *ptr6 = NULL; - if ( disp__gluBuild3DMipmapLevels == NULL ) return 0; + if ( disp__gluBuild2DMipmaps == NULL ) return 0; if(data!=NULL) { - ptr10 = (*env)->GetLongArrayElements(env, data, 0); + ptr6 = (*env)->GetIntArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild3DMipmapLevels ( + ret = (jint) disp__gluBuild2DMipmaps ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, - (GLsizei) depth, (GLenum) format, (GLenum) type, - (GLint) level, - (GLint) base, - (GLint) max, - (const void *) ptr10 + (const void *) ptr6 ); if(data!=NULL) { - (*env)->ReleaseLongArrayElements(env, data, ptr10, JNI_ABORT); + (*env)->ReleaseIntArrayElements(env, data, ptr6, JNI_ABORT); } return ret; } - -/** - * Original Function-Prototype : - * 
 
-   extern GLint gluBuild3DMipmaps ( GLenum target , GLint internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const void * data ) ;
- *
- */ JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmaps__IIIIIII_3B ( + Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3F ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, jint height, - jint depth, jint format, jint type, - jbyteArray data) + jfloatArray data) { jint ret; - jbyte *ptr7 = NULL; + jfloat *ptr6 = NULL; - if ( disp__gluBuild3DMipmaps == NULL ) return 0; + if ( disp__gluBuild2DMipmaps == NULL ) return 0; if(data!=NULL) { - ptr7 = (*env)->GetByteArrayElements(env, data, 0); + ptr6 = (*env)->GetFloatArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild3DMipmaps ( + ret = (jint) disp__gluBuild2DMipmaps ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, - (GLsizei) depth, (GLenum) format, (GLenum) type, - (const void *) ptr7 + (const void *) ptr6 ); if(data!=NULL) { - (*env)->ReleaseByteArrayElements(env, data, ptr7, JNI_ABORT); + (*env)->ReleaseFloatArrayElements(env, data, ptr6, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmaps__IIIIIII_3S ( + Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3D ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, jint height, - jint depth, jint format, jint type, - jshortArray data) + jdoubleArray data) { jint ret; - jshort *ptr7 = NULL; + jdouble *ptr6 = NULL; - if ( disp__gluBuild3DMipmaps == NULL ) return 0; + if ( disp__gluBuild2DMipmaps == NULL ) return 0; if(data!=NULL) { - ptr7 = (*env)->GetShortArrayElements(env, data, 0); + ptr6 = (*env)->GetDoubleArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild3DMipmaps ( + ret = (jint) disp__gluBuild2DMipmaps ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, - (GLsizei) depth, (GLenum) format, (GLenum) type, - (const void *) ptr7 + (const void *) ptr6 ); if(data!=NULL) { - (*env)->ReleaseShortArrayElements(env, data, ptr7, JNI_ABORT); + (*env)->ReleaseDoubleArrayElements(env, data, ptr6, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmaps__IIIIIII_3I ( + Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3Z ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, jint height, - jint depth, jint format, jint type, - jintArray data) + jbooleanArray data) { jint ret; - jint *ptr7 = NULL; + jboolean *ptr6 = NULL; - if ( disp__gluBuild3DMipmaps == NULL ) return 0; + if ( disp__gluBuild2DMipmaps == NULL ) return 0; if(data!=NULL) { - ptr7 = (*env)->GetIntArrayElements(env, data, 0); + ptr6 = (*env)->GetBooleanArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild3DMipmaps ( + ret = (jint) disp__gluBuild2DMipmaps ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, - (GLsizei) depth, (GLenum) format, (GLenum) type, - (const void *) ptr7 + (const void *) ptr6 ); if(data!=NULL) { - (*env)->ReleaseIntArrayElements(env, data, ptr7, JNI_ABORT); + (*env)->ReleaseBooleanArrayElements(env, data, ptr6, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmaps__IIIIIII_3F ( + Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3J ( JNIEnv *env, jobject obj, jint target, jint internalFormat, jint width, jint height, - jint depth, jint format, jint type, - jfloatArray data) + jlongArray data) { jint ret; - jfloat *ptr7 = NULL; + jlong *ptr6 = NULL; - if ( disp__gluBuild3DMipmaps == NULL ) return 0; + if ( disp__gluBuild2DMipmaps == NULL ) return 0; if(data!=NULL) { - ptr7 = (*env)->GetFloatArrayElements(env, data, 0); + ptr6 = (*env)->GetLongArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild3DMipmaps ( + ret = (jint) disp__gluBuild2DMipmaps ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, - (GLsizei) depth, (GLenum) format, (GLenum) type, - (const void *) ptr7 + (const void *) ptr6 ); if(data!=NULL) { - (*env)->ReleaseFloatArrayElements(env, data, ptr7, JNI_ABORT); + (*env)->ReleaseLongArrayElements(env, data, ptr6, JNI_ABORT); } return ret; } + +/** + * Original Function-Prototype : + * 
 
+   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 ) ;
+ *
+ */ JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmaps__IIIIIII_3D ( + Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3B ( JNIEnv *env, jobject obj, jint target, jint internalFormat, @@ -2001,19 +2034,22 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) jint depth, jint format, jint type, - jdoubleArray data) + jint level, + jint base, + jint max, + jbyteArray data) { jint ret; - jdouble *ptr7 = NULL; + jbyte *ptr10 = NULL; - if ( disp__gluBuild3DMipmaps == NULL ) return 0; + if ( disp__gluBuild3DMipmapLevels == NULL ) return 0; if(data!=NULL) { - ptr7 = (*env)->GetDoubleArrayElements(env, data, 0); + ptr10 = (*env)->GetByteArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild3DMipmaps ( + ret = (jint) disp__gluBuild3DMipmapLevels ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, @@ -2021,17 +2057,20 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) (GLsizei) depth, (GLenum) format, (GLenum) type, - (const void *) ptr7 + (GLint) level, + (GLint) base, + (GLint) max, + (const void *) ptr10 ); if(data!=NULL) { - (*env)->ReleaseDoubleArrayElements(env, data, ptr7, JNI_ABORT); + (*env)->ReleaseByteArrayElements(env, data, ptr10, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmaps__IIIIIII_3Z ( + Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3S ( JNIEnv *env, jobject obj, jint target, jint internalFormat, @@ -2040,19 +2079,22 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) jint depth, jint format, jint type, - jbooleanArray data) + jint level, + jint base, + jint max, + jshortArray data) { jint ret; - jboolean *ptr7 = NULL; + jshort *ptr10 = NULL; - if ( disp__gluBuild3DMipmaps == NULL ) return 0; + if ( disp__gluBuild3DMipmapLevels == NULL ) return 0; if(data!=NULL) { - ptr7 = (*env)->GetBooleanArrayElements(env, data, 0); + ptr10 = (*env)->GetShortArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild3DMipmaps ( + ret = (jint) disp__gluBuild3DMipmapLevels ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, @@ -2060,17 +2102,20 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) (GLsizei) depth, (GLenum) format, (GLenum) type, - (const void *) ptr7 + (GLint) level, + (GLint) base, + (GLint) max, + (const void *) ptr10 ); if(data!=NULL) { - (*env)->ReleaseBooleanArrayElements(env, data, ptr7, JNI_ABORT); + (*env)->ReleaseShortArrayElements(env, data, ptr10, JNI_ABORT); } return ret; } JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmaps__IIIIIII_3J ( + Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3I ( JNIEnv *env, jobject obj, jint target, jint internalFormat, @@ -2079,19 +2124,22 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) jint depth, jint format, jint type, - jlongArray data) + jint level, + jint base, + jint max, + jintArray data) { jint ret; - jlong *ptr7 = NULL; + jint *ptr10 = NULL; - if ( disp__gluBuild3DMipmaps == NULL ) return 0; + if ( disp__gluBuild3DMipmapLevels == NULL ) return 0; if(data!=NULL) { - ptr7 = (*env)->GetLongArrayElements(env, data, 0); + ptr10 = (*env)->GetIntArrayElements(env, data, 0); } - ret = (jint) disp__gluBuild3DMipmaps ( + ret = (jint) disp__gluBuild3DMipmapLevels ( (GLenum) target, (GLint) internalFormat, (GLsizei) width, @@ -2099,448 +2147,548 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) (GLsizei) depth, (GLenum) format, (GLenum) type, - (const void *) ptr7 + (GLint) level, + (GLint) base, + (GLint) max, + (const void *) ptr10 ); if(data!=NULL) { - (*env)->ReleaseLongArrayElements(env, data, ptr7, JNI_ABORT); + (*env)->ReleaseIntArrayElements(env, data, ptr10, JNI_ABORT); } return ret; } - -/** - * Original Function-Prototype : - * 
 
-   extern GLboolean gluCheckExtension ( const GLubyte * extName , const GLubyte * extString ) ;
- *
- */ - JNIEXPORT jboolean JNICALL - Java_gl4java_GLUFuncJauJNI_gluCheckExtension ( + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3F ( JNIEnv *env, jobject obj, - jbyteArray extName, - jbyteArray extString) + jint target, + jint internalFormat, + jint width, + jint height, + jint depth, + jint format, + jint type, + jint level, + jint base, + jint max, + jfloatArray data) { - jboolean ret; + jint ret; - jbyte *ptr0 = NULL; - jbyte *ptr1 = NULL; + jfloat *ptr10 = NULL; - if ( disp__gluCheckExtension == NULL ) return 0; + if ( disp__gluBuild3DMipmapLevels == NULL ) return 0; - if(extName!=NULL) - { - ptr0 = (*env)->GetByteArrayElements(env, extName, 0); - } - if(extString!=NULL) + if(data!=NULL) { - ptr1 = (*env)->GetByteArrayElements(env, extString, 0); + ptr10 = (*env)->GetFloatArrayElements(env, data, 0); } - ret = (jboolean) disp__gluCheckExtension ( - (const GLubyte *) ptr0, - (const GLubyte *) ptr1 + 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(extName!=NULL) - { - (*env)->ReleaseByteArrayElements(env, extName, ptr0, JNI_ABORT); - } - if(extString!=NULL) + if(data!=NULL) { - (*env)->ReleaseByteArrayElements(env, extString, ptr1, JNI_ABORT); + (*env)->ReleaseFloatArrayElements(env, data, ptr10, JNI_ABORT); } return ret; } - -/** - * Original Function-Prototype : - * 
 
-   extern void gluCylinder ( GLUquadric * quad , GLdouble base , GLdouble top , GLdouble height , GLint slices , GLint stacks ) ;
- *
- */ - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluCylinder ( + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3D ( JNIEnv *env, jobject obj, - jlong quad, - jdouble base, - jdouble top, - jdouble height, - jint slices, - jint stacks) + jint target, + jint internalFormat, + jint width, + jint height, + jint depth, + jint format, + jint type, + jint level, + jint base, + jint max, + jdoubleArray data) { + jint ret; - if ( disp__gluCylinder == NULL ) return; + jdouble *ptr10 = NULL; - disp__gluCylinder ( - (GLUquadric *) (PointerHolder) quad, - (GLdouble) base, - (GLdouble) top, - (GLdouble) height, - (GLint) slices, - (GLint) stacks + if ( disp__gluBuild3DMipmapLevels == NULL ) return 0; + + if(data!=NULL) + { + ptr10 = (*env)->GetDoubleArrayElements(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)->ReleaseDoubleArrayElements(env, data, ptr10, JNI_ABORT); + } + return ret; } - -/** - * Original Function-Prototype : - * 
 
-   extern void gluDisk ( GLUquadric * quad , GLdouble inner , GLdouble outer , GLint slices , GLint loops ) ;
- *
- */ - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluDisk ( + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3Z ( JNIEnv *env, jobject obj, - jlong quad, - jdouble inner, - jdouble outer, - jint slices, - jint loops) + jint target, + jint internalFormat, + jint width, + jint height, + jint depth, + jint format, + jint type, + jint level, + jint base, + jint max, + jbooleanArray data) { + jint ret; - if ( disp__gluDisk == NULL ) return; - - disp__gluDisk ( - (GLUquadric *) (PointerHolder) quad, - (GLdouble) inner, - (GLdouble) outer, - (GLint) slices, - (GLint) loops - ); - - } - -/** - * Original Function-Prototype : - * 
 
-   extern void gluEndCurve ( GLUnurbs * nurb ) ;
- *
- */ - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluEndCurve ( - JNIEnv *env, jobject obj, - jlong nurb) - { + jboolean *ptr10 = NULL; - if ( disp__gluEndCurve == NULL ) return; + if ( disp__gluBuild3DMipmapLevels == NULL ) return 0; - disp__gluEndCurve ( - (GLUnurbs *) (PointerHolder) nurb + if(data!=NULL) + { + ptr10 = (*env)->GetBooleanArrayElements(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)->ReleaseBooleanArrayElements(env, data, ptr10, JNI_ABORT); + } + return ret; } - -/** - * Original Function-Prototype : - * 
 
-   extern void gluEndPolygon ( GLUtesselator * tess ) ;
- *
- */ - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluEndPolygon ( + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3J ( JNIEnv *env, jobject obj, - jlong tess) + jint target, + jint internalFormat, + jint width, + jint height, + jint depth, + jint format, + jint type, + jint level, + jint base, + jint max, + jlongArray data) { + jint ret; - if ( disp__gluEndPolygon == NULL ) return; - - disp__gluEndPolygon ( - (GLUtesselator *) (PointerHolder) tess - ); - - } - -/** - * Original Function-Prototype : - * 
 
-   extern void gluEndSurface ( GLUnurbs * nurb ) ;
- *
- */ - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluEndSurface ( - JNIEnv *env, jobject obj, - jlong nurb) - { + jlong *ptr10 = NULL; - if ( disp__gluEndSurface == NULL ) return; + if ( disp__gluBuild3DMipmapLevels == NULL ) return 0; - disp__gluEndSurface ( - (GLUnurbs *) (PointerHolder) nurb + if(data!=NULL) + { + ptr10 = (*env)->GetLongArrayElements(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)->ReleaseLongArrayElements(env, data, ptr10, JNI_ABORT); + } + return ret; } /** * Original Function-Prototype : * 
 
-   extern void gluEndTrim ( GLUnurbs * nurb ) ;
+   extern GLint gluBuild3DMipmaps ( GLenum target , GLint internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const void * data ) ;
  *
*/ - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluEndTrim ( + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmaps__IIIIIII_3B ( JNIEnv *env, jobject obj, - jlong nurb) + jint target, + jint internalFormat, + jint width, + jint height, + jint depth, + jint format, + jint type, + jbyteArray data) { + jint ret; - if ( disp__gluEndTrim == NULL ) return; - - disp__gluEndTrim ( - (GLUnurbs *) (PointerHolder) nurb - ); - - } - -/** - * Original Function-Prototype : - * 
 
-   extern void gluGetNurbsProperty ( GLUnurbs * nurb , GLenum property , GLfloat * data ) ;
- *
- */ - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluGetNurbsProperty ( - JNIEnv *env, jobject obj, - jlong nurb, - jint property, - jfloatArray data) - { - jboolean isCopiedArray2 = JNI_FALSE; - jfloat *ptr2 = NULL; + jbyte *ptr7 = NULL; - if ( disp__gluGetNurbsProperty == NULL ) return; + if ( disp__gluBuild3DMipmaps == NULL ) return 0; if(data!=NULL) { - ptr2 = (*env)->GetFloatArrayElements(env, data, &isCopiedArray2); + ptr7 = (*env)->GetByteArrayElements(env, data, 0); } - disp__gluGetNurbsProperty ( - (GLUnurbs *) (PointerHolder) nurb, - (GLenum) property, - (GLfloat *) ptr2 + 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)->ReleaseFloatArrayElements(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseByteArrayElements(env, data, ptr7, JNI_ABORT); } + return ret; } - -/** - * Original Function-Prototype : - * 
 
-   extern void gluGetTessProperty ( GLUtesselator * tess , GLenum which , GLdouble * data ) ;
- *
- */ - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluGetTessProperty ( + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmaps__IIIIIII_3S ( JNIEnv *env, jobject obj, - jlong tess, - jint which, - jdoubleArray data) + jint target, + jint internalFormat, + jint width, + jint height, + jint depth, + jint format, + jint type, + jshortArray data) { - jboolean isCopiedArray2 = JNI_FALSE; - jdouble *ptr2 = NULL; + jint ret; - if ( disp__gluGetTessProperty == NULL ) return; + jshort *ptr7 = NULL; + + if ( disp__gluBuild3DMipmaps == NULL ) return 0; if(data!=NULL) { - ptr2 = (*env)->GetDoubleArrayElements(env, data, &isCopiedArray2); + ptr7 = (*env)->GetShortArrayElements(env, data, 0); } - disp__gluGetTessProperty ( - (GLUtesselator *) (PointerHolder) tess, - (GLenum) which, - (GLdouble *) ptr2 + 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)->ReleaseDoubleArrayElements(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseShortArrayElements(env, data, ptr7, JNI_ABORT); } + return ret; } - -/** - * Original Function-Prototype : - * 
 
-   extern void gluLoadSamplingMatrices ( GLUnurbs * nurb , const GLfloat * model , const GLfloat * perspective , const GLint * view ) ;
- *
- */ - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluLoadSamplingMatrices ( + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmaps__IIIIIII_3I ( JNIEnv *env, jobject obj, - jlong nurb, - jfloatArray model, - jfloatArray perspective, - jintArray view) + jint target, + jint internalFormat, + jint width, + jint height, + jint depth, + jint format, + jint type, + jintArray data) { - jfloat *ptr1 = NULL; - jfloat *ptr2 = NULL; - jint *ptr3 = NULL; + jint ret; - if ( disp__gluLoadSamplingMatrices == NULL ) return; + jint *ptr7 = NULL; - if(model!=NULL) + if ( disp__gluBuild3DMipmaps == NULL ) return 0; + + if(data!=NULL) { - ptr1 = (*env)->GetFloatArrayElements(env, model, 0); + ptr7 = (*env)->GetIntArrayElements(env, data, 0); } - if(perspective!=NULL) + ret = (jint) disp__gluBuild3DMipmaps ( + (GLenum) target, + (GLint) internalFormat, + (GLsizei) width, + (GLsizei) height, + (GLsizei) depth, + (GLenum) format, + (GLenum) type, + (const void *) ptr7 + ); + + if(data!=NULL) { - ptr2 = (*env)->GetFloatArrayElements(env, perspective, 0); + (*env)->ReleaseIntArrayElements(env, data, ptr7, JNI_ABORT); } - if(view!=NULL) + return ret; + } + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_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) { - ptr3 = (*env)->GetIntArrayElements(env, view, 0); + ptr7 = (*env)->GetFloatArrayElements(env, data, 0); } - disp__gluLoadSamplingMatrices ( - (GLUnurbs *) (PointerHolder) nurb, - (const GLfloat *) ptr1, - (const GLfloat *) ptr2, - (const GLint *) ptr3 + ret = (jint) disp__gluBuild3DMipmaps ( + (GLenum) target, + (GLint) internalFormat, + (GLsizei) width, + (GLsizei) height, + (GLsizei) depth, + (GLenum) format, + (GLenum) type, + (const void *) ptr7 ); - if(model!=NULL) + if(data!=NULL) { - (*env)->ReleaseFloatArrayElements(env, model, ptr1, JNI_ABORT); + (*env)->ReleaseFloatArrayElements(env, data, ptr7, JNI_ABORT); } - if(perspective!=NULL) + return ret; + } + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_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) { - (*env)->ReleaseFloatArrayElements(env, perspective, ptr2, JNI_ABORT); + ptr7 = (*env)->GetDoubleArrayElements(env, data, 0); } - if(view!=NULL) + 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)->ReleaseIntArrayElements(env, view, ptr3, JNI_ABORT); + (*env)->ReleaseDoubleArrayElements(env, data, ptr7, JNI_ABORT); } + return ret; } - -/** - * Original Function-Prototype : - * 
 
-   extern void gluLookAt ( GLdouble eyeX , GLdouble eyeY , GLdouble eyeZ , GLdouble centerX , GLdouble centerY , GLdouble centerZ , GLdouble upX , GLdouble upY , GLdouble upZ ) ;
- *
- */ - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluLookAt ( + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmaps__IIIIIII_3Z ( JNIEnv *env, jobject obj, - jdouble eyeX, - jdouble eyeY, - jdouble eyeZ, - jdouble centerX, - jdouble centerY, - jdouble centerZ, - jdouble upX, - jdouble upY, - jdouble upZ) + jint target, + jint internalFormat, + jint width, + jint height, + jint depth, + jint format, + jint type, + jbooleanArray data) { + jint ret; - if ( disp__gluLookAt == NULL ) return; + jboolean *ptr7 = NULL; - disp__gluLookAt ( - (GLdouble) eyeX, - (GLdouble) eyeY, - (GLdouble) eyeZ, - (GLdouble) centerX, - (GLdouble) centerY, - (GLdouble) centerZ, - (GLdouble) upX, - (GLdouble) upY, - (GLdouble) upZ + if ( disp__gluBuild3DMipmaps == NULL ) return 0; + + if(data!=NULL) + { + ptr7 = (*env)->GetBooleanArrayElements(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)->ReleaseBooleanArrayElements(env, data, ptr7, JNI_ABORT); + } + return ret; } - -/** - * Original Function-Prototype : - * 
 
-   extern void gluNextContour ( GLUtesselator * tess , GLenum type ) ;
- *
- */ - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluNextContour ( + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmaps__IIIIIII_3J ( JNIEnv *env, jobject obj, - jlong tess, - jint type) + jint target, + jint internalFormat, + jint width, + jint height, + jint depth, + jint format, + jint type, + jlongArray data) { + jint ret; - if ( disp__gluNextContour == NULL ) return; + jlong *ptr7 = NULL; - disp__gluNextContour ( - (GLUtesselator *) (PointerHolder) tess, - (GLenum) type + if ( disp__gluBuild3DMipmaps == NULL ) return 0; + + if(data!=NULL) + { + ptr7 = (*env)->GetLongArrayElements(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)->ReleaseLongArrayElements(env, data, ptr7, JNI_ABORT); + } + return ret; } /** * Original Function-Prototype : * 
 
-   extern void gluNurbsCurve ( GLUnurbs * nurb , GLint knotCount , GLfloat * knots , GLint stride , GLfloat * control , GLint order , GLenum type ) ;
+   extern GLboolean gluCheckExtension ( const GLubyte * extName , const GLubyte * extString ) ;
  *
*/ - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluNurbsCurve ( + JNIEXPORT jboolean JNICALL + Java_gl4java_GLUFuncJauJNI_gluCheckExtension ( JNIEnv *env, jobject obj, - jlong nurb, - jint knotCount, - jfloatArray knots, - jint stride, - jfloatArray control, - jint order, - jint type) + jbyteArray extName, + jbyteArray extString) { - jboolean isCopiedArray2 = JNI_FALSE; - jfloat *ptr2 = NULL; - jboolean isCopiedArray4 = JNI_FALSE; - jfloat *ptr4 = NULL; + jboolean ret; - if ( disp__gluNurbsCurve == NULL ) return; + jbyte *ptr0 = NULL; + jbyte *ptr1 = NULL; - if(knots!=NULL) + if ( disp__gluCheckExtension == NULL ) return 0; + + if(extName!=NULL) { - ptr2 = (*env)->GetFloatArrayElements(env, knots, &isCopiedArray2); + ptr0 = (*env)->GetByteArrayElements(env, extName, 0); } - if(control!=NULL) + if(extString!=NULL) { - ptr4 = (*env)->GetFloatArrayElements(env, control, &isCopiedArray4); + ptr1 = (*env)->GetByteArrayElements(env, extString, 0); } - disp__gluNurbsCurve ( - (GLUnurbs *) (PointerHolder) nurb, - (GLint) knotCount, - (GLfloat *) ptr2, - (GLint) stride, - (GLfloat *) ptr4, - (GLint) order, - (GLenum) type + ret = (jboolean) disp__gluCheckExtension ( + (const GLubyte *) ptr0, + (const GLubyte *) ptr1 ); - if(knots!=NULL) + if(extName!=NULL) { - (*env)->ReleaseFloatArrayElements(env, knots, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseByteArrayElements(env, extName, ptr0, JNI_ABORT); } - if(control!=NULL) + if(extString!=NULL) { - (*env)->ReleaseFloatArrayElements(env, control, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseByteArrayElements(env, extString, ptr1, JNI_ABORT); } + return ret; } /** * Original Function-Prototype : * 
 
-   extern void gluNurbsProperty ( GLUnurbs * nurb , GLenum property , GLfloat value ) ;
+   extern void gluCylinder ( GLUquadric * quad , GLdouble base , GLdouble top , GLdouble height , GLint slices , GLint stacks ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluNurbsProperty ( + Java_gl4java_GLUFuncJauJNI_gluCylinder ( JNIEnv *env, jobject obj, - jlong nurb, - jint property, - jfloat value) + jlong quad, + jdouble base, + jdouble top, + jdouble height, + jint slices, + jint stacks) { - if ( disp__gluNurbsProperty == NULL ) return; + if ( disp__gluCylinder == NULL ) return; - disp__gluNurbsProperty ( - (GLUnurbs *) (PointerHolder) nurb, - (GLenum) property, - (GLfloat) value + disp__gluCylinder ( + (GLUquadric *) (PointerHolder) quad, + (GLdouble) base, + (GLdouble) top, + (GLdouble) height, + (GLint) slices, + (GLint) stacks ); } @@ -2548,95 +2696,47 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) /** * Original Function-Prototype : * 
 
-   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 ) ;
+   extern void gluDisk ( GLUquadric * quad , GLdouble inner , GLdouble outer , GLint slices , GLint loops ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluNurbsSurface ( + Java_gl4java_GLUFuncJauJNI_gluDisk ( 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) + jlong quad, + jdouble inner, + jdouble outer, + jint slices, + jint loops) { - 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 ( disp__gluDisk == NULL ) return; - if(sKnots!=NULL) - { - ptr2 = (*env)->GetFloatArrayElements(env, sKnots, &isCopiedArray2); - } - if(tKnots!=NULL) - { - ptr4 = (*env)->GetFloatArrayElements(env, tKnots, &isCopiedArray4); - } - if(control!=NULL) - { - ptr7 = (*env)->GetFloatArrayElements(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 + disp__gluDisk ( + (GLUquadric *) (PointerHolder) quad, + (GLdouble) inner, + (GLdouble) outer, + (GLint) slices, + (GLint) loops ); - if(sKnots!=NULL) - { - (*env)->ReleaseFloatArrayElements(env, sKnots, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT); - } - if(tKnots!=NULL) - { - (*env)->ReleaseFloatArrayElements(env, tKnots, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT); - } - if(control!=NULL) - { - (*env)->ReleaseFloatArrayElements(env, control, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT); - } } /** * Original Function-Prototype : * 
 
-   extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ;
+   extern void gluEndCurve ( GLUnurbs * nurb ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluOrtho2D ( + Java_gl4java_GLUFuncJauJNI_gluEndCurve ( JNIEnv *env, jobject obj, - jdouble left, - jdouble right, - jdouble bottom, - jdouble top) + jlong nurb) { - if ( disp__gluOrtho2D == NULL ) return; + if ( disp__gluEndCurve == NULL ) return; - disp__gluOrtho2D ( - (GLdouble) left, - (GLdouble) right, - (GLdouble) bottom, - (GLdouble) top + disp__gluEndCurve ( + (GLUnurbs *) (PointerHolder) nurb ); } @@ -2644,31 +2744,19 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) /** * Original Function-Prototype : * 
 
-   extern void gluPartialDisk ( GLUquadric * quad , GLdouble inner , GLdouble outer , GLint slices , GLint loops , GLdouble start , GLdouble sweep ) ;
+   extern void gluEndPolygon ( GLUtesselator * tess ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluPartialDisk ( + Java_gl4java_GLUFuncJauJNI_gluEndPolygon ( JNIEnv *env, jobject obj, - jlong quad, - jdouble inner, - jdouble outer, - jint slices, - jint loops, - jdouble start, - jdouble sweep) + jlong tess) { - if ( disp__gluPartialDisk == NULL ) return; + if ( disp__gluEndPolygon == NULL ) return; - disp__gluPartialDisk ( - (GLUquadric *) (PointerHolder) quad, - (GLdouble) inner, - (GLdouble) outer, - (GLint) slices, - (GLint) loops, - (GLdouble) start, - (GLdouble) sweep + disp__gluEndPolygon ( + (GLUtesselator *) (PointerHolder) tess ); } @@ -2676,25 +2764,19 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) /** * Original Function-Prototype : * 
 
-   extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ;
+   extern void gluEndSurface ( GLUnurbs * nurb ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluPerspective ( + Java_gl4java_GLUFuncJauJNI_gluEndSurface ( JNIEnv *env, jobject obj, - jdouble fovy, - jdouble aspect, - jdouble zNear, - jdouble zFar) + jlong nurb) { - if ( disp__gluPerspective == NULL ) return; + if ( disp__gluEndSurface == NULL ) return; - disp__gluPerspective ( - (GLdouble) fovy, - (GLdouble) aspect, - (GLdouble) zNear, - (GLdouble) zFar + disp__gluEndSurface ( + (GLUnurbs *) (PointerHolder) nurb ); } @@ -2702,193 +2784,176 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) /** * Original Function-Prototype : * 
 
-   extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble delX , GLdouble delY , GLint * viewport ) ;
+   extern void gluEndTrim ( GLUnurbs * nurb ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluPickMatrix ( + Java_gl4java_GLUFuncJauJNI_gluEndTrim ( JNIEnv *env, jobject obj, - jdouble x, - jdouble y, - jdouble delX, - jdouble delY, - jintArray viewport) + jlong nurb) { - jboolean isCopiedArray4 = JNI_FALSE; - jint *ptr4 = NULL; - if ( disp__gluPickMatrix == NULL ) return; + if ( disp__gluEndTrim == NULL ) return; - if(viewport!=NULL) - { - ptr4 = (*env)->GetIntArrayElements(env, viewport, &isCopiedArray4); - } - disp__gluPickMatrix ( - (GLdouble) x, - (GLdouble) y, - (GLdouble) delX, - (GLdouble) delY, - (GLint *) ptr4 + disp__gluEndTrim ( + (GLUnurbs *) (PointerHolder) nurb ); - if(viewport!=NULL) - { - (*env)->ReleaseIntArrayElements(env, viewport, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT); - } } /** * Original Function-Prototype : * 
 
-   extern GLint gluProject ( GLdouble objX , GLdouble objY , GLdouble objZ , const GLdouble * model , const GLdouble * proj , const GLint * view , GLdouble * winX , GLdouble * winY , GLdouble * winZ ) ;
+   extern void gluGetNurbsProperty ( GLUnurbs * nurb , GLenum property , GLfloat * data ) ;
  *
*/ - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluProject ( + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluGetNurbsProperty ( JNIEnv *env, jobject obj, - jdouble objX, - jdouble objY, - jdouble objZ, - jdoubleArray model, - jdoubleArray proj, - jintArray view, - jdoubleArray winX, - jdoubleArray winY, - jdoubleArray winZ) + jlong nurb, + jint property, + jfloatArray data) { - 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; + jboolean isCopiedArray2 = JNI_FALSE; + jfloat *ptr2 = NULL; - if ( disp__gluProject == NULL ) return 0; + if ( disp__gluGetNurbsProperty == NULL ) return; - if(model!=NULL) + if(data!=NULL) { - ptr3 = (*env)->GetDoubleArrayElements(env, model, 0); + ptr2 = (*env)->GetFloatArrayElements(env, data, &isCopiedArray2); } - if(proj!=NULL) - { - ptr4 = (*env)->GetDoubleArrayElements(env, proj, 0); - } - if(view!=NULL) - { - ptr5 = (*env)->GetIntArrayElements(env, view, 0); - } - if(winX!=NULL) - { - ptr6 = (*env)->GetDoubleArrayElements(env, winX, &isCopiedArray6); - } - if(winY!=NULL) - { - ptr7 = (*env)->GetDoubleArrayElements(env, winY, &isCopiedArray7); - } - if(winZ!=NULL) - { - ptr8 = (*env)->GetDoubleArrayElements(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 + disp__gluGetNurbsProperty ( + (GLUnurbs *) (PointerHolder) nurb, + (GLenum) property, + (GLfloat *) ptr2 ); - if(model!=NULL) - { - (*env)->ReleaseDoubleArrayElements(env, model, ptr3, JNI_ABORT); - } - if(proj!=NULL) - { - (*env)->ReleaseDoubleArrayElements(env, proj, ptr4, JNI_ABORT); - } - if(view!=NULL) - { - (*env)->ReleaseIntArrayElements(env, view, ptr5, JNI_ABORT); - } - if(winX!=NULL) + if(data!=NULL) { - (*env)->ReleaseDoubleArrayElements(env, winX, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseFloatArrayElements(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT); } - if(winY!=NULL) + } + +/** + * Original Function-Prototype : + * 
 
+   extern void gluGetTessProperty ( GLUtesselator * tess , GLenum which , GLdouble * data ) ;
+ *
+ */ + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_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) { - (*env)->ReleaseDoubleArrayElements(env, winY, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT); + ptr2 = (*env)->GetDoubleArrayElements(env, data, &isCopiedArray2); } - if(winZ!=NULL) + disp__gluGetTessProperty ( + (GLUtesselator *) (PointerHolder) tess, + (GLenum) which, + (GLdouble *) ptr2 + ); + + if(data!=NULL) { - (*env)->ReleaseDoubleArrayElements(env, winZ, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseDoubleArrayElements(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT); } - return ret; } /** * Original Function-Prototype : * 
 
-   extern void gluPwlCurve ( GLUnurbs * nurb , GLint count , GLfloat * data , GLint stride , GLenum type ) ;
+   extern void gluLoadSamplingMatrices ( GLUnurbs * nurb , const GLfloat * model , const GLfloat * perspective , const GLint * view ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluPwlCurve ( + Java_gl4java_GLUFuncJauJNI_gluLoadSamplingMatrices ( JNIEnv *env, jobject obj, jlong nurb, - jint count, - jfloatArray data, - jint stride, - jint type) + jfloatArray model, + jfloatArray perspective, + jintArray view) { - jboolean isCopiedArray2 = JNI_FALSE; + jfloat *ptr1 = NULL; jfloat *ptr2 = NULL; + jint *ptr3 = NULL; - if ( disp__gluPwlCurve == NULL ) return; + if ( disp__gluLoadSamplingMatrices == NULL ) return; - if(data!=NULL) + if(model!=NULL) { - ptr2 = (*env)->GetFloatArrayElements(env, data, &isCopiedArray2); + ptr1 = (*env)->GetFloatArrayElements(env, model, 0); } - disp__gluPwlCurve ( + if(perspective!=NULL) + { + ptr2 = (*env)->GetFloatArrayElements(env, perspective, 0); + } + if(view!=NULL) + { + ptr3 = (*env)->GetIntArrayElements(env, view, 0); + } + disp__gluLoadSamplingMatrices ( (GLUnurbs *) (PointerHolder) nurb, - (GLint) count, - (GLfloat *) ptr2, - (GLint) stride, - (GLenum) type + (const GLfloat *) ptr1, + (const GLfloat *) ptr2, + (const GLint *) ptr3 ); - if(data!=NULL) + if(model!=NULL) { - (*env)->ReleaseFloatArrayElements(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseFloatArrayElements(env, model, ptr1, JNI_ABORT); + } + if(perspective!=NULL) + { + (*env)->ReleaseFloatArrayElements(env, perspective, ptr2, JNI_ABORT); + } + if(view!=NULL) + { + (*env)->ReleaseIntArrayElements(env, view, ptr3, JNI_ABORT); } } /** * Original Function-Prototype : * 
 
-   extern void gluQuadricDrawStyle ( GLUquadric * quad , GLenum draw ) ;
+   extern void gluLookAt ( GLdouble eyeX , GLdouble eyeY , GLdouble eyeZ , GLdouble centerX , GLdouble centerY , GLdouble centerZ , GLdouble upX , GLdouble upY , GLdouble upZ ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluQuadricDrawStyle ( + Java_gl4java_GLUFuncJauJNI_gluLookAt ( JNIEnv *env, jobject obj, - jlong quad, - jint draw) + jdouble eyeX, + jdouble eyeY, + jdouble eyeZ, + jdouble centerX, + jdouble centerY, + jdouble centerZ, + jdouble upX, + jdouble upY, + jdouble upZ) { - if ( disp__gluQuadricDrawStyle == NULL ) return; + if ( disp__gluLookAt == NULL ) return; - disp__gluQuadricDrawStyle ( - (GLUquadric *) (PointerHolder) quad, - (GLenum) draw + disp__gluLookAt ( + (GLdouble) eyeX, + (GLdouble) eyeY, + (GLdouble) eyeZ, + (GLdouble) centerX, + (GLdouble) centerY, + (GLdouble) centerZ, + (GLdouble) upX, + (GLdouble) upY, + (GLdouble) upZ ); } @@ -2896,21 +2961,21 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) /** * Original Function-Prototype : * 
 
-   extern void gluQuadricNormals ( GLUquadric * quad , GLenum normal ) ;
+   extern void gluNextContour ( GLUtesselator * tess , GLenum type ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluQuadricNormals ( + Java_gl4java_GLUFuncJauJNI_gluNextContour ( JNIEnv *env, jobject obj, - jlong quad, - jint normal) + jlong tess, + jint type) { - if ( disp__gluQuadricNormals == NULL ) return; + if ( disp__gluNextContour == NULL ) return; - disp__gluQuadricNormals ( - (GLUquadric *) (PointerHolder) quad, - (GLenum) normal + disp__gluNextContour ( + (GLUtesselator *) (PointerHolder) tess, + (GLenum) type ); } @@ -2918,43 +2983,75 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) /** * Original Function-Prototype : * 
 
-   extern void gluQuadricOrientation ( GLUquadric * quad , GLenum orientation ) ;
+   extern void gluNurbsCurve ( GLUnurbs * nurb , GLint knotCount , GLfloat * knots , GLint stride , GLfloat * control , GLint order , GLenum type ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluQuadricOrientation ( + Java_gl4java_GLUFuncJauJNI_gluNurbsCurve ( JNIEnv *env, jobject obj, - jlong quad, - jint orientation) + 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__gluQuadricOrientation == NULL ) return; + if ( disp__gluNurbsCurve == NULL ) return; - disp__gluQuadricOrientation ( - (GLUquadric *) (PointerHolder) quad, - (GLenum) orientation + if(knots!=NULL) + { + ptr2 = (*env)->GetFloatArrayElements(env, knots, &isCopiedArray2); + } + if(control!=NULL) + { + ptr4 = (*env)->GetFloatArrayElements(env, control, &isCopiedArray4); + } + disp__gluNurbsCurve ( + (GLUnurbs *) (PointerHolder) nurb, + (GLint) knotCount, + (GLfloat *) ptr2, + (GLint) stride, + (GLfloat *) ptr4, + (GLint) order, + (GLenum) type ); + if(knots!=NULL) + { + (*env)->ReleaseFloatArrayElements(env, knots, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT); + } + if(control!=NULL) + { + (*env)->ReleaseFloatArrayElements(env, control, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT); + } } /** * Original Function-Prototype : * 
 
-   extern void gluQuadricTexture ( GLUquadric * quad , GLboolean texture ) ;
+   extern void gluNurbsProperty ( GLUnurbs * nurb , GLenum property , GLfloat value ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluQuadricTexture ( + Java_gl4java_GLUFuncJauJNI_gluNurbsProperty ( JNIEnv *env, jobject obj, - jlong quad, - jboolean texture) + jlong nurb, + jint property, + jfloat value) { - if ( disp__gluQuadricTexture == NULL ) return; + if ( disp__gluNurbsProperty == NULL ) return; - disp__gluQuadricTexture ( - (GLUquadric *) (PointerHolder) quad, - (GLboolean) texture + disp__gluNurbsProperty ( + (GLUnurbs *) (PointerHolder) nurb, + (GLenum) property, + (GLfloat) value ); } @@ -2962,389 +3059,95 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) /** * Original Function-Prototype : * 
 
-   extern GLint gluScaleImage ( GLenum format , GLsizei wIn , GLsizei hIn , GLenum typeIn , const void * dataIn , GLsizei wOut , GLsizei hOut , GLenum typeOut , GLvoid * dataOut ) ;
+   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 ) ;
  *
*/ - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_gluScaleImage__IIII_3BIII_3B ( + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_gluNurbsSurface ( 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 = (*env)->GetByteArrayElements(env, dataIn, 0); - } - if(dataOut!=NULL) - { - ptr8 = (*env)->GetByteArrayElements(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)->ReleaseByteArrayElements(env, dataIn, ptr4, JNI_ABORT); - } - if(dataOut!=NULL) - { - (*env)->ReleaseByteArrayElements(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT); - } - return ret; - } - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_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 = (*env)->GetShortArrayElements(env, dataIn, 0); - } - if(dataOut!=NULL) - { - ptr8 = (*env)->GetShortArrayElements(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)->ReleaseShortArrayElements(env, dataIn, ptr4, JNI_ABORT); - } - if(dataOut!=NULL) - { - (*env)->ReleaseShortArrayElements(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT); - } - return ret; - } - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_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 = (*env)->GetIntArrayElements(env, dataIn, 0); - } - if(dataOut!=NULL) - { - ptr8 = (*env)->GetIntArrayElements(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)->ReleaseIntArrayElements(env, dataIn, ptr4, JNI_ABORT); - } - if(dataOut!=NULL) - { - (*env)->ReleaseIntArrayElements(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT); - } - return ret; - } - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_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) + jlong nurb, + jint sKnotCount, + jfloatArray sKnots, + jint tKnotCount, + jfloatArray tKnots, + jint sStride, + jint tStride, + jfloatArray control, + jint sOrder, + jint tOrder, + jint type) { - jint ret; - + jboolean isCopiedArray2 = JNI_FALSE; + jfloat *ptr2 = NULL; + jboolean isCopiedArray4 = JNI_FALSE; jfloat *ptr4 = NULL; - jboolean isCopiedArray8 = JNI_FALSE; - jfloat *ptr8 = NULL; - - if ( disp__gluScaleImage == NULL ) return 0; - - if(dataIn!=NULL) - { - ptr4 = (*env)->GetFloatArrayElements(env, dataIn, 0); - } - if(dataOut!=NULL) - { - ptr8 = (*env)->GetFloatArrayElements(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)->ReleaseFloatArrayElements(env, dataIn, ptr4, JNI_ABORT); - } - if(dataOut!=NULL) - { - (*env)->ReleaseFloatArrayElements(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT); - } - return ret; - } - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_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; + jboolean isCopiedArray7 = JNI_FALSE; + jfloat *ptr7 = NULL; - if(dataIn!=NULL) - { - ptr4 = (*env)->GetDoubleArrayElements(env, dataIn, 0); - } - if(dataOut!=NULL) - { - ptr8 = (*env)->GetDoubleArrayElements(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 ( disp__gluNurbsSurface == NULL ) return; - if(dataIn!=NULL) - { - (*env)->ReleaseDoubleArrayElements(env, dataIn, ptr4, JNI_ABORT); - } - if(dataOut!=NULL) + if(sKnots!=NULL) { - (*env)->ReleaseDoubleArrayElements(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT); + ptr2 = (*env)->GetFloatArrayElements(env, sKnots, &isCopiedArray2); } - return ret; - } - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_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) + if(tKnots!=NULL) { - ptr4 = (*env)->GetBooleanArrayElements(env, dataIn, 0); + ptr4 = (*env)->GetFloatArrayElements(env, tKnots, &isCopiedArray4); } - if(dataOut!=NULL) + if(control!=NULL) { - ptr8 = (*env)->GetBooleanArrayElements(env, dataOut, &isCopiedArray8); + ptr7 = (*env)->GetFloatArrayElements(env, control, &isCopiedArray7); } - ret = (jint) disp__gluScaleImage ( - (GLenum) format, - (GLsizei) wIn, - (GLsizei) hIn, - (GLenum) typeIn, - (const void *) ptr4, - (GLsizei) wOut, - (GLsizei) hOut, - (GLenum) typeOut, - (GLvoid *) ptr8 + 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(dataIn!=NULL) - { - (*env)->ReleaseBooleanArrayElements(env, dataIn, ptr4, JNI_ABORT); - } - if(dataOut!=NULL) - { - (*env)->ReleaseBooleanArrayElements(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT); - } - return ret; - } - JNIEXPORT jint JNICALL - Java_gl4java_GLUFuncJauJNI_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 = (*env)->GetLongArrayElements(env, dataIn, 0); - } - if(dataOut!=NULL) + if(sKnots!=NULL) { - ptr8 = (*env)->GetLongArrayElements(env, dataOut, &isCopiedArray8); + (*env)->ReleaseFloatArrayElements(env, sKnots, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT); } - 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) + if(tKnots!=NULL) { - (*env)->ReleaseLongArrayElements(env, dataIn, ptr4, JNI_ABORT); + (*env)->ReleaseFloatArrayElements(env, tKnots, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT); } - if(dataOut!=NULL) + if(control!=NULL) { - (*env)->ReleaseLongArrayElements(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseFloatArrayElements(env, control, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT); } - return ret; } /** * Original Function-Prototype : * 
 
-   extern void gluSphere ( GLUquadric * quad , GLdouble radius , GLint slices , GLint stacks ) ;
+   extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluSphere ( + Java_gl4java_GLUFuncJauJNI_gluOrtho2D ( JNIEnv *env, jobject obj, - jlong quad, - jdouble radius, - jint slices, - jint stacks) + jdouble left, + jdouble right, + jdouble bottom, + jdouble top) { - if ( disp__gluSphere == NULL ) return; + if ( disp__gluOrtho2D == NULL ) return; - disp__gluSphere ( - (GLUquadric *) (PointerHolder) quad, - (GLdouble) radius, - (GLint) slices, - (GLint) stacks + disp__gluOrtho2D ( + (GLdouble) left, + (GLdouble) right, + (GLdouble) bottom, + (GLdouble) top ); } @@ -3352,19 +3155,31 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) /** * Original Function-Prototype : * 
 
-   extern void gluTessBeginContour ( GLUtesselator * tess ) ;
+   extern void gluPartialDisk ( GLUquadric * quad , GLdouble inner , GLdouble outer , GLint slices , GLint loops , GLdouble start , GLdouble sweep ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluTessBeginContour ( + Java_gl4java_GLUFuncJauJNI_gluPartialDisk ( JNIEnv *env, jobject obj, - jlong tess) + jlong quad, + jdouble inner, + jdouble outer, + jint slices, + jint loops, + jdouble start, + jdouble sweep) { - if ( disp__gluTessBeginContour == NULL ) return; + if ( disp__gluPartialDisk == NULL ) return; - disp__gluTessBeginContour ( - (GLUtesselator *) (PointerHolder) tess + disp__gluPartialDisk ( + (GLUquadric *) (PointerHolder) quad, + (GLdouble) inner, + (GLdouble) outer, + (GLint) slices, + (GLint) loops, + (GLdouble) start, + (GLdouble) sweep ); } @@ -3372,201 +3187,219 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) /** * Original Function-Prototype : * 
 
-   extern void gluTessBeginPolygon ( GLUtesselator * tess , GLvoid * data ) ;
+   extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3B ( + Java_gl4java_GLUFuncJauJNI_gluPerspective ( JNIEnv *env, jobject obj, - jlong tess, - jbyteArray data) + jdouble fovy, + jdouble aspect, + jdouble zNear, + jdouble zFar) { - jboolean isCopiedArray1 = JNI_FALSE; - jbyte *ptr1 = NULL; - if ( disp__gluTessBeginPolygon == NULL ) return; + if ( disp__gluPerspective == NULL ) return; - if(data!=NULL) - { - ptr1 = (*env)->GetByteArrayElements(env, data, &isCopiedArray1); - } - disp__gluTessBeginPolygon ( - (GLUtesselator *) (PointerHolder) tess, - (GLvoid *) ptr1 + disp__gluPerspective ( + (GLdouble) fovy, + (GLdouble) aspect, + (GLdouble) zNear, + (GLdouble) zFar ); - if(data!=NULL) - { - (*env)->ReleaseByteArrayElements(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); - } } + +/** + * Original Function-Prototype : + * 
 
+   extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble delX , GLdouble delY , GLint * viewport ) ;
+ *
+ */ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3S ( + Java_gl4java_GLUFuncJauJNI_gluPickMatrix ( JNIEnv *env, jobject obj, - jlong tess, - jshortArray data) + jdouble x, + jdouble y, + jdouble delX, + jdouble delY, + jintArray viewport) { - jboolean isCopiedArray1 = JNI_FALSE; - jshort *ptr1 = NULL; + jboolean isCopiedArray4 = JNI_FALSE; + jint *ptr4 = NULL; - if ( disp__gluTessBeginPolygon == NULL ) return; + if ( disp__gluPickMatrix == NULL ) return; - if(data!=NULL) + if(viewport!=NULL) { - ptr1 = (*env)->GetShortArrayElements(env, data, &isCopiedArray1); + ptr4 = (*env)->GetIntArrayElements(env, viewport, &isCopiedArray4); } - disp__gluTessBeginPolygon ( - (GLUtesselator *) (PointerHolder) tess, - (GLvoid *) ptr1 + disp__gluPickMatrix ( + (GLdouble) x, + (GLdouble) y, + (GLdouble) delX, + (GLdouble) delY, + (GLint *) ptr4 ); - if(data!=NULL) + if(viewport!=NULL) { - (*env)->ReleaseShortArrayElements(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseIntArrayElements(env, viewport, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT); } } - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3I ( + +/** + * Original Function-Prototype : + * 
 
+   extern GLint gluProject ( GLdouble objX , GLdouble objY , GLdouble objZ , const GLdouble * model , const GLdouble * proj , const GLint * view , GLdouble * winX , GLdouble * winY , GLdouble * winZ ) ;
+ *
+ */ + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_gluProject ( JNIEnv *env, jobject obj, - jlong tess, - jintArray data) + jdouble objX, + jdouble objY, + jdouble objZ, + jdoubleArray model, + jdoubleArray proj, + jintArray view, + jdoubleArray winX, + jdoubleArray winY, + jdoubleArray winZ) { - jboolean isCopiedArray1 = JNI_FALSE; - jint *ptr1 = NULL; + jint ret; - if ( disp__gluTessBeginPolygon == NULL ) return; + 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(data!=NULL) + if ( disp__gluProject == NULL ) return 0; + + if(model!=NULL) { - ptr1 = (*env)->GetIntArrayElements(env, data, &isCopiedArray1); + ptr3 = (*env)->GetDoubleArrayElements(env, model, 0); } - disp__gluTessBeginPolygon ( - (GLUtesselator *) (PointerHolder) tess, - (GLvoid *) ptr1 - ); - - if(data!=NULL) + if(proj!=NULL) { - (*env)->ReleaseIntArrayElements(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); + ptr4 = (*env)->GetDoubleArrayElements(env, proj, 0); } - } - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_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) + if(view!=NULL) { - ptr1 = (*env)->GetFloatArrayElements(env, data, &isCopiedArray1); + ptr5 = (*env)->GetIntArrayElements(env, view, 0); } - disp__gluTessBeginPolygon ( - (GLUtesselator *) (PointerHolder) tess, - (GLvoid *) ptr1 - ); - - if(data!=NULL) + if(winX!=NULL) { - (*env)->ReleaseFloatArrayElements(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); + ptr6 = (*env)->GetDoubleArrayElements(env, winX, &isCopiedArray6); } - } - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_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) + if(winY!=NULL) { - ptr1 = (*env)->GetDoubleArrayElements(env, data, &isCopiedArray1); + ptr7 = (*env)->GetDoubleArrayElements(env, winY, &isCopiedArray7); } - disp__gluTessBeginPolygon ( - (GLUtesselator *) (PointerHolder) tess, - (GLvoid *) ptr1 + if(winZ!=NULL) + { + ptr8 = (*env)->GetDoubleArrayElements(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(data!=NULL) + if(model!=NULL) { - (*env)->ReleaseDoubleArrayElements(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseDoubleArrayElements(env, model, ptr3, JNI_ABORT); } - } - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_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) + if(proj!=NULL) { - ptr1 = (*env)->GetBooleanArrayElements(env, data, &isCopiedArray1); + (*env)->ReleaseDoubleArrayElements(env, proj, ptr4, JNI_ABORT); } - disp__gluTessBeginPolygon ( - (GLUtesselator *) (PointerHolder) tess, - (GLvoid *) ptr1 - ); - - if(data!=NULL) + if(view!=NULL) + { + (*env)->ReleaseIntArrayElements(env, view, ptr5, JNI_ABORT); + } + if(winX!=NULL) + { + (*env)->ReleaseDoubleArrayElements(env, winX, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT); + } + if(winY!=NULL) + { + (*env)->ReleaseDoubleArrayElements(env, winY, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT); + } + if(winZ!=NULL) { - (*env)->ReleaseBooleanArrayElements(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseDoubleArrayElements(env, winZ, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT); } + return ret; } + +/** + * Original Function-Prototype : + * 
 
+   extern void gluPwlCurve ( GLUnurbs * nurb , GLint count , GLfloat * data , GLint stride , GLenum type ) ;
+ *
+ */ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3J ( + Java_gl4java_GLUFuncJauJNI_gluPwlCurve ( JNIEnv *env, jobject obj, - jlong tess, - jlongArray data) + jlong nurb, + jint count, + jfloatArray data, + jint stride, + jint type) { - jboolean isCopiedArray1 = JNI_FALSE; - jlong *ptr1 = NULL; + jboolean isCopiedArray2 = JNI_FALSE; + jfloat *ptr2 = NULL; - if ( disp__gluTessBeginPolygon == NULL ) return; + if ( disp__gluPwlCurve == NULL ) return; if(data!=NULL) { - ptr1 = (*env)->GetLongArrayElements(env, data, &isCopiedArray1); + ptr2 = (*env)->GetFloatArrayElements(env, data, &isCopiedArray2); } - disp__gluTessBeginPolygon ( - (GLUtesselator *) (PointerHolder) tess, - (GLvoid *) ptr1 + disp__gluPwlCurve ( + (GLUnurbs *) (PointerHolder) nurb, + (GLint) count, + (GLfloat *) ptr2, + (GLint) stride, + (GLenum) type ); if(data!=NULL) { - (*env)->ReleaseLongArrayElements(env, data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseFloatArrayElements(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT); } } /** * Original Function-Prototype : * 
 
-   extern void gluTessEndContour ( GLUtesselator * tess ) ;
+   extern void gluQuadricDrawStyle ( GLUquadric * quad , GLenum draw ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluTessEndContour ( + Java_gl4java_GLUFuncJauJNI_gluQuadricDrawStyle ( JNIEnv *env, jobject obj, - jlong tess) + jlong quad, + jint draw) { - if ( disp__gluTessEndContour == NULL ) return; + if ( disp__gluQuadricDrawStyle == NULL ) return; - disp__gluTessEndContour ( - (GLUtesselator *) (PointerHolder) tess + disp__gluQuadricDrawStyle ( + (GLUquadric *) (PointerHolder) quad, + (GLenum) draw ); } @@ -3574,19 +3407,21 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) /** * Original Function-Prototype : * 
 
-   extern void gluTessEndPolygon ( GLUtesselator * tess ) ;
+   extern void gluQuadricNormals ( GLUquadric * quad , GLenum normal ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluTessEndPolygon ( + Java_gl4java_GLUFuncJauJNI_gluQuadricNormals ( JNIEnv *env, jobject obj, - jlong tess) + jlong quad, + jint normal) { - if ( disp__gluTessEndPolygon == NULL ) return; + if ( disp__gluQuadricNormals == NULL ) return; - disp__gluTessEndPolygon ( - (GLUtesselator *) (PointerHolder) tess + disp__gluQuadricNormals ( + (GLUquadric *) (PointerHolder) quad, + (GLenum) normal ); } @@ -3594,25 +3429,21 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) /** * Original Function-Prototype : * 
 
-   extern void gluTessNormal ( GLUtesselator * tess , GLdouble valueX , GLdouble valueY , GLdouble valueZ ) ;
+   extern void gluQuadricOrientation ( GLUquadric * quad , GLenum orientation ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluTessNormal ( + Java_gl4java_GLUFuncJauJNI_gluQuadricOrientation ( JNIEnv *env, jobject obj, - jlong tess, - jdouble valueX, - jdouble valueY, - jdouble valueZ) + jlong quad, + jint orientation) { - if ( disp__gluTessNormal == NULL ) return; + if ( disp__gluQuadricOrientation == NULL ) return; - disp__gluTessNormal ( - (GLUtesselator *) (PointerHolder) tess, - (GLdouble) valueX, - (GLdouble) valueY, - (GLdouble) valueZ + disp__gluQuadricOrientation ( + (GLUquadric *) (PointerHolder) quad, + (GLenum) orientation ); } @@ -3620,23 +3451,21 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) /** * Original Function-Prototype : * 
 
-   extern void gluTessProperty ( GLUtesselator * tess , GLenum which , GLdouble data ) ;
+   extern void gluQuadricTexture ( GLUquadric * quad , GLboolean texture ) ;
  *
*/ JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluTessProperty ( + Java_gl4java_GLUFuncJauJNI_gluQuadricTexture ( JNIEnv *env, jobject obj, - jlong tess, - jint which, - jdouble data) + jlong quad, + jboolean texture) { - if ( disp__gluTessProperty == NULL ) return; + if ( disp__gluQuadricTexture == NULL ) return; - disp__gluTessProperty ( - (GLUtesselator *) (PointerHolder) tess, - (GLenum) which, - (GLdouble) data + disp__gluQuadricTexture ( + (GLUquadric *) (PointerHolder) quad, + (GLboolean) texture ); } @@ -3644,267 +3473,391 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj) /** * Original Function-Prototype : * 
 
-   extern void gluTessVertex ( GLUtesselator * tess , GLdouble * location , GLvoid * data ) ;
+   extern GLint gluScaleImage ( GLenum format , GLsizei wIn , GLsizei hIn , GLenum typeIn , const void * dataIn , GLsizei wOut , GLsizei hOut , GLenum typeOut , GLvoid * dataOut ) ;
  *
*/ - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3B ( + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_gluScaleImage__IIII_3BIII_3B ( JNIEnv *env, jobject obj, - jlong tess, - jdoubleArray location, - jbyteArray data) + jint format, + jint wIn, + jint hIn, + jint typeIn, + jbyteArray dataIn, + jint wOut, + jint hOut, + jint typeOut, + jbyteArray dataOut) { - jboolean isCopiedArray1 = JNI_FALSE; - jdouble *ptr1 = NULL; - jboolean isCopiedArray2 = JNI_FALSE; - jbyte *ptr2 = NULL; + jint ret; - if ( disp__gluTessVertex == NULL ) return; + jbyte *ptr4 = NULL; + jboolean isCopiedArray8 = JNI_FALSE; + jbyte *ptr8 = NULL; - if(location!=NULL) + if ( disp__gluScaleImage == NULL ) return 0; + + if(dataIn!=NULL) { - ptr1 = (*env)->GetDoubleArrayElements(env, location, &isCopiedArray1); + ptr4 = (*env)->GetByteArrayElements(env, dataIn, 0); } - if(data!=NULL) + if(dataOut!=NULL) { - ptr2 = (*env)->GetByteArrayElements(env, data, &isCopiedArray2); + ptr8 = (*env)->GetByteArrayElements(env, dataOut, &isCopiedArray8); } - disp__gluTessVertex ( - (GLUtesselator *) (PointerHolder) tess, - (GLdouble *) ptr1, - (GLvoid *) ptr2 + ret = (jint) disp__gluScaleImage ( + (GLenum) format, + (GLsizei) wIn, + (GLsizei) hIn, + (GLenum) typeIn, + (const void *) ptr4, + (GLsizei) wOut, + (GLsizei) hOut, + (GLenum) typeOut, + (GLvoid *) ptr8 ); - if(location!=NULL) + if(dataIn!=NULL) { - (*env)->ReleaseDoubleArrayElements(env, location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseByteArrayElements(env, dataIn, ptr4, JNI_ABORT); } - if(data!=NULL) + if(dataOut!=NULL) { - (*env)->ReleaseByteArrayElements(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseByteArrayElements(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT); } + return ret; } - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3S ( + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_gluScaleImage__IIII_3SIII_3S ( JNIEnv *env, jobject obj, - jlong tess, - jdoubleArray location, - jshortArray data) + jint format, + jint wIn, + jint hIn, + jint typeIn, + jshortArray dataIn, + jint wOut, + jint hOut, + jint typeOut, + jshortArray dataOut) { - jboolean isCopiedArray1 = JNI_FALSE; - jdouble *ptr1 = NULL; - jboolean isCopiedArray2 = JNI_FALSE; - jshort *ptr2 = NULL; + jint ret; - if ( disp__gluTessVertex == NULL ) return; + jshort *ptr4 = NULL; + jboolean isCopiedArray8 = JNI_FALSE; + jshort *ptr8 = NULL; - if(location!=NULL) + if ( disp__gluScaleImage == NULL ) return 0; + + if(dataIn!=NULL) { - ptr1 = (*env)->GetDoubleArrayElements(env, location, &isCopiedArray1); + ptr4 = (*env)->GetShortArrayElements(env, dataIn, 0); } - if(data!=NULL) + if(dataOut!=NULL) { - ptr2 = (*env)->GetShortArrayElements(env, data, &isCopiedArray2); + ptr8 = (*env)->GetShortArrayElements(env, dataOut, &isCopiedArray8); } - disp__gluTessVertex ( - (GLUtesselator *) (PointerHolder) tess, - (GLdouble *) ptr1, - (GLvoid *) ptr2 + ret = (jint) disp__gluScaleImage ( + (GLenum) format, + (GLsizei) wIn, + (GLsizei) hIn, + (GLenum) typeIn, + (const void *) ptr4, + (GLsizei) wOut, + (GLsizei) hOut, + (GLenum) typeOut, + (GLvoid *) ptr8 ); - if(location!=NULL) + if(dataIn!=NULL) { - (*env)->ReleaseDoubleArrayElements(env, location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseShortArrayElements(env, dataIn, ptr4, JNI_ABORT); } - if(data!=NULL) + if(dataOut!=NULL) { - (*env)->ReleaseShortArrayElements(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseShortArrayElements(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT); } + return ret; } - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3I ( + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_gluScaleImage__IIII_3IIII_3I ( JNIEnv *env, jobject obj, - jlong tess, - jdoubleArray location, - jintArray data) + jint format, + jint wIn, + jint hIn, + jint typeIn, + jintArray dataIn, + jint wOut, + jint hOut, + jint typeOut, + jintArray dataOut) { - jboolean isCopiedArray1 = JNI_FALSE; - jdouble *ptr1 = NULL; - jboolean isCopiedArray2 = JNI_FALSE; - jint *ptr2 = NULL; + jint ret; - if ( disp__gluTessVertex == NULL ) return; + jint *ptr4 = NULL; + jboolean isCopiedArray8 = JNI_FALSE; + jint *ptr8 = NULL; - if(location!=NULL) + if ( disp__gluScaleImage == NULL ) return 0; + + if(dataIn!=NULL) { - ptr1 = (*env)->GetDoubleArrayElements(env, location, &isCopiedArray1); + ptr4 = (*env)->GetIntArrayElements(env, dataIn, 0); } - if(data!=NULL) + if(dataOut!=NULL) { - ptr2 = (*env)->GetIntArrayElements(env, data, &isCopiedArray2); + ptr8 = (*env)->GetIntArrayElements(env, dataOut, &isCopiedArray8); } - disp__gluTessVertex ( - (GLUtesselator *) (PointerHolder) tess, - (GLdouble *) ptr1, - (GLvoid *) ptr2 + ret = (jint) disp__gluScaleImage ( + (GLenum) format, + (GLsizei) wIn, + (GLsizei) hIn, + (GLenum) typeIn, + (const void *) ptr4, + (GLsizei) wOut, + (GLsizei) hOut, + (GLenum) typeOut, + (GLvoid *) ptr8 ); - if(location!=NULL) + if(dataIn!=NULL) { - (*env)->ReleaseDoubleArrayElements(env, location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseIntArrayElements(env, dataIn, ptr4, JNI_ABORT); } - if(data!=NULL) + if(dataOut!=NULL) { - (*env)->ReleaseIntArrayElements(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseIntArrayElements(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT); } + return ret; } - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3F ( + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_gluScaleImage__IIII_3FIII_3F ( JNIEnv *env, jobject obj, - jlong tess, - jdoubleArray location, - jfloatArray data) + jint format, + jint wIn, + jint hIn, + jint typeIn, + jfloatArray dataIn, + jint wOut, + jint hOut, + jint typeOut, + jfloatArray dataOut) { - jboolean isCopiedArray1 = JNI_FALSE; - jdouble *ptr1 = NULL; - jboolean isCopiedArray2 = JNI_FALSE; - jfloat *ptr2 = NULL; + jint ret; - if ( disp__gluTessVertex == NULL ) return; + jfloat *ptr4 = NULL; + jboolean isCopiedArray8 = JNI_FALSE; + jfloat *ptr8 = NULL; - if(location!=NULL) + if ( disp__gluScaleImage == NULL ) return 0; + + if(dataIn!=NULL) { - ptr1 = (*env)->GetDoubleArrayElements(env, location, &isCopiedArray1); + ptr4 = (*env)->GetFloatArrayElements(env, dataIn, 0); } - if(data!=NULL) + if(dataOut!=NULL) { - ptr2 = (*env)->GetFloatArrayElements(env, data, &isCopiedArray2); + ptr8 = (*env)->GetFloatArrayElements(env, dataOut, &isCopiedArray8); } - disp__gluTessVertex ( - (GLUtesselator *) (PointerHolder) tess, - (GLdouble *) ptr1, - (GLvoid *) ptr2 + ret = (jint) disp__gluScaleImage ( + (GLenum) format, + (GLsizei) wIn, + (GLsizei) hIn, + (GLenum) typeIn, + (const void *) ptr4, + (GLsizei) wOut, + (GLsizei) hOut, + (GLenum) typeOut, + (GLvoid *) ptr8 ); - if(location!=NULL) + if(dataIn!=NULL) { - (*env)->ReleaseDoubleArrayElements(env, location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseFloatArrayElements(env, dataIn, ptr4, JNI_ABORT); } - if(data!=NULL) + if(dataOut!=NULL) { - (*env)->ReleaseFloatArrayElements(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseFloatArrayElements(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT); } + return ret; } - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3D ( + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_gluScaleImage__IIII_3DIII_3D ( JNIEnv *env, jobject obj, - jlong tess, - jdoubleArray location, - jdoubleArray data) + jint format, + jint wIn, + jint hIn, + jint typeIn, + jdoubleArray dataIn, + jint wOut, + jint hOut, + jint typeOut, + jdoubleArray dataOut) { - jboolean isCopiedArray1 = JNI_FALSE; - jdouble *ptr1 = NULL; - jboolean isCopiedArray2 = JNI_FALSE; - jdouble *ptr2 = NULL; + jint ret; - if ( disp__gluTessVertex == NULL ) return; + jdouble *ptr4 = NULL; + jboolean isCopiedArray8 = JNI_FALSE; + jdouble *ptr8 = NULL; - if(location!=NULL) + if ( disp__gluScaleImage == NULL ) return 0; + + if(dataIn!=NULL) { - ptr1 = (*env)->GetDoubleArrayElements(env, location, &isCopiedArray1); + ptr4 = (*env)->GetDoubleArrayElements(env, dataIn, 0); } - if(data!=NULL) + if(dataOut!=NULL) { - ptr2 = (*env)->GetDoubleArrayElements(env, data, &isCopiedArray2); + ptr8 = (*env)->GetDoubleArrayElements(env, dataOut, &isCopiedArray8); } - disp__gluTessVertex ( - (GLUtesselator *) (PointerHolder) tess, - (GLdouble *) ptr1, - (GLvoid *) ptr2 + ret = (jint) disp__gluScaleImage ( + (GLenum) format, + (GLsizei) wIn, + (GLsizei) hIn, + (GLenum) typeIn, + (const void *) ptr4, + (GLsizei) wOut, + (GLsizei) hOut, + (GLenum) typeOut, + (GLvoid *) ptr8 ); - if(location!=NULL) + if(dataIn!=NULL) { - (*env)->ReleaseDoubleArrayElements(env, location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseDoubleArrayElements(env, dataIn, ptr4, JNI_ABORT); } - if(data!=NULL) + if(dataOut!=NULL) { - (*env)->ReleaseDoubleArrayElements(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseDoubleArrayElements(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT); } + return ret; } - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3Z ( + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_gluScaleImage__IIII_3ZIII_3Z ( JNIEnv *env, jobject obj, - jlong tess, - jdoubleArray location, - jbooleanArray data) + jint format, + jint wIn, + jint hIn, + jint typeIn, + jbooleanArray dataIn, + jint wOut, + jint hOut, + jint typeOut, + jbooleanArray dataOut) { - jboolean isCopiedArray1 = JNI_FALSE; - jdouble *ptr1 = NULL; - jboolean isCopiedArray2 = JNI_FALSE; - jboolean *ptr2 = NULL; + jint ret; - if ( disp__gluTessVertex == NULL ) return; + jboolean *ptr4 = NULL; + jboolean isCopiedArray8 = JNI_FALSE; + jboolean *ptr8 = NULL; - if(location!=NULL) + if ( disp__gluScaleImage == NULL ) return 0; + + if(dataIn!=NULL) { - ptr1 = (*env)->GetDoubleArrayElements(env, location, &isCopiedArray1); + ptr4 = (*env)->GetBooleanArrayElements(env, dataIn, 0); } - if(data!=NULL) + if(dataOut!=NULL) { - ptr2 = (*env)->GetBooleanArrayElements(env, data, &isCopiedArray2); + ptr8 = (*env)->GetBooleanArrayElements(env, dataOut, &isCopiedArray8); } - disp__gluTessVertex ( - (GLUtesselator *) (PointerHolder) tess, - (GLdouble *) ptr1, - (GLvoid *) ptr2 + ret = (jint) disp__gluScaleImage ( + (GLenum) format, + (GLsizei) wIn, + (GLsizei) hIn, + (GLenum) typeIn, + (const void *) ptr4, + (GLsizei) wOut, + (GLsizei) hOut, + (GLenum) typeOut, + (GLvoid *) ptr8 ); - if(location!=NULL) + if(dataIn!=NULL) { - (*env)->ReleaseDoubleArrayElements(env, location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseBooleanArrayElements(env, dataIn, ptr4, JNI_ABORT); } - if(data!=NULL) + if(dataOut!=NULL) { - (*env)->ReleaseBooleanArrayElements(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseBooleanArrayElements(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT); } + return ret; } - JNIEXPORT void JNICALL - Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3J ( + JNIEXPORT jint JNICALL + Java_gl4java_GLUFuncJauJNI_gluScaleImage__IIII_3JIII_3J ( JNIEnv *env, jobject obj, - jlong tess, - jdoubleArray location, - jlongArray data) + jint format, + jint wIn, + jint hIn, + jint typeIn, + jlongArray dataIn, + jint wOut, + jint hOut, + jint typeOut, + jlongArray dataOut) { - jboolean isCopiedArray1 = JNI_FALSE; - jdouble *ptr1 = NULL; - jboolean isCopiedArray2 = JNI_FALSE; - jlong *ptr2 = NULL; + jint ret; - if ( disp__gluTessVertex == NULL ) return; + jlong *ptr4 = NULL; + jboolean isCopiedArray8 = JNI_FALSE; + jlong *ptr8 = NULL; - if(location!=NULL) + if ( disp__gluScaleImage == NULL ) return 0; + + if(dataIn!=NULL) { - ptr1 = (*env)->GetDoubleArrayElements(env, location, &isCopiedArray1); + ptr4 = (*env)->GetLongArrayElements(env, dataIn, 0); } - if(data!=NULL) + if(dataOut!=NULL) { - ptr2 = (*env)->GetLongArrayElements(env, data, &isCopiedArray2); + ptr8 = (*env)->GetLongArrayElements(env, dataOut, &isCopiedArray8); } - disp__gluTessVertex ( - (GLUtesselator *) (PointerHolder) tess, - (GLdouble *) ptr1, - (GLvoid *) ptr2 + ret = (jint) disp__gluScaleImage ( + (GLenum) format, + (GLsizei) wIn, + (GLsizei) hIn, + (GLenum) typeIn, + (const void *) ptr4, + (GLsizei) wOut, + (GLsizei) hOut, + (GLenum) typeOut, + (GLvoid *) ptr8 ); - if(location!=NULL) + if(dataIn!=NULL) { - (*env)->ReleaseDoubleArrayElements(env, location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseLongArrayElements(env, dataIn, ptr4, JNI_ABORT); } - if(data!=NULL) + if(dataOut!=NULL) { - (*env)->ReleaseLongArrayElements(env, data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT); + (*env)->ReleaseLongArrayElements(env, dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT); } + return ret; + } + +/** + * Original Function-Prototype : + * 
 
+   extern void gluSphere ( GLUquadric * quad , GLdouble radius , GLint slices , GLint stacks ) ;
+ *
+ */ + JNIEXPORT void JNICALL + Java_gl4java_GLUFuncJauJNI_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 + ); + } /** -- cgit v1.2.3