*** empty log message ***

6 files changed, 627 insertions, 218 deletions

diff --git a/bundles/org.eclipse.swt.opengl/common/library/glu.c b/bundles/org.eclipse.swt.opengl/common/library/glu.c
index 5f49ee97e6..f83c1ec1be 100644
--- a/bundles/org.eclipse.swt.opengl/common/library/glu.c
+++ b/bundles/org.eclipse.swt.opengl/common/library/glu.c
@@ -1,354 +1,498 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2003 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Common Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/cpl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-#ifdef WIN32
-#include <windows.h>
-#endif
-#include <GL/glu.h>
 #include "swt.h"
+#include "glu_structs.h"
+#include "glu_stats.h"
 
 #define GLU_NATIVE(func) Java_org_eclipse_swt_opengl_GLU_##func
 
+#ifndef NO_gluBeginCurve
 JNIEXPORT void JNICALL GLU_NATIVE(gluBeginCurve)
 	(JNIEnv *env, jclass that, jint arg0)
 {
-	NATIVE_ENTER(env, that, "gluBeginCurve\n")
-	gluBeginCurve((GLUnurbsObj *)arg0);
-	NATIVE_EXIT(env, that, "gluBeginCurve\n")
+	GLU_NATIVE_ENTER(env, that, gluBeginCurve_FUNC);
+	gluBeginCurve((GLUnurbs *)arg0);
+	GLU_NATIVE_EXIT(env, that, gluBeginCurve_FUNC);
 }
+#endif
 
+#ifndef NO_gluBeginPolygon
 JNIEXPORT void JNICALL GLU_NATIVE(gluBeginPolygon)
 	(JNIEnv *env, jclass that, jint arg0)
 {
-	NATIVE_ENTER(env, that, "gluBeginPolygon\n")
-	gluBeginPolygon((GLUtesselator *)arg0);
-	NATIVE_EXIT(env, that, "gluBeginPolygon\n")
+	GLU_NATIVE_ENTER(env, that, gluBeginPolygon_FUNC);
+	gluBeginPolygon((GLUtesselator*)arg0);
+	GLU_NATIVE_EXIT(env, that, gluBeginPolygon_FUNC);
 }
+#endif
 
+#ifndef NO_gluBeginSurface
 JNIEXPORT void JNICALL GLU_NATIVE(gluBeginSurface)
 	(JNIEnv *env, jclass that, jint arg0)
 {
-	NATIVE_ENTER(env, that, "gluBeginSurface\n")
+	GLU_NATIVE_ENTER(env, that, gluBeginSurface_FUNC);
 	gluBeginSurface((GLUnurbs *)arg0);
-	NATIVE_EXIT(env, that, "gluBeginSurface\n")
+	GLU_NATIVE_EXIT(env, that, gluBeginSurface_FUNC);
 }
+#endif
 
+#ifndef NO_gluBeginTrim
 JNIEXPORT void JNICALL GLU_NATIVE(gluBeginTrim)
 	(JNIEnv *env, jclass that, jint arg0)
 {
-	NATIVE_ENTER(env, that, "gluBeginTrim\n")
+	GLU_NATIVE_ENTER(env, that, gluBeginTrim_FUNC);
 	gluBeginTrim((GLUnurbs *)arg0);
-	NATIVE_EXIT(env, that, "gluBeginTrim\n")
+	GLU_NATIVE_EXIT(env, that, gluBeginTrim_FUNC);
 }
+#endif
 
+#ifndef NO_gluBuild1DMipmaps
 JNIEXPORT jint JNICALL GLU_NATIVE(gluBuild1DMipmaps)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5)
 {
-    jint rc;
-	NATIVE_ENTER(env, that, "gluBuild1DMipmaps\n")
+	jint rc;
+	GLU_NATIVE_ENTER(env, that, gluBuild1DMipmaps_FUNC);
 	rc = (jint)gluBuild1DMipmaps(arg0, arg1, arg2, arg3, arg4, (const void *)arg5);
-	NATIVE_EXIT(env, that, "gluBuild1DMipmaps\n")
+	GLU_NATIVE_EXIT(env, that, gluBuild1DMipmaps_FUNC);
 	return rc;
 }
+#endif
 
-/*
-JNIEXPORT jint JNICALL GLU_NATIVE(gluBuild2DMipmaps)
-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6)
-{
-    jint rc;
-	NATIVE_ENTER(env, that, "gluBuild2DMipmaps\n")
-	rc = (jint)gluBuild2DMipmaps(arg0, arg1, arg2, arg3, arg4, arg5, (const void *)arg6);
-	NATIVE_EXIT(env, that, "gluBuild2DMipmaps\n")
-	return rc;
-}
-*/
-
+#ifndef NO_gluBuild2DMipmaps
 JNIEXPORT jint JNICALL GLU_NATIVE(gluBuild2DMipmaps)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jbyteArray arg6)
 {
 	jbyte *lparg6=NULL;
 	jint rc;
-	
-	NATIVE_ENTER(env, that, "gluBuild2DMipmaps\n")
-	if (arg6) lparg6 = (*env)->GetByteArrayElements(env, arg6, NULL);
-	rc = (jint)gluBuild2DMipmaps(arg0, arg1, arg2, arg3, arg4, arg5, (const void *)lparg6);
-	if (arg6) (*env)->ReleaseByteArrayElements(env, arg6, lparg6, 0);	
-	NATIVE_EXIT(env, that, "gluBuild2DMipmaps\n")
+	GLU_NATIVE_ENTER(env, that, gluBuild2DMipmaps_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg6) lparg6 = (*env)->GetPrimitiveArrayCritical(env, arg6, NULL);
+	} else
+#endif
+	{
+		if (arg6) lparg6 = (*env)->GetByteArrayElements(env, arg6, NULL);
+	}
+	rc = (jint)gluBuild2DMipmaps(arg0, arg1, arg2, arg3, arg4, arg5, lparg6);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg6) (*env)->ReleasePrimitiveArrayCritical(env, arg6, lparg6, 0);
+	} else
+#endif
+	{
+		if (arg6) (*env)->ReleaseByteArrayElements(env, arg6, lparg6, 0);
+	}
+	GLU_NATIVE_EXIT(env, that, gluBuild2DMipmaps_FUNC);
 	return rc;
 }
+#endif
 
+#ifndef NO_gluCylinder
 JNIEXPORT void JNICALL GLU_NATIVE(gluCylinder)
 	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jdouble arg3, jint arg4, jint arg5)
 {
-	NATIVE_ENTER(env, that, "gluCylinder\n")
+	GLU_NATIVE_ENTER(env, that, gluCylinder_FUNC);
 	gluCylinder((GLUquadric *)arg0, arg1, arg2, arg3, arg4, arg5);
-	NATIVE_EXIT(env, that, "gluCylinder\n")
+	GLU_NATIVE_EXIT(env, that, gluCylinder_FUNC);
 }
