java.nio, mesa-4.0 (gl1.3)

1 files changed, 2532 insertions, 865 deletions

diff --git a/CNativeCode/OpenGLU_JauJNI_funcs.c b/CNativeCode/OpenGLU_JauJNI_funcs.c
index 276761c..114bfff 100644
--- a/CNativeCode/OpenGLU_JauJNI_funcs.c
+++ b/CNativeCode/OpenGLU_JauJNI_funcs.c
@@ -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.0.0";
+static const char * _glu_lib_version_="2.8.0.8";
 
 JNIEXPORT jstring JNICALL
 Java_gl4java_GLUFuncJauJNI_getNativeVendor ( JNIEnv *env, jobject obj )
@@ -301,7 +301,7 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 }
 
 /**
- * C2J Parser Version 2.2
+ * C2J Parser Version 3.0
  * Jausoft - Sven Goethel Software Development
  * Reading from file: glu-proto-auto.orig.h . . .
  * Destination-Class: gl4java_GLUFuncJauJNI ! 
@@ -310,35 +310,19 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluLookAt ( GLdouble eyex , GLdouble eyey , GLdouble eyez , GLdouble centerx , GLdouble centery , GLdouble centerz , GLdouble upx , GLdouble upy , GLdouble upz ) ;
+   extern void gluBeginCurve ( GLUnurbs * nurb ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluLookAt (
+	Java_gl4java_GLUFuncJauJNI_gluBeginCurve (
 		JNIEnv *env, jobject obj,
-		jdouble eyex,
-		jdouble eyey,
-		jdouble eyez,
-		jdouble centerx,
-		jdouble centery,
-		jdouble centerz,
-		jdouble upx,
-		jdouble upy,
-		jdouble upz)
+		jlong nurb)
 	{
 
-		if ( disp__gluLookAt == NULL ) return;
+		if ( disp__gluBeginCurve == NULL ) return;
 
-		disp__gluLookAt (
-			(GLdouble) eyex,
-			(GLdouble) eyey,
-			(GLdouble) eyez,
-			(GLdouble) centerx,
-			(GLdouble) centery,
-			(GLdouble) centerz,
-			(GLdouble) upx,
-			(GLdouble) upy,
-			(GLdouble) upz
+		disp__gluBeginCurve (
+			(GLUnurbs *) (PointerHolder) nurb
 		);
 
 	}
@@ -346,25 +330,19 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ;
+   extern void gluBeginPolygon ( GLUtesselator * tess ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluOrtho2D (
+	Java_gl4java_GLUFuncJauJNI_gluBeginPolygon (
 		JNIEnv *env, jobject obj,
-		jdouble left,
-		jdouble right,
-		jdouble bottom,
-		jdouble top)
+		jlong tess)
 	{
 
-		if ( disp__gluOrtho2D == NULL ) return;
+		if ( disp__gluBeginPolygon == NULL ) return;
 
-		disp__gluOrtho2D (
-			(GLdouble) left,
-			(GLdouble) right,
-			(GLdouble) bottom,
-			(GLdouble) top
+		disp__gluBeginPolygon (
+			(GLUtesselator *) (PointerHolder) tess
 		);
 
 	}
@@ -372,25 +350,19 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ;
+   extern void gluBeginSurface ( GLUnurbs * nurb ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluPerspective (
+	Java_gl4java_GLUFuncJauJNI_gluBeginSurface (
 		JNIEnv *env, jobject obj,
-		jdouble fovy,
-		jdouble aspect,
-		jdouble zNear,
-		jdouble zFar)
+		jlong nurb)
 	{
 
-		if ( disp__gluPerspective == NULL ) return;
+		if ( disp__gluBeginSurface == NULL ) return;
 
-		disp__gluPerspective (
-			(GLdouble) fovy,
-			(GLdouble) aspect,
-			(GLdouble) zNear,
-			(GLdouble) zFar
+		disp__gluBeginSurface (
+			(GLUnurbs *) (PointerHolder) nurb
 		);
 
 	}
@@ -398,287 +370,313 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble width , GLdouble height , GLint * viewport ) ;
+   extern void gluBeginTrim ( GLUnurbs * nurb ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluPickMatrix (
+	Java_gl4java_GLUFuncJauJNI_gluBeginTrim (
 		JNIEnv *env, jobject obj,
-		jdouble x,
-		jdouble y,
-		jdouble width,
-		jdouble height,
-		jintArray viewport)
+		jlong nurb)
 	{
-		jboolean isCopiedArray4 = JNI_FALSE;
-		jint *ptr4 = NULL;
 
-		if ( disp__gluPickMatrix == NULL ) return;
+		if ( disp__gluBeginTrim == NULL ) return;
 
-		if(viewport!=NULL)
-		{
-			ptr4 = (*env)->GetIntArrayElements(env, viewport, &isCopiedArray4);
-		}
-		disp__gluPickMatrix (
-			(GLdouble) x,
-			(GLdouble) y,
-			(GLdouble) width,
-			(GLdouble) height,
-			(GLint *) ptr4
+		disp__gluBeginTrim (
+			(GLUnurbs *) (PointerHolder) nurb
 		);
 
-		if(viewport!=NULL)
-		{
-			(*env)->ReleaseIntArrayElements(env,  viewport, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
-		}
 	}
 
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern GLint gluProject ( GLdouble objx , GLdouble objy , GLdouble objz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * winx , GLdouble * winy , GLdouble * winz ) ;
+   extern GLint gluBuild1DMipmapLevels ( GLenum target , GLint internalFormat , GLsizei width , GLenum format , GLenum type , GLint level , GLint base , GLint max , const void * data ) ;
  * </pre> 
  */
 	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluProject (
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3B (
 		JNIEnv *env, jobject obj,
-		jdouble objx,
-		jdouble objy,
-		jdouble objz,
-		jdoubleArray modelMatrix,
-		jdoubleArray projMatrix,
-		jintArray viewport,
-		jdoubleArray winx,
-		jdoubleArray winy,
-		jdoubleArray winz)
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jbyteArray 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;
+		jbyte *ptr8 = NULL;
 
-		if ( disp__gluProject == NULL ) return 0;
+		if ( disp__gluBuild1DMipmapLevels == NULL ) return 0;
 
-		if(modelMatrix!=NULL)
-		{
-			ptr3 = (*env)->GetDoubleArrayElements(env, modelMatrix, 0);
-		}
-		if(projMatrix!=NULL)
-		{
-			ptr4 = (*env)->GetDoubleArrayElements(env, projMatrix, 0);
-		}
-		if(viewport!=NULL)
-		{
-			ptr5 = (*env)->GetIntArrayElements(env, viewport, 0);
-		}
-		if(winx!=NULL)
+		if(data!=NULL)
 		{
-			ptr6 = (*env)->GetDoubleArrayElements(env, winx, &isCopiedArray6);
+			ptr8 = (*env)->GetByteArrayElements(env, data, 0);
 		}
-		if(winy!=NULL)
+		ret = (jint) disp__gluBuild1DMipmapLevels (
+			(GLenum) target,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(GLint) level,
+			(GLint) base,
+			(GLint) max,
+			(const void *) ptr8
+		);
+
+		if(data!=NULL)
 		{
-			ptr7 = (*env)->GetDoubleArrayElements(env, winy, &isCopiedArray7);
+			(*env)->ReleaseByteArrayElements(env,  data, ptr8, JNI_ABORT);
 		}
-		if(winz!=NULL)
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jshortArray data)
+	{
+		jint ret;
+
+		jshort *ptr8 = NULL;
+
+		if ( disp__gluBuild1DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
 		{
-			ptr8 = (*env)->GetDoubleArrayElements(env, winz, &isCopiedArray8);
+			ptr8 = (*env)->GetShortArrayElements(env, data, 0);
 		}
-		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
+		ret = (jint) disp__gluBuild1DMipmapLevels (
+			(GLenum) target,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(GLint) level,
+			(GLint) base,
+			(GLint) max,
+			(const void *) ptr8
 		);
 
-		if(modelMatrix!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  modelMatrix, ptr3, JNI_ABORT);
-		}
-		if(projMatrix!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseDoubleArrayElements(env,  projMatrix, ptr4, JNI_ABORT);
+			(*env)->ReleaseShortArrayElements(env,  data, ptr8, JNI_ABORT);
 		}
-		if(viewport!=NULL)
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jintArray data)
+	{
+		jint ret;
+
+		jint *ptr8 = NULL;
+
+		if ( disp__gluBuild1DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
 		{
-			(*env)->ReleaseIntArrayElements(env,  viewport, ptr5, JNI_ABORT);
+			ptr8 = (*env)->GetIntArrayElements(env, data, 0);
 		}
-		if(winx!=NULL)
+		ret = (jint) disp__gluBuild1DMipmapLevels (
+			(GLenum) target,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(GLint) level,
+			(GLint) base,
+			(GLint) max,
+			(const void *) ptr8
+		);
+
+		if(data!=NULL)
 		{
-			(*env)->ReleaseDoubleArrayElements(env,  winx, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseIntArrayElements(env,  data, ptr8, JNI_ABORT);
 		}
-		if(winy!=NULL)
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jfloatArray data)
+	{
+		jint ret;
+
+		jfloat *ptr8 = NULL;
+
+		if ( disp__gluBuild1DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
 		{
-			(*env)->ReleaseDoubleArrayElements(env,  winy, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+			ptr8 = (*env)->GetFloatArrayElements(env, data, 0);
 		}
-		if(winz!=NULL)
+		ret = (jint) disp__gluBuild1DMipmapLevels (
+			(GLenum) target,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(GLint) level,
+			(GLint) base,
+			(GLint) max,
+			(const void *) ptr8
+		);
+
+		if(data!=NULL)
 		{
-			(*env)->ReleaseDoubleArrayElements(env,  winz, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr8, JNI_ABORT);
 		}
 		return ret;
 	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern GLint gluUnProject ( GLdouble winx , GLdouble winy , GLdouble winz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * objx , GLdouble * objy , GLdouble * objz ) ;
- * </pre> 
- */
 	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluUnProject (
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3D (
 		JNIEnv *env, jobject obj,
-		jdouble winx,
-		jdouble winy,
-		jdouble winz,
-		jdoubleArray modelMatrix,
-		jdoubleArray projMatrix,
-		jintArray viewport,
-		jdoubleArray objx,
-		jdoubleArray objy,
-		jdoubleArray objz)
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jdoubleArray 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;
 
-		if ( disp__gluUnProject == NULL ) return 0;
+		if ( disp__gluBuild1DMipmapLevels == NULL ) return 0;
 
-		if(modelMatrix!=NULL)
-		{
-			ptr3 = (*env)->GetDoubleArrayElements(env, modelMatrix, 0);
-		}
-		if(projMatrix!=NULL)
-		{
-			ptr4 = (*env)->GetDoubleArrayElements(env, projMatrix, 0);
-		}
-		if(viewport!=NULL)
-		{
-			ptr5 = (*env)->GetIntArrayElements(env, viewport, 0);
-		}
-		if(objx!=NULL)
-		{
-			ptr6 = (*env)->GetDoubleArrayElements(env, objx, &isCopiedArray6);
-		}
-		if(objy!=NULL)
-		{
-			ptr7 = (*env)->GetDoubleArrayElements(env, objy, &isCopiedArray7);
-		}
-		if(objz!=NULL)
+		if(data!=NULL)
 		{
-			ptr8 = (*env)->GetDoubleArrayElements(env, objz, &isCopiedArray8);
+			ptr8 = (*env)->GetDoubleArrayElements(env, data, 0);
 		}
-		ret = (jint) disp__gluUnProject (
-			(GLdouble) winx,
-			(GLdouble) winy,
-			(GLdouble) winz,
-			(const GLdouble *) ptr3,
-			(const GLdouble *) ptr4,
-			(const GLint *) ptr5,
-			(GLdouble *) ptr6,
-			(GLdouble *) ptr7,
-			(GLdouble *) ptr8
+		ret = (jint) disp__gluBuild1DMipmapLevels (
+			(GLenum) target,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(GLint) level,
+			(GLint) base,
+			(GLint) max,
+			(const void *) ptr8
 		);
 
-		if(modelMatrix!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  modelMatrix, ptr3, JNI_ABORT);
-		}
-		if(projMatrix!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  projMatrix, ptr4, JNI_ABORT);
-		}
-		if(viewport!=NULL)
-		{
-			(*env)->ReleaseIntArrayElements(env,  viewport, ptr5, JNI_ABORT);
-		}
-		if(objx!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseDoubleArrayElements(env,  objx, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr8, JNI_ABORT);
 		}
-		if(objy!=NULL)
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jbooleanArray data)
+	{
+		jint ret;
+
+		jboolean *ptr8 = NULL;
+
+		if ( disp__gluBuild1DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
 		{
-			(*env)->ReleaseDoubleArrayElements(env,  objy, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+			ptr8 = (*env)->GetBooleanArrayElements(env, data, 0);
 		}
-		if(objz!=NULL)
+		ret = (jint) disp__gluBuild1DMipmapLevels (
+			(GLenum) target,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(GLint) level,
+			(GLint) base,
+			(GLint) max,
+			(const void *) ptr8
+		);
+
+		if(data!=NULL)
 		{
-			(*env)->ReleaseDoubleArrayElements(env,  objz, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr8, JNI_ABORT);
 		}
 		return ret;
 	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern GLint gluScaleImage ( GLenum format , GLsizei widthin , GLsizei heightin , GLenum typein , const GLbyte * datain , GLsizei widthout , GLsizei heightout , GLenum typeout , GLbyte * dataout ) ;
- * </pre> 
- */
 	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluScaleImage (
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmapLevels__IIIIIIII_3J (
 		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
 		jint format,
-		jint widthin,
-		jint heightin,
-		jint typein,
-		jbyteArray datain,
-		jint widthout,
-		jint heightout,
-		jint typeout,
-		jbyteArray dataout)
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jlongArray data)
 	{
 		jint ret;
 
-		jbyte *ptr4 = NULL;
-		jboolean isCopiedArray8 = JNI_FALSE;
-		jbyte *ptr8 = NULL;
+		jlong *ptr8 = NULL;
 
-		if ( disp__gluScaleImage == NULL ) return 0;
+		if ( disp__gluBuild1DMipmapLevels == NULL ) return 0;
 
-		if(datain!=NULL)
-		{
-			ptr4 = (*env)->GetByteArrayElements(env, datain, 0);
-		}
-		if(dataout!=NULL)
+		if(data!=NULL)
 		{
-			ptr8 = (*env)->GetByteArrayElements(env, dataout, &isCopiedArray8);
+			ptr8 = (*env)->GetLongArrayElements(env, data, 0);
 		}
-		ret = (jint) disp__gluScaleImage (
+		ret = (jint) disp__gluBuild1DMipmapLevels (
+			(GLenum) target,
+			(GLint) internalFormat,
+			(GLsizei) width,
 			(GLenum) format,
-			(GLsizei) widthin,
-			(GLsizei) heightin,
-			(GLenum) typein,
-			(const GLbyte *) ptr4,
-			(GLsizei) widthout,
-			(GLsizei) heightout,
-			(GLenum) typeout,
-			(GLbyte *) ptr8
+			(GLenum) type,
+			(GLint) level,
+			(GLint) base,
+			(GLint) max,
+			(const void *) ptr8
 		);
 
-		if(datain!=NULL)
-		{
-			(*env)->ReleaseByteArrayElements(env,  datain, ptr4, JNI_ABORT);
-		}
-		if(dataout!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseByteArrayElements(env,  dataout, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseLongArrayElements(env,  data, ptr8, JNI_ABORT);
 		}
 		return ret;
 	}
@@ -686,14 +684,14 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern GLint gluBuild1DMipmaps ( GLenum target , GLint components , GLint width , GLenum format , GLenum type , const void * data ) ;
+   extern GLint gluBuild1DMipmaps ( GLenum target , GLint internalFormat , GLsizei width , GLenum format , GLenum type , const void * data ) ;
  * </pre> 
  */
 	JNIEXPORT jint JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3B (
 		JNIEnv *env, jobject obj,
 		jint target,
-		jint components,
+		jint internalFormat,
 		jint width,
 		jint format,
 		jint type,
@@ -711,8 +709,8 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 		}
 		ret = (jint) disp__gluBuild1DMipmaps (
 			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
+			(GLint) internalFormat,
+			(GLsizei) width,
 			(GLenum) format,
 			(GLenum) type,
 			(const void *) ptr5
@@ -728,7 +726,7 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3S (
 		JNIEnv *env, jobject obj,
 		jint target,
-		jint components,
+		jint internalFormat,
 		jint width,
 		jint format,
 		jint type,
@@ -746,8 +744,8 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 		}
 		ret = (jint) disp__gluBuild1DMipmaps (
 			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
+			(GLint) internalFormat,
+			(GLsizei) width,
 			(GLenum) format,
 			(GLenum) type,
 			(const void *) ptr5
@@ -763,7 +761,7 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3I (
 		JNIEnv *env, jobject obj,
 		jint target,
-		jint components,
+		jint internalFormat,
 		jint width,
 		jint format,
 		jint type,
@@ -781,8 +779,8 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 		}
 		ret = (jint) disp__gluBuild1DMipmaps (
 			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
+			(GLint) internalFormat,
+			(GLsizei) width,
 			(GLenum) format,
 			(GLenum) type,
 			(const void *) ptr5
@@ -798,7 +796,7 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3F (
 		JNIEnv *env, jobject obj,
 		jint target,
-		jint components,
+		jint internalFormat,
 		jint width,
 		jint format,
 		jint type,
@@ -816,8 +814,8 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 		}
 		ret = (jint) disp__gluBuild1DMipmaps (
 			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
+			(GLint) internalFormat,
+			(GLsizei) width,
 			(GLenum) format,
 			(GLenum) type,
 			(const void *) ptr5
@@ -833,7 +831,7 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3D (
 		JNIEnv *env, jobject obj,
 		jint target,
-		jint components,
+		jint internalFormat,
 		jint width,
 		jint format,
 		jint type,
@@ -851,8 +849,8 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 		}
 		ret = (jint) disp__gluBuild1DMipmaps (
 			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
+			(GLint) internalFormat,
+			(GLsizei) width,
 			(GLenum) format,
 			(GLenum) type,
 			(const void *) ptr5
@@ -868,7 +866,7 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3Z (
 		JNIEnv *env, jobject obj,
 		jint target,
-		jint components,
+		jint internalFormat,
 		jint width,
 		jint format,
 		jint type,
@@ -886,8 +884,8 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 		}
 		ret = (jint) disp__gluBuild1DMipmaps (
 			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
+			(GLint) internalFormat,
+			(GLsizei) width,
 			(GLenum) format,
 			(GLenum) type,
 			(const void *) ptr5
@@ -903,7 +901,7 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3J (
 		JNIEnv *env, jobject obj,
 		jint target,
-		jint components,
+		jint internalFormat,
 		jint width,
 		jint format,
 		jint type,
@@ -921,8 +919,8 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 		}
 		ret = (jint) disp__gluBuild1DMipmaps (
 			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
+			(GLint) internalFormat,
+			(GLsizei) width,
 			(GLenum) format,
 			(GLenum) type,
 			(const void *) ptr5
@@ -938,14 +936,322 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern GLint gluBuild2DMipmaps ( GLenum target , GLint components , GLint width , GLint height , GLenum format , GLenum type , const void * data ) ;
+   extern GLint gluBuild2DMipmapLevels ( GLenum target , GLint internalFormat , GLsizei width , GLsizei height , GLenum format , GLenum type , GLint level , GLint base , GLint max , const void * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jbyteArray data)
+	{
+		jint ret;
+
+		jbyte *ptr9 = NULL;
+
+		if ( disp__gluBuild2DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr9 = (*env)->GetByteArrayElements(env, data, 0);
+		}
+		ret = (jint) disp__gluBuild2DMipmapLevels (
+			(GLenum) target,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLint) level,
+			(GLint) base,
+			(GLint) max,
+			(const void *) ptr9
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  data, ptr9, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jshortArray data)
+	{
+		jint ret;
+
+		jshort *ptr9 = NULL;
+
+		if ( disp__gluBuild2DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr9 = (*env)->GetShortArrayElements(env, data, 0);
+		}
+		ret = (jint) disp__gluBuild2DMipmapLevels (
+			(GLenum) target,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLint) level,
+			(GLint) base,
+			(GLint) max,
+			(const void *) ptr9
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  data, ptr9, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jintArray data)
+	{
+		jint ret;
+
+		jint *ptr9 = NULL;
+
+		if ( disp__gluBuild2DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr9 = (*env)->GetIntArrayElements(env, data, 0);
+		}
+		ret = (jint) disp__gluBuild2DMipmapLevels (
+			(GLenum) target,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLint) level,
+			(GLint) base,
+			(GLint) max,
+			(const void *) ptr9
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  data, ptr9, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jfloatArray data)
+	{
+		jint ret;
+
+		jfloat *ptr9 = NULL;
+
+		if ( disp__gluBuild2DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr9 = (*env)->GetFloatArrayElements(env, data, 0);
+		}
+		ret = (jint) disp__gluBuild2DMipmapLevels (
+			(GLenum) target,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLint) level,
+			(GLint) base,
+			(GLint) max,
+			(const void *) ptr9
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr9, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jdoubleArray data)
+	{
+		jint ret;
+
+		jdouble *ptr9 = NULL;
+
+		if ( disp__gluBuild2DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr9 = (*env)->GetDoubleArrayElements(env, data, 0);
+		}
+		ret = (jint) disp__gluBuild2DMipmapLevels (
+			(GLenum) target,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLint) level,
+			(GLint) base,
+			(GLint) max,
+			(const void *) ptr9
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr9, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jbooleanArray data)
+	{
+		jint ret;
+
+		jboolean *ptr9 = NULL;
+
+		if ( disp__gluBuild2DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr9 = (*env)->GetBooleanArrayElements(env, data, 0);
+		}
+		ret = (jint) disp__gluBuild2DMipmapLevels (
+			(GLenum) target,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLint) level,
+			(GLint) base,
+			(GLint) max,
+			(const void *) ptr9
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr9, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmapLevels__IIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jlongArray data)
+	{
+		jint ret;
+
+		jlong *ptr9 = NULL;
+
+		if ( disp__gluBuild2DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr9 = (*env)->GetLongArrayElements(env, data, 0);
+		}
+		ret = (jint) disp__gluBuild2DMipmapLevels (
+			(GLenum) target,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLint) level,
+			(GLint) base,
+			(GLint) max,
+			(const void *) ptr9
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  data, ptr9, JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluBuild2DMipmaps ( GLenum target , GLint internalFormat , GLsizei width , GLsizei height , GLenum format , GLenum type , const void * data ) ;
  * </pre> 
  */
 	JNIEXPORT jint JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3B (
 		JNIEnv *env, jobject obj,
 		jint target,
-		jint components,
+		jint internalFormat,
 		jint width,
 		jint height,
 		jint format,
@@ -964,9 +1270,9 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 		}
 		ret = (jint) disp__gluBuild2DMipmaps (
 			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLint) height,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
 			(GLenum) format,
 			(GLenum) type,
 			(const void *) ptr6
@@ -982,7 +1288,7 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3S (
 		JNIEnv *env, jobject obj,
 		jint target,
-		jint components,
+		jint internalFormat,
 		jint width,
 		jint height,
 		jint format,
@@ -1001,9 +1307,9 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 		}
 		ret = (jint) disp__gluBuild2DMipmaps (
 			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLint) height,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
 			(GLenum) format,
 			(GLenum) type,
 			(const void *) ptr6
@@ -1019,7 +1325,7 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3I (
 		JNIEnv *env, jobject obj,
 		jint target,
-		jint components,
+		jint internalFormat,
 		jint width,
 		jint height,
 		jint format,
@@ -1038,9 +1344,9 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 		}
 		ret = (jint) disp__gluBuild2DMipmaps (
 			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLint) height,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
 			(GLenum) format,
 			(GLenum) type,
 			(const void *) ptr6
@@ -1056,7 +1362,7 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3F (
 		JNIEnv *env, jobject obj,
 		jint target,
-		jint components,
+		jint internalFormat,
 		jint width,
 		jint height,
 		jint format,
@@ -1075,9 +1381,9 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 		}
 		ret = (jint) disp__gluBuild2DMipmaps (
 			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLint) height,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
 			(GLenum) format,
 			(GLenum) type,
 			(const void *) ptr6
@@ -1093,7 +1399,7 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3D (
 		JNIEnv *env, jobject obj,
 		jint target,
-		jint components,
+		jint internalFormat,
 		jint width,
 		jint height,
 		jint format,
@@ -1112,9 +1418,9 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 		}
 		ret = (jint) disp__gluBuild2DMipmaps (
 			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLint) height,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
 			(GLenum) format,
 			(GLenum) type,
 			(const void *) ptr6
@@ -1130,7 +1436,7 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3Z (
 		JNIEnv *env, jobject obj,
 		jint target,
-		jint components,
+		jint internalFormat,
 		jint width,
 		jint height,
 		jint format,
@@ -1149,9 +1455,9 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 		}
 		ret = (jint) disp__gluBuild2DMipmaps (
 			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLint) height,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
 			(GLenum) format,
 			(GLenum) type,
 			(const void *) ptr6
@@ -1167,7 +1473,7 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3J (
 		JNIEnv *env, jobject obj,
 		jint target,
-		jint components,
+		jint internalFormat,
 		jint width,
 		jint height,
 		jint format,
@@ -1186,9 +1492,9 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 		}
 		ret = (jint) disp__gluBuild2DMipmaps (
 			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLint) height,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
 			(GLenum) format,
 			(GLenum) type,
 			(const void *) ptr6
@@ -1204,103 +1510,660 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluQuadricDrawStyle ( GLUquadricObj * quadObject , GLenum drawStyle ) ;
+   extern GLint gluBuild3DMipmapLevels ( GLenum target , GLint internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , GLint level , GLint base , GLint max , const void * data ) ;
  * </pre> 
  */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluQuadricDrawStyle (
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3B (
 		JNIEnv *env, jobject obj,
-		jlong quadObject,
-		jint drawStyle)
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jbyteArray data)
 	{
+		jint ret;
 
-		if ( disp__gluQuadricDrawStyle == NULL ) return;
+		jbyte *ptr10 = NULL;
 
-		disp__gluQuadricDrawStyle (
-			(GLUquadricObj *) (PointerHolder) quadObject,
-			(GLenum) drawStyle
+		if ( disp__gluBuild3DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr10 = (*env)->GetByteArrayElements(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)->ReleaseByteArrayElements(env,  data, ptr10, JNI_ABORT);
+		}
+		return ret;
 	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jshortArray data)
+	{
+		jint ret;
 
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluQuadricOrientation ( GLUquadricObj * quadObject , GLenum orientation ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluQuadricOrientation (
+		jshort *ptr10 = NULL;
+
+		if ( disp__gluBuild3DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr10 = (*env)->GetShortArrayElements(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)->ReleaseShortArrayElements(env,  data, ptr10, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3I (
 		JNIEnv *env, jobject obj,
-		jlong quadObject,
-		jint orientation)
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jintArray data)
 	{
+		jint ret;
 
-		if ( disp__gluQuadricOrientation == NULL ) return;
+		jint *ptr10 = NULL;
 
-		disp__gluQuadricOrientation (
-			(GLUquadricObj *) (PointerHolder) quadObject,
-			(GLenum) orientation
+		if ( disp__gluBuild3DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr10 = (*env)->GetIntArrayElements(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)->ReleaseIntArrayElements(env,  data, ptr10, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jfloatArray data)
+	{
+		jint ret;
+
+		jfloat *ptr10 = NULL;
+
+		if ( disp__gluBuild3DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr10 = (*env)->GetFloatArrayElements(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)->ReleaseFloatArrayElements(env,  data, ptr10, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jdoubleArray data)
+	{
+		jint ret;
+
+		jdouble *ptr10 = NULL;
+
+		if ( disp__gluBuild3DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr10 = (*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;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jbooleanArray data)
+	{
+		jint ret;
+
+		jboolean *ptr10 = NULL;
+
+		if ( disp__gluBuild3DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr10 = (*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;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmapLevels__IIIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jint level,
+		jint base,
+		jint max,
+		jlongArray data)
+	{
+		jint ret;
+
+		jlong *ptr10 = NULL;
+
+		if ( disp__gluBuild3DMipmapLevels == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr10 = (*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 :
  * <pre> 
-   extern void gluQuadricNormals ( GLUquadricObj * quadObject , GLenum normals ) ;
+   extern GLint gluBuild3DMipmaps ( GLenum target , GLint internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const void * data ) ;
  * </pre> 
  */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluQuadricNormals (
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmaps__IIIIIII_3B (
 		JNIEnv *env, jobject obj,
-		jlong quadObject,
-		jint normals)
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbyteArray data)
 	{
+		jint ret;
 
-		if ( disp__gluQuadricNormals == NULL ) return;
+		jbyte *ptr7 = NULL;
 
-		disp__gluQuadricNormals (
-			(GLUquadricObj *) (PointerHolder) quadObject,
-			(GLenum) normals
+		if ( disp__gluBuild3DMipmaps == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr7 = (*env)->GetByteArrayElements(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)->ReleaseByteArrayElements(env,  data, ptr7, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmaps__IIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		jint ret;
+
+		jshort *ptr7 = NULL;
+
+		if ( disp__gluBuild3DMipmaps == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr7 = (*env)->GetShortArrayElements(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)->ReleaseShortArrayElements(env,  data, ptr7, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmaps__IIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		jint ret;
+
+		jint *ptr7 = NULL;
+
+		if ( disp__gluBuild3DMipmaps == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr7 = (*env)->GetIntArrayElements(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)->ReleaseIntArrayElements(env,  data, ptr7, JNI_ABORT);
+		}
+		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)
+		{
+			ptr7 = (*env)->GetFloatArrayElements(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)->ReleaseFloatArrayElements(env,  data, ptr7, JNI_ABORT);
+		}
+		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)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(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)->ReleaseDoubleArrayElements(env,  data, ptr7, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmaps__IIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		jint ret;
+
+		jboolean *ptr7 = NULL;
+
+		if ( disp__gluBuild3DMipmaps == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr7 = (*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;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild3DMipmaps__IIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		jint ret;
+
+		jlong *ptr7 = NULL;
+
+		if ( disp__gluBuild3DMipmaps == NULL ) return 0;
+
+		if(data!=NULL)
+		{
+			ptr7 = (*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 :
  * <pre> 
-   extern void gluQuadricTexture ( GLUquadricObj * quadObject , GLboolean textureCoords ) ;
+   extern GLboolean gluCheckExtension ( const GLubyte * extName , const GLubyte * extString ) ;
  * </pre> 
  */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluQuadricTexture (
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluCheckExtension (
 		JNIEnv *env, jobject obj,
-		jlong quadObject,
-		jboolean textureCoords)
+		jbyteArray extName,
+		jbyteArray extString)
 	{
+		jboolean ret;
 
-		if ( disp__gluQuadricTexture == NULL ) return;
+		jbyte *ptr0 = NULL;
+		jbyte *ptr1 = NULL;
 
-		disp__gluQuadricTexture (
-			(GLUquadricObj *) (PointerHolder) quadObject,
-			(GLboolean) textureCoords
+		if ( disp__gluCheckExtension == NULL ) return 0;
+
+		if(extName!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, extName, 0);
+		}
+		if(extString!=NULL)
+		{
+			ptr1 = (*env)->GetByteArrayElements(env, extString, 0);
+		}
+		ret = (jboolean) disp__gluCheckExtension (
+			(const GLubyte *) ptr0,
+			(const GLubyte *) ptr1
 		);
 
+		if(extName!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  extName, ptr0, JNI_ABORT);
+		}
+		if(extString!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  extString, ptr1, JNI_ABORT);
+		}
+		return ret;
 	}
 
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluCylinder ( GLUquadricObj * qobj , GLdouble baseRadius , GLdouble topRadius , GLdouble height , GLint slices , GLint stacks ) ;
+   extern void gluCylinder ( GLUquadric * quad , GLdouble base , GLdouble top , GLdouble height , GLint slices , GLint stacks ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluCylinder (
 		JNIEnv *env, jobject obj,
-		jlong qobj,
-		jdouble baseRadius,
-		jdouble topRadius,
+		jlong quad,
+		jdouble base,
+		jdouble top,
 		jdouble height,
 		jint slices,
 		jint stacks)
@@ -1309,9 +2172,9 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 		if ( disp__gluCylinder == NULL ) return;
 
 		disp__gluCylinder (
-			(GLUquadricObj *) (PointerHolder) qobj,
-			(GLdouble) baseRadius,
-			(GLdouble) topRadius,
+			(GLUquadric *) (PointerHolder) quad,
+			(GLdouble) base,
+			(GLdouble) top,
 			(GLdouble) height,
 			(GLint) slices,
 			(GLint) stacks
@@ -1322,25 +2185,27 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluSphere ( GLUquadricObj * qobj , GLdouble radius , GLint slices , GLint stacks ) ;
+   extern void gluDisk ( GLUquadric * quad , GLdouble inner , GLdouble outer , GLint slices , GLint loops ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluSphere (
+	Java_gl4java_GLUFuncJauJNI_gluDisk (
 		JNIEnv *env, jobject obj,
-		jlong qobj,
-		jdouble radius,
+		jlong quad,
+		jdouble inner,
+		jdouble outer,
 		jint slices,
-		jint stacks)
+		jint loops)
 	{
 
-		if ( disp__gluSphere == NULL ) return;
+		if ( disp__gluDisk == NULL ) return;
 
-		disp__gluSphere (
-			(GLUquadricObj *) (PointerHolder) qobj,
-			(GLdouble) radius,
+		disp__gluDisk (
+			(GLUquadric *) (PointerHolder) quad,
+			(GLdouble) inner,
+			(GLdouble) outer,
 			(GLint) slices,
-			(GLint) stacks
+			(GLint) loops
 		);
 
 	}
@@ -1348,27 +2213,19 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops ) ;
+   extern void gluEndCurve ( GLUnurbs * nurb ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluDisk (
+	Java_gl4java_GLUFuncJauJNI_gluEndCurve (
 		JNIEnv *env, jobject obj,
-		jlong qobj,
-		jdouble innerRadius,
-		jdouble outerRadius,
-		jint slices,
-		jint loops)
+		jlong nurb)
 	{
 
-		if ( disp__gluDisk == NULL ) return;
+		if ( disp__gluEndCurve == NULL ) return;
 
-		disp__gluDisk (
-			(GLUquadricObj *) (PointerHolder) qobj,
-			(GLdouble) innerRadius,
-			(GLdouble) outerRadius,
-			(GLint) slices,
-			(GLint) loops
+		disp__gluEndCurve (
+			(GLUnurbs *) (PointerHolder) nurb
 		);
 
 	}
@@ -1376,31 +2233,19 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluPartialDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops , GLdouble startAngle , GLdouble sweepAngle ) ;
+   extern void gluEndPolygon ( GLUtesselator * tess ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluPartialDisk (
+	Java_gl4java_GLUFuncJauJNI_gluEndPolygon (
 		JNIEnv *env, jobject obj,
-		jlong qobj,
-		jdouble innerRadius,
-		jdouble outerRadius,
-		jint slices,
-		jint loops,
-		jdouble startAngle,
-		jdouble sweepAngle)
+		jlong tess)
 	{
 
-		if ( disp__gluPartialDisk == NULL ) return;
+		if ( disp__gluEndPolygon == NULL ) return;
 
-		disp__gluPartialDisk (
-			(GLUquadricObj *) (PointerHolder) qobj,
-			(GLdouble) innerRadius,
-			(GLdouble) outerRadius,
-			(GLint) slices,
-			(GLint) loops,
-			(GLdouble) startAngle,
-			(GLdouble) sweepAngle
+		disp__gluEndPolygon (
+			(GLUtesselator *) (PointerHolder) tess
 		);
 
 	}
@@ -1408,76 +2253,39 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluLoadSamplingMatrices ( GLUnurbsObj * nobj , const GLfloat modelMatrix [ 16 ] , const GLfloat projMatrix [ 16 ] , const GLint viewport [ 4 ] ) ;
+   extern void gluEndSurface ( GLUnurbs * nurb ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluLoadSamplingMatrices (
+	Java_gl4java_GLUFuncJauJNI_gluEndSurface (
 		JNIEnv *env, jobject obj,
-		jlong nobj,
-		jfloatArray modelMatrix,
-		jfloatArray projMatrix,
-		jintArray viewport)
+		jlong nurb)
 	{
-		jfloat *ptr1 = NULL;
-		jfloat *ptr2 = NULL;
-		jint *ptr3 = NULL;
 
-		if ( disp__gluLoadSamplingMatrices == NULL ) return;
+		if ( disp__gluEndSurface == NULL ) return;
 
-		if(modelMatrix!=NULL)
-		{
-			ptr1 = (*env)->GetFloatArrayElements(env, modelMatrix, 0);
-		}
-		if(projMatrix!=NULL)
-		{
-			ptr2 = (*env)->GetFloatArrayElements(env, projMatrix, 0);
-		}
-		if(viewport!=NULL)
-		{
-			ptr3 = (*env)->GetIntArrayElements(env, viewport, 0);
-		}
-		disp__gluLoadSamplingMatrices (
-			(GLUnurbsObj *) (PointerHolder) nobj,
-			(const GLfloat *) ptr1,
-			(const GLfloat *) ptr2,
-			(const GLint *) ptr3
+		disp__gluEndSurface (
+			(GLUnurbs *) (PointerHolder) nurb
 		);
 
-		if(modelMatrix!=NULL)
-		{
-			(*env)->ReleaseFloatArrayElements(env,  modelMatrix, ptr1, JNI_ABORT);
-		}
-		if(projMatrix!=NULL)
-		{
-			(*env)->ReleaseFloatArrayElements(env,  projMatrix, ptr2, JNI_ABORT);
-		}
-		if(viewport!=NULL)
-		{
-			(*env)->ReleaseIntArrayElements(env,  viewport, ptr3, JNI_ABORT);
-		}
 	}
 
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat value ) ;
+   extern void gluEndTrim ( GLUnurbs * nurb ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluNurbsProperty (
+	Java_gl4java_GLUFuncJauJNI_gluEndTrim (
 		JNIEnv *env, jobject obj,
-		jlong nobj,
-		jint property,
-		jfloat value)
+		jlong nurb)
 	{
 
-		if ( disp__gluNurbsProperty == NULL ) return;
+		if ( disp__gluEndTrim == NULL ) return;
 
-		disp__gluNurbsProperty (
-			(GLUnurbsObj *) (PointerHolder) nobj,
-			(GLenum) property,
-			(GLfloat) value
+		disp__gluEndTrim (
+			(GLUnurbs *) (PointerHolder) nurb
 		);
 
 	}
@@ -1485,73 +2293,156 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluGetNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat * value ) ;
+   extern void gluGetNurbsProperty ( GLUnurbs * nurb , GLenum property , GLfloat * data ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluGetNurbsProperty (
 		JNIEnv *env, jobject obj,
-		jlong nobj,
+		jlong nurb,
 		jint property,
-		jfloatArray value)
+		jfloatArray data)
 	{
 		jboolean isCopiedArray2 = JNI_FALSE;
 		jfloat *ptr2 = NULL;
 
 		if ( disp__gluGetNurbsProperty == NULL ) return;
 
-		if(value!=NULL)
+		if(data!=NULL)
 		{
-			ptr2 = (*env)->GetFloatArrayElements(env, value, &isCopiedArray2);
+			ptr2 = (*env)->GetFloatArrayElements(env, data, &isCopiedArray2);
 		}
 		disp__gluGetNurbsProperty (
-			(GLUnurbsObj *) (PointerHolder) nobj,
+			(GLUnurbs *) (PointerHolder) nurb,
 			(GLenum) property,
 			(GLfloat *) ptr2
 		);
 
-		if(value!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseFloatArrayElements(env,  value, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluBeginCurve ( GLUnurbsObj * nobj ) ;
+   extern void gluGetTessProperty ( GLUtesselator * tess , GLenum which , GLdouble * data ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluBeginCurve (
+	Java_gl4java_GLUFuncJauJNI_gluGetTessProperty (
 		JNIEnv *env, jobject obj,
-		jlong nobj)
+		jlong tess,
+		jint which,
+		jdoubleArray data)
 	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
 
-		if ( disp__gluBeginCurve == NULL ) return;
+		if ( disp__gluGetTessProperty == NULL ) return;
 
-		disp__gluBeginCurve (
-			(GLUnurbsObj *) (PointerHolder) nobj
+		if(data!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, data, &isCopiedArray2);
+		}
+		disp__gluGetTessProperty (
+			(GLUtesselator *) (PointerHolder) tess,
+			(GLenum) which,
+			(GLdouble *) ptr2
 		);
 
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
 	}
 
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluEndCurve ( GLUnurbsObj * nobj ) ;
+   extern void gluLoadSamplingMatrices ( GLUnurbs * nurb , const GLfloat * model , const GLfloat * perspective , const GLint * view ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluEndCurve (
+	Java_gl4java_GLUFuncJauJNI_gluLoadSamplingMatrices (
 		JNIEnv *env, jobject obj,
-		jlong nobj)
+		jlong nurb,
+		jfloatArray model,
+		jfloatArray perspective,
+		jintArray view)
 	{
+		jfloat *ptr1 = NULL;
+		jfloat *ptr2 = NULL;
+		jint *ptr3 = NULL;
 
-		if ( disp__gluEndCurve == NULL ) return;
+		if ( disp__gluLoadSamplingMatrices == NULL ) return;
 
-		disp__gluEndCurve (
-			(GLUnurbsObj *) (PointerHolder) nobj
+		if(model!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, model, 0);
+		}
+		if(perspective!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, perspective, 0);
+		}
+		if(view!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, view, 0);
+		}
+		disp__gluLoadSamplingMatrices (
+			(GLUnurbs *) (PointerHolder) nurb,
+			(const GLfloat *) ptr1,
+			(const GLfloat *) ptr2,
+			(const GLint *) ptr3
+		);
+
+		if(model!=NULL)
+		{
+			(*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 :
+ * <pre> 
+   extern void gluLookAt ( GLdouble eyeX , GLdouble eyeY , GLdouble eyeZ , GLdouble centerX , GLdouble centerY , GLdouble centerZ , GLdouble upX , GLdouble upY , GLdouble upZ ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluLookAt (
+		JNIEnv *env, jobject obj,
+		jdouble eyeX,
+		jdouble eyeY,
+		jdouble eyeZ,
+		jdouble centerX,
+		jdouble centerY,
+		jdouble centerZ,
+		jdouble upX,
+		jdouble upY,
+		jdouble upZ)
+	{
+
+		if ( disp__gluLookAt == NULL ) return;
+
+		disp__gluLookAt (
+			(GLdouble) eyeX,
+			(GLdouble) eyeY,
+			(GLdouble) eyeZ,
+			(GLdouble) centerX,
+			(GLdouble) centerY,
+			(GLdouble) centerZ,
+			(GLdouble) upX,
+			(GLdouble) upY,
+			(GLdouble) upZ
 		);
 
 	}
@@ -1559,17 +2450,39 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluNurbsCurve ( GLUnurbsObj * nobj , GLint nknots , GLfloat * knot , GLint stride , GLfloat * ctlarray , GLint order , GLenum type ) ;
+   extern void gluNextContour ( GLUtesselator * tess , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNextContour (
+		JNIEnv *env, jobject obj,
+		jlong tess,
+		jint type)
+	{
+
+		if ( disp__gluNextContour == NULL ) return;
+
+		disp__gluNextContour (
+			(GLUtesselator *) (PointerHolder) tess,
+			(GLenum) type
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsCurve ( GLUnurbs * nurb , GLint knotCount , GLfloat * knots , GLint stride , GLfloat * control , GLint order , GLenum type ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluNurbsCurve (
 		JNIEnv *env, jobject obj,
-		jlong nobj,
-		jint nknots,
-		jfloatArray knot,
+		jlong nurb,
+		jint knotCount,
+		jfloatArray knots,
 		jint stride,
-		jfloatArray ctlarray,
+		jfloatArray control,
 		jint order,
 		jint type)
 	{
@@ -1580,17 +2493,17 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 
 		if ( disp__gluNurbsCurve == NULL ) return;
 
-		if(knot!=NULL)
+		if(knots!=NULL)
 		{
-			ptr2 = (*env)->GetFloatArrayElements(env, knot, &isCopiedArray2);
+			ptr2 = (*env)->GetFloatArrayElements(env, knots, &isCopiedArray2);
 		}
-		if(ctlarray!=NULL)
+		if(control!=NULL)
 		{
-			ptr4 = (*env)->GetFloatArrayElements(env, ctlarray, &isCopiedArray4);
+			ptr4 = (*env)->GetFloatArrayElements(env, control, &isCopiedArray4);
 		}
 		disp__gluNurbsCurve (
-			(GLUnurbsObj *) (PointerHolder) nobj,
-			(GLint) nknots,
+			(GLUnurbs *) (PointerHolder) nurb,
+			(GLint) knotCount,
 			(GLfloat *) ptr2,
 			(GLint) stride,
 			(GLfloat *) ptr4,
@@ -1598,52 +2511,36 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 			(GLenum) type
 		);
 
-		if(knot!=NULL)
+		if(knots!=NULL)
 		{
-			(*env)->ReleaseFloatArrayElements(env,  knot, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseFloatArrayElements(env,  knots, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
 		}
-		if(ctlarray!=NULL)
+		if(control!=NULL)
 		{
-			(*env)->ReleaseFloatArrayElements(env,  ctlarray, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseFloatArrayElements(env,  control, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluBeginSurface ( GLUnurbsObj * nobj ) ;
+   extern void gluNurbsProperty ( GLUnurbs * nurb , GLenum property , GLfloat value ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluBeginSurface (
-		JNIEnv *env, jobject obj,
-		jlong nobj)
-	{
-
-		if ( disp__gluBeginSurface == NULL ) return;
-
-		disp__gluBeginSurface (
-			(GLUnurbsObj *) (PointerHolder) nobj
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluEndSurface ( GLUnurbsObj * nobj ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluEndSurface (
+	Java_gl4java_GLUFuncJauJNI_gluNurbsProperty (
 		JNIEnv *env, jobject obj,
-		jlong nobj)
+		jlong nurb,
+		jint property,
+		jfloat value)
 	{
 
-		if ( disp__gluEndSurface == NULL ) return;
+		if ( disp__gluNurbsProperty == NULL ) return;
 
-		disp__gluEndSurface (
-			(GLUnurbsObj *) (PointerHolder) nobj
+		disp__gluNurbsProperty (
+			(GLUnurbs *) (PointerHolder) nurb,
+			(GLenum) property,
+			(GLfloat) value
 		);
 
 	}
@@ -1651,22 +2548,22 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluNurbsSurface ( GLUnurbsObj * nobj , GLint sknot_count , GLfloat * sknot , GLint tknot_count , GLfloat * tknot , GLint s_stride , GLint t_stride , GLfloat * ctlarray , GLint sorder , GLint torder , GLenum type ) ;
+   extern void gluNurbsSurface ( GLUnurbs * nurb , GLint sKnotCount , GLfloat * sKnots , GLint tKnotCount , GLfloat * tKnots , GLint sStride , GLint tStride , GLfloat * control , GLint sOrder , GLint tOrder , GLenum type ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluNurbsSurface (
 		JNIEnv *env, jobject obj,
-		jlong nobj,
-		jint sknot_count,
-		jfloatArray sknot,
-		jint tknot_count,
-		jfloatArray tknot,
-		jint s_stride,
-		jint t_stride,
-		jfloatArray ctlarray,
-		jint sorder,
-		jint torder,
+		jlong nurb,
+		jint sKnotCount,
+		jfloatArray sKnots,
+		jint tKnotCount,
+		jfloatArray tKnots,
+		jint sStride,
+		jint tStride,
+		jfloatArray control,
+		jint sOrder,
+		jint tOrder,
 		jint type)
 	{
 		jboolean isCopiedArray2 = JNI_FALSE;
@@ -1678,62 +2575,68 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 
 		if ( disp__gluNurbsSurface == NULL ) return;
 
-		if(sknot!=NULL)
+		if(sKnots!=NULL)
 		{
-			ptr2 = (*env)->GetFloatArrayElements(env, sknot, &isCopiedArray2);
+			ptr2 = (*env)->GetFloatArrayElements(env, sKnots, &isCopiedArray2);
 		}
-		if(tknot!=NULL)
+		if(tKnots!=NULL)
 		{
-			ptr4 = (*env)->GetFloatArrayElements(env, tknot, &isCopiedArray4);
+			ptr4 = (*env)->GetFloatArrayElements(env, tKnots, &isCopiedArray4);
 		}
-		if(ctlarray!=NULL)
+		if(control!=NULL)
 		{
-			ptr7 = (*env)->GetFloatArrayElements(env, ctlarray, &isCopiedArray7);
+			ptr7 = (*env)->GetFloatArrayElements(env, control, &isCopiedArray7);
 		}
 		disp__gluNurbsSurface (
-			(GLUnurbsObj *) (PointerHolder) nobj,
-			(GLint) sknot_count,
+			(GLUnurbs *) (PointerHolder) nurb,
+			(GLint) sKnotCount,
 			(GLfloat *) ptr2,
-			(GLint) tknot_count,
+			(GLint) tKnotCount,
 			(GLfloat *) ptr4,
-			(GLint) s_stride,
-			(GLint) t_stride,
+			(GLint) sStride,
+			(GLint) tStride,
 			(GLfloat *) ptr7,
-			(GLint) sorder,
-			(GLint) torder,
+			(GLint) sOrder,
+			(GLint) tOrder,
 			(GLenum) type
 		);
 
-		if(sknot!=NULL)
+		if(sKnots!=NULL)
 		{
-			(*env)->ReleaseFloatArrayElements(env,  sknot, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseFloatArrayElements(env,  sKnots, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
 		}
-		if(tknot!=NULL)
+		if(tKnots!=NULL)
 		{
-			(*env)->ReleaseFloatArrayElements(env,  tknot, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseFloatArrayElements(env,  tKnots, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
 		}
-		if(ctlarray!=NULL)
+		if(control!=NULL)
 		{
-			(*env)->ReleaseFloatArrayElements(env,  ctlarray, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseFloatArrayElements(env,  control, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluBeginTrim ( GLUnurbsObj * nobj ) ;
+   extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluBeginTrim (
+	Java_gl4java_GLUFuncJauJNI_gluOrtho2D (
 		JNIEnv *env, jobject obj,
-		jlong nobj)
+		jdouble left,
+		jdouble right,
+		jdouble bottom,
+		jdouble top)
 	{
 
-		if ( disp__gluBeginTrim == NULL ) return;
+		if ( disp__gluOrtho2D == NULL ) return;
 
-		disp__gluBeginTrim (
-			(GLUnurbsObj *) (PointerHolder) nobj
+		disp__gluOrtho2D (
+			(GLdouble) left,
+			(GLdouble) right,
+			(GLdouble) bottom,
+			(GLdouble) top
 		);
 
 	}
@@ -1741,35 +2644,207 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluEndTrim ( GLUnurbsObj * nobj ) ;
+   extern void gluPartialDisk ( GLUquadric * quad , GLdouble inner , GLdouble outer , GLint slices , GLint loops , GLdouble start , GLdouble sweep ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluEndTrim (
+	Java_gl4java_GLUFuncJauJNI_gluPartialDisk (
 		JNIEnv *env, jobject obj,
-		jlong nobj)
+		jlong quad,
+		jdouble inner,
+		jdouble outer,
+		jint slices,
+		jint loops,
+		jdouble start,
+		jdouble sweep)
 	{
 
-		if ( disp__gluEndTrim == NULL ) return;
+		if ( disp__gluPartialDisk == NULL ) return;
 
-		disp__gluEndTrim (
-			(GLUnurbsObj *) (PointerHolder) nobj
+		disp__gluPartialDisk (
+			(GLUquadric *) (PointerHolder) quad,
+			(GLdouble) inner,
+			(GLdouble) outer,
+			(GLint) slices,
+			(GLint) loops,
+			(GLdouble) start,
+			(GLdouble) sweep
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPerspective (
+		JNIEnv *env, jobject obj,
+		jdouble fovy,
+		jdouble aspect,
+		jdouble zNear,
+		jdouble zFar)
+	{
+
+		if ( disp__gluPerspective == NULL ) return;
+
+		disp__gluPerspective (
+			(GLdouble) fovy,
+			(GLdouble) aspect,
+			(GLdouble) zNear,
+			(GLdouble) zFar
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble delX , GLdouble delY , GLint * viewport ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPickMatrix (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble delX,
+		jdouble delY,
+		jintArray viewport)
+	{
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+
+		if ( disp__gluPickMatrix == NULL ) return;
+
+		if(viewport!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, viewport, &isCopiedArray4);
+		}
+		disp__gluPickMatrix (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) delX,
+			(GLdouble) delY,
+			(GLint *) ptr4
+		);
+
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluProject ( GLdouble objX , GLdouble objY , GLdouble objZ , const GLdouble * model , const GLdouble * proj , const GLint * view , GLdouble * winX , GLdouble * winY , GLdouble * winZ ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluProject (
+		JNIEnv *env, jobject obj,
+		jdouble objX,
+		jdouble objY,
+		jdouble objZ,
+		jdoubleArray model,
+		jdoubleArray proj,
+		jintArray view,
+		jdoubleArray winX,
+		jdoubleArray winY,
+		jdoubleArray winZ)
+	{
+		jint ret;
+
+		jdouble *ptr3 = NULL;
+		jdouble *ptr4 = NULL;
+		jint *ptr5 = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
+
+		if ( disp__gluProject == NULL ) return 0;
+
+		if(model!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, model, 0);
+		}
+		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
 		);
 
+		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)
+		{
+			(*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)->ReleaseDoubleArrayElements(env,  winZ, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
 	}
 
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluPwlCurve ( GLUnurbsObj * nobj , GLint count , GLfloat * array , GLint stride , GLenum type ) ;
+   extern void gluPwlCurve ( GLUnurbs * nurb , GLint count , GLfloat * data , GLint stride , GLenum type ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluPwlCurve (
 		JNIEnv *env, jobject obj,
-		jlong nobj,
+		jlong nurb,
 		jint count,
-		jfloatArray array,
+		jfloatArray data,
 		jint stride,
 		jint type)
 	{
@@ -1778,222 +2853,766 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 
 		if ( disp__gluPwlCurve == NULL ) return;
 
-		if(array!=NULL)
+		if(data!=NULL)
 		{
-			ptr2 = (*env)->GetFloatArrayElements(env, array, &isCopiedArray2);
+			ptr2 = (*env)->GetFloatArrayElements(env, data, &isCopiedArray2);
 		}
 		disp__gluPwlCurve (
-			(GLUnurbsObj *) (PointerHolder) nobj,
+			(GLUnurbs *) (PointerHolder) nurb,
 			(GLint) count,
 			(GLfloat *) ptr2,
 			(GLint) stride,
 			(GLenum) type
 		);
 
-		if(array!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseFloatArrayElements(env,  array, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluTessBeginPolygon ( GLUtesselator * tobj , void * polygon_data ) ;
+   extern void gluQuadricDrawStyle ( GLUquadric * quad , GLenum draw ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricDrawStyle (
+		JNIEnv *env, jobject obj,
+		jlong quad,
+		jint draw)
+	{
+
+		if ( disp__gluQuadricDrawStyle == NULL ) return;
+
+		disp__gluQuadricDrawStyle (
+			(GLUquadric *) (PointerHolder) quad,
+			(GLenum) draw
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricNormals ( GLUquadric * quad , GLenum normal ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricNormals (
+		JNIEnv *env, jobject obj,
+		jlong quad,
+		jint normal)
+	{
+
+		if ( disp__gluQuadricNormals == NULL ) return;
+
+		disp__gluQuadricNormals (
+			(GLUquadric *) (PointerHolder) quad,
+			(GLenum) normal
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricOrientation ( GLUquadric * quad , GLenum orientation ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricOrientation (
+		JNIEnv *env, jobject obj,
+		jlong quad,
+		jint orientation)
+	{
+
+		if ( disp__gluQuadricOrientation == NULL ) return;
+
+		disp__gluQuadricOrientation (
+			(GLUquadric *) (PointerHolder) quad,
+			(GLenum) orientation
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricTexture ( GLUquadric * quad , GLboolean texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricTexture (
+		JNIEnv *env, jobject obj,
+		jlong quad,
+		jboolean texture)
+	{
+
+		if ( disp__gluQuadricTexture == NULL ) return;
+
+		disp__gluQuadricTexture (
+			(GLUquadric *) (PointerHolder) quad,
+			(GLboolean) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluScaleImage ( GLenum format , GLsizei wIn , GLsizei hIn , GLenum typeIn , const void * dataIn , GLsizei wOut , GLsizei hOut , GLenum typeOut , GLvoid * dataOut ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluScaleImage__IIII_3BIII_3B (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint wIn,
+		jint hIn,
+		jint typeIn,
+		jbyteArray dataIn,
+		jint wOut,
+		jint hOut,
+		jint typeOut,
+		jbyteArray dataOut)
+	{
+		jint ret;
+
+		jbyte *ptr4 = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jbyte *ptr8 = NULL;
+
+		if ( disp__gluScaleImage == NULL ) return 0;
+
+		if(dataIn!=NULL)
+		{
+			ptr4 = (*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)
+	{
+		jint ret;
+
+		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;
+
+		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(dataIn!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  dataIn, ptr4, JNI_ABORT);
+		}
+		if(dataOut!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		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)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, dataIn, 0);
+		}
+		if(dataOut!=NULL)
+		{
+			ptr8 = (*env)->GetBooleanArrayElements(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)->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)
+		{
+			ptr8 = (*env)->GetLongArrayElements(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)->ReleaseLongArrayElements(env,  dataIn, ptr4, JNI_ABORT);
+		}
+		if(dataOut!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  dataOut, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluSphere ( GLUquadric * quad , GLdouble radius , GLint slices , GLint stacks ) ;
+ * </pre> 
+ */
+	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
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessBeginContour ( GLUtesselator * tess ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginContour (
+		JNIEnv *env, jobject obj,
+		jlong tess)
+	{
+
+		if ( disp__gluTessBeginContour == NULL ) return;
+
+		disp__gluTessBeginContour (
+			(GLUtesselator *) (PointerHolder) tess
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessBeginPolygon ( GLUtesselator * tess , GLvoid * data ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3B (
 		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jbyteArray polygon_data)
+		jlong tess,
+		jbyteArray data)
 	{
 		jboolean isCopiedArray1 = JNI_FALSE;
 		jbyte *ptr1 = NULL;
 
 		if ( disp__gluTessBeginPolygon == NULL ) return;
 
-		if(polygon_data!=NULL)
+		if(data!=NULL)
 		{
-			ptr1 = (*env)->GetByteArrayElements(env, polygon_data, &isCopiedArray1);
+			ptr1 = (*env)->GetByteArrayElements(env, data, &isCopiedArray1);
 		}
 		disp__gluTessBeginPolygon (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(void *) ptr1
+			(GLUtesselator *) (PointerHolder) tess,
+			(GLvoid *) ptr1
 		);
 
-		if(polygon_data!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseByteArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseByteArrayElements(env,  data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3S (
 		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jshortArray polygon_data)
+		jlong tess,
+		jshortArray data)
 	{
 		jboolean isCopiedArray1 = JNI_FALSE;
 		jshort *ptr1 = NULL;
 
 		if ( disp__gluTessBeginPolygon == NULL ) return;
 
-		if(polygon_data!=NULL)
+		if(data!=NULL)
 		{
-			ptr1 = (*env)->GetShortArrayElements(env, polygon_data, &isCopiedArray1);
+			ptr1 = (*env)->GetShortArrayElements(env, data, &isCopiedArray1);
 		}
 		disp__gluTessBeginPolygon (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(void *) ptr1
+			(GLUtesselator *) (PointerHolder) tess,
+			(GLvoid *) ptr1
 		);
 
-		if(polygon_data!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseShortArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseShortArrayElements(env,  data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3I (
 		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jintArray polygon_data)
+		jlong tess,
+		jintArray data)
 	{
 		jboolean isCopiedArray1 = JNI_FALSE;
 		jint *ptr1 = NULL;
 
 		if ( disp__gluTessBeginPolygon == NULL ) return;
 
-		if(polygon_data!=NULL)
+		if(data!=NULL)
 		{
-			ptr1 = (*env)->GetIntArrayElements(env, polygon_data, &isCopiedArray1);
+			ptr1 = (*env)->GetIntArrayElements(env, data, &isCopiedArray1);
 		}
 		disp__gluTessBeginPolygon (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(void *) ptr1
+			(GLUtesselator *) (PointerHolder) tess,
+			(GLvoid *) ptr1
 		);
 
-		if(polygon_data!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseIntArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseIntArrayElements(env,  data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3F (
 		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jfloatArray polygon_data)
+		jlong tess,
+		jfloatArray data)
 	{
 		jboolean isCopiedArray1 = JNI_FALSE;
 		jfloat *ptr1 = NULL;
 
 		if ( disp__gluTessBeginPolygon == NULL ) return;
 
-		if(polygon_data!=NULL)
+		if(data!=NULL)
 		{
-			ptr1 = (*env)->GetFloatArrayElements(env, polygon_data, &isCopiedArray1);
+			ptr1 = (*env)->GetFloatArrayElements(env, data, &isCopiedArray1);
 		}
 		disp__gluTessBeginPolygon (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(void *) ptr1
+			(GLUtesselator *) (PointerHolder) tess,
+			(GLvoid *) ptr1
 		);
 
-		if(polygon_data!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseFloatArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3D (
 		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdoubleArray polygon_data)
+		jlong tess,
+		jdoubleArray data)
 	{
 		jboolean isCopiedArray1 = JNI_FALSE;
 		jdouble *ptr1 = NULL;
 
 		if ( disp__gluTessBeginPolygon == NULL ) return;
 
-		if(polygon_data!=NULL)
+		if(data!=NULL)
 		{
-			ptr1 = (*env)->GetDoubleArrayElements(env, polygon_data, &isCopiedArray1);
+			ptr1 = (*env)->GetDoubleArrayElements(env, data, &isCopiedArray1);
 		}
 		disp__gluTessBeginPolygon (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(void *) ptr1
+			(GLUtesselator *) (PointerHolder) tess,
+			(GLvoid *) ptr1
 		);
 
-		if(polygon_data!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseDoubleArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3Z (
 		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jbooleanArray polygon_data)
+		jlong tess,
+		jbooleanArray data)
 	{
 		jboolean isCopiedArray1 = JNI_FALSE;
 		jboolean *ptr1 = NULL;
 
 		if ( disp__gluTessBeginPolygon == NULL ) return;
 
-		if(polygon_data!=NULL)
+		if(data!=NULL)
 		{
-			ptr1 = (*env)->GetBooleanArrayElements(env, polygon_data, &isCopiedArray1);
+			ptr1 = (*env)->GetBooleanArrayElements(env, data, &isCopiedArray1);
 		}
 		disp__gluTessBeginPolygon (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(void *) ptr1
+			(GLUtesselator *) (PointerHolder) tess,
+			(GLvoid *) ptr1
 		);
 
-		if(polygon_data!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseBooleanArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__J_3J (
 		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jlongArray polygon_data)
+		jlong tess,
+		jlongArray data)
 	{
 		jboolean isCopiedArray1 = JNI_FALSE;
 		jlong *ptr1 = NULL;
 
 		if ( disp__gluTessBeginPolygon == NULL ) return;
 
-		if(polygon_data!=NULL)
+		if(data!=NULL)
 		{
-			ptr1 = (*env)->GetLongArrayElements(env, polygon_data, &isCopiedArray1);
+			ptr1 = (*env)->GetLongArrayElements(env, data, &isCopiedArray1);
 		}
 		disp__gluTessBeginPolygon (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(void *) ptr1
+			(GLUtesselator *) (PointerHolder) tess,
+			(GLvoid *) ptr1
 		);
 
-		if(polygon_data!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseLongArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseLongArrayElements(env,  data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluTessBeginContour ( GLUtesselator * tobj ) ;
+   extern void gluTessEndContour ( GLUtesselator * tess ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluTessBeginContour (
+	Java_gl4java_GLUFuncJauJNI_gluTessEndContour (
 		JNIEnv *env, jobject obj,
-		jlong tobj)
+		jlong tess)
 	{
 
-		if ( disp__gluTessBeginContour == NULL ) return;
+		if ( disp__gluTessEndContour == NULL ) return;
 
-		disp__gluTessBeginContour (
-			(GLUtesselator *) (PointerHolder) tobj
+		disp__gluTessEndContour (
+			(GLUtesselator *) (PointerHolder) tess
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessEndPolygon ( GLUtesselator * tess ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessEndPolygon (
+		JNIEnv *env, jobject obj,
+		jlong tess)
+	{
+
+		if ( disp__gluTessEndPolygon == NULL ) return;
+
+		disp__gluTessEndPolygon (
+			(GLUtesselator *) (PointerHolder) tess
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessNormal ( GLUtesselator * tess , GLdouble valueX , GLdouble valueY , GLdouble valueZ ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessNormal (
+		JNIEnv *env, jobject obj,
+		jlong tess,
+		jdouble valueX,
+		jdouble valueY,
+		jdouble valueZ)
+	{
+
+		if ( disp__gluTessNormal == NULL ) return;
+
+		disp__gluTessNormal (
+			(GLUtesselator *) (PointerHolder) tess,
+			(GLdouble) valueX,
+			(GLdouble) valueY,
+			(GLdouble) valueZ
 		);
 
 	}
@@ -2001,15 +3620,39 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluTessVertex ( GLUtesselator * tobj , GLdouble coords [ 3 ] , void * vertex_data ) ;
+   extern void gluTessProperty ( GLUtesselator * tess , GLenum which , GLdouble data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessProperty (
+		JNIEnv *env, jobject obj,
+		jlong tess,
+		jint which,
+		jdouble data)
+	{
+
+		if ( disp__gluTessProperty == NULL ) return;
+
+		disp__gluTessProperty (
+			(GLUtesselator *) (PointerHolder) tess,
+			(GLenum) which,
+			(GLdouble) data
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessVertex ( GLUtesselator * tess , GLdouble * location , GLvoid * data ) ;
  * </pre> 
  */
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3B (
 		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdoubleArray coords,
-		jbyteArray vertex_data)
+		jlong tess,
+		jdoubleArray location,
+		jbyteArray data)
 	{
 		jboolean isCopiedArray1 = JNI_FALSE;
 		jdouble *ptr1 = NULL;
@@ -2018,35 +3661,35 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 
 		if ( disp__gluTessVertex == NULL ) return;
 
-		if(coords!=NULL)
+		if(location!=NULL)
 		{
-			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			ptr1 = (*env)->GetDoubleArrayElements(env, location, &isCopiedArray1);
 		}
-		if(vertex_data!=NULL)
+		if(data!=NULL)
 		{
-			ptr2 = (*env)->GetByteArrayElements(env, vertex_data, &isCopiedArray2);
+			ptr2 = (*env)->GetByteArrayElements(env, data, &isCopiedArray2);
 		}
 		disp__gluTessVertex (
-			(GLUtesselator *) (PointerHolder) tobj,
+			(GLUtesselator *) (PointerHolder) tess,
 			(GLdouble *) ptr1,
-			(void *) ptr2
+			(GLvoid *) ptr2
 		);
 
-		if(coords!=NULL)
+		if(location!=NULL)
 		{
-			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseDoubleArrayElements(env,  location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
 		}
-		if(vertex_data!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseByteArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseByteArrayElements(env,  data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3S (
 		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdoubleArray coords,
-		jshortArray vertex_data)
+		jlong tess,
+		jdoubleArray location,
+		jshortArray data)
 	{
 		jboolean isCopiedArray1 = JNI_FALSE;
 		jdouble *ptr1 = NULL;
@@ -2055,35 +3698,35 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 
 		if ( disp__gluTessVertex == NULL ) return;
 
-		if(coords!=NULL)
+		if(location!=NULL)
 		{
-			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			ptr1 = (*env)->GetDoubleArrayElements(env, location, &isCopiedArray1);
 		}
-		if(vertex_data!=NULL)
+		if(data!=NULL)
 		{
-			ptr2 = (*env)->GetShortArrayElements(env, vertex_data, &isCopiedArray2);
+			ptr2 = (*env)->GetShortArrayElements(env, data, &isCopiedArray2);
 		}
 		disp__gluTessVertex (
-			(GLUtesselator *) (PointerHolder) tobj,
+			(GLUtesselator *) (PointerHolder) tess,
 			(GLdouble *) ptr1,
-			(void *) ptr2
+			(GLvoid *) ptr2
 		);
 
-		if(coords!=NULL)
+		if(location!=NULL)
 		{
-			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseDoubleArrayElements(env,  location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
 		}
-		if(vertex_data!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseShortArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseShortArrayElements(env,  data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3I (
 		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdoubleArray coords,
-		jintArray vertex_data)
+		jlong tess,
+		jdoubleArray location,
+		jintArray data)
 	{
 		jboolean isCopiedArray1 = JNI_FALSE;
 		jdouble *ptr1 = NULL;
@@ -2092,35 +3735,35 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 
 		if ( disp__gluTessVertex == NULL ) return;
 
-		if(coords!=NULL)
+		if(location!=NULL)
 		{
-			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			ptr1 = (*env)->GetDoubleArrayElements(env, location, &isCopiedArray1);
 		}
-		if(vertex_data!=NULL)
+		if(data!=NULL)
 		{
-			ptr2 = (*env)->GetIntArrayElements(env, vertex_data, &isCopiedArray2);
+			ptr2 = (*env)->GetIntArrayElements(env, data, &isCopiedArray2);
 		}
 		disp__gluTessVertex (
-			(GLUtesselator *) (PointerHolder) tobj,
+			(GLUtesselator *) (PointerHolder) tess,
 			(GLdouble *) ptr1,
-			(void *) ptr2
+			(GLvoid *) ptr2
 		);
 
-		if(coords!=NULL)
+		if(location!=NULL)
 		{
-			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseDoubleArrayElements(env,  location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
 		}
-		if(vertex_data!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseIntArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseIntArrayElements(env,  data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3F (
 		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdoubleArray coords,
-		jfloatArray vertex_data)
+		jlong tess,
+		jdoubleArray location,
+		jfloatArray data)
 	{
 		jboolean isCopiedArray1 = JNI_FALSE;
 		jdouble *ptr1 = NULL;
@@ -2129,35 +3772,35 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 
 		if ( disp__gluTessVertex == NULL ) return;
 
-		if(coords!=NULL)
+		if(location!=NULL)
 		{
-			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			ptr1 = (*env)->GetDoubleArrayElements(env, location, &isCopiedArray1);
 		}
-		if(vertex_data!=NULL)
+		if(data!=NULL)
 		{
-			ptr2 = (*env)->GetFloatArrayElements(env, vertex_data, &isCopiedArray2);
+			ptr2 = (*env)->GetFloatArrayElements(env, data, &isCopiedArray2);
 		}
 		disp__gluTessVertex (
-			(GLUtesselator *) (PointerHolder) tobj,
+			(GLUtesselator *) (PointerHolder) tess,
 			(GLdouble *) ptr1,
-			(void *) ptr2
+			(GLvoid *) ptr2
 		);
 
-		if(coords!=NULL)
+		if(location!=NULL)
 		{
-			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseDoubleArrayElements(env,  location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
 		}
-		if(vertex_data!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseFloatArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3D (
 		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdoubleArray coords,
-		jdoubleArray vertex_data)
+		jlong tess,
+		jdoubleArray location,
+		jdoubleArray data)
 	{
 		jboolean isCopiedArray1 = JNI_FALSE;
 		jdouble *ptr1 = NULL;
@@ -2166,35 +3809,35 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 
 		if ( disp__gluTessVertex == NULL ) return;
 
-		if(coords!=NULL)
+		if(location!=NULL)
 		{
-			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			ptr1 = (*env)->GetDoubleArrayElements(env, location, &isCopiedArray1);
 		}
-		if(vertex_data!=NULL)
+		if(data!=NULL)
 		{
-			ptr2 = (*env)->GetDoubleArrayElements(env, vertex_data, &isCopiedArray2);
+			ptr2 = (*env)->GetDoubleArrayElements(env, data, &isCopiedArray2);
 		}
 		disp__gluTessVertex (
-			(GLUtesselator *) (PointerHolder) tobj,
+			(GLUtesselator *) (PointerHolder) tess,
 			(GLdouble *) ptr1,
-			(void *) ptr2
+			(GLvoid *) ptr2
 		);
 
-		if(coords!=NULL)
+		if(location!=NULL)
 		{
-			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseDoubleArrayElements(env,  location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
 		}
-		if(vertex_data!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseDoubleArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3Z (
 		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdoubleArray coords,
-		jbooleanArray vertex_data)
+		jlong tess,
+		jdoubleArray location,
+		jbooleanArray data)
 	{
 		jboolean isCopiedArray1 = JNI_FALSE;
 		jdouble *ptr1 = NULL;
@@ -2203,35 +3846,35 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 
 		if ( disp__gluTessVertex == NULL ) return;
 
-		if(coords!=NULL)
+		if(location!=NULL)
 		{
-			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			ptr1 = (*env)->GetDoubleArrayElements(env, location, &isCopiedArray1);
 		}
-		if(vertex_data!=NULL)
+		if(data!=NULL)
 		{
-			ptr2 = (*env)->GetBooleanArrayElements(env, vertex_data, &isCopiedArray2);
+			ptr2 = (*env)->GetBooleanArrayElements(env, data, &isCopiedArray2);
 		}
 		disp__gluTessVertex (
-			(GLUtesselator *) (PointerHolder) tobj,
+			(GLUtesselator *) (PointerHolder) tess,
 			(GLdouble *) ptr1,
-			(void *) ptr2
+			(GLvoid *) ptr2
 		);
 
-		if(coords!=NULL)
+		if(location!=NULL)
 		{
-			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseDoubleArrayElements(env,  location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
 		}
-		if(vertex_data!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseBooleanArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 	JNIEXPORT void JNICALL
 	Java_gl4java_GLUFuncJauJNI_gluTessVertex__J_3D_3J (
 		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdoubleArray coords,
-		jlongArray vertex_data)
+		jlong tess,
+		jdoubleArray location,
+		jlongArray data)
 	{
 		jboolean isCopiedArray1 = JNI_FALSE;
 		jdouble *ptr1 = NULL;
@@ -2240,214 +3883,238 @@ Java_gl4java_GLUFuncJauJNI_gluNewTess( JNIEnv *env, jobject obj)
 
 		if ( disp__gluTessVertex == NULL ) return;
 
-		if(coords!=NULL)
+		if(location!=NULL)
 		{
-			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			ptr1 = (*env)->GetDoubleArrayElements(env, location, &isCopiedArray1);
 		}
-		if(vertex_data!=NULL)
+		if(data!=NULL)
 		{
-			ptr2 = (*env)->GetLongArrayElements(env, vertex_data, &isCopiedArray2);
+			ptr2 = (*env)->GetLongArrayElements(env, data, &isCopiedArray2);
 		}
 		disp__gluTessVertex (
-			(GLUtesselator *) (PointerHolder) tobj,
+			(GLUtesselator *) (PointerHolder) tess,
 			(GLdouble *) ptr1,
-			(void *) ptr2
+			(GLvoid *) ptr2
 		);
 
-		if(coords!=NULL)
+		if(location!=NULL)
 		{
-			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseDoubleArrayElements(env,  location, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
 		}
-		if(vertex_data!=NULL)
+		if(data!=NULL)
 		{
-			(*env)->ReleaseLongArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+			(*env)->ReleaseLongArrayElements(env,  data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
 		}
 	}
 
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluTessEndContour ( GLUtesselator * tobj ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluTessEndContour (
-		JNIEnv *env, jobject obj,
-		jlong tobj)
-	{
-
-		if ( disp__gluTessEndContour == NULL ) return;
-
-		disp__gluTessEndContour (
-			(GLUtesselator *) (PointerHolder) tobj
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluTessEndPolygon ( GLUtesselator * tobj ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluTessEndPolygon (
-		JNIEnv *env, jobject obj,
-		jlong tobj)
-	{
-
-		if ( disp__gluTessEndPolygon == NULL ) return;
-
-		disp__gluTessEndPolygon (
-			(GLUtesselator *) (PointerHolder) tobj
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble value ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluTessProperty (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jint which,
-		jdouble value)
-	{
-
-		if ( disp__gluTessProperty == NULL ) return;
-
-		disp__gluTessProperty (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(GLenum) which,
-			(GLdouble) value
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluTessNormal ( GLUtesselator * tobj , GLdouble x , GLdouble y , GLdouble z ) ;
+   extern GLint gluUnProject ( GLdouble winX , GLdouble winY , GLdouble winZ , const GLdouble * model , const GLdouble * proj , const GLint * view , GLdouble * objX , GLdouble * objY , GLdouble * objZ ) ;
  * </pre> 
  */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluTessNormal (
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluUnProject (
 		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdouble x,
-		jdouble y,
-		jdouble z)
+		jdouble winX,
+		jdouble winY,
+		jdouble winZ,
+		jdoubleArray model,
+		jdoubleArray proj,
+		jintArray view,
+		jdoubleArray objX,
+		jdoubleArray objY,
+		jdoubleArray objZ)
 	{
+		jint ret;
 
-		if ( disp__gluTessNormal == NULL ) return;
-
-		disp__gluTessNormal (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(GLdouble) x,
-			(GLdouble) y,
-			(GLdouble) z
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluGetTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble * value ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluGetTessProperty (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jint which,
-		jdoubleArray value)
-	{
-		jboolean isCopiedArray2 = JNI_FALSE;
-		jdouble *ptr2 = NULL;
+		jdouble *ptr3 = NULL;
+		jdouble *ptr4 = NULL;
+		jint *ptr5 = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
 
-		if ( disp__gluGetTessProperty == NULL ) return;
+		if ( disp__gluUnProject == NULL ) return 0;
 
-		if(value!=NULL)
+		if(model!=NULL)
 		{
-			ptr2 = (*env)->GetDoubleArrayElements(env, value, &isCopiedArray2);
+			ptr3 = (*env)->GetDoubleArrayElements(env, model, 0);
 		}
-		disp__gluGetTessProperty (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(GLenum) which,
-			(GLdouble *) ptr2
-		);
-
-		if(value!=NULL)
+		if(proj!=NULL)
 		{
-			(*env)->ReleaseDoubleArrayElements(env,  value, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+			ptr4 = (*env)->GetDoubleArrayElements(env, proj, 0);
 		}
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluBeginPolygon ( GLUtesselator * tobj ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluBeginPolygon (
-		JNIEnv *env, jobject obj,
-		jlong tobj)
-	{
-
-		if ( disp__gluBeginPolygon == NULL ) return;
-
-		disp__gluBeginPolygon (
-			(GLUtesselator *) (PointerHolder) tobj
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluNextContour ( GLUtesselator * tobj , GLenum type ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluNextContour (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jint type)
-	{
-
-		if ( disp__gluNextContour == NULL ) return;
-
-		disp__gluNextContour (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(GLenum) type
+		if(view!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, view, 0);
+		}
+		if(objX!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, objX, &isCopiedArray6);
+		}
+		if(objY!=NULL)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(env, objY, &isCopiedArray7);
+		}
+		if(objZ!=NULL)
+		{
+			ptr8 = (*env)->GetDoubleArrayElements(env, objZ, &isCopiedArray8);
+		}
+		ret = (jint) disp__gluUnProject (
+			(GLdouble) winX,
+			(GLdouble) winY,
+			(GLdouble) winZ,
+			(const GLdouble *) ptr3,
+			(const GLdouble *) ptr4,
+			(const GLint *) ptr5,
+			(GLdouble *) ptr6,
+			(GLdouble *) ptr7,
+			(GLdouble *) ptr8
 		);
 
+		if(model!=NULL)
+		{
+			(*env)->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(objX!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objX, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(objY!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objY, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(objZ!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objZ, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
 	}
 
 /**
  * Original Function-Prototype :
  * <pre> 
-   extern void gluEndPolygon ( GLUtesselator * tobj ) ;
+   extern GLint gluUnProject4 ( GLdouble winX , GLdouble winY , GLdouble winZ , GLdouble clipW , const GLdouble * model , const GLdouble * proj , const GLint * view , GLdouble nearVal , GLdouble farVal , GLdouble * objX , GLdouble * objY , GLdouble * objZ , GLdouble * objW ) ;
  * </pre> 
  */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNI_gluEndPolygon (
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluUnProject4 (
 		JNIEnv *env, jobject obj,
-		jlong tobj)
+		jdouble winX,
+		jdouble winY,
+		jdouble winZ,
+		jdouble clipW,
+		jdoubleArray model,
+		jdoubleArray proj,
+		jintArray view,
+		jdouble nearVal,
+		jdouble farVal,
+		jdoubleArray objX,
+		jdoubleArray objY,
+		jdoubleArray objZ,
+		jdoubleArray objW)
 	{
+		jint ret;
 
-		if ( disp__gluEndPolygon == NULL ) return;
-
-		disp__gluEndPolygon (
-			(GLUtesselator *) (PointerHolder) tobj
+		jdouble *ptr4 = NULL;
+		jdouble *ptr5 = NULL;
+		jint *ptr6 = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jdouble *ptr9 = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jdouble *ptr10 = NULL;
+		jboolean isCopiedArray11 = JNI_FALSE;
+		jdouble *ptr11 = NULL;
+		jboolean isCopiedArray12 = JNI_FALSE;
+		jdouble *ptr12 = NULL;
+
+		if ( disp__gluUnProject4 == NULL ) return 0;
+
+		if(model!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, model, 0);
+		}
+		if(proj!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, proj, 0);
+		}
+		if(view!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, view, 0);
+		}
+		if(objX!=NULL)
+		{
+			ptr9 = (*env)->GetDoubleArrayElements(env, objX, &isCopiedArray9);
+		}
+		if(objY!=NULL)
+		{
+			ptr10 = (*env)->GetDoubleArrayElements(env, objY, &isCopiedArray10);
+		}
+		if(objZ!=NULL)
+		{
+			ptr11 = (*env)->GetDoubleArrayElements(env, objZ, &isCopiedArray11);
+		}
+		if(objW!=NULL)
+		{
+			ptr12 = (*env)->GetDoubleArrayElements(env, objW, &isCopiedArray12);
+		}
+		ret = (jint) disp__gluUnProject4 (
+			(GLdouble) winX,
+			(GLdouble) winY,
+			(GLdouble) winZ,
+			(GLdouble) clipW,
+			(const GLdouble *) ptr4,
+			(const GLdouble *) ptr5,
+			(const GLint *) ptr6,
+			(GLdouble) nearVal,
+			(GLdouble) farVal,
+			(GLdouble *) ptr9,
+			(GLdouble *) ptr10,
+			(GLdouble *) ptr11,
+			(GLdouble *) ptr12
 		);
 
+		if(model!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  model, ptr4, JNI_ABORT);
+		}
+		if(proj!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  proj, ptr5, JNI_ABORT);
+		}
+		if(view!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  view, ptr6, JNI_ABORT);
+		}
+		if(objX!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objX, ptr9, (isCopiedArray9 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(objY!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objY, ptr10, (isCopiedArray10 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(objZ!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objZ, ptr11, (isCopiedArray11 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(objW!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objW, ptr12, (isCopiedArray12 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
 	}
 
-/* C2J Parser Version 2.2:  Java program parsed successfully. */ 
+/* C2J Parser Version 3.0:  Java program parsed successfully. */