+#endif
 
+#ifndef NO_gluDeleteNurbsRenderer
 JNIEXPORT void JNICALL GLU_NATIVE(gluDeleteNurbsRenderer)
 	(JNIEnv *env, jclass that, jint arg0)
 {
-	NATIVE_ENTER(env, that, "gluDeleteNurbsRenderer\n")
+	GLU_NATIVE_ENTER(env, that, gluDeleteNurbsRenderer_FUNC);
 	gluDeleteNurbsRenderer((GLUnurbs *)arg0);
-	NATIVE_EXIT(env, that, "gluDeleteNurbsRenderer\n")
+	GLU_NATIVE_EXIT(env, that, gluDeleteNurbsRenderer_FUNC);
 }
+#endif
 
+#ifndef NO_gluDeleteQuadric
 JNIEXPORT void JNICALL GLU_NATIVE(gluDeleteQuadric)
 	(JNIEnv *env, jclass that, jint arg0)
 {
-	NATIVE_ENTER(env, that, "gluDeleteQuadric\n")
+	GLU_NATIVE_ENTER(env, that, gluDeleteQuadric_FUNC);
 	gluDeleteQuadric((GLUquadric *)arg0);
-	NATIVE_EXIT(env, that, "gluDeleteQuadric\n")
+	GLU_NATIVE_EXIT(env, that, gluDeleteQuadric_FUNC);
 }
+#endif
 
+#ifndef NO_gluDeleteTess
 JNIEXPORT void JNICALL GLU_NATIVE(gluDeleteTess)
 	(JNIEnv *env, jclass that, jint arg0)
 {
-	NATIVE_ENTER(env, that, "gluDeleteTess\n")
+	GLU_NATIVE_ENTER(env, that, gluDeleteTess_FUNC);
 	gluDeleteTess((GLUtesselator *)arg0);
-	NATIVE_EXIT(env, that, "gluDeleteTess\n")
+	GLU_NATIVE_EXIT(env, that, gluDeleteTess_FUNC);
 }
+#endif
 
+#ifndef NO_gluDisk
 JNIEXPORT void JNICALL GLU_NATIVE(gluDisk)
 	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4)
 {
-	NATIVE_ENTER(env, that, "gluDisk\n")
-	gluDisk((GLUquadric *)arg0, arg1, arg2, arg3, arg4);
-	NATIVE_EXIT(env, that, "gluDisk\n")
+	GLU_NATIVE_ENTER(env, that, gluDisk_FUNC);
+	gluDisk((GLUquadricObj *)arg0, arg1, arg2, arg3, arg4);
+	GLU_NATIVE_EXIT(env, that, gluDisk_FUNC);
 }
+#endif
 
+#ifndef NO_gluEndCurve
 JNIEXPORT void JNICALL GLU_NATIVE(gluEndCurve)
 	(JNIEnv *env, jclass that, jint arg0)
 {
-	NATIVE_ENTER(env, that, "gluEndCurve\n")
+	GLU_NATIVE_ENTER(env, that, gluEndCurve_FUNC);
 	gluEndCurve((GLUnurbsObj *)arg0);
-	NATIVE_EXIT(env, that, "gluEndCurve\n")
+	GLU_NATIVE_EXIT(env, that, gluEndCurve_FUNC);
 }
+#endif
 
+#ifndef NO_gluEndPolygon
 JNIEXPORT void JNICALL GLU_NATIVE(gluEndPolygon)
 	(JNIEnv *env, jclass that, jint arg0)
 {
-	NATIVE_ENTER(env, that, "gluEndPolygon\n")
-	gluEndPolygon((GLUtesselator *)arg0);
-	NATIVE_EXIT(env, that, "gluEndPolygon\n")
+	GLU_NATIVE_ENTER(env, that, gluEndPolygon_FUNC);
+	gluEndPolygon((GLUtriangulatorObj *)arg0);
+	GLU_NATIVE_EXIT(env, that, gluEndPolygon_FUNC);
 }
+#endif
 
+#ifndef NO_gluEndSurface
 JNIEXPORT void JNICALL GLU_NATIVE(gluEndSurface)
 	(JNIEnv *env, jclass that, jint arg0)
 {
-	NATIVE_ENTER(env, that, "gluEndSurface\n")
-	gluEndSurface((GLUnurbs *)arg0);
-	NATIVE_EXIT(env, that, "gluEndSurface\n")
+	GLU_NATIVE_ENTER(env, that, gluEndSurface_FUNC);
+	gluEndSurface((GLUnurbsObj *)arg0);
+	GLU_NATIVE_EXIT(env, that, gluEndSurface_FUNC);
 }
+#endif
 
+#ifndef NO_gluEndTrim
 JNIEXPORT void JNICALL GLU_NATIVE(gluEndTrim)
 	(JNIEnv *env, jclass that, jint arg0)
 {
-	NATIVE_ENTER(env, that, "gluEndTrim\n")
-	gluEndTrim((GLUnurbs *)arg0);
-	NATIVE_EXIT(env, that, "gluEndTrim\n")
+	GLU_NATIVE_ENTER(env, that, gluEndTrim_FUNC);
+	gluEndTrim((GLUnurbsObj *)arg0);
+	GLU_NATIVE_EXIT(env, that, gluEndTrim_FUNC);
 }
+#endif
 
+#ifndef NO_gluErrorString
 JNIEXPORT jint JNICALL GLU_NATIVE(gluErrorString)
 	(JNIEnv *env, jclass that, jint arg0)
 {
-    jint rc;
-	NATIVE_ENTER(env, that, "gluErrorString\n")
+	jint rc;
+	GLU_NATIVE_ENTER(env, that, gluErrorString_FUNC);
 	rc = (jint)gluErrorString(arg0);
-	NATIVE_EXIT(env, that, "gluErrorString\n")
+	GLU_NATIVE_EXIT(env, that, gluErrorString_FUNC);
 	return rc;
 }
+#endif
 
+#ifndef NO_gluGetNurbsProperty
 JNIEXPORT void JNICALL GLU_NATIVE(gluGetNurbsProperty)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
 {
 	jfloat *lparg2=NULL;
-
-	NATIVE_ENTER(env, that, "gluGetNurbsProperty\n")
-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	GLU_NATIVE_ENTER(env, that, gluGetNurbsProperty_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
+	} else
+#endif
+	{
+		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	}
 	gluGetNurbsProperty((GLUnurbs *)arg0, arg1, lparg2);
-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
-	NATIVE_EXIT(env, that, "gluGetNurbsProperty\n")
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+	}
+	GLU_NATIVE_EXIT(env, that, gluGetNurbsProperty_FUNC);
 }
+#endif
 
+#ifndef NO_gluGetString
 JNIEXPORT jint JNICALL GLU_NATIVE(gluGetString)
 	(JNIEnv *env, jclass that, jint arg0)
 {
-    jint rc;
-	NATIVE_ENTER(env, that, "gluGetString\n")
+	jint rc;
+	GLU_NATIVE_ENTER(env, that, gluGetString_FUNC);
 	rc = (jint)gluGetString(arg0);
-	NATIVE_EXIT(env, that, "gluGetString\n")
+	GLU_NATIVE_EXIT(env, that, gluGetString_FUNC);
 	return rc;
 }
+#endif
 
+#ifndef NO_gluGetTessProperty
 JNIEXPORT void JNICALL GLU_NATIVE(gluGetTessProperty)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2)
 {
 	jdouble *lparg2=NULL;
-
-	NATIVE_ENTER(env, that, "gluGetTessProperty\n")
-	if (arg2) lparg2 = (*env)->GetDoubleArrayElements(env, arg2, NULL);
+	GLU_NATIVE_ENTER(env, that, gluGetTessProperty_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
+	} else
+#endif
+	{
+		if (arg2) lparg2 = (*env)->GetDoubleArrayElements(env, arg2, NULL);
+	}
 	gluGetTessProperty((GLUtesselator *)arg0, arg1, lparg2);
-	if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0);
-	NATIVE_EXIT(env, that, "gluGetTessProperty\n")
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0);
+	}
+	GLU_NATIVE_EXIT(env, that, gluGetTessProperty_FUNC);
 }
+#endif
 
+#ifndef NO_gluLoadSamplingMatrices
 JNIEXPORT void JNICALL GLU_NATIVE(gluLoadSamplingMatrices)
 	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1, jfloatArray arg2, jintArray arg3)
 {
 	jfloat *lparg1=NULL;
 	jfloat *lparg2=NULL;
 	jint *lparg3=NULL;
-
-	NATIVE_ENTER(env, that, "gluLoadSamplingMatrices\n")
-	if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);
-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
-	if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
-	gluLoadSamplingMatrices((GLUnurbs *)arg0, lparg1, lparg2, (GLint *)lparg3);
-	if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
-	if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
-	NATIVE_EXIT(env, that, "gluLoadSamplingMatrices\n")
+	GLU_NATIVE_ENTER(env, that, gluLoadSamplingMatrices_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
+		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
+		if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
+	} else
+#endif
+	{
+		if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);
+		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+		if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
+	}
+	gluLoadSamplingMatrices((GLUnurbs *)arg0, lparg1, lparg2, lparg3);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+	} else
+#endif
+	{
+		if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
+		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+		if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
+	}
+	GLU_NATIVE_EXIT(env, that, gluLoadSamplingMatrices_FUNC);
 }
+#endif
 
+#ifndef NO_gluLookAt
 JNIEXPORT void JNICALL GLU_NATIVE(gluLookAt)
 	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3, jdouble arg4, jdouble arg5, jdouble arg6, jdouble arg7, jdouble arg8)
 {
-	NATIVE_ENTER(env, that, "gluLookAt\n")
+	GLU_NATIVE_ENTER(env, that, gluLookAt_FUNC);
 	gluLookAt(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
-	NATIVE_EXIT(env, that, "gluLookAt\n")
+	GLU_NATIVE_EXIT(env, that, gluLookAt_FUNC);
 }
+#endif
 
+#ifndef NO_gluNewNurbsRenderer
 JNIEXPORT jint JNICALL GLU_NATIVE(gluNewNurbsRenderer)
 	(JNIEnv *env, jclass that)
 {
-    jint rc;
-	NATIVE_ENTER(env, that, "gluNewNurbsRenderer\n")
+	jint rc;
+	GLU_NATIVE_ENTER(env, that, gluNewNurbsRenderer_FUNC);
 	rc = (jint)gluNewNurbsRenderer();
-	NATIVE_EXIT(env, that, "gluNewNurbsRenderer\n")
+	GLU_NATIVE_EXIT(env, that, gluNewNurbsRenderer_FUNC);
 	return rc;
 }
+#endif
 
+#ifndef NO_gluNewQuadric
 JNIEXPORT jint JNICALL GLU_NATIVE(gluNewQuadric)
 	(JNIEnv *env, jclass that)
 {
-    jint rc;
-	NATIVE_ENTER(env, that, "gluNewQuadric\n")
+	jint rc;
+	GLU_NATIVE_ENTER(env, that, gluNewQuadric_FUNC);
 	rc = (jint)gluNewQuadric();
-	NATIVE_EXIT(env, that, "gluNewQuadric\n")
+	GLU_NATIVE_EXIT(env, that, gluNewQuadric_FUNC);
 	return rc;
 }
+#endif
 
+#ifndef NO_gluNewTess
 JNIEXPORT jint JNICALL GLU_NATIVE(gluNewTess)
 	(JNIEnv *env, jclass that)
 {
-    jint rc;
-	NATIVE_ENTER(env, that, "gluNewTess\n")
+	jint rc;
+	GLU_NATIVE_ENTER(env, that, gluNewTess_FUNC);
 	rc = (jint)gluNewTess();
-	NATIVE_EXIT(env, that, "gluNewTess\n")
+	GLU_NATIVE_EXIT(env, that, gluNewTess_FUNC);
 	return rc;
 }
+#endif
 
+#ifndef NO_gluNextContour
 JNIEXPORT void JNICALL GLU_NATIVE(gluNextContour)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1)
 {
-	NATIVE_ENTER(env, that, "gluNextContour\n")
+	GLU_NATIVE_ENTER(env, that, gluNextContour_FUNC);
 	gluNextContour((GLUtesselator *)arg0, arg1);
-	NATIVE_EXIT(env, that, "gluNextContour\n")
+	GLU_NATIVE_EXIT(env, that, gluNextContour_FUNC);
 }
+#endif
 
+#ifndef NO_gluNurbsCallback
 JNIEXPORT void JNICALL GLU_NATIVE(gluNurbsCallback)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
 {
-	NATIVE_ENTER(env, that, "gluNurbsCallback\n")
-	gluNurbsCallback((GLUnurbs *)arg0, arg1, (GLvoid(*))arg2);
-	NATIVE_EXIT(env, that, "gluNurbsCallback\n")
+	GLU_NATIVE_ENTER(env, that, gluNurbsCallback_FUNC);
+	gluNurbsCallback((GLUnurbs *)arg0, arg1, (void (__stdcall *)())arg2);
+	GLU_NATIVE_EXIT(env, that, gluNurbsCallback_FUNC);
 }
+#endif
 
+#ifndef NO_gluNurbsCurve
 JNIEXPORT void JNICALL GLU_NATIVE(gluNurbsCurve)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2, jint arg3, jfloatArray arg4, jint arg5, jint arg6)
 {
 	jfloat *lparg2=NULL;
 	jfloat *lparg4=NULL;
-
-	NATIVE_ENTER(env, that, "gluNurbsCurve\n")
-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
-	if (arg4) lparg4 = (*env)->GetFloatArrayElements(env, arg4, NULL);
+	GLU_NATIVE_ENTER(env, that, gluNurbsCurve_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
+		if (arg4) lparg4 = (*env)->GetPrimitiveArrayCritical(env, arg4, NULL);
+	} else
+#endif
+	{
+		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+		if (arg4) lparg4 = (*env)->GetFloatArrayElements(env, arg4, NULL);
+	}
 	gluNurbsCurve((GLUnurbs *)arg0, arg1, lparg2, arg3, lparg4, arg5, arg6);
-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
-	if (arg4) (*env)->ReleaseFloatArrayElements(env, arg4, lparg4, 0);
-	NATIVE_EXIT(env, that, "gluNurbsCurve\n")
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg4) (*env)->ReleasePrimitiveArrayCritical(env, arg4, lparg4, 0);
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg4) (*env)->ReleaseFloatArrayElements(env, arg4, lparg4, 0);
+		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+	}
+	GLU_NATIVE_EXIT(env, that, gluNurbsCurve_FUNC);
 }
+#endif
 
+#ifndef NO_gluNurbsProperty
 JNIEXPORT void JNICALL GLU_NATIVE(gluNurbsProperty)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
 {
-	NATIVE_ENTER(env, that, "gluNurbsProperty\n")
+	GLU_NATIVE_ENTER(env, that, gluNurbsProperty_FUNC);
 	gluNurbsProperty((GLUnurbs *)arg0, arg1, arg2);
-	NATIVE_EXIT(env, that, "gluNurbsProperty\n")
+	GLU_NATIVE_EXIT(env, that, gluNurbsProperty_FUNC);
 }
+#endif
 
+#ifndef NO_gluNurbsSurface
 JNIEXPORT void JNICALL GLU_NATIVE(gluNurbsSurface)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2, jint arg3, jfloatArray arg4, jint arg5, jint arg6, jfloatArray arg7, jint arg8, jint arg9, jint arg10)
 {
 	jfloat *lparg2=NULL;
 	jfloat *lparg4=NULL;
 	jfloat *lparg7=NULL;
-
-	NATIVE_ENTER(env, that, "gluNurbsSurface\n")
-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
-	if (arg4) lparg4 = (*env)->GetFloatArrayElements(env, arg4, NULL);
-	if (arg7) lparg7 = (*env)->GetFloatArrayElements(env, arg7, NULL);
-	gluNurbsSurface((GLUnurbs *)arg0, arg1, lparg2, arg3, lparg4, arg5, arg6, lparg7, arg8, arg9, arg10);
-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
-	if (arg4) (*env)->ReleaseFloatArrayElements(env, arg4, lparg4, 0);
-	if (arg7) (*env)->ReleaseFloatArrayElements(env, arg7, lparg7, 0);
-	NATIVE_EXIT(env, that, "gluNurbsSurface\n")
+	GLU_NATIVE_ENTER(env, that, gluNurbsSurface_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
+		if (arg4) lparg4 = (*env)->GetPrimitiveArrayCritical(env, arg4, NULL);
+		if (arg7) lparg7 = (*env)->GetPrimitiveArrayCritical(env, arg7, NULL);
+	} else
+#endif
+	{
+		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+		if (arg4) lparg4 = (*env)->GetFloatArrayElements(env, arg4, NULL);
+		if (arg7) lparg7 = (*env)->GetFloatArrayElements(env, arg7, NULL);
+	}
+	gluNurbsSurface((GLUnurbsObj *)arg0, arg1, lparg2, arg3, lparg4, arg5, arg6, lparg7, arg8, arg9, arg10);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg7) (*env)->ReleasePrimitiveArrayCritical(env, arg7, lparg7, 0);
+		if (arg4) (*env)->ReleasePrimitiveArrayCritical(env, arg4, lparg4, 0);
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg7) (*env)->ReleaseFloatArrayElements(env, arg7, lparg7, 0);
+		if (arg4) (*env)->ReleaseFloatArrayElements(env, arg4, lparg4, 0);
+		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+	}
+	GLU_NATIVE_EXIT(env, that, gluNurbsSurface_FUNC);
 }
+#endif
 
+#ifndef NO_gluOrtho2D
 JNIEXPORT void JNICALL GLU_NATIVE(gluOrtho2D)
 	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
 {
-	NATIVE_ENTER(env, that, "gluOrtho2D\n")
+	GLU_NATIVE_ENTER(env, that, gluOrtho2D_FUNC);
 	gluOrtho2D(arg0, arg1, arg2, arg3);
-	NATIVE_EXIT(env, that, "gluOrtho2D\n")
+	GLU_NATIVE_EXIT(env, that, gluOrtho2D_FUNC);
 }
+#endif
 
+#ifndef NO_gluPartialDisk
 JNIEXPORT void JNICALL GLU_NATIVE(gluPartialDisk)
 	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4, jdouble arg5, jdouble arg6)
 {
-	NATIVE_ENTER(env, that, "gluPartialDisk\n")
+	GLU_NATIVE_ENTER(env, that, gluPartialDisk_FUNC);
 	gluPartialDisk((GLUquadric *)arg0, arg1, arg2, arg3, arg4, arg5, arg6);
-	NATIVE_EXIT(env, that, "gluPartialDisk\n")
+	GLU_NATIVE_EXIT(env, that, gluPartialDisk_FUNC);
 }
+#endif
 
+#ifndef NO_gluPerspective
 JNIEXPORT void JNICALL GLU_NATIVE(gluPerspective)
 	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
 {
-	NATIVE_ENTER(env, that, "gluPerspective\n")
+	GLU_NATIVE_ENTER(env, that, gluPerspective_FUNC);
 	gluPerspective(arg0, arg1, arg2, arg3);
-	NATIVE_EXIT(env, that, "gluPerspective\n")
+	GLU_NATIVE_EXIT(env, that, gluPerspective_FUNC);
 }
+#endif
 
+#ifndef NO_gluPickMatrix
 JNIEXPORT void JNICALL GLU_NATIVE(gluPickMatrix)
 	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3, jintArray arg4)
 {
 	jint *lparg4=NULL;
-
-	NATIVE_ENTER(env, that, "gluPickMatrix\n")
-	if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL);
-	gluPickMatrix(arg0, arg1, arg2, arg3, (GLint *)lparg4);
-	if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
-	NATIVE_EXIT(env, that, "gluPickMatrix\n")
+	GLU_NATIVE_ENTER(env, that, gluPickMatrix_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg4) lparg4 = (*env)->GetPrimitiveArrayCritical(env, arg4, NULL);
+	} else
+#endif
+	{
+		if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL);
+	}
+	gluPickMatrix(arg0, arg1, arg2, arg3, lparg4);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg4) (*env)->ReleasePrimitiveArrayCritical(env, arg4, lparg4, 0);
+	} else
+#endif
+	{
+		if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
+	}
+	GLU_NATIVE_EXIT(env, that, gluPickMatrix_FUNC);
 }
+#endif
 
+#ifndef NO_gluProject
 JNIEXPORT jint JNICALL GLU_NATIVE(gluProject)
 	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdoubleArray arg3, jdoubleArray arg4, jintArray arg5, jdoubleArray arg6, jdoubleArray arg7, jdoubleArray arg8)
 {
@@ -359,163 +503,246 @@ JNIEXPORT jint JNICALL GLU_NATIVE(gluProject)
 	jdouble *lparg7=NULL;
 	jdouble *lparg8=NULL;
 	jint rc;
-
-	NATIVE_ENTER(env, that, "gluProject\n")
-	if (arg3) lparg3 = (*env)->GetDoubleArrayElements(env, arg3, NULL);
-	if (arg4) lparg4 = (*env)->GetDoubleArrayElements(env, arg4, NULL);
-	if (arg5) lparg5 = (*env)->GetIntArrayElements(env, arg5, NULL);
-	if (arg6) lparg6 = (*env)->GetDoubleArrayElements(env, arg6, NULL);
-	if (arg7) lparg7 = (*env)->GetDoubleArrayElements(env, arg7, NULL);
-	if (arg8) lparg8 = (*env)->GetDoubleArrayElements(env, arg8, NULL);
-	rc = (jint)gluProject(arg0, arg1, arg2, lparg3, lparg4, (GLint *)lparg5, lparg6, lparg7, lparg8);
-	if (arg3) (*env)->ReleaseDoubleArrayElements(env, arg3, lparg3, 0);
-	if (arg4) (*env)->ReleaseDoubleArrayElements(env, arg4, lparg4, 0);
-	if (arg5) (*env)->ReleaseIntArrayElements(env, arg5, lparg5, 0);
-	if (arg6) (*env)->ReleaseDoubleArrayElements(env, arg6, lparg6, 0);
-	if (arg7) (*env)->ReleaseDoubleArrayElements(env, arg7, lparg7, 0);
-	if (arg8) (*env)->ReleaseDoubleArrayElements(env, arg8, lparg8, 0);
-	NATIVE_EXIT(env, that, "gluProject\n")
+	GLU_NATIVE_ENTER(env, that, gluProject_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
+		if (arg4) lparg4 = (*env)->GetPrimitiveArrayCritical(env, arg4, NULL);
+		if (arg5) lparg5 = (*env)->GetPrimitiveArrayCritical(env, arg5, NULL);
+		if (arg6) lparg6 = (*env)->GetPrimitiveArrayCritical(env, arg6, NULL);
+		if (arg7) lparg7 = (*env)->GetPrimitiveArrayCritical(env, arg7, NULL);
+		if (arg8) lparg8 = (*env)->GetPrimitiveArrayCritical(env, arg8, NULL);
+	} else
+#endif
+	{
+		if (arg3) lparg3 = (*env)->GetDoubleArrayElements(env, arg3, NULL);
+		if (arg4) lparg4 = (*env)->GetDoubleArrayElements(env, arg4, NULL);
+		if (arg5) lparg5 = (*env)->GetIntArrayElements(env, arg5, NULL);
+		if (arg6) lparg6 = (*env)->GetDoubleArrayElements(env, arg6, NULL);
+		if (arg7) lparg7 = (*env)->GetDoubleArrayElements(env, arg7, NULL);
+		if (arg8) lparg8 = (*env)->GetDoubleArrayElements(env, arg8, NULL);
+	}
+	rc = (jint)gluProject(arg0, arg1, arg2, lparg3, lparg4, lparg5, lparg6, lparg7, lparg8);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg8) (*env)->ReleasePrimitiveArrayCritical(env, arg8, lparg8, 0);
+		if (arg7) (*env)->ReleasePrimitiveArrayCritical(env, arg7, lparg7, 0);
+		if (arg6) (*env)->ReleasePrimitiveArrayCritical(env, arg6, lparg6, 0);
+		if (arg5) (*env)->ReleasePrimitiveArrayCritical(env, arg5, lparg5, 0);
+		if (arg4) (*env)->ReleasePrimitiveArrayCritical(env, arg4, lparg4, 0);
+		if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
+	} else
+#endif
+	{
+		if (arg8) (*env)->ReleaseDoubleArrayElements(env, arg8, lparg8, 0);
+		if (arg7) (*env)->ReleaseDoubleArrayElements(env, arg7, lparg7, 0);
+		if (arg6) (*env)->ReleaseDoubleArrayElements(env, arg6, lparg6, 0);
+		if (arg5) (*env)->ReleaseIntArrayElements(env, arg5, lparg5, 0);
+		if (arg4) (*env)->ReleaseDoubleArrayElements(env, arg4, lparg4, 0);
+		if (arg3) (*env)->ReleaseDoubleArrayElements(env, arg3, lparg3, 0);
+	}
+	GLU_NATIVE_EXIT(env, that, gluProject_FUNC);
 	return rc;
 }
+#endif
 
+#ifndef NO_gluPwlCurve
 JNIEXPORT void JNICALL GLU_NATIVE(gluPwlCurve)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2, jint arg3, jint arg4)
 {
 	jfloat *lparg2=NULL;
-
-	NATIVE_ENTER(env, that, "gluPwlCurve\n")
-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	GLU_NATIVE_ENTER(env, that, gluPwlCurve_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
+	} else
+#endif
+	{
+		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	}
 	gluPwlCurve((GLUnurbs *)arg0, arg1, lparg2, arg3, arg4);
-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
-	NATIVE_EXIT(env, that, "gluPwlCurve\n")
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+	}
+	GLU_NATIVE_EXIT(env, that, gluPwlCurve_FUNC);
 }
+#endif
 
+#ifndef NO_gluQuadricCallback
 JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricCallback)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
 {
-	NATIVE_ENTER(env, that, "gluQuadricCallback\n")
-	gluQuadricCallback((GLUquadric *)arg0, arg1, (GLvoid(*))arg2);
-	NATIVE_EXIT(env, that, "gluQuadricCallback\n")
+	GLU_NATIVE_ENTER(env, that, gluQuadricCallback_FUNC);
+	gluQuadricCallback((GLUquadricObj *)arg0, arg1, (void (__stdcall *)())arg2);
+	GLU_NATIVE_EXIT(env, that, gluQuadricCallback_FUNC);
 }
+#endif
 
+#ifndef NO_gluQuadricDrawStyle
 JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricDrawStyle)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1)
 {
-	NATIVE_ENTER(env, that, "gluQuadricDrawStyle\n")
-	gluQuadricDrawStyle((GLUquadric *)arg0, arg1);
-	NATIVE_EXIT(env, that, "gluQuadricDrawStyle\n")
+	GLU_NATIVE_ENTER(env, that, gluQuadricDrawStyle_FUNC);
+	gluQuadricDrawStyle((GLUquadricObj *)arg0, arg1);
+	GLU_NATIVE_EXIT(env, that, gluQuadricDrawStyle_FUNC);
 }
+#endif
 
+#ifndef NO_gluQuadricNormals
 JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricNormals)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1)
 {
-	NATIVE_ENTER(env, that, "gluQuadricNormals\n")
-	gluQuadricNormals((GLUquadric *)arg0, arg1);
-	NATIVE_EXIT(env, that, "gluQuadricNormals\n")
+	GLU_NATIVE_ENTER(env, that, gluQuadricNormals_FUNC);
+	gluQuadricNormals((GLUquadricObj *)arg0, arg1);
+	GLU_NATIVE_EXIT(env, that, gluQuadricNormals_FUNC);
 }
+#endif
 
+#ifndef NO_gluQuadricOrientation
 JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricOrientation)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1)
 {
-	NATIVE_ENTER(env, that, "gluQuadricOrientation\n")
+	GLU_NATIVE_ENTER(env, that, gluQuadricOrientation_FUNC);
 	gluQuadricOrientation((GLUquadric *)arg0, arg1);
-	NATIVE_EXIT(env, that, "gluQuadricOrientation\n")
+	GLU_NATIVE_EXIT(env, that, gluQuadricOrientation_FUNC);
 }
+#endif
 
+#ifndef NO_gluQuadricTexture
 JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricTexture)
 	(JNIEnv *env, jclass that, jint arg0, jboolean arg1)
 {
-	NATIVE_ENTER(env, that, "gluQuadricTexture\n")
+	GLU_NATIVE_ENTER(env, that, gluQuadricTexture_FUNC);
 	gluQuadricTexture((GLUquadric *)arg0, arg1);
-	NATIVE_EXIT(env, that, "gluQuadricTexture\n")
+	GLU_NATIVE_EXIT(env, that, gluQuadricTexture_FUNC);
 }
+#endif
 
+#ifndef NO_gluScaleImage
 JNIEXPORT jint JNICALL GLU_NATIVE(gluScaleImage)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7, jint arg8)
 {
-    jint rc;
-	NATIVE_ENTER(env, that, "gluScaleImage\n")
+	jint rc;
+	GLU_NATIVE_ENTER(env, that, gluScaleImage_FUNC);
 	rc = (jint)gluScaleImage(arg0, arg1, arg2, arg3, (const void *)arg4, arg5, arg6, arg7, (void *)arg8);
-	NATIVE_EXIT(env, that, "gluScaleImage\n")
+	GLU_NATIVE_EXIT(env, that, gluScaleImage_FUNC);
 	return rc;
 }
+#endif
 
+#ifndef NO_gluSphere
 JNIEXPORT void JNICALL GLU_NATIVE(gluSphere)
 	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jint arg2, jint arg3)
 {
-	NATIVE_ENTER(env, that, "gluSphere\n")
+	GLU_NATIVE_ENTER(env, that, gluSphere_FUNC);
 	gluSphere((GLUquadric *)arg0, arg1, arg2, arg3);
-	NATIVE_EXIT(env, that, "gluSphere\n")
+	GLU_NATIVE_EXIT(env, that, gluSphere_FUNC);
 }
+#endif
 
+#ifndef NO_gluTessBeginContour
 JNIEXPORT void JNICALL GLU_NATIVE(gluTessBeginContour)
 	(JNIEnv *env, jclass that, jint arg0)
 {
-	NATIVE_ENTER(env, that, "gluTessBeginContour\n")
+	GLU_NATIVE_ENTER(env, that, gluTessBeginContour_FUNC);
 	gluTessBeginContour((GLUtesselator *)arg0);
-	NATIVE_EXIT(env, that, "gluTessBeginContour\n")
+	GLU_NATIVE_EXIT(env, that, gluTessBeginContour_FUNC);
 }
+#endif
 
+#ifndef NO_gluTessBeginPolygon
 JNIEXPORT void JNICALL GLU_NATIVE(gluTessBeginPolygon)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1)
 {
-	NATIVE_ENTER(env, that, "gluTessBeginPolygon\n")
-	gluTessBeginPolygon((GLUtesselator *)arg0, (void *)arg1);
-	NATIVE_EXIT(env, that, "gluTessBeginPolygon\n")
+	GLU_NATIVE_ENTER(env, that, gluTessBeginPolygon_FUNC);
+	gluTessBeginPolygon((GLUtesselator *)arg0, (GLvoid *)arg1);
+	GLU_NATIVE_EXIT(env, that, gluTessBeginPolygon_FUNC);
 }
+#endif
 
+#ifndef NO_gluTessCallback
 JNIEXPORT void JNICALL GLU_NATIVE(gluTessCallback)
 	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
 {
-	NATIVE_ENTER(env, that, "gluTessCallback\n")
-	gluTessCallback((GLUtesselator *)arg0, arg1, (GLvoid(*))arg2);
-	NATIVE_EXIT(env, that, "gluTessCallback\n")
+	GLU_NATIVE_ENTER(env, that, gluTessCallback_FUNC);
+	gluTessCallback((GLUtesselator *)arg0, arg1, (void (__stdcall *)())arg2);
+	GLU_NATIVE_EXIT(env, that, gluTessCallback_FUNC);
 }
+#endif
 
+#ifndef NO_gluTessEndContour
 JNIEXPORT void JNICALL GLU_NATIVE(gluTessEndContour)
 	(JNIEnv *env, jclass that, jint arg0)
 {
-	NATIVE_ENTER(env, that, "gluTessEndContour\n")
+	GLU_NATIVE_ENTER(env, that, gluTessEndContour_FUNC);
 	gluTessEndContour((GLUtesselator *)arg0);
-	NATIVE_EXIT(env, that, "gluTessEndContour\n")
+	GLU_NATIVE_EXIT(env, that, gluTessEndContour_FUNC);
 }
+#endif
 
+#ifndef NO_gluTessEndPolygon
 JNIEXPORT void JNICALL GLU_NATIVE(gluTessEndPolygon)
 	(JNIEnv *env, jclass that, jint arg0)
 {
-	NATIVE_ENTER(env, that, "gluTessEndPolygon\n")
+	GLU_NATIVE_ENTER(env, that, gluTessEndPolygon_FUNC);
 	gluTessEndPolygon((GLUtesselator *)arg0);
-	NATIVE_EXIT(env, that, "gluTessEndPolygon\n")
+	GLU_NATIVE_EXIT(env, that, gluTessEndPolygon_FUNC);
 }
+#endif
 
+#ifndef NO_gluTessNormal
 JNIEXPORT void JNICALL GLU_NATIVE(gluTessNormal)
 	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jdouble arg3)
 {
-	NATIVE_ENTER(env, that, "gluTessNormal\n")
+	GLU_NATIVE_ENTER(env, that, gluTessNormal_FUNC);
 	gluTessNormal((GLUtesselator *)arg0, arg1, arg2, arg3);
-	NATIVE_EXIT(env, that, "gluTessNormal\n")
+	GLU_NATIVE_EXIT(env, that, gluTessNormal_FUNC);
 }
+#endif
 
+#ifndef NO_gluTessProperty
 JNIEXPORT void JNICALL GLU_NATIVE(gluTessProperty)
-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdouble arg2)
 {
-	NATIVE_ENTER(env, that, "gluTessProperty\n")
+	GLU_NATIVE_ENTER(env, that, gluTessProperty_FUNC);
 	gluTessProperty((GLUtesselator *)arg0, arg1, arg2);
-	NATIVE_EXIT(env, that, "gluTessProperty\n")
+	GLU_NATIVE_EXIT(env, that, gluTessProperty_FUNC);
 }
+#endif
 
+#ifndef NO_gluTessVertex
 JNIEXPORT void JNICALL GLU_NATIVE(gluTessVertex)
 	(JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1, jint arg2)
 {
 	jdouble *lparg1=NULL;
-
-	NATIVE_ENTER(env, that, "gluTessVertex\n")
-	if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);
-	gluTessVertex((GLUtesselator *)arg0, lparg1, (void *)arg2);
-	if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);
-	NATIVE_EXIT(env, that, "gluTessVertex\n")
+	GLU_NATIVE_ENTER(env, that, gluTessVertex_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
+	} else
+#endif
+	{
+		if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);
+	}
+	gluTessVertex((GLUtesselator *)arg0, lparg1, (GLvoid *)arg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);
+	}
+	GLU_NATIVE_EXIT(env, that, gluTessVertex_FUNC);
 }
+#endif
 
+#ifndef NO_gluUnProject
 JNIEXPORT jint JNICALL GLU_NATIVE(gluUnProject)
 	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdoubleArray arg3, jdoubleArray arg4, jintArray arg5, jdoubleArray arg6, jdoubleArray arg7, jdoubleArray arg8)
 {
@@ -526,21 +753,46 @@ JNIEXPORT jint JNICALL GLU_NATIVE(gluUnProject)
 	jdouble *lparg7=NULL;
 	jdouble *lparg8=NULL;
 	jint rc;
-
-	NATIVE_ENTER(env, that, "gluUnProject\n")
-	if (arg3) lparg3 = (*env)->GetDoubleArrayElements(env, arg3, NULL);
-	if (arg4) lparg4 = (*env)->GetDoubleArrayElements(env, arg4, NULL);
-	if (arg5) lparg5 = (*env)->GetIntArrayElements(env, arg5, NULL);
-	if (arg6) lparg6 = (*env)->GetDoubleArrayElements(env, arg6, NULL);
-	if (arg7) lparg7 = (*env)->GetDoubleArrayElements(env, arg7, NULL);
-	if (arg8) lparg8 = (*env)->GetDoubleArrayElements(env, arg8, NULL);
-	rc = (jint)gluUnProject(arg0, arg1, arg2, lparg3, lparg4, (GLint *)lparg5, lparg6, lparg7, lparg8);
-	if (arg3) (*env)->ReleaseDoubleArrayElements(env, arg3, lparg3, 0);
-	if (arg4) (*env)->ReleaseDoubleArrayElements(env, arg4, lparg4, 0);
-	if (arg5) (*env)->ReleaseIntArrayElements(env, arg5, lparg5, 0);
-	if (arg6) (*env)->ReleaseDoubleArrayElements(env, arg6, lparg6, 0);
-	if (arg7) (*env)->ReleaseDoubleArrayElements(env, arg7, lparg7, 0);
-	if (arg8) (*env)->ReleaseDoubleArrayElements(env, arg8, lparg8, 0);
-	NATIVE_EXIT(env, that, "gluUnProject\n")
+	GLU_NATIVE_ENTER(env, that, gluUnProject_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
+		if (arg4) lparg4 = (*env)->GetPrimitiveArrayCritical(env, arg4, NULL);
+		if (arg5) lparg5 = (*env)->GetPrimitiveArrayCritical(env, arg5, NULL);
+		if (arg6) lparg6 = (*env)->GetPrimitiveArrayCritical(env, arg6, NULL);
+		if (arg7) lparg7 = (*env)->GetPrimitiveArrayCritical(env, arg7, NULL);
+		if (arg8) lparg8 = (*env)->GetPrimitiveArrayCritical(env, arg8, NULL);
+	} else
+#endif
+	{
+		if (arg3) lparg3 = (*env)->GetDoubleArrayElements(env, arg3, NULL);
+		if (arg4) lparg4 = (*env)->GetDoubleArrayElements(env, arg4, NULL);
+		if (arg5) lparg5 = (*env)->GetIntArrayElements(env, arg5, NULL);
+		if (arg6) lparg6 = (*env)->GetDoubleArrayElements(env, arg6, NULL);
+		if (arg7) lparg7 = (*env)->GetDoubleArrayElements(env, arg7, NULL);
+		if (arg8) lparg8 = (*env)->GetDoubleArrayElements(env, arg8, NULL);
+	}
+	rc = (jint)gluUnProject(arg0, arg1, arg2, lparg3, lparg4, lparg5, lparg6, lparg7, lparg8);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg8) (*env)->ReleasePrimitiveArrayCritical(env, arg8, lparg8, 0);
+		if (arg7) (*env)->ReleasePrimitiveArrayCritical(env, arg7, lparg7, 0);
+		if (arg6) (*env)->ReleasePrimitiveArrayCritical(env, arg6, lparg6, 0);
+		if (arg5) (*env)->ReleasePrimitiveArrayCritical(env, arg5, lparg5, 0);
+		if (arg4) (*env)->ReleasePrimitiveArrayCritical(env, arg4, lparg4, 0);
+		if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
+	} else
+#endif
+	{
+		if (arg8) (*env)->ReleaseDoubleArrayElements(env, arg8, lparg8, 0);
+		if (arg7) (*env)->ReleaseDoubleArrayElements(env, arg7, lparg7, 0);
+		if (arg6) (*env)->ReleaseDoubleArrayElements(env, arg6, lparg6, 0);
+		if (arg5) (*env)->ReleaseIntArrayElements(env, arg5, lparg5, 0);
+		if (arg4) (*env)->ReleaseDoubleArrayElements(env, arg4, lparg4, 0);
+		if (arg3) (*env)->ReleaseDoubleArrayElements(env, arg3, lparg3, 0);
+	}
+	GLU_NATIVE_EXIT(env, that, gluUnProject_FUNC);
 	return rc;
 }
+#endif
+
diff --git a/bundles/org.eclipse.swt.opengl/common/library/glu.h b/bundles/org.eclipse.swt.opengl/common/library/glu.h
new file mode 100644
index 0000000000..9ec3bbb147
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/library/glu.h
@@ -0,0 +1,6 @@
+#ifdef WIN32
+#include <windows.h>
+#endif
+#include <GL/glu.h>
+
+extern int IS_JNI_1_2;
diff --git a/bundles/org.eclipse.swt.opengl/common/library/glu_stats.c b/bundles/org.eclipse.swt.opengl/common/library/glu_stats.c
new file mode 100644
index 0000000000..3befc268da
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/library/glu_stats.c
@@ -0,0 +1,82 @@
+#include "swt.h"
+#include "glu_stats.h"
+
+#ifdef NATIVE_STATS
+
+int GLU_nativeFunctionCount = 51;
+int GLU_nativeFunctionCallCount[51];
+char * GLU_nativeFunctionNames[] = {
+	"gluBeginCurve", 
+	"gluBeginPolygon", 
+	"gluBeginSurface", 
+	"gluBeginTrim", 
+	"gluBuild1DMipmaps", 
+	"gluBuild2DMipmaps", 
+	"gluCylinder", 
+	"gluDeleteNurbsRenderer", 
+	"gluDeleteQuadric", 
+	"gluDeleteTess", 
+	"gluDisk", 
+	"gluEndCurve", 
+	"gluEndPolygon", 
+	"gluEndSurface", 
+	"gluEndTrim", 
+	"gluErrorString", 
+	"gluGetNurbsProperty", 
+	"gluGetString", 
+	"gluGetTessProperty", 
+	"gluLoadSamplingMatrices", 
+	"gluLookAt", 
+	"gluNewNurbsRenderer", 
+	"gluNewQuadric", 
+	"gluNewTess", 
+	"gluNextContour", 
+	"gluNurbsCallback", 
+	"gluNurbsCurve", 
+	"gluNurbsProperty", 
+	"gluNurbsSurface", 
+	"gluOrtho2D", 
+	"gluPartialDisk", 
+	"gluPerspective", 
+	"gluPickMatrix", 
+	"gluProject", 
+	"gluPwlCurve", 
+	"gluQuadricCallback", 
+	"gluQuadricDrawStyle", 
+	"gluQuadricNormals", 
+	"gluQuadricOrientation", 
+	"gluQuadricTexture", 
+	"gluScaleImage", 
+	"gluSphere", 
+	"gluTessBeginContour", 
+	"gluTessBeginPolygon", 
+	"gluTessCallback", 
+	"gluTessEndContour", 
+	"gluTessEndPolygon", 
+	"gluTessNormal", 
+	"gluTessProperty", 
+	"gluTessVertex", 
+	"gluUnProject", 
+};
+
+#define STATS_NATIVE(func) Java_org_eclipse_swt_tools_internal_NativeStats_##func
+
+JNIEXPORT jint JNICALL STATS_NATIVE(GLU_1GetFunctionCount)
+	(JNIEnv *env, jclass that)
+{
+	return GLU_nativeFunctionCount;
+}
+
+JNIEXPORT jstring JNICALL STATS_NATIVE(GLU_1GetFunctionName)
+	(JNIEnv *env, jclass that, jint index)
+{
+	return (*env)->NewStringUTF(env, GLU_nativeFunctionNames[index]);
+}
+
+JNIEXPORT jint JNICALL STATS_NATIVE(GLU_1GetFunctionCallCount)
+	(JNIEnv *env, jclass that, jint index)
+{
+	return GLU_nativeFunctionCallCount[index];
+}
+
+#endif
diff --git a/bundles/org.eclipse.swt.opengl/common/library/glu_stats.h b/bundles/org.eclipse.swt.opengl/common/library/glu_stats.h
new file mode 100644
index 0000000000..99173e6713
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/library/glu_stats.h
@@ -0,0 +1,64 @@
+#ifdef NATIVE_STATS
+extern int GLU_nativeFunctionCount;
+extern int GLU_nativeFunctionCallCount[];
+extern char* GLU_nativeFunctionNames[];
+#define GLU_NATIVE_ENTER(env, that, func) GLU_nativeFunctionCallCount[func]++;
+#define GLU_NATIVE_EXIT(env, that, func) 
+#else
+#define GLU_NATIVE_ENTER(env, that, func) 
+#define GLU_NATIVE_EXIT(env, that, func) 
+#endif
+
+typedef enum {
+	gluBeginCurve_FUNC,
+	gluBeginPolygon_FUNC,
+	gluBeginSurface_FUNC,
+	gluBeginTrim_FUNC,
+	gluBuild1DMipmaps_FUNC,
+	gluBuild2DMipmaps_FUNC,
+	gluCylinder_FUNC,
+	gluDeleteNurbsRenderer_FUNC,
+	gluDeleteQuadric_FUNC,
+	gluDeleteTess_FUNC,
+	gluDisk_FUNC,
+	gluEndCurve_FUNC,
+	gluEndPolygon_FUNC,
+	gluEndSurface_FUNC,
+	gluEndTrim_FUNC,
+	gluErrorString_FUNC,
+	gluGetNurbsProperty_FUNC,
+	gluGetString_FUNC,
+	gluGetTessProperty_FUNC,
+	gluLoadSamplingMatrices_FUNC,
+	gluLookAt_FUNC,
+	gluNewNurbsRenderer_FUNC,
+	gluNewQuadric_FUNC,
+	gluNewTess_FUNC,
+	gluNextContour_FUNC,
+	gluNurbsCallback_FUNC,
+	gluNurbsCurve_FUNC,
+	gluNurbsProperty_FUNC,
+	gluNurbsSurface_FUNC,
+	gluOrtho2D_FUNC,
+	gluPartialDisk_FUNC,
+	gluPerspective_FUNC,
+	gluPickMatrix_FUNC,
+	gluProject_FUNC,
+	gluPwlCurve_FUNC,
+	gluQuadricCallback_FUNC,
+	gluQuadricDrawStyle_FUNC,
+	gluQuadricNormals_FUNC,
+	gluQuadricOrientation_FUNC,
+	gluQuadricTexture_FUNC,
+	gluScaleImage_FUNC,
+	gluSphere_FUNC,
+	gluTessBeginContour_FUNC,
+	gluTessBeginPolygon_FUNC,
+	gluTessCallback_FUNC,
+	gluTessEndContour_FUNC,
+	gluTessEndPolygon_FUNC,
+	gluTessNormal_FUNC,
+	gluTessProperty_FUNC,
+	gluTessVertex_FUNC,
+	gluUnProject_FUNC,
+} GLU_FUNCS;
diff --git a/bundles/org.eclipse.swt.opengl/common/library/glu_structs.c b/bundles/org.eclipse.swt.opengl/common/library/glu_structs.c
new file mode 100644
index 0000000000..620ce43b12
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/library/glu_structs.c
@@ -0,0 +1,3 @@
+#include "swt.h"
+#include "glu_structs.h"
+
diff --git a/bundles/org.eclipse.swt.opengl/common/library/glu_structs.h b/bundles/org.eclipse.swt.opengl/common/library/glu_structs.h
new file mode 100644
index 0000000000..5d11acf289
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/library/glu_structs.h
@@ -0,0 +1,2 @@
+#include "glu.h"
+