*** keyword substitution change ***

9 files changed, 7293 insertions, 4719 deletions

diff --git a/bundles/org.eclipse.swt.opengl/common/library/gl.c b/bundles/org.eclipse.swt.opengl/common/library/gl.c
index 3147f0cdda..5826303c38 100644
--- a/bundles/org.eclipse.swt.opengl/common/library/gl.c
+++ b/bundles/org.eclipse.swt.opengl/common/library/gl.c
@@ -1,3356 +1,5930 @@
-/*******************************************************************************

- * 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/gl.h>

-#include "swt.h"

-

-#define GL_NATIVE(func) Java_org_eclipse_swt_opengl_GL_##func

-

-JNIEXPORT void JNICALL GL_NATIVE(glAccum)

-	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)

-{

-	NATIVE_ENTER(env, that, "glAccum\n")

-	glAccum(arg0, arg1);

-	NATIVE_EXIT(env, that, "glAccum\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glAlphaFunc)

-	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)

-{

-	NATIVE_ENTER(env, that, "glAlphaFunc\n")

-	glAlphaFunc(arg0, arg1);

-	NATIVE_EXIT(env, that, "glAlphaFunc\n")

-}

-

-JNIEXPORT jboolean JNICALL GL_NATIVE(glAreTexturesResident)

-	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jbooleanArray arg2)

-{

-	jint *lparg1=NULL;

-	jboolean *lparg2=NULL;

-	jboolean rc;

-

-	NATIVE_ENTER(env, that, "glAreTexturesResident\n")

-	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);

-	if (arg2) lparg2 = (*env)->GetBooleanArrayElements(env, arg2, NULL);

-	rc = (jboolean)glAreTexturesResident(arg0, (unsigned int *)lparg1, lparg2);

-	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);

-	if (arg2) (*env)->ReleaseBooleanArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glAreTexturesResident\n")

-	return rc;

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glArrayElement)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glArrayElement\n")

-	glArrayElement(arg0);

-	NATIVE_EXIT(env, that, "glArrayElement\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glBegin)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glBegin\n")

-	glBegin(arg0);

-	NATIVE_EXIT(env, that, "glBegin\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glBindTexture)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	NATIVE_ENTER(env, that, "glBindTexture\n")

-	glBindTexture(arg0, arg1);

-	NATIVE_EXIT(env, that, "glBindTexture\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glBitmap)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2, jfloat arg3, jfloat arg4, jfloat arg5, jbyteArray arg6)

-{

-	jbyte *lparg6=NULL;

-

-	NATIVE_ENTER(env, that, "glBitmap\n")

-	if (arg6) lparg6 = (*env)->GetByteArrayElements(env, arg6, NULL);

-	glBitmap(arg0, arg1, arg2, arg3, arg4, arg5, (unsigned char *)lparg6);

-	if (arg6) (*env)->ReleaseByteArrayElements(env, arg6, lparg6, 0);

-	NATIVE_EXIT(env, that, "glBitmap\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glBlendFunc)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	NATIVE_ENTER(env, that, "glBlendFunc\n")

-	glBlendFunc(arg0, arg1);

-	NATIVE_EXIT(env, that, "glBlendFunc\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glCallList)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glCallList\n")

-	glCallList(arg0);

-	NATIVE_EXIT(env, that, "glCallList\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glCallLists__II_3B)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jbyteArray arg2)

-{

-	jbyte *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glCallLists__II_3B\n")

-	if (arg2) lparg2 = (*env)->GetByteArrayElements(env, arg2, NULL);

-	glCallLists(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseByteArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glCallLists__II_3B\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glCallLists__II_3C)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jcharArray arg2)

-{

-	jchar *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glCallLists__II_3C\n")

-	if (arg2) lparg2 = (*env)->GetCharArrayElements(env, arg2, NULL);

-	glCallLists(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseCharArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glCallLists__II_3C\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glCallLists__II_3I)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)

-{

-	jint *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glCallLists__II_3I\n")

-	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);

-	glCallLists(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glCallLists__II_3I\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glClear)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glClear\n")

-	glClear(arg0);

-	NATIVE_EXIT(env, that, "glClear\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glClearAccum)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)

-{

-	NATIVE_ENTER(env, that, "glClearAccum\n")

-	glClearAccum(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glClearAccum\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glClearColor)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)

-{

-	NATIVE_ENTER(env, that, "glClearColor\n")

-	glClearColor(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glClearColor\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glClearDepth)

-	(JNIEnv *env, jclass that, jdouble arg0)

-{

-	NATIVE_ENTER(env, that, "glClearDepth\n")

-	glClearDepth(arg0);

-	NATIVE_EXIT(env, that, "glClearDepth\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glClearIndex)

-	(JNIEnv *env, jclass that, jfloat arg0)

-{

-	NATIVE_ENTER(env, that, "glClearIndex\n")

-	glClearIndex(arg0);

-	NATIVE_EXIT(env, that, "glClearIndex\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glClearStencil)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glClearStencil\n")

-	glClearStencil(arg0);

-	NATIVE_EXIT(env, that, "glClearStencil\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glClipPlane)

-	(JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1)

-{

-	jdouble *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glClipPlane\n")

-	if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);

-	glClipPlane(arg0, lparg1);

-	if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glClipPlane\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor3b)

-	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2)

-{

-	NATIVE_ENTER(env, that, "glColor3b\n")

-	glColor3b(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glColor3b\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor3bv)

-	(JNIEnv *env, jclass that, jbyteArray arg0)

-{

-	jbyte *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glColor3bv\n")

-	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);

-	glColor3bv(lparg0);

-	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glColor3bv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor3d)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)

-{

-	NATIVE_ENTER(env, that, "glColor3d\n")

-	glColor3d(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glColor3d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor3dv)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glColor3dv\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glColor3dv(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glColor3dv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor3f)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)

-{

-	NATIVE_ENTER(env, that, "glColor3f\n")

-	glColor3f(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glColor3f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor3fv)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glColor3fv\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glColor3fv(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glColor3fv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor3i)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)

-{

-	NATIVE_ENTER(env, that, "glColor3i\n")

-	glColor3i(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glColor3i\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor3iv)

-	(JNIEnv *env, jclass that, jintArray arg0)

-{

-	jint *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glColor3iv\n")

-	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);

-	glColor3iv((GLint *)lparg0);

-	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glColor3iv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor3s)

-	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)

-{

-	NATIVE_ENTER(env, that, "glColor3s\n")

-	glColor3s(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glColor3s\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor3ub)

-	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2)

-{

-	NATIVE_ENTER(env, that, "glColor3ub\n")

-	glColor3ub(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glColor3ub\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor3ubv)

-	(JNIEnv *env, jclass that, jbyteArray arg0)

-{

-	jbyte *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glColor3ubv\n")

-	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);

-	glColor3ubv((unsigned char *)lparg0);

-	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glColor3ubv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor3ui)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)

-{

-	NATIVE_ENTER(env, that, "glColor3ui\n")

-	glColor3ui(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glColor3ui\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor3uiv)

-	(JNIEnv *env, jclass that, jintArray arg0)

-{

-	jint *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glColor3uiv\n")

-	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);

-	glColor3uiv((unsigned int *)lparg0);

-	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glColor3uiv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor3us)

-	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)

-{

-	NATIVE_ENTER(env, that, "glColor3us\n")

-	glColor3us(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glColor3us\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor3usv)

-	(JNIEnv *env, jclass that, jshortArray arg0)

-{

-	jshort *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glColor3usv\n")

-	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);

-	glColor3usv((unsigned short *)lparg0);

-	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glColor3usv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor4b)

-	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2, jbyte arg3)

-{

-	NATIVE_ENTER(env, that, "glColor4b\n")

-	glColor4b(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glColor4b\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor4bv)

-	(JNIEnv *env, jclass that, jbyteArray arg0)

-{

-	jbyte *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glColor4bv\n")

-	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);

-	glColor4bv(lparg0);

-	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glColor4bv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor4d)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)

-{

-	NATIVE_ENTER(env, that, "glColor4d\n")

-	glColor4d(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glColor4d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor4dv)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glColor4dv\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glColor4dv(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glColor4dv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor4f)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)

-{

-	NATIVE_ENTER(env, that, "glColor4f\n")

-	glColor4f(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glColor4f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor4fv)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glColor4fv\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glColor4fv(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glColor4fv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor4i)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)

-{

-	NATIVE_ENTER(env, that, "glColor4i\n")

-	glColor4i(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glColor4i\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor4iv)

-	(JNIEnv *env, jclass that, jintArray arg0)

-{

-	jint *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glColor4iv\n")

-	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);

-	glColor4iv((GLint *)lparg0);

-	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glColor4iv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor4s)

-	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)

-{

-	NATIVE_ENTER(env, that, "glColor4s\n")

-	glColor4s(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glColor4s\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor4ub)

-	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2, jbyte arg3)

-{

-	NATIVE_ENTER(env, that, "glColor4ub\n")

-	glColor4ub(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glColor4ub\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor4ubv)

-	(JNIEnv *env, jclass that, jbyteArray arg0)

-{

-	jbyte *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glColor4ubv\n")

-	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);

-	glColor4ubv((unsigned char *)lparg0);

-	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glColor4ubv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor4ui)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)

-{

-	NATIVE_ENTER(env, that, "glColor4ui\n")

-	glColor4ui(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glColor4ui\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor4uiv)

-	(JNIEnv *env, jclass that, jintArray arg0)

-{

-	jint *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glColor4uiv\n")

-	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);

-	glColor4uiv((unsigned int *)lparg0);

-	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glColor4uiv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor4us)

-	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)

-{

-	NATIVE_ENTER(env, that, "glColor4us\n")

-	glColor4us(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glColor4us\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColor4usv)

-	(JNIEnv *env, jclass that, jshortArray arg0)

-{

-	jshort *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glColor4usv\n")

-	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);

-	glColor4usv((unsigned short *)lparg0);

-	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glColor4usv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColorMask)

-	(JNIEnv *env, jclass that, jboolean arg0, jboolean arg1, jboolean arg2, jboolean arg3)

-{

-	NATIVE_ENTER(env, that, "glColorMask\n")

-	glColorMask(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glColorMask\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColorMaterial)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	NATIVE_ENTER(env, that, "glColorMaterial\n")

-	glColorMaterial(arg0, arg1);

-	NATIVE_EXIT(env, that, "glColorMaterial\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glColorPointer)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)

-{

-	jint *lparg3=NULL;

-

-	NATIVE_ENTER(env, that, "glColorPointer\n")

-	if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);

-	glColorPointer(arg0, arg1, arg2, lparg3);

-	if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);

-	NATIVE_EXIT(env, that, "glColorPointer\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glCopyPixels)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4)

-{

-	NATIVE_ENTER(env, that, "glCopyPixels\n")

-	glCopyPixels(arg0, arg1, arg2, arg3, arg4);

-	NATIVE_EXIT(env, that, "glCopyPixels\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glCopyTexImage1D)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6)

-{

-	NATIVE_ENTER(env, that, "glCopyTexImage1D\n")

-	glCopyTexImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6);

-	NATIVE_EXIT(env, that, "glCopyTexImage1D\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glCopyTexImage2D)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7)

-{

-	NATIVE_ENTER(env, that, "glCopyTexImage2D\n")

-	glCopyTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);

-	NATIVE_EXIT(env, that, "glCopyTexImage2D\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glCopyTexSubImage1D)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5)

-{

-	NATIVE_ENTER(env, that, "glCopyTexSubImage1D\n")

-	glCopyTexSubImage1D(arg0, arg1, arg2, arg3, arg4, arg5);

-	NATIVE_EXIT(env, that, "glCopyTexSubImage1D\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glCopyTexSubImage2D)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7)

-{

-	NATIVE_ENTER(env, that, "glCopyTexSubImage2D\n")

-	glCopyTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);

-	NATIVE_EXIT(env, that, "glCopyTexSubImage2D\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glCullFace)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glCullFace\n")

-	glCullFace(arg0);

-	NATIVE_EXIT(env, that, "glCullFace\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glDeleteLists)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	NATIVE_ENTER(env, that, "glDeleteLists\n")

-	glDeleteLists(arg0, arg1);

-	NATIVE_EXIT(env, that, "glDeleteLists\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glDeleteTextures)

-	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)

-{

-	jint *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glDeleteTextures\n")

-	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);

-	glDeleteTextures(arg0, (unsigned int *)lparg1);

-	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glDeleteTextures\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glDepthFunc)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glDepthFunc\n")

-	glDepthFunc(arg0);

-	NATIVE_EXIT(env, that, "glDepthFunc\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glDepthMask)

-	(JNIEnv *env, jclass that, jboolean arg0)

-{

-	NATIVE_ENTER(env, that, "glDepthMask\n")

-	glDepthMask(arg0);

-	NATIVE_EXIT(env, that, "glDepthMask\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glDepthRange)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)

-{

-	NATIVE_ENTER(env, that, "glDepthRange\n")

-	glDepthRange(arg0, arg1);

-	NATIVE_EXIT(env, that, "glDepthRange\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glDisable)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glDisable\n")

-	glDisable(arg0);

-	NATIVE_EXIT(env, that, "glDisable\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glDisableClientState)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glDisableClientState\n")

-	glDisableClientState(arg0);

-	NATIVE_EXIT(env, that, "glDisableClientState\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glDrawArrays)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)

-{

-	NATIVE_ENTER(env, that, "glDrawArrays\n")

-	glDrawArrays(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glDrawArrays\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glDrawBuffer)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glDrawBuffer\n")

-	glDrawBuffer(arg0);

-	NATIVE_EXIT(env, that, "glDrawBuffer\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glDrawElements)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)

-{

-	jint *lparg3=NULL;

-

-	NATIVE_ENTER(env, that, "glDrawElements\n")

-	if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);

-	glDrawElements(arg0, arg1, arg2, lparg3);

-	if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);

-	NATIVE_EXIT(env, that, "glDrawElements\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glDrawPixels)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jintArray arg4)

-{

-	jint *lparg4=NULL;

-

-	NATIVE_ENTER(env, that, "glDrawPixels\n")

-	if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL);

-	glDrawPixels(arg0, arg1, arg2, arg3, lparg4);

-	if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);

-	NATIVE_EXIT(env, that, "glDrawPixels\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEdgeFlag)

-	(JNIEnv *env, jclass that, jboolean arg0)

-{

-	NATIVE_ENTER(env, that, "glEdgeFlag\n")

-	glEdgeFlag(arg0);

-	NATIVE_EXIT(env, that, "glEdgeFlag\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEdgeFlagPointer)

-	(JNIEnv *env, jclass that, jint arg0, jbooleanArray arg1)

-{

-	jboolean *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glEdgeFlagPointer\n")

-	if (arg1) lparg1 = (*env)->GetBooleanArrayElements(env, arg1, NULL);

-	glEdgeFlagPointer(arg0, lparg1);

-	if (arg1) (*env)->ReleaseBooleanArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glEdgeFlagPointer\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEdgeFlagv)

-	(JNIEnv *env, jclass that, jbooleanArray arg0)

-{

-	jboolean *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glEdgeFlagv\n")

-	if (arg0) lparg0 = (*env)->GetBooleanArrayElements(env, arg0, NULL);

-	glEdgeFlagv(lparg0);

-	if (arg0) (*env)->ReleaseBooleanArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glEdgeFlagv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEnable)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glEnable\n")

-	glEnable(arg0);

-	NATIVE_EXIT(env, that, "glEnable\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEnableClientState)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glEnableClientState\n")

-	glEnableClientState(arg0);

-	NATIVE_EXIT(env, that, "glEnableClientState\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEnd)

-	(JNIEnv *env, jclass that)

-{

-	NATIVE_ENTER(env, that, "glEnd\n")

-	glEnd();

-	NATIVE_EXIT(env, that, "glEnd\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEndList)

-	(JNIEnv *env, jclass that)

-{

-	NATIVE_ENTER(env, that, "glEndList\n")

-	glEndList();

-	NATIVE_EXIT(env, that, "glEndList\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1d)

-	(JNIEnv *env, jclass that, jdouble arg0)

-{

-	NATIVE_ENTER(env, that, "glEvalCoord1d\n")

-	glEvalCoord1d(arg0);

-	NATIVE_EXIT(env, that, "glEvalCoord1d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1dv)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glEvalCoord1dv\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glEvalCoord1dv(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glEvalCoord1dv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1f)

-	(JNIEnv *env, jclass that, jfloat arg0)

-{

-	NATIVE_ENTER(env, that, "glEvalCoord1f\n")

-	glEvalCoord1f(arg0);

-	NATIVE_EXIT(env, that, "glEvalCoord1f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1fv)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glEvalCoord1fv\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glEvalCoord1fv(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glEvalCoord1fv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2d)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)

-{

-	NATIVE_ENTER(env, that, "glEvalCoord2d\n")

-	glEvalCoord2d(arg0, arg1);

-	NATIVE_EXIT(env, that, "glEvalCoord2d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2dv)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glEvalCoord2dv\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glEvalCoord2dv(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glEvalCoord2dv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2f)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)

-{

-	NATIVE_ENTER(env, that, "glEvalCoord2f\n")

-	glEvalCoord2f(arg0, arg1);

-	NATIVE_EXIT(env, that, "glEvalCoord2f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2fv)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glEvalCoord2fv\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glEvalCoord2fv(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glEvalCoord2fv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEvalMesh1)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)

-{

-	NATIVE_ENTER(env, that, "glEvalMesh1\n")

-	glEvalMesh1(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glEvalMesh1\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEvalMesh2)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4)

-{

-	NATIVE_ENTER(env, that, "glEvalMesh2\n")

-	glEvalMesh2(arg0, arg1, arg2, arg3, arg4);

-	NATIVE_EXIT(env, that, "glEvalMesh2\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEvalPoint1)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glEvalPoint1\n")

-	glEvalPoint1(arg0);

-	NATIVE_EXIT(env, that, "glEvalPoint1\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glEvalPoint2)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	NATIVE_ENTER(env, that, "glEvalPoint2\n")

-	glEvalPoint2(arg0, arg1);

-	NATIVE_EXIT(env, that, "glEvalPoint2\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glFeedbackBuffer)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)

-{

-	jfloat *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glFeedbackBuffer\n")

-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);

-	glFeedbackBuffer(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glFeedbackBuffer\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glFinish)

-	(JNIEnv *env, jclass that)

-{

-	NATIVE_ENTER(env, that, "glFinish\n")

-	glFinish();

-	NATIVE_EXIT(env, that, "glFinish\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glFlush)

-	(JNIEnv *env, jclass that)

-{

-	NATIVE_ENTER(env, that, "glFlush\n")

-	glFlush();

-	NATIVE_EXIT(env, that, "glFlush\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glFogf)

-	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)

-{

-	NATIVE_ENTER(env, that, "glFogf\n")

-	glFogf(arg0, arg1);

-	NATIVE_EXIT(env, that, "glFogf\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glFogfv)

-	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1)

-{

-	jfloat *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glFogfv\n")

-	if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);

-	glFogfv(arg0, lparg1);

-	if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glFogfv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glFogi)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	NATIVE_ENTER(env, that, "glFogi\n")

-	glFogi(arg0, arg1);

-	NATIVE_EXIT(env, that, "glFogi\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glFogiv)

-	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)

-{

-	jint *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glFogiv\n")

-	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);

-	glFogiv(arg0, (GLint *)lparg1);

-	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glFogiv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glFrontFace)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glFrontFace\n")

-	glFrontFace(arg0);

-	NATIVE_EXIT(env, that, "glFrontFace\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glFrustum)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3, jdouble arg4, jdouble arg5)

-{

-	NATIVE_ENTER(env, that, "glFrustum\n")

-	glFrustum(arg0, arg1, arg2, arg3, arg4, arg5);

-	NATIVE_EXIT(env, that, "glFrustum\n")

-}

-

-JNIEXPORT jint JNICALL GL_NATIVE(glGenLists)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-    jint rc;

-	NATIVE_ENTER(env, that, "glGenLists\n")

-	rc = (jint)glGenLists(arg0);

-	NATIVE_EXIT(env, that, "glGenLists\n")

-	return rc;

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGenTextures)

-	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)

-{

-	jint *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glGenTextures\n")

-	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);

-	glGenTextures(arg0, (unsigned int *)lparg1);

-	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glGenTextures\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetBooleanv)

-	(JNIEnv *env, jclass that, jint arg0, jbooleanArray arg1)

-{

-	jboolean *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glGetBooleanv\n")

-	if (arg1) lparg1 = (*env)->GetBooleanArrayElements(env, arg1, NULL);

-	glGetBooleanv(arg0, lparg1);

-	if (arg1) (*env)->ReleaseBooleanArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glGetBooleanv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetClipPlane)

-	(JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1)

-{

-	jdouble *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glGetClipPlane\n")

-	if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);

-	glGetClipPlane(arg0, lparg1);

-	if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glGetClipPlane\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetDoublev)

-	(JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1)

-{

-	jdouble *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glGetDoublev\n")

-	if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);

-	glGetDoublev(arg0, lparg1);

-	if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glGetDoublev\n")

-}

-

-JNIEXPORT jint JNICALL GL_NATIVE(glGetError)

-	(JNIEnv *env, jclass that)

-{

-    jint rc;

-	NATIVE_ENTER(env, that, "glGetError\n")

-	rc = (jint)glGetError();

-	NATIVE_EXIT(env, that, "glGetError\n")

-	return rc;

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetFloatv)

-	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1)

-{

-	jfloat *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glGetFloatv\n")

-	if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);

-	glGetFloatv(arg0, lparg1);

-	if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glGetFloatv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetIntegerv)

-	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)

-{

-	jint *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glGetIntegerv\n")

-	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);

-	glGetIntegerv(arg0, (GLint *)lparg1);

-	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glGetIntegerv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetLightfv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)

-{

-	jfloat *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glGetLightfv\n")

-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);

-	glGetLightfv(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glGetLightfv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetLightiv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)

-{

-	jint *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glGetLightiv\n")

-	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);

-	glGetLightiv(arg0, arg1, (GLint *)lparg2);

-	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glGetLightiv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetMapdv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2)

-{

-	jdouble *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glGetMapdv\n")

-	if (arg2) lparg2 = (*env)->GetDoubleArrayElements(env, arg2, NULL);

-	glGetMapdv(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glGetMapdv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetMapfv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)

-{

-	jfloat *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glGetMapfv\n")

-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);

-	glGetMapfv(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glGetMapfv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetMapiv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)

-{

-	jint *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glGetMapiv\n")

-	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);

-	glGetMapiv(arg0, arg1, (GLint *)lparg2);

-	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glGetMapiv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetMaterialfv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)

-{

-	jfloat *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glGetMaterialfv\n")

-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);

-	glGetMaterialfv(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glGetMaterialfv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetMaterialiv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)

-{

-	jint *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glGetMaterialiv\n")

-	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);

-	glGetMaterialiv(arg0, arg1, (GLint *)lparg2);

-	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glGetMaterialiv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetPixelMapfv)

-	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1)

-{

-	jfloat *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glGetPixelMapfv\n")

-	if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);

-	glGetPixelMapfv(arg0, lparg1);

-	if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glGetPixelMapfv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetPixelMapuiv)

-	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)

-{

-	jint *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glGetPixelMapuiv\n")

-	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);

-	glGetPixelMapuiv(arg0, (unsigned int *)lparg1);

-	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glGetPixelMapuiv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetPixelMapusv)

-	(JNIEnv *env, jclass that, jint arg0, jshortArray arg1)

-{

-	jshort *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glGetPixelMapusv\n")

-	if (arg1) lparg1 = (*env)->GetShortArrayElements(env, arg1, NULL);

-	glGetPixelMapusv(arg0, (unsigned short *)lparg1);

-	if (arg1) (*env)->ReleaseShortArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glGetPixelMapusv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetPointerv)

-	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)

-{

-	jint *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glGetPointerv\n")

-	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);

-	glGetPointerv(arg0, (void **)lparg1);

-	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glGetPointerv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetPolygonStipple)

-	(JNIEnv *env, jclass that, jbyteArray arg0)

-{

-	jbyte *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glGetPolygonStipple\n")

-	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);

-	glGetPolygonStipple((unsigned char *)lparg0);

-	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glGetPolygonStipple\n")

-}

-

-JNIEXPORT jint JNICALL GL_NATIVE(glGetString)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glGetString\n")

-	printf ("%s,\n",glGetString(arg0));

-	NATIVE_EXIT(env, that, "glGetString\n")

-	return 1;

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetTexEnvfv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)

-{

-	jfloat *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glGetTexEnvfv\n")

-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);

-	glGetTexEnvfv(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glGetTexEnvfv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetTexEnviv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)

-{

-	jint *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glGetTexEnviv\n")

-	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);

-	glGetTexEnviv(arg0, arg1, (GLint *)lparg2);

-	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glGetTexEnviv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetTexGendv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2)

-{

-	jdouble *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glGetTexGendv\n")

-	if (arg2) lparg2 = (*env)->GetDoubleArrayElements(env, arg2, NULL);

-	glGetTexGendv(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glGetTexGendv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetTexGenfv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)

-{

-	jfloat *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glGetTexGenfv\n")

-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);

-	glGetTexGenfv(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glGetTexGenfv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetTexGeniv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)

-{

-	jint *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glGetTexGeniv\n")

-	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);

-	glGetTexGeniv(arg0, arg1, (GLint *)lparg2);

-	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glGetTexGeniv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetTexImage)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jintArray arg4)

-{

-	jint *lparg4=NULL;

-

-	NATIVE_ENTER(env, that, "glGetTexImage\n")

-	if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL);

-	glGetTexImage(arg0, arg1, arg2, arg3, lparg4);

-	if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);

-	NATIVE_EXIT(env, that, "glGetTexImage\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetTexLevelParameterfv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jfloatArray arg3)

-{

-	jfloat *lparg3=NULL;

-

-	NATIVE_ENTER(env, that, "glGetTexLevelParameterfv\n")

-	if (arg3) lparg3 = (*env)->GetFloatArrayElements(env, arg3, NULL);

-	glGetTexLevelParameterfv(arg0, arg1, arg2, lparg3);

-	if (arg3) (*env)->ReleaseFloatArrayElements(env, arg3, lparg3, 0);

-	NATIVE_EXIT(env, that, "glGetTexLevelParameterfv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetTexLevelParameteriv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)

-{

-	jint *lparg3=NULL;

-

-	NATIVE_ENTER(env, that, "glGetTexLevelParameteriv\n")

-	if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);

-	glGetTexLevelParameteriv(arg0, arg1, arg2, (GLint *)lparg3);

-	if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);

-	NATIVE_EXIT(env, that, "glGetTexLevelParameteriv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetTexParameterfv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)

-{

-	jfloat *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glGetTexParameterfv\n")

-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);

-	glGetTexParameterfv(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glGetTexParameterfv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glGetTexParameteriv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)

-{

-	jint *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glGetTexParameteriv\n")

-	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);

-	glGetTexParameteriv(arg0, arg1, (GLint *)lparg2);

-	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glGetTexParameteriv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glHint)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	NATIVE_ENTER(env, that, "glHint\n")

-	glHint(arg0, arg1);

-	NATIVE_EXIT(env, that, "glHint\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glIndexMask)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glIndexMask\n")

-	glIndexMask(arg0);

-	NATIVE_EXIT(env, that, "glIndexMask\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glIndexPointer)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)

-{

-	jint *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glIndexPointer\n")

-	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);

-	glIndexPointer(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glIndexPointer\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glIndexd)

-	(JNIEnv *env, jclass that, jdouble arg0)

-{

-	NATIVE_ENTER(env, that, "glIndexd\n")

-	glIndexd(arg0);

-	NATIVE_EXIT(env, that, "glIndexd\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glIndexdv)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glIndexdv\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glIndexdv(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glIndexdv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glIndexf)

-	(JNIEnv *env, jclass that, jfloat arg0)

-{

-	NATIVE_ENTER(env, that, "glIndexf\n")

-	glIndexf(arg0);

-	NATIVE_EXIT(env, that, "glIndexf\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glIndexfv)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glIndexfv\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glIndexfv(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glIndexfv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glIndexi)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glIndexi\n")

-	glIndexi(arg0);

-	NATIVE_EXIT(env, that, "glIndexi\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glIndexiv)

-	(JNIEnv *env, jclass that, jintArray arg0)

-{

-	jint *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glIndexiv\n")

-	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);

-	glIndexiv((GLint *)lparg0);

-	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glIndexiv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glIndexs)

-	(JNIEnv *env, jclass that, jshort arg0)

-{

-	NATIVE_ENTER(env, that, "glIndexs\n")

-	glIndexs(arg0);

-	NATIVE_EXIT(env, that, "glIndexs\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glIndexsv)

-	(JNIEnv *env, jclass that, jshortArray arg0)

-{

-	jshort *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glIndexsv\n")

-	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);

-	glIndexsv(lparg0);

-	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glIndexsv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glInitNames)

-	(JNIEnv *env, jclass that)

-{

-	NATIVE_ENTER(env, that, "glInitNames\n")

-	glInitNames();

-	NATIVE_EXIT(env, that, "glInitNames\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glInterleavedArrays)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)

-{

-	jint *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glInterleavedArrays\n")

-	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);

-	glInterleavedArrays(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glInterleavedArrays\n")

-}

-

-JNIEXPORT jboolean JNICALL GL_NATIVE(glIsEnabled)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-    jboolean result;

-	NATIVE_ENTER(env, that, "glIsEnabled\n")

-	result = (jboolean)glIsEnabled(arg0);

-	NATIVE_EXIT(env, that, "glIsEnabled\n")

-	return result;

-}

-

-JNIEXPORT jboolean JNICALL GL_NATIVE(glIsList)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-    jboolean result;

-	NATIVE_ENTER(env, that, "glIsList\n")

-	result = (jboolean)glIsList(arg0);

-	NATIVE_EXIT(env, that, "glIsList\n")

-	return result;

-}

-

-JNIEXPORT jboolean JNICALL GL_NATIVE(glIsTexture)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-    jboolean result;

-	NATIVE_ENTER(env, that, "glIsTexture\n")

-	result = (jboolean)glIsTexture(arg0);

-	NATIVE_EXIT(env, that, "glIsTexture\n")

-	return result;

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glLightModelf)

-	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)

-{

-	NATIVE_ENTER(env, that, "glLightModelf\n")

-	glLightModelf(arg0, arg1);

-	NATIVE_EXIT(env, that, "glLightModelf\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glLightModelfv)

-	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1)

-{

-	jfloat *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glLightModelfv\n")

-	if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);

-	glLightModelfv(arg0, lparg1);

-	if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glLightModelfv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glLightModeli)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	NATIVE_ENTER(env, that, "glLightModeli\n")

-	glLightModeli(arg0, arg1);

-	NATIVE_EXIT(env, that, "glLightModeli\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glLightModeliv)

-	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)

-{

-	jint *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glLightModeliv\n")

-	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);

-	glLightModeliv(arg0, (GLint *)lparg1);

-	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glLightModeliv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glLightf)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)

-{

-	NATIVE_ENTER(env, that, "glLightf\n")

-	glLightf(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glLightf\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glLightfv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)

-{

-	jfloat *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glLightfv\n")

-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);

-	glLightfv(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glLightfv\n")

-}

-/*

-JNIEXPORT void JNICALL GL_NATIVE(glLightfv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat *arg2)

-{

-	NATIVE_ENTER(env, that, "glLightfv\n")

-	glLightfv(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glLightfv\n")

-}

-*/

-JNIEXPORT void JNICALL GL_NATIVE(glLighti)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)

-{

-	NATIVE_ENTER(env, that, "glLighti\n")

-	glLighti(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glLighti\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glLightiv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)

-{

-	jint *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glLightiv\n")

-	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);

-	glLightiv(arg0, arg1, (GLint *)lparg2);

-	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glLightiv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glLineStipple)

-	(JNIEnv *env, jclass that, jint arg0, jshort arg1)

-{

-	NATIVE_ENTER(env, that, "glLineStipple\n")

-	glLineStipple(arg0, arg1);

-	NATIVE_EXIT(env, that, "glLineStipple\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glLineWidth)

-	(JNIEnv *env, jclass that, jfloat arg0)

-{

-	NATIVE_ENTER(env, that, "glLineWidth\n")

-	glLineWidth(arg0);

-	NATIVE_EXIT(env, that, "glLineWidth\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glListBase)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glListBase\n")

-	glListBase(arg0);

-	NATIVE_EXIT(env, that, "glListBase\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glLoadIdentity)

-	(JNIEnv *env, jclass that)

-{

-	NATIVE_ENTER(env, that, "glLoadIdentity\n")

-	glLoadIdentity();

-	NATIVE_EXIT(env, that, "glLoadIdentity\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glLoadMatrixd)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glLoadMatrixd\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glLoadMatrixd(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glLoadMatrixd\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glLoadMatrixf)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glLoadMatrixf\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glLoadMatrixf(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glLoadMatrixf\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glLoadName)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glLoadName\n")

-	glLoadName(arg0);

-	NATIVE_EXIT(env, that, "glLoadName\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glLogicOp)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glLogicOp\n")

-	glLogicOp(arg0);

-	NATIVE_EXIT(env, that, "glLogicOp\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glMap2f)

-	(JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2, jint arg3, jint arg4,

-	  jfloat arg5, jfloat arg6, jint arg7, jint arg8, jfloatArray arg9)

-{

-	jfloat *lparg9=NULL;

-

-	NATIVE_ENTER(env, that, "glMap2f\n")

-	if (arg9) lparg9 = (*env)->GetFloatArrayElements(env, arg9, NULL);

-	glMap2f(arg0, arg1, arg2, arg3, arg4 ,arg5, arg6, arg7, arg8, lparg9);

-	if (arg9) (*env)->ReleaseFloatArrayElements(env, arg9, lparg9, 0);

-	NATIVE_EXIT(env, that, "glMap2f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glMap2d)

-	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4,

-	  jdouble arg5, jdouble arg6, jint arg7, jint arg8, jdoubleArray arg9)

-{

-	jdouble *lparg9=NULL;

-

-	NATIVE_ENTER(env, that, "glMap2d\n")

-	if (arg9) lparg9 = (*env)->GetDoubleArrayElements(env, arg9, NULL);

-	glMap2d(arg0, arg1, arg2, arg3, arg4 ,arg5, arg6, arg7, arg8, lparg9);

-	if (arg9) (*env)->ReleaseDoubleArrayElements(env, arg9, lparg9, 0);

-	NATIVE_EXIT(env, that, "glMap2d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glMap1d)

-	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4, jdoubleArray arg5)

-{

-	jdouble *lparg5=NULL;

-

-	NATIVE_ENTER(env, that, "glMap1d\n")

-	if (arg5) lparg5 = (*env)->GetDoubleArrayElements(env, arg5, NULL);

-	glMap1d(arg0, arg1, arg2, arg3, arg4, lparg5);

-	if (arg5) (*env)->ReleaseDoubleArrayElements(env, arg5, lparg5, 0);

-	NATIVE_EXIT(env, that, "glMap1d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glMap1f)

-	(JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2, jint arg3, jint arg4, jfloatArray arg5)

-{

-	jfloat *lparg5=NULL;

-

-	NATIVE_ENTER(env, that, "glMap1f\n")

-	if (arg5) lparg5 = (*env)->GetFloatArrayElements(env, arg5, NULL);

-	glMap1f(arg0, arg1, arg2, arg3, arg4, lparg5);

-	if (arg5) (*env)->ReleaseFloatArrayElements(env, arg5, lparg5, 0);

-	NATIVE_EXIT(env, that, "glMap1f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glMapGrid1d)

-	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2)

-{

-	NATIVE_ENTER(env, that, "glMapGrid1d\n")

-	glMapGrid1d(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glMapGrid1d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glMapGrid1f)

-	(JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2)

-{

-	NATIVE_ENTER(env, that, "glMapGrid1f\n")

-	glMapGrid1f(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glMapGrid1f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glMapGrid2d)

-	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jdouble arg4, jdouble arg5)

-{

-	NATIVE_ENTER(env, that, "glMapGrid2d\n")

-	glMapGrid2d(arg0, arg1, arg2, arg3, arg4, arg5);

-	NATIVE_EXIT(env, that, "glMapGrid2d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glMapGrid2f)

-	(JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2, jint arg3, jfloat arg4, jfloat arg5)

-{

-	NATIVE_ENTER(env, that, "glMapGrid2f\n")

-	glMapGrid2f(arg0, arg1, arg2, arg3, arg4, arg5);

-	NATIVE_EXIT(env, that, "glMapGrid2f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glMaterialf)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)

-{

-	NATIVE_ENTER(env, that, "glMaterialf\n")

-	glMaterialf(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glMaterialf\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glMaterialfv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)

-{

-	jfloat *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glMaterialfv\n")

-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);

-	glMaterialfv(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glMaterialfv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glMateriali)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)

-{

-	NATIVE_ENTER(env, that, "glMateriali\n")

-	glMateriali(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glMateriali\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glMaterialiv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)

-{

-	jint *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glMaterialiv\n")

-	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);

-	glMaterialiv(arg0, arg1, (GLint *)lparg2);

-	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glMaterialiv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glMatrixMode)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glMatrixMode\n")

-	glMatrixMode(arg0);

-	NATIVE_EXIT(env, that, "glMatrixMode\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glMultMatrixd)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glMultMatrixd\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glMultMatrixd(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glMultMatrixd\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glMultMatrixf)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glMultMatrixf\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glMultMatrixf(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glMultMatrixf\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glNewList)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	NATIVE_ENTER(env, that, "glNewList\n")

-	glNewList(arg0, arg1);

-	NATIVE_EXIT(env, that, "glNewList\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glNormal3b)

-	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2)

-{

-	NATIVE_ENTER(env, that, "glNormal3b\n")

-	glNormal3b(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glNormal3b\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glNormal3bv)

-	(JNIEnv *env, jclass that, jbyteArray arg0)

-{

-	jbyte *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glNormal3bv\n")

-	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);

-	glNormal3bv(lparg0);

-	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glNormal3bv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glNormal3d)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)

-{

-	NATIVE_ENTER(env, that, "glNormal3d\n")

-	glNormal3d(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glNormal3d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glNormal3dv)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glNormal3dv\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glNormal3dv(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glNormal3dv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glNormal3f)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)

-{

-	NATIVE_ENTER(env, that, "glNormal3f\n")

-	glNormal3f(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glNormal3f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glNormal3fv)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glNormal3fv\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glNormal3fv(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glNormal3fv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glNormal3i)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)

-{

-	NATIVE_ENTER(env, that, "glNormal3i\n")

-	glNormal3i(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glNormal3i\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glNormal3iv)

-	(JNIEnv *env, jclass that, jintArray arg0)

-{

-	jint *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glNormal3iv\n")

-	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);

-	glNormal3iv((GLint *)lparg0);

-	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glNormal3iv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glNormal3s)

-	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)

-{

-	NATIVE_ENTER(env, that, "glNormal3s\n")

-	glNormal3s(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glNormal3s\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glNormal3sv)

-	(JNIEnv *env, jclass that, jshortArray arg0)

-{

-	jshort *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glNormal3sv\n")

-	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);

-	glNormal3sv(lparg0);

-	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glNormal3sv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glNormalPointer)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)

-{

-	jint *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glNormalPointer\n")

-	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);

-	glNormalPointer(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glNormalPointer\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glOrtho)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3, jdouble arg4, jdouble arg5)

-{

-	NATIVE_ENTER(env, that, "glOrtho\n")

-	glOrtho(arg0, arg1, arg2, arg3, arg4, arg5);

-	NATIVE_EXIT(env, that, "glOrtho\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPassThrough)

-	(JNIEnv *env, jclass that, jfloat arg0)

-{

-	NATIVE_ENTER(env, that, "glPassThrough\n")

-	glPassThrough(arg0);

-	NATIVE_EXIT(env, that, "glPassThrough\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPixelMapfv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)

-{

-	jfloat *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glPixelMapfv\n")

-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);

-	glPixelMapfv(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glPixelMapfv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPixelMapuiv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)

-{

-	jint *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glPixelMapuiv\n")

-	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);

-	glPixelMapuiv(arg0, arg1, (unsigned int *)lparg2);

-	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glPixelMapuiv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPixelMapusv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jshortArray arg2)

-{

-	jshort *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glPixelMapusv\n")

-	if (arg2) lparg2 = (*env)->GetShortArrayElements(env, arg2, NULL);

-	glPixelMapusv(arg0, arg1, (unsigned short *)lparg2);

-	if (arg2) (*env)->ReleaseShortArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glPixelMapusv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPixelStoref)

-	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)

-{

-	NATIVE_ENTER(env, that, "glPixelStoref\n")

-	glPixelStoref(arg0, arg1);

-	NATIVE_EXIT(env, that, "glPixelStoref\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPixelStorei)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	NATIVE_ENTER(env, that, "glPixelStorei\n")

-	glPixelStorei(arg0, arg1);

-	NATIVE_EXIT(env, that, "glPixelStorei\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPixelTransferf)

-	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)

-{

-	NATIVE_ENTER(env, that, "glPixelTransferf\n")

-	glPixelTransferf(arg0, arg1);

-	NATIVE_EXIT(env, that, "glPixelTransferf\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPixelTransferi)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	NATIVE_ENTER(env, that, "glPixelTransferi\n")

-	glPixelTransferi(arg0, arg1);

-	NATIVE_EXIT(env, that, "glPixelTransferi\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPixelZoom)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)

-{

-	NATIVE_ENTER(env, that, "glPixelZoom\n")

-	glPixelZoom(arg0, arg1);

-	NATIVE_EXIT(env, that, "glPixelZoom\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPointSize)

-	(JNIEnv *env, jclass that, jfloat arg0)

-{

-	NATIVE_ENTER(env, that, "glPointSize\n")

-	glPointSize(arg0);

-	NATIVE_EXIT(env, that, "glPointSize\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPolygonMode)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	NATIVE_ENTER(env, that, "glPolygonMode\n")

-	glPolygonMode(arg0, arg1);

-	NATIVE_EXIT(env, that, "glPolygonMode\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPolygonOffset)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)

-{

-	NATIVE_ENTER(env, that, "glPolygonOffset\n")

-	glPolygonOffset(arg0, arg1);

-	NATIVE_EXIT(env, that, "glPolygonOffset\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPolygonStipple)

-	(JNIEnv *env, jclass that, jbyteArray arg0)

-{

-	jbyte *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glPolygonStipple\n")

-	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);

-	glPolygonStipple((unsigned char *)lparg0);

-	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glPolygonStipple\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPopAttrib)

-	(JNIEnv *env, jclass that)

-{

-	NATIVE_ENTER(env, that, "glPopAttrib\n")

-	glPopAttrib();

-	NATIVE_EXIT(env, that, "glPopAttrib\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPopClientAttrib)

-	(JNIEnv *env, jclass that)

-{

-	NATIVE_ENTER(env, that, "glPopClientAttrib\n")

-	glPopClientAttrib();

-	NATIVE_EXIT(env, that, "glPopClientAttrib\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPopMatrix)

-	(JNIEnv *env, jclass that)

-{

-	NATIVE_ENTER(env, that, "glPopMatrix\n")

-	glPopMatrix();

-	NATIVE_EXIT(env, that, "glPopMatrix\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPopName)

-	(JNIEnv *env, jclass that)

-{

-	NATIVE_ENTER(env, that, "glPopName\n")

-	glPopName();

-	NATIVE_EXIT(env, that, "glPopName\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPrioritizeTextures)

-	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jfloatArray arg2)

-{

-	jint *lparg1=NULL;

-	jfloat *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glPrioritizeTextures\n")

-	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);

-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);

-	glPrioritizeTextures(arg0, (unsigned int *)lparg1, lparg2);

-	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);

-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glPrioritizeTextures\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPushAttrib)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glPushAttrib\n")

-	glPushAttrib(arg0);

-	NATIVE_EXIT(env, that, "glPushAttrib\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPushClientAttrib)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glPushClientAttrib\n")

-	glPushClientAttrib(arg0);

-	NATIVE_EXIT(env, that, "glPushClientAttrib\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPushMatrix)

-	(JNIEnv *env, jclass that)

-{

-	NATIVE_ENTER(env, that, "glPushMatrix\n")

-	glPushMatrix();

-	NATIVE_EXIT(env, that, "glPushMatrix\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glPushName)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glPushName\n")

-	glPushName(arg0);

-	NATIVE_EXIT(env, that, "glPushName\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2d)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)

-{

-	NATIVE_ENTER(env, that, "glRasterPos2d\n")

-	glRasterPos2d(arg0, arg1);

-	NATIVE_EXIT(env, that, "glRasterPos2d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2dv)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glRasterPos2dv\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glRasterPos2dv(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glRasterPos2dv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2f)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)

-{

-	NATIVE_ENTER(env, that, "glRasterPos2f\n")

-	glRasterPos2f(arg0, arg1);

-	NATIVE_EXIT(env, that, "glRasterPos2f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2fv)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glRasterPos2fv\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glRasterPos2fv(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glRasterPos2fv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2i)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	NATIVE_ENTER(env, that, "glRasterPos2i\n")

-	glRasterPos2i(arg0, arg1);

-	NATIVE_EXIT(env, that, "glRasterPos2i\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2iv)

-	(JNIEnv *env, jclass that, jintArray arg0)

-{

-	jint *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glRasterPos2iv\n")

-	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);

-	glRasterPos2iv((GLint *)lparg0);

-	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glRasterPos2iv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2s)

-	(JNIEnv *env, jclass that, jshort arg0, jshort arg1)

-{

-	NATIVE_ENTER(env, that, "glRasterPos2s\n")

-	glRasterPos2s(arg0, arg1);

-	NATIVE_EXIT(env, that, "glRasterPos2s\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2sv)

-	(JNIEnv *env, jclass that, jshortArray arg0)

-{

-	jshort *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glRasterPos2sv\n")

-	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);

-	glRasterPos2sv(lparg0);

-	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glRasterPos2sv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3d)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)

-{

-	NATIVE_ENTER(env, that, "glRasterPos3d\n")

-	glRasterPos3d(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glRasterPos3d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3dv)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glRasterPos3dv\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glRasterPos3dv(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glRasterPos3dv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3f)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)

-{

-	NATIVE_ENTER(env, that, "glRasterPos3f\n")

-	glRasterPos3f(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glRasterPos3f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3fv)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glRasterPos3fv\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glRasterPos3fv(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glRasterPos3fv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3i)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)

-{

-	NATIVE_ENTER(env, that, "glRasterPos3i\n")

-	glRasterPos3i(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glRasterPos3i\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3iv)

-	(JNIEnv *env, jclass that, jintArray arg0)

-{

-	jint *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glRasterPos3iv\n")

-	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);

-	glRasterPos3iv((GLint *)lparg0);

-	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glRasterPos3iv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3s)

-	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)

-{

-	NATIVE_ENTER(env, that, "glRasterPos3s\n")

-	glRasterPos3s(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glRasterPos3s\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3sv)

-	(JNIEnv *env, jclass that, jshortArray arg0)

-{

-	jshort *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glRasterPos3sv\n")

-	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);

-	glRasterPos3sv(lparg0);

-	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glRasterPos3sv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4d)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)

-{

-	NATIVE_ENTER(env, that, "glRasterPos4d\n")

-	glRasterPos4d(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glRasterPos4d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4dv)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glRasterPos4dv\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glRasterPos4dv(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glRasterPos4dv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4f)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)

-{

-	NATIVE_ENTER(env, that, "glRasterPos4f\n")

-	glRasterPos4f(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glRasterPos4f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4fv)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glRasterPos4fv\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glRasterPos4fv(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glRasterPos4fv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4i)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)

-{

-	NATIVE_ENTER(env, that, "glRasterPos4i\n")

-	glRasterPos4i(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glRasterPos4i\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4iv)

-	(JNIEnv *env, jclass that, jintArray arg0)

-{

-	jint *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glRasterPos4iv\n")

-	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);

-	glRasterPos4iv((GLint *)lparg0);

-	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glRasterPos4iv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4s)

-	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)

-{

-	NATIVE_ENTER(env, that, "glRasterPos4s\n")

-	glRasterPos4s(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glRasterPos4s\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4sv)

-	(JNIEnv *env, jclass that, jshortArray arg0)

-{

-	jshort *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glRasterPos4sv\n")

-	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);

-	glRasterPos4sv(lparg0);

-	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glRasterPos4sv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glReadBuffer)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glReadBuffer\n")

-	glReadBuffer(arg0);

-	NATIVE_EXIT(env, that, "glReadBuffer\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glReadPixels)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jintArray arg6)

-{

-	jint *lparg6=NULL;

-

-	NATIVE_ENTER(env, that, "glReadPixels\n")

-	if (arg6) lparg6 = (*env)->GetIntArrayElements(env, arg6, NULL);

-	glReadPixels(arg0, arg1, arg2, arg3, arg4, arg5, lparg6);

-	if (arg6) (*env)->ReleaseIntArrayElements(env, arg6, lparg6, 0);

-	NATIVE_EXIT(env, that, "glReadPixels\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRectd)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)

-{

-	NATIVE_ENTER(env, that, "glRectd\n")

-	glRectd(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glRectd\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRectdv)

-	(JNIEnv *env, jclass that, jdoubleArray arg0, jdoubleArray arg1)

-{

-	jdouble *lparg0=NULL;

-	jdouble *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glRectdv\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);

-	glRectdv(lparg0, lparg1);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glRectdv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRectf)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)

-{

-	NATIVE_ENTER(env, that, "glRectf\n")

-	glRectf(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glRectf\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRectfv)

-	(JNIEnv *env, jclass that, jfloatArray arg0, jfloatArray arg1)

-{

-	jfloat *lparg0=NULL;

-	jfloat *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glRectfv\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);

-	glRectfv(lparg0, lparg1);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glRectfv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRecti)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)

-{

-	NATIVE_ENTER(env, that, "glRecti\n")

-	glRecti(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glRecti\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRectiv)

-	(JNIEnv *env, jclass that, jintArray arg0, jintArray arg1)

-{

-	jint *lparg0=NULL;

-	jint *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glRectiv\n")

-	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);

-	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);

-	glRectiv((GLint *)lparg0, (GLint *)lparg1);

-	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);

-	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glRectiv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRects)

-	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)

-{

-	NATIVE_ENTER(env, that, "glRects\n")

-	glRects(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glRects\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRectsv)

-	(JNIEnv *env, jclass that, jshortArray arg0, jshortArray arg1)

-{

-	jshort *lparg0=NULL;

-	jshort *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glRectsv\n")

-	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);

-	if (arg1) lparg1 = (*env)->GetShortArrayElements(env, arg1, NULL);

-	glRectsv(lparg0, lparg1);

-	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);

-	if (arg1) (*env)->ReleaseShortArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glRectsv\n")

-}

-

-JNIEXPORT jint JNICALL GL_NATIVE(glRenderMode)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-    jint rc;

-	NATIVE_ENTER(env, that, "glRenderMode\n")

-	rc = (jint)glRenderMode(arg0);

-	NATIVE_EXIT(env, that, "glRenderMode\n")

-	return rc;

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRotated)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)

-{

-	NATIVE_ENTER(env, that, "glRotated\n")

-	glRotated(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glRotated\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glRotatef)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)

-{

-	NATIVE_ENTER(env, that, "glRotatef\n")

-	glRotatef(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glRotatef\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glScaled)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)

-{

-	NATIVE_ENTER(env, that, "glScaled\n")

-	glScaled(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glScaled\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glScalef)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)

-{

-	NATIVE_ENTER(env, that, "glScalef\n")

-	glScalef(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glScalef\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glScissor)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)

-{

-	NATIVE_ENTER(env, that, "glScissor\n")

-	glScissor(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glScissor\n")

-}

-

-/*

-JNIEXPORT void JNICALL GL_NATIVE(glSelectBuffer)

-	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)

-{

-	jint *lparg1=NULL;

-

-	NATIVE_ENTER(env, that, "glSelectBuffer\n")

-	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);

-	glSelectBuffer(arg0, lparg1);

-	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);

-	NATIVE_EXIT(env, that, "glSelectBuffer\n")

-}

-*/

- 

- 

-JNIEXPORT void JNICALL GL_NATIVE(glSelectBuffer)

-	(JNIEnv *env, jclass that, jint arg0, jint *arg1)

-{

-	NATIVE_ENTER(env, that, "glSelectBuffer\n")

-	glSelectBuffer(arg0, (unsigned int *)arg1);

-	NATIVE_EXIT(env, that, "glSelectBuffer\n")

-}

-

-

-JNIEXPORT void JNICALL GL_NATIVE(glShadeModel)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glShadeModel\n")

-	glShadeModel(arg0);

-	NATIVE_EXIT(env, that, "glShadeModel\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glStencilFunc)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)

-{

-	NATIVE_ENTER(env, that, "glStencilFunc\n")

-	glStencilFunc(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glStencilFunc\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glStencilMask)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glStencilMask\n")

-	glStencilMask(arg0);

-	NATIVE_EXIT(env, that, "glStencilMask\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glStencilOp)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)

-{

-	NATIVE_ENTER(env, that, "glStencilOp\n")

-	glStencilOp(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glStencilOp\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1d)

-	(JNIEnv *env, jclass that, jdouble arg0)

-{

-	NATIVE_ENTER(env, that, "glTexCoord1d\n")

-	glTexCoord1d(arg0);

-	NATIVE_EXIT(env, that, "glTexCoord1d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1dv)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glTexCoord1dv\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glTexCoord1dv(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glTexCoord1dv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1f)

-	(JNIEnv *env, jclass that, jfloat arg0)

-{

-	NATIVE_ENTER(env, that, "glTexCoord1f\n")

-	glTexCoord1f(arg0);

-	NATIVE_EXIT(env, that, "glTexCoord1f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1fv)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glTexCoord1fv\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glTexCoord1fv(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glTexCoord1fv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1i)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glTexCoord1i\n")

-	glTexCoord1i(arg0);

-	NATIVE_EXIT(env, that, "glTexCoord1i\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1iv)

-	(JNIEnv *env, jclass that, jintArray arg0)

-{

-	jint *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glTexCoord1iv\n")

-	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);

-	glTexCoord1iv((GLint *)lparg0);

-	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glTexCoord1iv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1s)

-	(JNIEnv *env, jclass that, jshort arg0)

-{

-	NATIVE_ENTER(env, that, "glTexCoord1s\n")

-	glTexCoord1s(arg0);

-	NATIVE_EXIT(env, that, "glTexCoord1s\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1sv)

-	(JNIEnv *env, jclass that, jshortArray arg0)

-{

-	jshort *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glTexCoord1sv\n")

-	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);

-	glTexCoord1sv(lparg0);

-	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glTexCoord1sv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2d)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)

-{

-	NATIVE_ENTER(env, that, "glTexCoord2d\n")

-	glTexCoord2d(arg0, arg1);

-	NATIVE_EXIT(env, that, "glTexCoord2d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2dv)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glTexCoord2dv\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glTexCoord2dv(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glTexCoord2dv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2f)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)

-{

-	NATIVE_ENTER(env, that, "glTexCoord2f\n")

-	glTexCoord2f(arg0, arg1);

-	NATIVE_EXIT(env, that, "glTexCoord2f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2fv)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glTexCoord2fv\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glTexCoord2fv(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glTexCoord2fv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2i)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	NATIVE_ENTER(env, that, "glTexCoord2i\n")

-	glTexCoord2i(arg0, arg1);

-	NATIVE_EXIT(env, that, "glTexCoord2i\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2iv)

-	(JNIEnv *env, jclass that, jintArray arg0)

-{

-	jint *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glTexCoord2iv\n")

-	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);

-	glTexCoord2iv((GLint *)lparg0);

-	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glTexCoord2iv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2s)

-	(JNIEnv *env, jclass that, jshort arg0, jshort arg1)

-{

-	NATIVE_ENTER(env, that, "glTexCoord2s\n")

-	glTexCoord2s(arg0, arg1);

-	NATIVE_EXIT(env, that, "glTexCoord2s\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2sv)

-	(JNIEnv *env, jclass that, jshortArray arg0)

-{

-	jshort *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glTexCoord2sv\n")

-	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);

-	glTexCoord2sv(lparg0);

-	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glTexCoord2sv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3d)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)

-{

-	NATIVE_ENTER(env, that, "glTexCoord3d\n")

-	glTexCoord3d(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glTexCoord3d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3dv)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glTexCoord3dv\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glTexCoord3dv(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glTexCoord3dv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3f)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)

-{

-	NATIVE_ENTER(env, that, "glTexCoord3f\n")

-	glTexCoord3f(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glTexCoord3f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3fv)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glTexCoord3fv\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glTexCoord3fv(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glTexCoord3fv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3i)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)

-{

-	NATIVE_ENTER(env, that, "glTexCoord3i\n")

-	glTexCoord3i(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glTexCoord3i\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3iv)

-	(JNIEnv *env, jclass that, jintArray arg0)

-{

-	jint *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glTexCoord3iv\n")

-	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);

-	glTexCoord3iv((GLint *)lparg0);

-	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glTexCoord3iv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3s)

-	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)

-{

-	NATIVE_ENTER(env, that, "glTexCoord3s\n")

-	glTexCoord3s(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glTexCoord3s\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3sv)

-	(JNIEnv *env, jclass that, jshortArray arg0)

-{

-	jshort *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glTexCoord3sv\n")

-	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);

-	glTexCoord3sv(lparg0);

-	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glTexCoord3sv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4d)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)

-{

-	NATIVE_ENTER(env, that, "glTexCoord4d\n")

-	glTexCoord4d(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glTexCoord4d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4dv)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glTexCoord4dv\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glTexCoord4dv(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glTexCoord4dv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4f)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)

-{

-	NATIVE_ENTER(env, that, "glTexCoord4f\n")

-	glTexCoord4f(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glTexCoord4f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4fv)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glTexCoord4fv\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glTexCoord4fv(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glTexCoord4fv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4i)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)

-{

-	NATIVE_ENTER(env, that, "glTexCoord4i\n")

-	glTexCoord4i(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glTexCoord4i\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4iv)

-	(JNIEnv *env, jclass that, jintArray arg0)

-{

-	jint *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glTexCoord4iv\n")

-	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);

-	glTexCoord4iv((GLint *)lparg0);

-	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glTexCoord4iv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4s)

-	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)

-{

-	NATIVE_ENTER(env, that, "glTexCoord4s\n")

-	glTexCoord4s(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glTexCoord4s\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4sv)

-	(JNIEnv *env, jclass that, jshortArray arg0)

-{

-	jshort *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glTexCoord4sv\n")

-	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);

-	glTexCoord4sv(lparg0);

-	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glTexCoord4sv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexCoordPointer)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)

-{

-	jint *lparg3=NULL;

-

-	NATIVE_ENTER(env, that, "glTexCoordPointer\n")

-	if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);

-	glTexCoordPointer(arg0, arg1, arg2, lparg3);

-	if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);

-	NATIVE_EXIT(env, that, "glTexCoordPointer\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexEnvf)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)

-{

-	NATIVE_ENTER(env, that, "glTexEnvf\n")

-	glTexEnvf(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glTexEnvf\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexEnvfv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)

-{

-	jfloat *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glTexEnvfv\n")

-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);

-	glTexEnvfv(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glTexEnvfv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexEnvi)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)

-{

-	NATIVE_ENTER(env, that, "glTexEnvi\n")

-	glTexEnvi(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glTexEnvi\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexEnviv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)

-{

-	jint *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glTexEnviv\n")

-	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);

-	glTexEnviv(arg0, arg1, (GLint *)lparg2);

-	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glTexEnviv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexGend)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdouble arg2)

-{

-	NATIVE_ENTER(env, that, "glTexGend\n")

-	glTexGend(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glTexGend\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexGendv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2)

-{

-	jdouble *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glTexGendv\n")

-	if (arg2) lparg2 = (*env)->GetDoubleArrayElements(env, arg2, NULL);

-	glTexGendv(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glTexGendv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexGenf)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)

-{

-	NATIVE_ENTER(env, that, "glTexGenf\n")

-	glTexGenf(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glTexGenf\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexGenfv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)

-{

-	jfloat *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glTexGenfv\n")

-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);

-	glTexGenfv(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glTexGenfv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexGeni)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)

-{

-	NATIVE_ENTER(env, that, "glTexGeni\n")

-	glTexGeni(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glTexGeni\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexGeniv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)

-{

-	jint *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glTexGeniv\n")

-	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);

-	glTexGeniv(arg0, arg1, (GLint *)lparg2);

-	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glTexGeniv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexImage1D)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jintArray arg7)

-{

-	jint *lparg7=NULL;

-

-	NATIVE_ENTER(env, that, "glTexImage1D\n")

-	if (arg7) lparg7 = (*env)->GetIntArrayElements(env, arg7, NULL);

-	glTexImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, lparg7);

-	if (arg7) (*env)->ReleaseIntArrayElements(env, arg7, lparg7, 0);

-	NATIVE_EXIT(env, that, "glTexImage1D\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexImage2D)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7, jbyteArray arg8)

-{

-	jbyte *lparg8=NULL;

-

-	NATIVE_ENTER(env, that, "glTexImage2D\n")

-	if (arg8) lparg8 = (*env)->GetByteArrayElements(env, arg8, NULL);

-	glTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, lparg8);

-	if (arg8) (*env)->ReleaseByteArrayElements(env, arg8, lparg8, 0);

-	NATIVE_EXIT(env, that, "glTexImage2D\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexParameterf)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)

-{

-	NATIVE_ENTER(env, that, "glTexParameterf\n")

-	glTexParameterf(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glTexParameterf\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexParameterfv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)

-{

-	jfloat *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glTexParameterfv\n")

-	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);

-	glTexParameterfv(arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glTexParameterfv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexParameteri)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)

-{

-	NATIVE_ENTER(env, that, "glTexParameteri\n")

-	glTexParameteri(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glTexParameteri\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexParameteriv)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)

-{

-	jint *lparg2=NULL;

-

-	NATIVE_ENTER(env, that, "glTexParameteriv\n")

-	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);

-	glTexParameteriv(arg0, arg1, (GLint *)lparg2);

-	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "glTexParameteriv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexSubImage1D)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jintArray arg6)

-{

-	jint *lparg6=NULL;

-

-	NATIVE_ENTER(env, that, "glTexSubImage1D\n")

-	if (arg6) lparg6 = (*env)->GetIntArrayElements(env, arg6, NULL);

-	glTexSubImage1D(arg0, arg1, arg2, arg3, arg4, arg5, lparg6);

-	if (arg6) (*env)->ReleaseIntArrayElements(env, arg6, lparg6, 0);

-	NATIVE_EXIT(env, that, "glTexSubImage1D\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTexSubImage2D)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7, jintArray arg8)

-{

-	jint *lparg8=NULL;

-

-	NATIVE_ENTER(env, that, "glTexSubImage2D\n")

-	if (arg8) lparg8 = (*env)->GetIntArrayElements(env, arg8, NULL);

-	glTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, lparg8);

-	if (arg8) (*env)->ReleaseIntArrayElements(env, arg8, lparg8, 0);

-	NATIVE_EXIT(env, that, "glTexSubImage2D\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTranslated)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)

-{

-	NATIVE_ENTER(env, that, "glTranslated\n")

-	glTranslated(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glTranslated\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glTranslatef)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)

-{

-	NATIVE_ENTER(env, that, "glTranslatef\n")

-	glTranslatef(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glTranslatef\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex2d)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)

-{

-	NATIVE_ENTER(env, that, "glVertex2d\n")

-	glVertex2d(arg0, arg1);

-	NATIVE_EXIT(env, that, "glVertex2d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex2dv)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glVertex2dv\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glVertex2dv(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glVertex2dv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex2f)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)

-{

-	NATIVE_ENTER(env, that, "glVertex2f\n")

-	glVertex2f(arg0, arg1);

-	NATIVE_EXIT(env, that, "glVertex2f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex2fv)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glVertex2fv\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glVertex2fv(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glVertex2fv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex2i)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	NATIVE_ENTER(env, that, "glVertex2i\n")

-	glVertex2i(arg0, arg1);

-	NATIVE_EXIT(env, that, "glVertex2i\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex2iv)

-	(JNIEnv *env, jclass that, jintArray arg0)

-{

-	jint *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glVertex2iv\n")

-	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);

-	glVertex2iv((GLint *)lparg0);

-	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glVertex2iv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex2s)

-	(JNIEnv *env, jclass that, jshort arg0, jshort arg1)

-{

-	NATIVE_ENTER(env, that, "glVertex2s\n")

-	glVertex2s(arg0, arg1);

-	NATIVE_EXIT(env, that, "glVertex2s\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex2sv)

-	(JNIEnv *env, jclass that, jshortArray arg0)

-{

-	jshort *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glVertex2sv\n")

-	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);

-	glVertex2sv(lparg0);

-	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glVertex2sv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex3d)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)

-{

-	NATIVE_ENTER(env, that, "glVertex3d\n")

-	glVertex3d(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glVertex3d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex3dv__I)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glVertex3dv\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glVertex3dv(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glVertex3dv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex3dv)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "glVertex3dv\n")

-	glVertex3dv((double*)arg0);

-	NATIVE_EXIT(env, that, "glVertex3dv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex3f)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)

-{

-	NATIVE_ENTER(env, that, "glVertex3f\n")

-	glVertex3f(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glVertex3f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex3fv)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glVertex3fv\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glVertex3fv(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glVertex3fv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex3i)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)

-{

-	NATIVE_ENTER(env, that, "glVertex3i\n")

-	glVertex3i(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glVertex3i\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex3iv)

-	(JNIEnv *env, jclass that, jintArray arg0)

-{

-	jint *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glVertex3iv\n")

-	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);

-	glVertex3iv((GLint *)lparg0);

-	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glVertex3iv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex3s)

-	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)

-{

-	NATIVE_ENTER(env, that, "glVertex3s\n")

-	glVertex3s(arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "glVertex3s\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex3sv)

-	(JNIEnv *env, jclass that, jshortArray arg0)

-{

-	jshort *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glVertex3sv\n")

-	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);

-	glVertex3sv(lparg0);

-	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glVertex3sv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex4d)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)

-{

-	NATIVE_ENTER(env, that, "glVertex4d\n")

-	glVertex4d(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glVertex4d\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex4dv)

-	(JNIEnv *env, jclass that, jdoubleArray arg0)

-{

-	jdouble *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glVertex4dv\n")

-	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);

-	glVertex4dv(lparg0);

-	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glVertex4dv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex4f)

-	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)

-{

-	NATIVE_ENTER(env, that, "glVertex4f\n")

-	glVertex4f(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glVertex4f\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex4fv)

-	(JNIEnv *env, jclass that, jfloatArray arg0)

-{

-	jfloat *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glVertex4fv\n")

-	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);

-	glVertex4fv(lparg0);

-	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glVertex4fv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex4i)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)

-{

-	NATIVE_ENTER(env, that, "glVertex4i\n")

-	glVertex4i(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glVertex4i\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex4iv)

-	(JNIEnv *env, jclass that, jintArray arg0)

-{

-	jint *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glVertex4iv\n")

-	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);

-	glVertex4iv((GLint *)lparg0);

-	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glVertex4iv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex4s)

-	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)

-{

-	NATIVE_ENTER(env, that, "glVertex4s\n")

-	glVertex4s(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glVertex4s\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertex4sv)

-	(JNIEnv *env, jclass that, jshortArray arg0)

-{

-	jshort *lparg0=NULL;

-

-	NATIVE_ENTER(env, that, "glVertex4sv\n")

-	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);

-	glVertex4sv(lparg0);

-	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);

-	NATIVE_EXIT(env, that, "glVertex4sv\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glVertexPointer)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)

-{

-	jint *lparg3=NULL;

-

-	NATIVE_ENTER(env, that, "glVertexPointer\n")

-	if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);

-	glVertexPointer(arg0, arg1, arg2, lparg3);

-	if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);

-	NATIVE_EXIT(env, that, "glVertexPointer\n")

-}

-

-JNIEXPORT void JNICALL GL_NATIVE(glViewport)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)

-{

-	NATIVE_ENTER(env, that, "glViewport\n")

-	glViewport(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "glViewport\n")

-}

+#include "swt.h"
+#include "gl_structs.h"
+#include "gl_stats.h"
+
+#define GL_NATIVE(func) Java_org_eclipse_swt_opengl_GL_##func
+
+#ifndef NO_glAccum
+JNIEXPORT void JNICALL GL_NATIVE(glAccum)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
+{
+	GL_NATIVE_ENTER(env, that, glAccum_FUNC);
+	glAccum(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glAccum_FUNC);
+}
+#endif
+
+#ifndef NO_glAlphaFunc
+JNIEXPORT void JNICALL GL_NATIVE(glAlphaFunc)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
+{
+	GL_NATIVE_ENTER(env, that, glAlphaFunc_FUNC);
+	glAlphaFunc(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glAlphaFunc_FUNC);
+}
+#endif
+
+#ifndef NO_glAreTexturesResident
+JNIEXPORT jboolean JNICALL GL_NATIVE(glAreTexturesResident)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jbooleanArray arg2)
+{
+	jint *lparg1=NULL;
+	jboolean *lparg2=NULL;
+	jboolean rc;
+	GL_NATIVE_ENTER(env, that, glAreTexturesResident_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);
+	} else
+#endif
+	{
+		if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+		if (arg2) lparg2 = (*env)->GetBooleanArrayElements(env, arg2, NULL);
+	}
+	rc = (jboolean)glAreTexturesResident(arg0, lparg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseBooleanArrayElements(env, arg2, lparg2, 0);
+		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glAreTexturesResident_FUNC);
+	return rc;
+}
+#endif
+
+#ifndef NO_glArrayElement
+JNIEXPORT void JNICALL GL_NATIVE(glArrayElement)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glArrayElement_FUNC);
+	glArrayElement(arg0);
+	GL_NATIVE_EXIT(env, that, glArrayElement_FUNC);
+}
+#endif
+
+#ifndef NO_glBegin
+JNIEXPORT void JNICALL GL_NATIVE(glBegin)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glBegin_FUNC);
+	glBegin(arg0);
+	GL_NATIVE_EXIT(env, that, glBegin_FUNC);
+}
+#endif
+
+#ifndef NO_glBindTexture
+JNIEXPORT void JNICALL GL_NATIVE(glBindTexture)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	GL_NATIVE_ENTER(env, that, glBindTexture_FUNC);
+	glBindTexture(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glBindTexture_FUNC);
+}
+#endif
+
+#ifndef NO_glBitmap
+JNIEXPORT void JNICALL GL_NATIVE(glBitmap)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2, jfloat arg3, jfloat arg4, jfloat arg5, jbyteArray arg6)
+{
+	jbyte *lparg6=NULL;
+	GL_NATIVE_ENTER(env, that, glBitmap_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);
+	}
+	glBitmap(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);
+	}
+	GL_NATIVE_EXIT(env, that, glBitmap_FUNC);
+}
+#endif
+
+#ifndef NO_glBlendFunc
+JNIEXPORT void JNICALL GL_NATIVE(glBlendFunc)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	GL_NATIVE_ENTER(env, that, glBlendFunc_FUNC);
+	glBlendFunc(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glBlendFunc_FUNC);
+}
+#endif
+
+#ifndef NO_glCallList
+JNIEXPORT void JNICALL GL_NATIVE(glCallList)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glCallList_FUNC);
+	glCallList(arg0);
+	GL_NATIVE_EXIT(env, that, glCallList_FUNC);
+}
+#endif
+
+#ifndef NO_glCallLists__II_3B
+JNIEXPORT void JNICALL GL_NATIVE(glCallLists__II_3B)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jbyteArray arg2)
+{
+	jbyte *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glCallLists__II_3B_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)->GetByteArrayElements(env, arg2, NULL);
+	}
+	glCallLists(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseByteArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glCallLists__II_3B_FUNC);
+}
+#endif
+
+#ifndef NO_glCallLists__II_3C
+JNIEXPORT void JNICALL GL_NATIVE(glCallLists__II_3C)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jcharArray arg2)
+{
+	jchar *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glCallLists__II_3C_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)->GetCharArrayElements(env, arg2, NULL);
+	}
+	glCallLists(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseCharArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glCallLists__II_3C_FUNC);
+}
+#endif
+
+#ifndef NO_glCallLists__II_3I
+JNIEXPORT void JNICALL GL_NATIVE(glCallLists__II_3I)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glCallLists__II_3I_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)->GetIntArrayElements(env, arg2, NULL);
+	}
+	glCallLists(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glCallLists__II_3I_FUNC);
+}
+#endif
+
+#ifndef NO_glClear
+JNIEXPORT void JNICALL GL_NATIVE(glClear)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glClear_FUNC);
+	glClear(arg0);
+	GL_NATIVE_EXIT(env, that, glClear_FUNC);
+}
+#endif
+
+#ifndef NO_glClearAccum
+JNIEXPORT void JNICALL GL_NATIVE(glClearAccum)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
+{
+	GL_NATIVE_ENTER(env, that, glClearAccum_FUNC);
+	glClearAccum(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glClearAccum_FUNC);
+}
+#endif
+
+#ifndef NO_glClearColor
+JNIEXPORT void JNICALL GL_NATIVE(glClearColor)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
+{
+	GL_NATIVE_ENTER(env, that, glClearColor_FUNC);
+	glClearColor(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glClearColor_FUNC);
+}
+#endif
+
+#ifndef NO_glClearDepth
+JNIEXPORT void JNICALL GL_NATIVE(glClearDepth)
+	(JNIEnv *env, jclass that, jdouble arg0)
+{
+	GL_NATIVE_ENTER(env, that, glClearDepth_FUNC);
+	glClearDepth(arg0);
+	GL_NATIVE_EXIT(env, that, glClearDepth_FUNC);
+}
+#endif
+
+#ifndef NO_glClearIndex
+JNIEXPORT void JNICALL GL_NATIVE(glClearIndex)
+	(JNIEnv *env, jclass that, jfloat arg0)
+{
+	GL_NATIVE_ENTER(env, that, glClearIndex_FUNC);
+	glClearIndex(arg0);
+	GL_NATIVE_EXIT(env, that, glClearIndex_FUNC);
+}
+#endif
+
+#ifndef NO_glClearStencil
+JNIEXPORT void JNICALL GL_NATIVE(glClearStencil)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glClearStencil_FUNC);
+	glClearStencil(arg0);
+	GL_NATIVE_EXIT(env, that, glClearStencil_FUNC);
+}
+#endif
+
+#ifndef NO_glClipPlane
+JNIEXPORT void JNICALL GL_NATIVE(glClipPlane)
+	(JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1)
+{
+	jdouble *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glClipPlane_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);
+	}
+	glClipPlane(arg0, lparg1);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glClipPlane_FUNC);
+}
+#endif
+
+#ifndef NO_glColor3b
+JNIEXPORT void JNICALL GL_NATIVE(glColor3b)
+	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2)
+{
+	GL_NATIVE_ENTER(env, that, glColor3b_FUNC);
+	glColor3b(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glColor3b_FUNC);
+}
+#endif
+
+#ifndef NO_glColor3bv
+JNIEXPORT void JNICALL GL_NATIVE(glColor3bv)
+	(JNIEnv *env, jclass that, jbyteArray arg0)
+{
+	jbyte *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glColor3bv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
+	}
+	glColor3bv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glColor3bv_FUNC);
+}
+#endif
+
+#ifndef NO_glColor3d
+JNIEXPORT void JNICALL GL_NATIVE(glColor3d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
+{
+	GL_NATIVE_ENTER(env, that, glColor3d_FUNC);
+	glColor3d(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glColor3d_FUNC);
+}
+#endif
+
+#ifndef NO_glColor3dv
+JNIEXPORT void JNICALL GL_NATIVE(glColor3dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glColor3dv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	}
+	glColor3dv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glColor3dv_FUNC);
+}
+#endif
+
+#ifndef NO_glColor3f
+JNIEXPORT void JNICALL GL_NATIVE(glColor3f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
+{
+	GL_NATIVE_ENTER(env, that, glColor3f_FUNC);
+	glColor3f(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glColor3f_FUNC);
+}
+#endif
+
+#ifndef NO_glColor3fv
+JNIEXPORT void JNICALL GL_NATIVE(glColor3fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glColor3fv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glColor3fv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glColor3fv_FUNC);
+}
+#endif
+
+#ifndef NO_glColor3i
+JNIEXPORT void JNICALL GL_NATIVE(glColor3i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	GL_NATIVE_ENTER(env, that, glColor3i_FUNC);
+	glColor3i(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glColor3i_FUNC);
+}
+#endif
+
+#ifndef NO_glColor3iv
+JNIEXPORT void JNICALL GL_NATIVE(glColor3iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glColor3iv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	}
+	glColor3iv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glColor3iv_FUNC);
+}
+#endif
+
+#ifndef NO_glColor3s
+JNIEXPORT void JNICALL GL_NATIVE(glColor3s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
+{
+	GL_NATIVE_ENTER(env, that, glColor3s_FUNC);
+	glColor3s(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glColor3s_FUNC);
+}
+#endif
+
+#ifndef NO_glColor3sv
+JNIEXPORT void JNICALL GL_NATIVE(glColor3sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glColor3sv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	}
+	glColor3sv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glColor3sv_FUNC);
+}
+#endif
+
+#ifndef NO_glColor3ub
+JNIEXPORT void JNICALL GL_NATIVE(glColor3ub)
+	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2)
+{
+	GL_NATIVE_ENTER(env, that, glColor3ub_FUNC);
+	glColor3ub(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glColor3ub_FUNC);
+}
+#endif
+
+#ifndef NO_glColor3ubv
+JNIEXPORT void JNICALL GL_NATIVE(glColor3ubv)
+	(JNIEnv *env, jclass that, jbyteArray arg0)
+{
+	jbyte *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glColor3ubv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
+	}
+	glColor3ubv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glColor3ubv_FUNC);
+}
+#endif
+
+#ifndef NO_glColor3ui
+JNIEXPORT void JNICALL GL_NATIVE(glColor3ui)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	GL_NATIVE_ENTER(env, that, glColor3ui_FUNC);
+	glColor3ui(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glColor3ui_FUNC);
+}
+#endif
+
+#ifndef NO_glColor3uiv
+JNIEXPORT void JNICALL GL_NATIVE(glColor3uiv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glColor3uiv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	}
+	glColor3uiv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glColor3uiv_FUNC);
+}
+#endif
+
+#ifndef NO_glColor3us
+JNIEXPORT void JNICALL GL_NATIVE(glColor3us)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
+{
+	GL_NATIVE_ENTER(env, that, glColor3us_FUNC);
+	glColor3us(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glColor3us_FUNC);
+}
+#endif
+
+#ifndef NO_glColor3usv
+JNIEXPORT void JNICALL GL_NATIVE(glColor3usv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glColor3usv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	}
+	glColor3usv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glColor3usv_FUNC);
+}
+#endif
+
+#ifndef NO_glColor4b
+JNIEXPORT void JNICALL GL_NATIVE(glColor4b)
+	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2, jbyte arg3)
+{
+	GL_NATIVE_ENTER(env, that, glColor4b_FUNC);
+	glColor4b(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glColor4b_FUNC);
+}
+#endif
+
+#ifndef NO_glColor4bv
+JNIEXPORT void JNICALL GL_NATIVE(glColor4bv)
+	(JNIEnv *env, jclass that, jbyteArray arg0)
+{
+	jbyte *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glColor4bv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
+	}
+	glColor4bv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glColor4bv_FUNC);
+}
+#endif
+
+#ifndef NO_glColor4d
+JNIEXPORT void JNICALL GL_NATIVE(glColor4d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	GL_NATIVE_ENTER(env, that, glColor4d_FUNC);
+	glColor4d(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glColor4d_FUNC);
+}
+#endif
+
+#ifndef NO_glColor4dv
+JNIEXPORT void JNICALL GL_NATIVE(glColor4dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glColor4dv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	}
+	glColor4dv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glColor4dv_FUNC);
+}
+#endif
+
+#ifndef NO_glColor4f
+JNIEXPORT void JNICALL GL_NATIVE(glColor4f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
+{
+	GL_NATIVE_ENTER(env, that, glColor4f_FUNC);
+	glColor4f(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glColor4f_FUNC);
+}
+#endif
+
+#ifndef NO_glColor4fv
+JNIEXPORT void JNICALL GL_NATIVE(glColor4fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glColor4fv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glColor4fv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glColor4fv_FUNC);
+}
+#endif
+
+#ifndef NO_glColor4i
+JNIEXPORT void JNICALL GL_NATIVE(glColor4i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	GL_NATIVE_ENTER(env, that, glColor4i_FUNC);
+	glColor4i(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glColor4i_FUNC);
+}
+#endif
+
+#ifndef NO_glColor4iv
+JNIEXPORT void JNICALL GL_NATIVE(glColor4iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glColor4iv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	}
+	glColor4iv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glColor4iv_FUNC);
+}
+#endif
+
+#ifndef NO_glColor4s
+JNIEXPORT void JNICALL GL_NATIVE(glColor4s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
+{
+	GL_NATIVE_ENTER(env, that, glColor4s_FUNC);
+	glColor4s(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glColor4s_FUNC);
+}
+#endif
+
+#ifndef NO_glColor4ub
+JNIEXPORT void JNICALL GL_NATIVE(glColor4ub)
+	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2, jbyte arg3)
+{
+	GL_NATIVE_ENTER(env, that, glColor4ub_FUNC);
+	glColor4ub(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glColor4ub_FUNC);
+}
+#endif
+
+#ifndef NO_glColor4ubv
+JNIEXPORT void JNICALL GL_NATIVE(glColor4ubv)
+	(JNIEnv *env, jclass that, jbyteArray arg0)
+{
+	jbyte *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glColor4ubv_FUNC);
+	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
+	glColor4ubv(lparg0);
+	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
+	GL_NATIVE_EXIT(env, that, glColor4ubv_FUNC);
+}
+#endif
+
+#ifndef NO_glColor4ui
+JNIEXPORT void JNICALL GL_NATIVE(glColor4ui)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	GL_NATIVE_ENTER(env, that, glColor4ui_FUNC);
+	glColor4ui(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glColor4ui_FUNC);
+}
+#endif
+
+#ifndef NO_glColor4uiv
+JNIEXPORT void JNICALL GL_NATIVE(glColor4uiv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glColor4uiv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	}
+	glColor4uiv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glColor4uiv_FUNC);
+}
+#endif
+
+#ifndef NO_glColor4us
+JNIEXPORT void JNICALL GL_NATIVE(glColor4us)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
+{
+	GL_NATIVE_ENTER(env, that, glColor4us_FUNC);
+	glColor4us(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glColor4us_FUNC);
+}
+#endif
+
+#ifndef NO_glColor4usv
+JNIEXPORT void JNICALL GL_NATIVE(glColor4usv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glColor4usv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	}
+	glColor4usv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glColor4usv_FUNC);
+}
+#endif
+
+#ifndef NO_glColorMask
+JNIEXPORT void JNICALL GL_NATIVE(glColorMask)
+	(JNIEnv *env, jclass that, jboolean arg0, jboolean arg1, jboolean arg2, jboolean arg3)
+{
+	GL_NATIVE_ENTER(env, that, glColorMask_FUNC);
+	glColorMask(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glColorMask_FUNC);
+}
+#endif
+
+#ifndef NO_glColorMaterial
+JNIEXPORT void JNICALL GL_NATIVE(glColorMaterial)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	GL_NATIVE_ENTER(env, that, glColorMaterial_FUNC);
+	glColorMaterial(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glColorMaterial_FUNC);
+}
+#endif
+
+#ifndef NO_glColorPointer
+JNIEXPORT void JNICALL GL_NATIVE(glColorPointer)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)
+{
+	jint *lparg3=NULL;
+	GL_NATIVE_ENTER(env, that, glColorPointer_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
+	} else
+#endif
+	{
+		if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
+	}
+	glColorPointer(arg0, arg1, arg2, lparg3);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
+	} else
+#endif
+	{
+		if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glColorPointer_FUNC);
+}
+#endif
+
+#ifndef NO_glCopyPixels
+JNIEXPORT void JNICALL GL_NATIVE(glCopyPixels)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4)
+{
+	GL_NATIVE_ENTER(env, that, glCopyPixels_FUNC);
+	glCopyPixels(arg0, arg1, arg2, arg3, arg4);
+	GL_NATIVE_EXIT(env, that, glCopyPixels_FUNC);
+}
+#endif
+
+#ifndef NO_glCopyTexImage1D
+JNIEXPORT void JNICALL GL_NATIVE(glCopyTexImage1D)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6)
+{
+	GL_NATIVE_ENTER(env, that, glCopyTexImage1D_FUNC);
+	glCopyTexImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+	GL_NATIVE_EXIT(env, that, glCopyTexImage1D_FUNC);
+}
+#endif
+
+#ifndef NO_glCopyTexImage2D
+JNIEXPORT void JNICALL GL_NATIVE(glCopyTexImage2D)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7)
+{
+	GL_NATIVE_ENTER(env, that, glCopyTexImage2D_FUNC);
+	glCopyTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+	GL_NATIVE_EXIT(env, that, glCopyTexImage2D_FUNC);
+}
+#endif
+
+#ifndef NO_glCopyTexSubImage1D
+JNIEXPORT void JNICALL GL_NATIVE(glCopyTexSubImage1D)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5)
+{
+	GL_NATIVE_ENTER(env, that, glCopyTexSubImage1D_FUNC);
+	glCopyTexSubImage1D(arg0, arg1, arg2, arg3, arg4, arg5);
+	GL_NATIVE_EXIT(env, that, glCopyTexSubImage1D_FUNC);
+}
+#endif
+
+#ifndef NO_glCopyTexSubImage2D
+JNIEXPORT void JNICALL GL_NATIVE(glCopyTexSubImage2D)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7)
+{
+	GL_NATIVE_ENTER(env, that, glCopyTexSubImage2D_FUNC);
+	glCopyTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+	GL_NATIVE_EXIT(env, that, glCopyTexSubImage2D_FUNC);
+}
+#endif
+
+#ifndef NO_glCullFace
+JNIEXPORT void JNICALL GL_NATIVE(glCullFace)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glCullFace_FUNC);
+	glCullFace(arg0);
+	GL_NATIVE_EXIT(env, that, glCullFace_FUNC);
+}
+#endif
+
+#ifndef NO_glDeleteLists
+JNIEXPORT void JNICALL GL_NATIVE(glDeleteLists)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	GL_NATIVE_ENTER(env, that, glDeleteLists_FUNC);
+	glDeleteLists(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glDeleteLists_FUNC);
+}
+#endif
+
+#ifndef NO_glDeleteTextures
+JNIEXPORT void JNICALL GL_NATIVE(glDeleteTextures)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
+{
+	jint *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glDeleteTextures_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)->GetIntArrayElements(env, arg1, NULL);
+	}
+	glDeleteTextures(arg0, lparg1);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glDeleteTextures_FUNC);
+}
+#endif
+
+#ifndef NO_glDepthFunc
+JNIEXPORT void JNICALL GL_NATIVE(glDepthFunc)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glDepthFunc_FUNC);
+	glDepthFunc(arg0);
+	GL_NATIVE_EXIT(env, that, glDepthFunc_FUNC);
+}
+#endif
+
+#ifndef NO_glDepthMask
+JNIEXPORT void JNICALL GL_NATIVE(glDepthMask)
+	(JNIEnv *env, jclass that, jboolean arg0)
+{
+	GL_NATIVE_ENTER(env, that, glDepthMask_FUNC);
+	glDepthMask(arg0);
+	GL_NATIVE_EXIT(env, that, glDepthMask_FUNC);
+}
+#endif
+
+#ifndef NO_glDepthRange
+JNIEXPORT void JNICALL GL_NATIVE(glDepthRange)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)
+{
+	GL_NATIVE_ENTER(env, that, glDepthRange_FUNC);
+	glDepthRange(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glDepthRange_FUNC);
+}
+#endif
+
+#ifndef NO_glDisable
+JNIEXPORT void JNICALL GL_NATIVE(glDisable)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glDisable_FUNC);
+	glDisable(arg0);
+	GL_NATIVE_EXIT(env, that, glDisable_FUNC);
+}
+#endif
+
+#ifndef NO_glDisableClientState
+JNIEXPORT void JNICALL GL_NATIVE(glDisableClientState)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glDisableClientState_FUNC);
+	glDisableClientState(arg0);
+	GL_NATIVE_EXIT(env, that, glDisableClientState_FUNC);
+}
+#endif
+
+#ifndef NO_glDrawArrays
+JNIEXPORT void JNICALL GL_NATIVE(glDrawArrays)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	GL_NATIVE_ENTER(env, that, glDrawArrays_FUNC);
+	glDrawArrays(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glDrawArrays_FUNC);
+}
+#endif
+
+#ifndef NO_glDrawBuffer
+JNIEXPORT void JNICALL GL_NATIVE(glDrawBuffer)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glDrawBuffer_FUNC);
+	glDrawBuffer(arg0);
+	GL_NATIVE_EXIT(env, that, glDrawBuffer_FUNC);
+}
+#endif
+
+#ifndef NO_glDrawElements
+JNIEXPORT void JNICALL GL_NATIVE(glDrawElements)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)
+{
+	jint *lparg3=NULL;
+	GL_NATIVE_ENTER(env, that, glDrawElements_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
+	} else
+#endif
+	{
+		if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
+	}
+	glDrawElements(arg0, arg1, arg2, lparg3);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
+	} else
+#endif
+	{
+		if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glDrawElements_FUNC);
+}
+#endif
+
+#ifndef NO_glDrawPixels
+JNIEXPORT void JNICALL GL_NATIVE(glDrawPixels)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jintArray arg4)
+{
+	jint *lparg4=NULL;
+	GL_NATIVE_ENTER(env, that, glDrawPixels_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);
+	}
+	glDrawPixels(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);
+	}
+	GL_NATIVE_EXIT(env, that, glDrawPixels_FUNC);
+}
+#endif
+
+#ifndef NO_glEdgeFlag
+JNIEXPORT void JNICALL GL_NATIVE(glEdgeFlag)
+	(JNIEnv *env, jclass that, jboolean arg0)
+{
+	GL_NATIVE_ENTER(env, that, glEdgeFlag_FUNC);
+	glEdgeFlag(arg0);
+	GL_NATIVE_EXIT(env, that, glEdgeFlag_FUNC);
+}
+#endif
+
+#ifndef NO_glEdgeFlagPointer
+JNIEXPORT void JNICALL GL_NATIVE(glEdgeFlagPointer)
+	(JNIEnv *env, jclass that, jint arg0, jbooleanArray arg1)
+{
+	jboolean *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glEdgeFlagPointer_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)->GetBooleanArrayElements(env, arg1, NULL);
+	}
+	glEdgeFlagPointer(arg0, lparg1);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseBooleanArrayElements(env, arg1, lparg1, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glEdgeFlagPointer_FUNC);
+}
+#endif
+
+#ifndef NO_glEdgeFlagv
+JNIEXPORT void JNICALL GL_NATIVE(glEdgeFlagv)
+	(JNIEnv *env, jclass that, jbooleanArray arg0)
+{
+	jboolean *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glEdgeFlagv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetBooleanArrayElements(env, arg0, NULL);
+	}
+	glEdgeFlagv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseBooleanArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glEdgeFlagv_FUNC);
+}
+#endif
+
+#ifndef NO_glEnable
+JNIEXPORT void JNICALL GL_NATIVE(glEnable)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glEnable_FUNC);
+	glEnable(arg0);
+	GL_NATIVE_EXIT(env, that, glEnable_FUNC);
+}
+#endif
+
+#ifndef NO_glEnableClientState
+JNIEXPORT void JNICALL GL_NATIVE(glEnableClientState)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glEnableClientState_FUNC);
+	glEnableClientState(arg0);
+	GL_NATIVE_EXIT(env, that, glEnableClientState_FUNC);
+}
+#endif
+
+#ifndef NO_glEnd
+JNIEXPORT void JNICALL GL_NATIVE(glEnd)
+	(JNIEnv *env, jclass that)
+{
+	GL_NATIVE_ENTER(env, that, glEnd_FUNC);
+	glEnd();
+	GL_NATIVE_EXIT(env, that, glEnd_FUNC);
+}
+#endif
+
+#ifndef NO_glEndList
+JNIEXPORT void JNICALL GL_NATIVE(glEndList)
+	(JNIEnv *env, jclass that)
+{
+	GL_NATIVE_ENTER(env, that, glEndList_FUNC);
+	glEndList();
+	GL_NATIVE_EXIT(env, that, glEndList_FUNC);
+}
+#endif
+
+#ifndef NO_glEvalCoord1d
+JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1d)
+	(JNIEnv *env, jclass that, jdouble arg0)
+{
+	GL_NATIVE_ENTER(env, that, glEvalCoord1d_FUNC);
+	glEvalCoord1d(arg0);
+	GL_NATIVE_EXIT(env, that, glEvalCoord1d_FUNC);
+}
+#endif
+
+#ifndef NO_glEvalCoord1dv
+JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glEvalCoord1dv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	}
+	glEvalCoord1dv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glEvalCoord1dv_FUNC);
+}
+#endif
+
+#ifndef NO_glEvalCoord1f
+JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1f)
+	(JNIEnv *env, jclass that, jfloat arg0)
+{
+	GL_NATIVE_ENTER(env, that, glEvalCoord1f_FUNC);
+	glEvalCoord1f(arg0);
+	GL_NATIVE_EXIT(env, that, glEvalCoord1f_FUNC);
+}
+#endif
+
+#ifndef NO_glEvalCoord1fv
+JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glEvalCoord1fv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glEvalCoord1fv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glEvalCoord1fv_FUNC);
+}
+#endif
+
+#ifndef NO_glEvalCoord2d
+JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)
+{
+	GL_NATIVE_ENTER(env, that, glEvalCoord2d_FUNC);
+	glEvalCoord2d(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glEvalCoord2d_FUNC);
+}
+#endif
+
+#ifndef NO_glEvalCoord2dv
+JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glEvalCoord2dv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	}
+	glEvalCoord2dv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glEvalCoord2dv_FUNC);
+}
+#endif
+
+#ifndef NO_glEvalCoord2f
+JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
+{
+	GL_NATIVE_ENTER(env, that, glEvalCoord2f_FUNC);
+	glEvalCoord2f(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glEvalCoord2f_FUNC);
+}
+#endif
+
+#ifndef NO_glEvalCoord2fv
+JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glEvalCoord2fv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glEvalCoord2fv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glEvalCoord2fv_FUNC);
+}
+#endif
+
+#ifndef NO_glEvalMesh1
+JNIEXPORT void JNICALL GL_NATIVE(glEvalMesh1)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	GL_NATIVE_ENTER(env, that, glEvalMesh1_FUNC);
+	glEvalMesh1(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glEvalMesh1_FUNC);
+}
+#endif
+
+#ifndef NO_glEvalMesh2
+JNIEXPORT void JNICALL GL_NATIVE(glEvalMesh2)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4)
+{
+	GL_NATIVE_ENTER(env, that, glEvalMesh2_FUNC);
+	glEvalMesh2(arg0, arg1, arg2, arg3, arg4);
+	GL_NATIVE_EXIT(env, that, glEvalMesh2_FUNC);
+}
+#endif
+
+#ifndef NO_glEvalPoint1
+JNIEXPORT void JNICALL GL_NATIVE(glEvalPoint1)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glEvalPoint1_FUNC);
+	glEvalPoint1(arg0);
+	GL_NATIVE_EXIT(env, that, glEvalPoint1_FUNC);
+}
+#endif
+
+#ifndef NO_glEvalPoint2
+JNIEXPORT void JNICALL GL_NATIVE(glEvalPoint2)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	GL_NATIVE_ENTER(env, that, glEvalPoint2_FUNC);
+	glEvalPoint2(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glEvalPoint2_FUNC);
+}
+#endif
+
+#ifndef NO_glFeedbackBuffer
+JNIEXPORT void JNICALL GL_NATIVE(glFeedbackBuffer)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glFeedbackBuffer_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);
+	}
+	glFeedbackBuffer(arg0, arg1, lparg2);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glFeedbackBuffer_FUNC);
+}
+#endif
+
+#ifndef NO_glFinish
+JNIEXPORT void JNICALL GL_NATIVE(glFinish)
+	(JNIEnv *env, jclass that)
+{
+	GL_NATIVE_ENTER(env, that, glFinish_FUNC);
+	glFinish();
+	GL_NATIVE_EXIT(env, that, glFinish_FUNC);
+}
+#endif
+
+#ifndef NO_glFlush
+JNIEXPORT void JNICALL GL_NATIVE(glFlush)
+	(JNIEnv *env, jclass that)
+{
+	GL_NATIVE_ENTER(env, that, glFlush_FUNC);
+	glFlush();
+	GL_NATIVE_EXIT(env, that, glFlush_FUNC);
+}
+#endif
+
+#ifndef NO_glFogf
+JNIEXPORT void JNICALL GL_NATIVE(glFogf)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
+{
+	GL_NATIVE_ENTER(env, that, glFogf_FUNC);
+	glFogf(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glFogf_FUNC);
+}
+#endif
+
+#ifndef NO_glFogfv
+JNIEXPORT void JNICALL GL_NATIVE(glFogfv)
+	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1)
+{
+	jfloat *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glFogfv_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)->GetFloatArrayElements(env, arg1, NULL);
+	}
+	glFogfv(arg0, lparg1);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glFogfv_FUNC);
+}
+#endif
+
+#ifndef NO_glFogi
+JNIEXPORT void JNICALL GL_NATIVE(glFogi)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	GL_NATIVE_ENTER(env, that, glFogi_FUNC);
+	glFogi(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glFogi_FUNC);
+}
+#endif
+
+#ifndef NO_glFogiv
+JNIEXPORT void JNICALL GL_NATIVE(glFogiv)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
+{
+	jint *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glFogiv_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)->GetIntArrayElements(env, arg1, NULL);
+	}
+	glFogiv(arg0, lparg1);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glFogiv_FUNC);
+}
+#endif
+
+#ifndef NO_glFrontFace
+JNIEXPORT void JNICALL GL_NATIVE(glFrontFace)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glFrontFace_FUNC);
+	glFrontFace(arg0);
+	GL_NATIVE_EXIT(env, that, glFrontFace_FUNC);
+}
+#endif
+
+#ifndef NO_glFrustum
+JNIEXPORT void JNICALL GL_NATIVE(glFrustum)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3, jdouble arg4, jdouble arg5)
+{
+	GL_NATIVE_ENTER(env, that, glFrustum_FUNC);
+	glFrustum(arg0, arg1, arg2, arg3, arg4, arg5);
+	GL_NATIVE_EXIT(env, that, glFrustum_FUNC);
+}
+#endif
+
+#ifndef NO_glGenLists
+JNIEXPORT jint JNICALL GL_NATIVE(glGenLists)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	jint rc;
+	GL_NATIVE_ENTER(env, that, glGenLists_FUNC);
+	rc = (jint)glGenLists(arg0);
+	GL_NATIVE_EXIT(env, that, glGenLists_FUNC);
+	return rc;
+}
+#endif
+
+#ifndef NO_glGenTextures
+JNIEXPORT void JNICALL GL_NATIVE(glGenTextures)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
+{
+	jint *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glGenTextures_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)->GetIntArrayElements(env, arg1, NULL);
+	}
+	glGenTextures(arg0, lparg1);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glGenTextures_FUNC);
+}
+#endif
+
+#ifndef NO_glGetBooleanv
+JNIEXPORT void JNICALL GL_NATIVE(glGetBooleanv)
+	(JNIEnv *env, jclass that, jint arg0, jbooleanArray arg1)
+{
+	jboolean *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glGetBooleanv_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)->GetBooleanArrayElements(env, arg1, NULL);
+	}
+	glGetBooleanv(arg0, lparg1);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseBooleanArrayElements(env, arg1, lparg1, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glGetBooleanv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetClipPlane
+JNIEXPORT void JNICALL GL_NATIVE(glGetClipPlane)
+	(JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1)
+{
+	jdouble *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glGetClipPlane_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);
+	}
+	glGetClipPlane(arg0, lparg1);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glGetClipPlane_FUNC);
+}
+#endif
+
+#ifndef NO_glGetDoublev
+JNIEXPORT void JNICALL GL_NATIVE(glGetDoublev)
+	(JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1)
+{
+	jdouble *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glGetDoublev_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);
+	}
+	glGetDoublev(arg0, lparg1);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glGetDoublev_FUNC);
+}
+#endif
+
+#ifndef NO_glGetError
+JNIEXPORT jint JNICALL GL_NATIVE(glGetError)
+	(JNIEnv *env, jclass that)
+{
+	jint rc;
+	GL_NATIVE_ENTER(env, that, glGetError_FUNC);
+	rc = (jint)glGetError();
+	GL_NATIVE_EXIT(env, that, glGetError_FUNC);
+	return rc;
+}
+#endif
+
+#ifndef NO_glGetFloatv
+JNIEXPORT void JNICALL GL_NATIVE(glGetFloatv)
+	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1)
+{
+	jfloat *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glGetFloatv_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)->GetFloatArrayElements(env, arg1, NULL);
+	}
+	glGetFloatv(arg0, lparg1);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glGetFloatv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetIntegerv
+JNIEXPORT void JNICALL GL_NATIVE(glGetIntegerv)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
+{
+	jint *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glGetIntegerv_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)->GetIntArrayElements(env, arg1, NULL);
+	}
+	glGetIntegerv(arg0, lparg1);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glGetIntegerv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetLightfv
+JNIEXPORT void JNICALL GL_NATIVE(glGetLightfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glGetLightfv_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);
+	}
+	glGetLightfv(arg0, arg1, lparg2);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glGetLightfv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetLightiv
+JNIEXPORT void JNICALL GL_NATIVE(glGetLightiv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glGetLightiv_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)->GetIntArrayElements(env, arg2, NULL);
+	}
+	glGetLightiv(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glGetLightiv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetMapdv
+JNIEXPORT void JNICALL GL_NATIVE(glGetMapdv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2)
+{
+	jdouble *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glGetMapdv_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);
+	}
+	glGetMapdv(arg0, arg1, lparg2);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glGetMapdv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetMapfv
+JNIEXPORT void JNICALL GL_NATIVE(glGetMapfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glGetMapfv_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);
+	}
+	glGetMapfv(arg0, arg1, lparg2);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glGetMapfv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetMapiv
+JNIEXPORT void JNICALL GL_NATIVE(glGetMapiv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glGetMapiv_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)->GetIntArrayElements(env, arg2, NULL);
+	}
+	glGetMapiv(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glGetMapiv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetMaterialfv
+JNIEXPORT void JNICALL GL_NATIVE(glGetMaterialfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glGetMaterialfv_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);
+	}
+	glGetMaterialfv(arg0, arg1, lparg2);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glGetMaterialfv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetMaterialiv
+JNIEXPORT void JNICALL GL_NATIVE(glGetMaterialiv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glGetMaterialiv_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)->GetIntArrayElements(env, arg2, NULL);
+	}
+	glGetMaterialiv(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glGetMaterialiv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetPixelMapfv
+JNIEXPORT void JNICALL GL_NATIVE(glGetPixelMapfv)
+	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1)
+{
+	jfloat *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glGetPixelMapfv_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)->GetFloatArrayElements(env, arg1, NULL);
+	}
+	glGetPixelMapfv(arg0, lparg1);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glGetPixelMapfv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetPixelMapuiv
+JNIEXPORT void JNICALL GL_NATIVE(glGetPixelMapuiv)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
+{
+	jint *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glGetPixelMapuiv_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)->GetIntArrayElements(env, arg1, NULL);
+	}
+	glGetPixelMapuiv(arg0, lparg1);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glGetPixelMapuiv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetPixelMapusv
+JNIEXPORT void JNICALL GL_NATIVE(glGetPixelMapusv)
+	(JNIEnv *env, jclass that, jint arg0, jshortArray arg1)
+{
+	jshort *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glGetPixelMapusv_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)->GetShortArrayElements(env, arg1, NULL);
+	}
+	glGetPixelMapusv(arg0, lparg1);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseShortArrayElements(env, arg1, lparg1, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glGetPixelMapusv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetPointerv
+JNIEXPORT void JNICALL GL_NATIVE(glGetPointerv)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
+{
+	jint *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glGetPointerv_FUNC);
+	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+	glGetPointerv(arg0, (GLvoid **)lparg1);
+	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+	GL_NATIVE_EXIT(env, that, glGetPointerv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetPolygonStipple
+JNIEXPORT void JNICALL GL_NATIVE(glGetPolygonStipple)
+	(JNIEnv *env, jclass that, jbyteArray arg0)
+{
+	jbyte *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glGetPolygonStipple_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
+	}
+	glGetPolygonStipple(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glGetPolygonStipple_FUNC);
+}
+#endif
+
+#ifndef NO_glGetString
+JNIEXPORT jint JNICALL GL_NATIVE(glGetString)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	jint rc;
+	GL_NATIVE_ENTER(env, that, glGetString_FUNC);
+	rc = (jint)glGetString(arg0);
+	GL_NATIVE_EXIT(env, that, glGetString_FUNC);
+	return rc;
+}
+#endif
+
+#ifndef NO_glGetTexEnvfv
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexEnvfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glGetTexEnvfv_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);
+	}
+	glGetTexEnvfv(arg0, arg1, lparg2);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glGetTexEnvfv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetTexEnviv
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexEnviv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glGetTexEnviv_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)->GetIntArrayElements(env, arg2, NULL);
+	}
+	glGetTexEnviv(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glGetTexEnviv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetTexGendv
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexGendv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2)
+{
+	jdouble *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glGetTexGendv_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);
+	}
+	glGetTexGendv(arg0, arg1, lparg2);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glGetTexGendv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetTexGenfv
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexGenfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glGetTexGenfv_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);
+	}
+	glGetTexGenfv(arg0, arg1, lparg2);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glGetTexGenfv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetTexGeniv
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexGeniv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glGetTexGeniv_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)->GetIntArrayElements(env, arg2, NULL);
+	}
+	glGetTexGeniv(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glGetTexGeniv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetTexImage
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexImage)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jintArray arg4)
+{
+	jint *lparg4=NULL;
+	GL_NATIVE_ENTER(env, that, glGetTexImage_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);
+	}
+	glGetTexImage(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);
+	}
+	GL_NATIVE_EXIT(env, that, glGetTexImage_FUNC);
+}
+#endif
+
+#ifndef NO_glGetTexLevelParameterfv
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexLevelParameterfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jfloatArray arg3)
+{
+	jfloat *lparg3=NULL;
+	GL_NATIVE_ENTER(env, that, glGetTexLevelParameterfv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
+	} else
+#endif
+	{
+		if (arg3) lparg3 = (*env)->GetFloatArrayElements(env, arg3, NULL);
+	}
+	glGetTexLevelParameterfv(arg0, arg1, arg2, lparg3);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
+	} else
+#endif
+	{
+		if (arg3) (*env)->ReleaseFloatArrayElements(env, arg3, lparg3, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glGetTexLevelParameterfv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetTexLevelParameteriv
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexLevelParameteriv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)
+{
+	jint *lparg3=NULL;
+	GL_NATIVE_ENTER(env, that, glGetTexLevelParameteriv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
+	} else
+#endif
+	{
+		if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
+	}
+	glGetTexLevelParameteriv(arg0, arg1, arg2, lparg3);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
+	} else
+#endif
+	{
+		if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glGetTexLevelParameteriv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetTexParameterfv
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexParameterfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glGetTexParameterfv_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);
+	}
+	glGetTexParameterfv(arg0, arg1, lparg2);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glGetTexParameterfv_FUNC);
+}
+#endif
+
+#ifndef NO_glGetTexParameteriv
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexParameteriv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glGetTexParameteriv_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)->GetIntArrayElements(env, arg2, NULL);
+	}
+	glGetTexParameteriv(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glGetTexParameteriv_FUNC);
+}
+#endif
+
+#ifndef NO_glHint
+JNIEXPORT void JNICALL GL_NATIVE(glHint)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	GL_NATIVE_ENTER(env, that, glHint_FUNC);
+	glHint(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glHint_FUNC);
+}
+#endif
+
+#ifndef NO_glIndexMask
+JNIEXPORT void JNICALL GL_NATIVE(glIndexMask)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glIndexMask_FUNC);
+	glIndexMask(arg0);
+	GL_NATIVE_EXIT(env, that, glIndexMask_FUNC);
+}
+#endif
+
+#ifndef NO_glIndexPointer
+JNIEXPORT void JNICALL GL_NATIVE(glIndexPointer)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glIndexPointer_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)->GetIntArrayElements(env, arg2, NULL);
+	}
+	glIndexPointer(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glIndexPointer_FUNC);
+}
+#endif
+
+#ifndef NO_glIndexd
+JNIEXPORT void JNICALL GL_NATIVE(glIndexd)
+	(JNIEnv *env, jclass that, jdouble arg0)
+{
+	GL_NATIVE_ENTER(env, that, glIndexd_FUNC);
+	glIndexd(arg0);
+	GL_NATIVE_EXIT(env, that, glIndexd_FUNC);
+}
+#endif
+
+#ifndef NO_glIndexdv
+JNIEXPORT void JNICALL GL_NATIVE(glIndexdv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glIndexdv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	}
+	glIndexdv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glIndexdv_FUNC);
+}
+#endif
+
+#ifndef NO_glIndexf
+JNIEXPORT void JNICALL GL_NATIVE(glIndexf)
+	(JNIEnv *env, jclass that, jfloat arg0)
+{
+	GL_NATIVE_ENTER(env, that, glIndexf_FUNC);
+	glIndexf(arg0);
+	GL_NATIVE_EXIT(env, that, glIndexf_FUNC);
+}
+#endif
+
+#ifndef NO_glIndexfv
+JNIEXPORT void JNICALL GL_NATIVE(glIndexfv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glIndexfv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glIndexfv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glIndexfv_FUNC);
+}
+#endif
+
+#ifndef NO_glIndexi
+JNIEXPORT void JNICALL GL_NATIVE(glIndexi)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glIndexi_FUNC);
+	glIndexi(arg0);
+	GL_NATIVE_EXIT(env, that, glIndexi_FUNC);
+}
+#endif
+
+#ifndef NO_glIndexiv
+JNIEXPORT void JNICALL GL_NATIVE(glIndexiv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glIndexiv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	}
+	glIndexiv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glIndexiv_FUNC);
+}
+#endif
+
+#ifndef NO_glIndexs
+JNIEXPORT void JNICALL GL_NATIVE(glIndexs)
+	(JNIEnv *env, jclass that, jshort arg0)
+{
+	GL_NATIVE_ENTER(env, that, glIndexs_FUNC);
+	glIndexs(arg0);
+	GL_NATIVE_EXIT(env, that, glIndexs_FUNC);
+}
+#endif
+
+#ifndef NO_glIndexsv
+JNIEXPORT void JNICALL GL_NATIVE(glIndexsv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glIndexsv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	}
+	glIndexsv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glIndexsv_FUNC);
+}
+#endif
+
+#ifndef NO_glInitNames
+JNIEXPORT void JNICALL GL_NATIVE(glInitNames)
+	(JNIEnv *env, jclass that)
+{
+	GL_NATIVE_ENTER(env, that, glInitNames_FUNC);
+	glInitNames();
+	GL_NATIVE_EXIT(env, that, glInitNames_FUNC);
+}
+#endif
+
+#ifndef NO_glInterleavedArrays
+JNIEXPORT void JNICALL GL_NATIVE(glInterleavedArrays)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glInterleavedArrays_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)->GetIntArrayElements(env, arg2, NULL);
+	}
+	glInterleavedArrays(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glInterleavedArrays_FUNC);
+}
+#endif
+
+#ifndef NO_glIsEnabled
+JNIEXPORT jboolean JNICALL GL_NATIVE(glIsEnabled)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	jboolean rc;
+	GL_NATIVE_ENTER(env, that, glIsEnabled_FUNC);
+	rc = (jboolean)glIsEnabled(arg0);
+	GL_NATIVE_EXIT(env, that, glIsEnabled_FUNC);
+	return rc;
+}
+#endif
+
+#ifndef NO_glIsList
+JNIEXPORT jboolean JNICALL GL_NATIVE(glIsList)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	jboolean rc;
+	GL_NATIVE_ENTER(env, that, glIsList_FUNC);
+	rc = (jboolean)glIsList(arg0);
+	GL_NATIVE_EXIT(env, that, glIsList_FUNC);
+	return rc;
+}
+#endif
+
+#ifndef NO_glIsTexture
+JNIEXPORT jboolean JNICALL GL_NATIVE(glIsTexture)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	jboolean rc;
+	GL_NATIVE_ENTER(env, that, glIsTexture_FUNC);
+	rc = (jboolean)glIsTexture(arg0);
+	GL_NATIVE_EXIT(env, that, glIsTexture_FUNC);
+	return rc;
+}
+#endif
+
+#ifndef NO_glLightModelf
+JNIEXPORT void JNICALL GL_NATIVE(glLightModelf)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
+{
+	GL_NATIVE_ENTER(env, that, glLightModelf_FUNC);
+	glLightModelf(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glLightModelf_FUNC);
+}
+#endif
+
+#ifndef NO_glLightModelfv
+JNIEXPORT void JNICALL GL_NATIVE(glLightModelfv)
+	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1)
+{
+	jfloat *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glLightModelfv_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)->GetFloatArrayElements(env, arg1, NULL);
+	}
+	glLightModelfv(arg0, lparg1);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glLightModelfv_FUNC);
+}
+#endif
+
+#ifndef NO_glLightModeli
+JNIEXPORT void JNICALL GL_NATIVE(glLightModeli)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	GL_NATIVE_ENTER(env, that, glLightModeli_FUNC);
+	glLightModeli(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glLightModeli_FUNC);
+}
+#endif
+
+#ifndef NO_glLightModeliv
+JNIEXPORT void JNICALL GL_NATIVE(glLightModeliv)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
+{
+	jint *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glLightModeliv_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)->GetIntArrayElements(env, arg1, NULL);
+	}
+	glLightModeliv(arg0, lparg1);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glLightModeliv_FUNC);
+}
+#endif
+
+#ifndef NO_glLightf
+JNIEXPORT void JNICALL GL_NATIVE(glLightf)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
+{
+	GL_NATIVE_ENTER(env, that, glLightf_FUNC);
+	glLightf(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glLightf_FUNC);
+}
+#endif
+
+#ifndef NO_glLightfv
+JNIEXPORT void JNICALL GL_NATIVE(glLightfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glLightfv_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);
+	}
+	glLightfv(arg0, arg1, lparg2);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glLightfv_FUNC);
+}
+#endif
+
+#ifndef NO_glLighti
+JNIEXPORT void JNICALL GL_NATIVE(glLighti)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	GL_NATIVE_ENTER(env, that, glLighti_FUNC);
+	glLighti(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glLighti_FUNC);
+}
+#endif
+
+#ifndef NO_glLightiv
+JNIEXPORT void JNICALL GL_NATIVE(glLightiv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glLightiv_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)->GetIntArrayElements(env, arg2, NULL);
+	}
+	glLightiv(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glLightiv_FUNC);
+}
+#endif
+
+#ifndef NO_glLineStipple
+JNIEXPORT void JNICALL GL_NATIVE(glLineStipple)
+	(JNIEnv *env, jclass that, jint arg0, jshort arg1)
+{
+	GL_NATIVE_ENTER(env, that, glLineStipple_FUNC);
+	glLineStipple(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glLineStipple_FUNC);
+}
+#endif
+
+#ifndef NO_glLineWidth
+JNIEXPORT void JNICALL GL_NATIVE(glLineWidth)
+	(JNIEnv *env, jclass that, jfloat arg0)
+{
+	GL_NATIVE_ENTER(env, that, glLineWidth_FUNC);
+	glLineWidth(arg0);
+	GL_NATIVE_EXIT(env, that, glLineWidth_FUNC);
+}
+#endif
+
+#ifndef NO_glListBase
+JNIEXPORT void JNICALL GL_NATIVE(glListBase)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glListBase_FUNC);
+	glListBase(arg0);
+	GL_NATIVE_EXIT(env, that, glListBase_FUNC);
+}
+#endif
+
+#ifndef NO_glLoadIdentity
+JNIEXPORT void JNICALL GL_NATIVE(glLoadIdentity)
+	(JNIEnv *env, jclass that)
+{
+	GL_NATIVE_ENTER(env, that, glLoadIdentity_FUNC);
+	glLoadIdentity();
+	GL_NATIVE_EXIT(env, that, glLoadIdentity_FUNC);
+}
+#endif
+
+#ifndef NO_glLoadMatrixd
+JNIEXPORT void JNICALL GL_NATIVE(glLoadMatrixd)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glLoadMatrixd_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	}
+	glLoadMatrixd(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glLoadMatrixd_FUNC);
+}
+#endif
+
+#ifndef NO_glLoadMatrixf
+JNIEXPORT void JNICALL GL_NATIVE(glLoadMatrixf)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glLoadMatrixf_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glLoadMatrixf(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glLoadMatrixf_FUNC);
+}
+#endif
+
+#ifndef NO_glLoadName
+JNIEXPORT void JNICALL GL_NATIVE(glLoadName)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glLoadName_FUNC);
+	glLoadName(arg0);
+	GL_NATIVE_EXIT(env, that, glLoadName_FUNC);
+}
+#endif
+
+#ifndef NO_glLogicOp
+JNIEXPORT void JNICALL GL_NATIVE(glLogicOp)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glLogicOp_FUNC);
+	glLogicOp(arg0);
+	GL_NATIVE_EXIT(env, that, glLogicOp_FUNC);
+}
+#endif
+
+#ifndef NO_glMap1d
+JNIEXPORT void JNICALL GL_NATIVE(glMap1d)
+	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4, jdoubleArray arg5)
+{
+	jdouble *lparg5=NULL;
+	GL_NATIVE_ENTER(env, that, glMap1d_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg5) lparg5 = (*env)->GetPrimitiveArrayCritical(env, arg5, NULL);
+	} else
+#endif
+	{
+		if (arg5) lparg5 = (*env)->GetDoubleArrayElements(env, arg5, NULL);
+	}
+	glMap1d(arg0, arg1, arg2, arg3, arg4, lparg5);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg5) (*env)->ReleasePrimitiveArrayCritical(env, arg5, lparg5, 0);
+	} else
+#endif
+	{
+		if (arg5) (*env)->ReleaseDoubleArrayElements(env, arg5, lparg5, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glMap1d_FUNC);
+}
+#endif
+
+#ifndef NO_glMap1f
+JNIEXPORT void JNICALL GL_NATIVE(glMap1f)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2, jint arg3, jint arg4, jfloatArray arg5)
+{
+	jfloat *lparg5=NULL;
+	GL_NATIVE_ENTER(env, that, glMap1f_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg5) lparg5 = (*env)->GetPrimitiveArrayCritical(env, arg5, NULL);
+	} else
+#endif
+	{
+		if (arg5) lparg5 = (*env)->GetFloatArrayElements(env, arg5, NULL);
+	}
+	glMap1f(arg0, arg1, arg2, arg3, arg4, lparg5);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg5) (*env)->ReleasePrimitiveArrayCritical(env, arg5, lparg5, 0);
+	} else
+#endif
+	{
+		if (arg5) (*env)->ReleaseFloatArrayElements(env, arg5, lparg5, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glMap1f_FUNC);
+}
+#endif
+
+#ifndef NO_glMap2d
+JNIEXPORT void JNICALL GL_NATIVE(glMap2d)
+	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4, jdouble arg5, jdouble arg6, jint arg7, jint arg8, jdoubleArray arg9)
+{
+	jdouble *lparg9=NULL;
+	GL_NATIVE_ENTER(env, that, glMap2d_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg9) lparg9 = (*env)->GetPrimitiveArrayCritical(env, arg9, NULL);
+	} else
+#endif
+	{
+		if (arg9) lparg9 = (*env)->GetDoubleArrayElements(env, arg9, NULL);
+	}
+	glMap2d(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, lparg9);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg9) (*env)->ReleasePrimitiveArrayCritical(env, arg9, lparg9, 0);
+	} else
+#endif
+	{
+		if (arg9) (*env)->ReleaseDoubleArrayElements(env, arg9, lparg9, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glMap2d_FUNC);
+}
+#endif
+
+#ifndef NO_glMap2f
+JNIEXPORT void JNICALL GL_NATIVE(glMap2f)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2, jint arg3, jint arg4, jfloat arg5, jfloat arg6, jint arg7, jint arg8, jfloatArray arg9)
+{
+	jfloat *lparg9=NULL;
+	GL_NATIVE_ENTER(env, that, glMap2f_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg9) lparg9 = (*env)->GetPrimitiveArrayCritical(env, arg9, NULL);
+	} else
+#endif
+	{
+		if (arg9) lparg9 = (*env)->GetFloatArrayElements(env, arg9, NULL);
+	}
+	glMap2f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, lparg9);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg9) (*env)->ReleasePrimitiveArrayCritical(env, arg9, lparg9, 0);
+	} else
+#endif
+	{
+		if (arg9) (*env)->ReleaseFloatArrayElements(env, arg9, lparg9, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glMap2f_FUNC);
+}
+#endif
+
+#ifndef NO_glMapGrid1d
+JNIEXPORT void JNICALL GL_NATIVE(glMapGrid1d)
+	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2)
+{
+	GL_NATIVE_ENTER(env, that, glMapGrid1d_FUNC);
+	glMapGrid1d(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glMapGrid1d_FUNC);
+}
+#endif
+
+#ifndef NO_glMapGrid1f
+JNIEXPORT void JNICALL GL_NATIVE(glMapGrid1f)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2)
+{
+	GL_NATIVE_ENTER(env, that, glMapGrid1f_FUNC);
+	glMapGrid1f(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glMapGrid1f_FUNC);
+}
+#endif
+
+#ifndef NO_glMapGrid2d
+JNIEXPORT void JNICALL GL_NATIVE(glMapGrid2d)
+	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jdouble arg4, jdouble arg5)
+{
+	GL_NATIVE_ENTER(env, that, glMapGrid2d_FUNC);
+	glMapGrid2d(arg0, arg1, arg2, arg3, arg4, arg5);
+	GL_NATIVE_EXIT(env, that, glMapGrid2d_FUNC);
+}
+#endif
+
+#ifndef NO_glMapGrid2f
+JNIEXPORT void JNICALL GL_NATIVE(glMapGrid2f)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2, jint arg3, jfloat arg4, jfloat arg5)
+{
+	GL_NATIVE_ENTER(env, that, glMapGrid2f_FUNC);
+	glMapGrid2f(arg0, arg1, arg2, arg3, arg4, arg5);
+	GL_NATIVE_EXIT(env, that, glMapGrid2f_FUNC);
+}
+#endif
+
+#ifndef NO_glMaterialf
+JNIEXPORT void JNICALL GL_NATIVE(glMaterialf)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
+{
+	GL_NATIVE_ENTER(env, that, glMaterialf_FUNC);
+	glMaterialf(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glMaterialf_FUNC);
+}
+#endif
+
+#ifndef NO_glMaterialfv
+JNIEXPORT void JNICALL GL_NATIVE(glMaterialfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glMaterialfv_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);
+	}
+	glMaterialfv(arg0, arg1, lparg2);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glMaterialfv_FUNC);
+}
+#endif
+
+#ifndef NO_glMateriali
+JNIEXPORT void JNICALL GL_NATIVE(glMateriali)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	GL_NATIVE_ENTER(env, that, glMateriali_FUNC);
+	glMateriali(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glMateriali_FUNC);
+}
+#endif
+
+#ifndef NO_glMaterialiv
+JNIEXPORT void JNICALL GL_NATIVE(glMaterialiv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glMaterialiv_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)->GetIntArrayElements(env, arg2, NULL);
+	}
+	glMaterialiv(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glMaterialiv_FUNC);
+}
+#endif
+
+#ifndef NO_glMatrixMode
+JNIEXPORT void JNICALL GL_NATIVE(glMatrixMode)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glMatrixMode_FUNC);
+	glMatrixMode(arg0);
+	GL_NATIVE_EXIT(env, that, glMatrixMode_FUNC);
+}
+#endif
+
+#ifndef NO_glMultMatrixd
+JNIEXPORT void JNICALL GL_NATIVE(glMultMatrixd)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glMultMatrixd_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	}
+	glMultMatrixd(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glMultMatrixd_FUNC);
+}
+#endif
+
+#ifndef NO_glMultMatrixf
+JNIEXPORT void JNICALL GL_NATIVE(glMultMatrixf)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glMultMatrixf_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glMultMatrixf(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glMultMatrixf_FUNC);
+}
+#endif
+
+#ifndef NO_glNewList
+JNIEXPORT void JNICALL GL_NATIVE(glNewList)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	GL_NATIVE_ENTER(env, that, glNewList_FUNC);
+	glNewList(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glNewList_FUNC);
+}
+#endif
+
+#ifndef NO_glNormal3b
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3b)
+	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2)
+{
+	GL_NATIVE_ENTER(env, that, glNormal3b_FUNC);
+	glNormal3b(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glNormal3b_FUNC);
+}
+#endif
+
+#ifndef NO_glNormal3bv
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3bv)
+	(JNIEnv *env, jclass that, jbyteArray arg0)
+{
+	jbyte *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glNormal3bv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
+	}
+	glNormal3bv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glNormal3bv_FUNC);
+}
+#endif
+
+#ifndef NO_glNormal3d
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
+{
+	GL_NATIVE_ENTER(env, that, glNormal3d_FUNC);
+	glNormal3d(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glNormal3d_FUNC);
+}
+#endif
+
+#ifndef NO_glNormal3dv
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glNormal3dv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	}
+	glNormal3dv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glNormal3dv_FUNC);
+}
+#endif
+
+#ifndef NO_glNormal3f
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
+{
+	GL_NATIVE_ENTER(env, that, glNormal3f_FUNC);
+	glNormal3f(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glNormal3f_FUNC);
+}
+#endif
+
+#ifndef NO_glNormal3fv
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glNormal3fv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glNormal3fv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glNormal3fv_FUNC);
+}
+#endif
+
+#ifndef NO_glNormal3i
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	GL_NATIVE_ENTER(env, that, glNormal3i_FUNC);
+	glNormal3i(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glNormal3i_FUNC);
+}
+#endif
+
+#ifndef NO_glNormal3iv
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glNormal3iv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	}
+	glNormal3iv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glNormal3iv_FUNC);
+}
+#endif
+
+#ifndef NO_glNormal3s
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
+{
+	GL_NATIVE_ENTER(env, that, glNormal3s_FUNC);
+	glNormal3s(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glNormal3s_FUNC);
+}
+#endif
+
+#ifndef NO_glNormal3sv
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glNormal3sv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	}
+	glNormal3sv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glNormal3sv_FUNC);
+}
+#endif
+
+#ifndef NO_glNormalPointer
+JNIEXPORT void JNICALL GL_NATIVE(glNormalPointer)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glNormalPointer_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)->GetIntArrayElements(env, arg2, NULL);
+	}
+	glNormalPointer(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glNormalPointer_FUNC);
+}
+#endif
+
+#ifndef NO_glOrtho
+JNIEXPORT void JNICALL GL_NATIVE(glOrtho)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3, jdouble arg4, jdouble arg5)
+{
+	GL_NATIVE_ENTER(env, that, glOrtho_FUNC);
+	glOrtho(arg0, arg1, arg2, arg3, arg4, arg5);
+	GL_NATIVE_EXIT(env, that, glOrtho_FUNC);
+}
+#endif
+
+#ifndef NO_glPassThrough
+JNIEXPORT void JNICALL GL_NATIVE(glPassThrough)
+	(JNIEnv *env, jclass that, jfloat arg0)
+{
+	GL_NATIVE_ENTER(env, that, glPassThrough_FUNC);
+	glPassThrough(arg0);
+	GL_NATIVE_EXIT(env, that, glPassThrough_FUNC);
+}
+#endif
+
+#ifndef NO_glPixelMapfv
+JNIEXPORT void JNICALL GL_NATIVE(glPixelMapfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glPixelMapfv_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);
+	}
+	glPixelMapfv(arg0, arg1, lparg2);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glPixelMapfv_FUNC);
+}
+#endif
+
+#ifndef NO_glPixelMapuiv
+JNIEXPORT void JNICALL GL_NATIVE(glPixelMapuiv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glPixelMapuiv_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)->GetIntArrayElements(env, arg2, NULL);
+	}
+	glPixelMapuiv(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glPixelMapuiv_FUNC);
+}
+#endif
+
+#ifndef NO_glPixelMapusv
+JNIEXPORT void JNICALL GL_NATIVE(glPixelMapusv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jshortArray arg2)
+{
+	jshort *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glPixelMapusv_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)->GetShortArrayElements(env, arg2, NULL);
+	}
+	glPixelMapusv(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseShortArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glPixelMapusv_FUNC);
+}
+#endif
+
+#ifndef NO_glPixelStoref
+JNIEXPORT void JNICALL GL_NATIVE(glPixelStoref)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
+{
+	GL_NATIVE_ENTER(env, that, glPixelStoref_FUNC);
+	glPixelStoref(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glPixelStoref_FUNC);
+}
+#endif
+
+#ifndef NO_glPixelStorei
+JNIEXPORT void JNICALL GL_NATIVE(glPixelStorei)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	GL_NATIVE_ENTER(env, that, glPixelStorei_FUNC);
+	glPixelStorei(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glPixelStorei_FUNC);
+}
+#endif
+
+#ifndef NO_glPixelTransferf
+JNIEXPORT void JNICALL GL_NATIVE(glPixelTransferf)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
+{
+	GL_NATIVE_ENTER(env, that, glPixelTransferf_FUNC);
+	glPixelTransferf(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glPixelTransferf_FUNC);
+}
+#endif
+
+#ifndef NO_glPixelTransferi
+JNIEXPORT void JNICALL GL_NATIVE(glPixelTransferi)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	GL_NATIVE_ENTER(env, that, glPixelTransferi_FUNC);
+	glPixelTransferi(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glPixelTransferi_FUNC);
+}
+#endif
+
+#ifndef NO_glPixelZoom
+JNIEXPORT void JNICALL GL_NATIVE(glPixelZoom)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
+{
+	GL_NATIVE_ENTER(env, that, glPixelZoom_FUNC);
+	glPixelZoom(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glPixelZoom_FUNC);
+}
+#endif
+
+#ifndef NO_glPointSize
+JNIEXPORT void JNICALL GL_NATIVE(glPointSize)
+	(JNIEnv *env, jclass that, jfloat arg0)
+{
+	GL_NATIVE_ENTER(env, that, glPointSize_FUNC);
+	glPointSize(arg0);
+	GL_NATIVE_EXIT(env, that, glPointSize_FUNC);
+}
+#endif
+
+#ifndef NO_glPolygonMode
+JNIEXPORT void JNICALL GL_NATIVE(glPolygonMode)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	GL_NATIVE_ENTER(env, that, glPolygonMode_FUNC);
+	glPolygonMode(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glPolygonMode_FUNC);
+}
+#endif
+
+#ifndef NO_glPolygonOffset
+JNIEXPORT void JNICALL GL_NATIVE(glPolygonOffset)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
+{
+	GL_NATIVE_ENTER(env, that, glPolygonOffset_FUNC);
+	glPolygonOffset(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glPolygonOffset_FUNC);
+}
+#endif
+
+#ifndef NO_glPolygonStipple
+JNIEXPORT void JNICALL GL_NATIVE(glPolygonStipple)
+	(JNIEnv *env, jclass that, jbyteArray arg0)
+{
+	jbyte *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glPolygonStipple_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
+	}
+	glPolygonStipple(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glPolygonStipple_FUNC);
+}
+#endif
+
+#ifndef NO_glPopAttrib
+JNIEXPORT void JNICALL GL_NATIVE(glPopAttrib)
+	(JNIEnv *env, jclass that)
+{
+	GL_NATIVE_ENTER(env, that, glPopAttrib_FUNC);
+	glPopAttrib();
+	GL_NATIVE_EXIT(env, that, glPopAttrib_FUNC);
+}
+#endif
+
+#ifndef NO_glPopClientAttrib
+JNIEXPORT void JNICALL GL_NATIVE(glPopClientAttrib)
+	(JNIEnv *env, jclass that)
+{
+	GL_NATIVE_ENTER(env, that, glPopClientAttrib_FUNC);
+	glPopClientAttrib();
+	GL_NATIVE_EXIT(env, that, glPopClientAttrib_FUNC);
+}
+#endif
+
+#ifndef NO_glPopMatrix
+JNIEXPORT void JNICALL GL_NATIVE(glPopMatrix)
+	(JNIEnv *env, jclass that)
+{
+	GL_NATIVE_ENTER(env, that, glPopMatrix_FUNC);
+	glPopMatrix();
+	GL_NATIVE_EXIT(env, that, glPopMatrix_FUNC);
+}
+#endif
+
+#ifndef NO_glPopName
+JNIEXPORT void JNICALL GL_NATIVE(glPopName)
+	(JNIEnv *env, jclass that)
+{
+	GL_NATIVE_ENTER(env, that, glPopName_FUNC);
+	glPopName();
+	GL_NATIVE_EXIT(env, that, glPopName_FUNC);
+}
+#endif
+
+#ifndef NO_glPrioritizeTextures
+JNIEXPORT void JNICALL GL_NATIVE(glPrioritizeTextures)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jfloatArray arg2)
+{
+	jint *lparg1=NULL;
+	jfloat *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glPrioritizeTextures_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);
+	} else
+#endif
+	{
+		if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	}
+	glPrioritizeTextures(arg0, lparg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glPrioritizeTextures_FUNC);
+}
+#endif
+
+#ifndef NO_glPushAttrib
+JNIEXPORT void JNICALL GL_NATIVE(glPushAttrib)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glPushAttrib_FUNC);
+	glPushAttrib(arg0);
+	GL_NATIVE_EXIT(env, that, glPushAttrib_FUNC);
+}
+#endif
+
+#ifndef NO_glPushClientAttrib
+JNIEXPORT void JNICALL GL_NATIVE(glPushClientAttrib)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glPushClientAttrib_FUNC);
+	glPushClientAttrib(arg0);
+	GL_NATIVE_EXIT(env, that, glPushClientAttrib_FUNC);
+}
+#endif
+
+#ifndef NO_glPushMatrix
+JNIEXPORT void JNICALL GL_NATIVE(glPushMatrix)
+	(JNIEnv *env, jclass that)
+{
+	GL_NATIVE_ENTER(env, that, glPushMatrix_FUNC);
+	glPushMatrix();
+	GL_NATIVE_EXIT(env, that, glPushMatrix_FUNC);
+}
+#endif
+
+#ifndef NO_glPushName
+JNIEXPORT void JNICALL GL_NATIVE(glPushName)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glPushName_FUNC);
+	glPushName(arg0);
+	GL_NATIVE_EXIT(env, that, glPushName_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos2d
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)
+{
+	GL_NATIVE_ENTER(env, that, glRasterPos2d_FUNC);
+	glRasterPos2d(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glRasterPos2d_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos2dv
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glRasterPos2dv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	}
+	glRasterPos2dv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glRasterPos2dv_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos2f
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
+{
+	GL_NATIVE_ENTER(env, that, glRasterPos2f_FUNC);
+	glRasterPos2f(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glRasterPos2f_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos2fv
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glRasterPos2fv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glRasterPos2fv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glRasterPos2fv_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos2i
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	GL_NATIVE_ENTER(env, that, glRasterPos2i_FUNC);
+	glRasterPos2i(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glRasterPos2i_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos2iv
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glRasterPos2iv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	}
+	glRasterPos2iv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glRasterPos2iv_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos2s
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1)
+{
+	GL_NATIVE_ENTER(env, that, glRasterPos2s_FUNC);
+	glRasterPos2s(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glRasterPos2s_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos2sv
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glRasterPos2sv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	}
+	glRasterPos2sv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glRasterPos2sv_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos3d
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
+{
+	GL_NATIVE_ENTER(env, that, glRasterPos3d_FUNC);
+	glRasterPos3d(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glRasterPos3d_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos3dv
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glRasterPos3dv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	}
+	glRasterPos3dv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glRasterPos3dv_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos3f
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
+{
+	GL_NATIVE_ENTER(env, that, glRasterPos3f_FUNC);
+	glRasterPos3f(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glRasterPos3f_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos3fv
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glRasterPos3fv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glRasterPos3fv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glRasterPos3fv_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos3i
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	GL_NATIVE_ENTER(env, that, glRasterPos3i_FUNC);
+	glRasterPos3i(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glRasterPos3i_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos3iv
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glRasterPos3iv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	}
+	glRasterPos3iv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glRasterPos3iv_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos3s
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
+{
+	GL_NATIVE_ENTER(env, that, glRasterPos3s_FUNC);
+	glRasterPos3s(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glRasterPos3s_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos3sv
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glRasterPos3sv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	}
+	glRasterPos3sv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glRasterPos3sv_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos4d
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	GL_NATIVE_ENTER(env, that, glRasterPos4d_FUNC);
+	glRasterPos4d(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glRasterPos4d_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos4dv
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glRasterPos4dv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	}
+	glRasterPos4dv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glRasterPos4dv_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos4f
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
+{
+	GL_NATIVE_ENTER(env, that, glRasterPos4f_FUNC);
+	glRasterPos4f(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glRasterPos4f_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos4fv
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glRasterPos4fv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glRasterPos4fv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glRasterPos4fv_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos4i
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	GL_NATIVE_ENTER(env, that, glRasterPos4i_FUNC);
+	glRasterPos4i(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glRasterPos4i_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos4iv
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glRasterPos4iv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	}
+	glRasterPos4iv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glRasterPos4iv_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos4s
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
+{
+	GL_NATIVE_ENTER(env, that, glRasterPos4s_FUNC);
+	glRasterPos4s(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glRasterPos4s_FUNC);
+}
+#endif
+
+#ifndef NO_glRasterPos4sv
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glRasterPos4sv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	}
+	glRasterPos4sv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glRasterPos4sv_FUNC);
+}
+#endif
+
+#ifndef NO_glReadBuffer
+JNIEXPORT void JNICALL GL_NATIVE(glReadBuffer)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glReadBuffer_FUNC);
+	glReadBuffer(arg0);
+	GL_NATIVE_EXIT(env, that, glReadBuffer_FUNC);
+}
+#endif
+
+#ifndef NO_glReadPixels
+JNIEXPORT void JNICALL GL_NATIVE(glReadPixels)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jintArray arg6)
+{
+	jint *lparg6=NULL;
+	GL_NATIVE_ENTER(env, that, glReadPixels_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)->GetIntArrayElements(env, arg6, NULL);
+	}
+	glReadPixels(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)->ReleaseIntArrayElements(env, arg6, lparg6, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glReadPixels_FUNC);
+}
+#endif
+
+#ifndef NO_glRectd
+JNIEXPORT void JNICALL GL_NATIVE(glRectd)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	GL_NATIVE_ENTER(env, that, glRectd_FUNC);
+	glRectd(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glRectd_FUNC);
+}
+#endif
+
+#ifndef NO_glRectdv
+JNIEXPORT void JNICALL GL_NATIVE(glRectdv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0, jdoubleArray arg1)
+{
+	jdouble *lparg0=NULL;
+	jdouble *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glRectdv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+		if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);
+	}
+	glRectdv(lparg0, lparg1);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glRectdv_FUNC);
+}
+#endif
+
+#ifndef NO_glRectf
+JNIEXPORT void JNICALL GL_NATIVE(glRectf)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
+{
+	GL_NATIVE_ENTER(env, that, glRectf_FUNC);
+	glRectf(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glRectf_FUNC);
+}
+#endif
+
+#ifndef NO_glRectfv
+JNIEXPORT void JNICALL GL_NATIVE(glRectfv)
+	(JNIEnv *env, jclass that, jfloatArray arg0, jfloatArray arg1)
+{
+	jfloat *lparg0=NULL;
+	jfloat *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glRectfv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+		if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);
+	}
+	glRectfv(lparg0, lparg1);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glRectfv_FUNC);
+}
+#endif
+
+#ifndef NO_glRecti
+JNIEXPORT void JNICALL GL_NATIVE(glRecti)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	GL_NATIVE_ENTER(env, that, glRecti_FUNC);
+	glRecti(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glRecti_FUNC);
+}
+#endif
+
+#ifndef NO_glRectiv
+JNIEXPORT void JNICALL GL_NATIVE(glRectiv)
+	(JNIEnv *env, jclass that, jintArray arg0, jintArray arg1)
+{
+	jint *lparg0=NULL;
+	jint *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glRectiv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+		if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+	}
+	glRectiv(lparg0, lparg1);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glRectiv_FUNC);
+}
+#endif
+
+#ifndef NO_glRects
+JNIEXPORT void JNICALL GL_NATIVE(glRects)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
+{
+	GL_NATIVE_ENTER(env, that, glRects_FUNC);
+	glRects(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glRects_FUNC);
+}
+#endif
+
+#ifndef NO_glRectsv
+JNIEXPORT void JNICALL GL_NATIVE(glRectsv)
+	(JNIEnv *env, jclass that, jshortArray arg0, jshortArray arg1)
+{
+	jshort *lparg0=NULL;
+	jshort *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glRectsv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+		if (arg1) lparg1 = (*env)->GetShortArrayElements(env, arg1, NULL);
+	}
+	glRectsv(lparg0, lparg1);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg1) (*env)->ReleaseShortArrayElements(env, arg1, lparg1, 0);
+		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glRectsv_FUNC);
+}
+#endif
+
+#ifndef NO_glRenderMode
+JNIEXPORT jint JNICALL GL_NATIVE(glRenderMode)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	jint rc;
+	GL_NATIVE_ENTER(env, that, glRenderMode_FUNC);
+	rc = (jint)glRenderMode(arg0);
+	GL_NATIVE_EXIT(env, that, glRenderMode_FUNC);
+	return rc;
+}
+#endif
+
+#ifndef NO_glRotated
+JNIEXPORT void JNICALL GL_NATIVE(glRotated)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	GL_NATIVE_ENTER(env, that, glRotated_FUNC);
+	glRotated(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glRotated_FUNC);
+}
+#endif
+
+#ifndef NO_glRotatef
+JNIEXPORT void JNICALL GL_NATIVE(glRotatef)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
+{
+	GL_NATIVE_ENTER(env, that, glRotatef_FUNC);
+	glRotatef(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glRotatef_FUNC);
+}
+#endif
+
+#ifndef NO_glScaled
+JNIEXPORT void JNICALL GL_NATIVE(glScaled)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
+{
+	GL_NATIVE_ENTER(env, that, glScaled_FUNC);
+	glScaled(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glScaled_FUNC);
+}
+#endif
+
+#ifndef NO_glScalef
+JNIEXPORT void JNICALL GL_NATIVE(glScalef)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
+{
+	GL_NATIVE_ENTER(env, that, glScalef_FUNC);
+	glScalef(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glScalef_FUNC);
+}
+#endif
+
+#ifndef NO_glScissor
+JNIEXPORT void JNICALL GL_NATIVE(glScissor)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	GL_NATIVE_ENTER(env, that, glScissor_FUNC);
+	glScissor(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glScissor_FUNC);
+}
+#endif
+
+#ifndef NO_glSelectBuffer
+JNIEXPORT void JNICALL GL_NATIVE(glSelectBuffer)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
+{
+	jint *lparg1=NULL;
+	GL_NATIVE_ENTER(env, that, glSelectBuffer_FUNC);
+	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+	glSelectBuffer(arg0, lparg1);
+	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+	GL_NATIVE_EXIT(env, that, glSelectBuffer_FUNC);
+}
+#endif
+
+#ifndef NO_glShadeModel
+JNIEXPORT void JNICALL GL_NATIVE(glShadeModel)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glShadeModel_FUNC);
+	glShadeModel(arg0);
+	GL_NATIVE_EXIT(env, that, glShadeModel_FUNC);
+}
+#endif
+
+#ifndef NO_glStencilFunc
+JNIEXPORT void JNICALL GL_NATIVE(glStencilFunc)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	GL_NATIVE_ENTER(env, that, glStencilFunc_FUNC);
+	glStencilFunc(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glStencilFunc_FUNC);
+}
+#endif
+
+#ifndef NO_glStencilMask
+JNIEXPORT void JNICALL GL_NATIVE(glStencilMask)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glStencilMask_FUNC);
+	glStencilMask(arg0);
+	GL_NATIVE_EXIT(env, that, glStencilMask_FUNC);
+}
+#endif
+
+#ifndef NO_glStencilOp
+JNIEXPORT void JNICALL GL_NATIVE(glStencilOp)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	GL_NATIVE_ENTER(env, that, glStencilOp_FUNC);
+	glStencilOp(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glStencilOp_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord1d
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1d)
+	(JNIEnv *env, jclass that, jdouble arg0)
+{
+	GL_NATIVE_ENTER(env, that, glTexCoord1d_FUNC);
+	glTexCoord1d(arg0);
+	GL_NATIVE_EXIT(env, that, glTexCoord1d_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord1dv
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glTexCoord1dv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	}
+	glTexCoord1dv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexCoord1dv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord1f
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1f)
+	(JNIEnv *env, jclass that, jfloat arg0)
+{
+	GL_NATIVE_ENTER(env, that, glTexCoord1f_FUNC);
+	glTexCoord1f(arg0);
+	GL_NATIVE_EXIT(env, that, glTexCoord1f_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord1fv
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glTexCoord1fv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glTexCoord1fv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexCoord1fv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord1i
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1i)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	GL_NATIVE_ENTER(env, that, glTexCoord1i_FUNC);
+	glTexCoord1i(arg0);
+	GL_NATIVE_EXIT(env, that, glTexCoord1i_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord1iv
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glTexCoord1iv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	}
+	glTexCoord1iv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexCoord1iv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord1s
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1s)
+	(JNIEnv *env, jclass that, jshort arg0)
+{
+	GL_NATIVE_ENTER(env, that, glTexCoord1s_FUNC);
+	glTexCoord1s(arg0);
+	GL_NATIVE_EXIT(env, that, glTexCoord1s_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord1sv
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glTexCoord1sv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	}
+	glTexCoord1sv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexCoord1sv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord2d
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)
+{
+	GL_NATIVE_ENTER(env, that, glTexCoord2d_FUNC);
+	glTexCoord2d(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glTexCoord2d_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord2dv
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glTexCoord2dv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	}
+	glTexCoord2dv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexCoord2dv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord2f
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
+{
+	GL_NATIVE_ENTER(env, that, glTexCoord2f_FUNC);
+	glTexCoord2f(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glTexCoord2f_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord2fv
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glTexCoord2fv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glTexCoord2fv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexCoord2fv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord2i
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	GL_NATIVE_ENTER(env, that, glTexCoord2i_FUNC);
+	glTexCoord2i(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glTexCoord2i_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord2iv
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glTexCoord2iv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	}
+	glTexCoord2iv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexCoord2iv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord2s
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1)
+{
+	GL_NATIVE_ENTER(env, that, glTexCoord2s_FUNC);
+	glTexCoord2s(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glTexCoord2s_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord2sv
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glTexCoord2sv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	}
+	glTexCoord2sv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexCoord2sv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord3d
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
+{
+	GL_NATIVE_ENTER(env, that, glTexCoord3d_FUNC);
+	glTexCoord3d(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glTexCoord3d_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord3dv
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glTexCoord3dv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	}
+	glTexCoord3dv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexCoord3dv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord3f
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
+{
+	GL_NATIVE_ENTER(env, that, glTexCoord3f_FUNC);
+	glTexCoord3f(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glTexCoord3f_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord3fv
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glTexCoord3fv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glTexCoord3fv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexCoord3fv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord3i
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	GL_NATIVE_ENTER(env, that, glTexCoord3i_FUNC);
+	glTexCoord3i(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glTexCoord3i_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord3iv
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glTexCoord3iv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	}
+	glTexCoord3iv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexCoord3iv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord3s
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
+{
+	GL_NATIVE_ENTER(env, that, glTexCoord3s_FUNC);
+	glTexCoord3s(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glTexCoord3s_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord3sv
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glTexCoord3sv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	}
+	glTexCoord3sv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexCoord3sv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord4d
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	GL_NATIVE_ENTER(env, that, glTexCoord4d_FUNC);
+	glTexCoord4d(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glTexCoord4d_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord4dv
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glTexCoord4dv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	}
+	glTexCoord4dv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexCoord4dv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord4f
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
+{
+	GL_NATIVE_ENTER(env, that, glTexCoord4f_FUNC);
+	glTexCoord4f(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glTexCoord4f_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord4fv
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glTexCoord4fv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glTexCoord4fv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexCoord4fv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord4i
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	GL_NATIVE_ENTER(env, that, glTexCoord4i_FUNC);
+	glTexCoord4i(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glTexCoord4i_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord4iv
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glTexCoord4iv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	}
+	glTexCoord4iv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexCoord4iv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord4s
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
+{
+	GL_NATIVE_ENTER(env, that, glTexCoord4s_FUNC);
+	glTexCoord4s(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glTexCoord4s_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoord4sv
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glTexCoord4sv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	}
+	glTexCoord4sv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexCoord4sv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexCoordPointer
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoordPointer)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)
+{
+	jint *lparg3=NULL;
+	GL_NATIVE_ENTER(env, that, glTexCoordPointer_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
+	} else
+#endif
+	{
+		if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
+	}
+	glTexCoordPointer(arg0, arg1, arg2, lparg3);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
+	} else
+#endif
+	{
+		if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexCoordPointer_FUNC);
+}
+#endif
+
+#ifndef NO_glTexEnvf
+JNIEXPORT void JNICALL GL_NATIVE(glTexEnvf)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
+{
+	GL_NATIVE_ENTER(env, that, glTexEnvf_FUNC);
+	glTexEnvf(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glTexEnvf_FUNC);
+}
+#endif
+
+#ifndef NO_glTexEnvfv
+JNIEXPORT void JNICALL GL_NATIVE(glTexEnvfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glTexEnvfv_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);
+	}
+	glTexEnvfv(arg0, arg1, lparg2);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glTexEnvfv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexEnvi
+JNIEXPORT void JNICALL GL_NATIVE(glTexEnvi)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	GL_NATIVE_ENTER(env, that, glTexEnvi_FUNC);
+	glTexEnvi(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glTexEnvi_FUNC);
+}
+#endif
+
+#ifndef NO_glTexEnviv
+JNIEXPORT void JNICALL GL_NATIVE(glTexEnviv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glTexEnviv_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)->GetIntArrayElements(env, arg2, NULL);
+	}
+	glTexEnviv(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexEnviv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexGend
+JNIEXPORT void JNICALL GL_NATIVE(glTexGend)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdouble arg2)
+{
+	GL_NATIVE_ENTER(env, that, glTexGend_FUNC);
+	glTexGend(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glTexGend_FUNC);
+}
+#endif
+
+#ifndef NO_glTexGendv
+JNIEXPORT void JNICALL GL_NATIVE(glTexGendv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2)
+{
+	jdouble *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glTexGendv_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);
+	}
+	glTexGendv(arg0, arg1, lparg2);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glTexGendv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexGenf
+JNIEXPORT void JNICALL GL_NATIVE(glTexGenf)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
+{
+	GL_NATIVE_ENTER(env, that, glTexGenf_FUNC);
+	glTexGenf(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glTexGenf_FUNC);
+}
+#endif
+
+#ifndef NO_glTexGenfv
+JNIEXPORT void JNICALL GL_NATIVE(glTexGenfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glTexGenfv_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);
+	}
+	glTexGenfv(arg0, arg1, lparg2);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glTexGenfv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexGeni
+JNIEXPORT void JNICALL GL_NATIVE(glTexGeni)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	GL_NATIVE_ENTER(env, that, glTexGeni_FUNC);
+	glTexGeni(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glTexGeni_FUNC);
+}
+#endif
+
+#ifndef NO_glTexGeniv
+JNIEXPORT void JNICALL GL_NATIVE(glTexGeniv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glTexGeniv_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)->GetIntArrayElements(env, arg2, NULL);
+	}
+	glTexGeniv(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexGeniv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexImage1D
+JNIEXPORT void JNICALL GL_NATIVE(glTexImage1D)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jintArray arg7)
+{
+	jint *lparg7=NULL;
+	GL_NATIVE_ENTER(env, that, glTexImage1D_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg7) lparg7 = (*env)->GetPrimitiveArrayCritical(env, arg7, NULL);
+	} else
+#endif
+	{
+		if (arg7) lparg7 = (*env)->GetIntArrayElements(env, arg7, NULL);
+	}
+	glTexImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, lparg7);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg7) (*env)->ReleasePrimitiveArrayCritical(env, arg7, lparg7, 0);
+	} else
+#endif
+	{
+		if (arg7) (*env)->ReleaseIntArrayElements(env, arg7, lparg7, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexImage1D_FUNC);
+}
+#endif
+
+#ifndef NO_glTexImage2D
+JNIEXPORT void JNICALL GL_NATIVE(glTexImage2D)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7, jbyteArray arg8)
+{
+	jbyte *lparg8=NULL;
+	GL_NATIVE_ENTER(env, that, glTexImage2D_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg8) lparg8 = (*env)->GetPrimitiveArrayCritical(env, arg8, NULL);
+	} else
+#endif
+	{
+		if (arg8) lparg8 = (*env)->GetByteArrayElements(env, arg8, NULL);
+	}
+	glTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, lparg8);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg8) (*env)->ReleasePrimitiveArrayCritical(env, arg8, lparg8, 0);
+	} else
+#endif
+	{
+		if (arg8) (*env)->ReleaseByteArrayElements(env, arg8, lparg8, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexImage2D_FUNC);
+}
+#endif
+
+#ifndef NO_glTexParameterf
+JNIEXPORT void JNICALL GL_NATIVE(glTexParameterf)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
+{
+	GL_NATIVE_ENTER(env, that, glTexParameterf_FUNC);
+	glTexParameterf(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glTexParameterf_FUNC);
+}
+#endif
+
+#ifndef NO_glTexParameterfv
+JNIEXPORT void JNICALL GL_NATIVE(glTexParameterfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glTexParameterfv_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);
+	}
+	glTexParameterfv(arg0, arg1, lparg2);
+#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);
+	}
+	GL_NATIVE_EXIT(env, that, glTexParameterfv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexParameteri
+JNIEXPORT void JNICALL GL_NATIVE(glTexParameteri)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	GL_NATIVE_ENTER(env, that, glTexParameteri_FUNC);
+	glTexParameteri(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glTexParameteri_FUNC);
+}
+#endif
+
+#ifndef NO_glTexParameteriv
+JNIEXPORT void JNICALL GL_NATIVE(glTexParameteriv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+	GL_NATIVE_ENTER(env, that, glTexParameteriv_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)->GetIntArrayElements(env, arg2, NULL);
+	}
+	glTexParameteriv(arg0, arg1, lparg2);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+	} else
+#endif
+	{
+		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexParameteriv_FUNC);
+}
+#endif
+
+#ifndef NO_glTexSubImage1D
+JNIEXPORT void JNICALL GL_NATIVE(glTexSubImage1D)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jintArray arg6)
+{
+	jint *lparg6=NULL;
+	GL_NATIVE_ENTER(env, that, glTexSubImage1D_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)->GetIntArrayElements(env, arg6, NULL);
+	}
+	glTexSubImage1D(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)->ReleaseIntArrayElements(env, arg6, lparg6, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexSubImage1D_FUNC);
+}
+#endif
+
+#ifndef NO_glTexSubImage2D
+JNIEXPORT void JNICALL GL_NATIVE(glTexSubImage2D)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7, jintArray arg8)
+{
+	jint *lparg8=NULL;
+	GL_NATIVE_ENTER(env, that, glTexSubImage2D_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg8) lparg8 = (*env)->GetPrimitiveArrayCritical(env, arg8, NULL);
+	} else
+#endif
+	{
+		if (arg8) lparg8 = (*env)->GetIntArrayElements(env, arg8, NULL);
+	}
+	glTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, lparg8);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg8) (*env)->ReleasePrimitiveArrayCritical(env, arg8, lparg8, 0);
+	} else
+#endif
+	{
+		if (arg8) (*env)->ReleaseIntArrayElements(env, arg8, lparg8, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glTexSubImage2D_FUNC);
+}
+#endif
+
+#ifndef NO_glTranslated
+JNIEXPORT void JNICALL GL_NATIVE(glTranslated)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
+{
+	GL_NATIVE_ENTER(env, that, glTranslated_FUNC);
+	glTranslated(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glTranslated_FUNC);
+}
+#endif
+
+#ifndef NO_glTranslatef
+JNIEXPORT void JNICALL GL_NATIVE(glTranslatef)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
+{
+	GL_NATIVE_ENTER(env, that, glTranslatef_FUNC);
+	glTranslatef(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glTranslatef_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex2d
+JNIEXPORT void JNICALL GL_NATIVE(glVertex2d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)
+{
+	GL_NATIVE_ENTER(env, that, glVertex2d_FUNC);
+	glVertex2d(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glVertex2d_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex2dv
+JNIEXPORT void JNICALL GL_NATIVE(glVertex2dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glVertex2dv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	}
+	glVertex2dv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glVertex2dv_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex2f
+JNIEXPORT void JNICALL GL_NATIVE(glVertex2f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
+{
+	GL_NATIVE_ENTER(env, that, glVertex2f_FUNC);
+	glVertex2f(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glVertex2f_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex2fv
+JNIEXPORT void JNICALL GL_NATIVE(glVertex2fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glVertex2fv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glVertex2fv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glVertex2fv_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex2i
+JNIEXPORT void JNICALL GL_NATIVE(glVertex2i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	GL_NATIVE_ENTER(env, that, glVertex2i_FUNC);
+	glVertex2i(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glVertex2i_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex2iv
+JNIEXPORT void JNICALL GL_NATIVE(glVertex2iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glVertex2iv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	}
+	glVertex2iv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glVertex2iv_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex2s
+JNIEXPORT void JNICALL GL_NATIVE(glVertex2s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1)
+{
+	GL_NATIVE_ENTER(env, that, glVertex2s_FUNC);
+	glVertex2s(arg0, arg1);
+	GL_NATIVE_EXIT(env, that, glVertex2s_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex2sv
+JNIEXPORT void JNICALL GL_NATIVE(glVertex2sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glVertex2sv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	}
+	glVertex2sv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glVertex2sv_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex3d
+JNIEXPORT void JNICALL GL_NATIVE(glVertex3d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
+{
+	GL_NATIVE_ENTER(env, that, glVertex3d_FUNC);
+	glVertex3d(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glVertex3d_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex3dv
+JNIEXPORT void JNICALL GL_NATIVE(glVertex3dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glVertex3dv_FUNC);
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glVertex3dv(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	GL_NATIVE_EXIT(env, that, glVertex3dv_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex3f
+JNIEXPORT void JNICALL GL_NATIVE(glVertex3f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
+{
+	GL_NATIVE_ENTER(env, that, glVertex3f_FUNC);
+	glVertex3f(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glVertex3f_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex3fv
+JNIEXPORT void JNICALL GL_NATIVE(glVertex3fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glVertex3fv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glVertex3fv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glVertex3fv_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex3i
+JNIEXPORT void JNICALL GL_NATIVE(glVertex3i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	GL_NATIVE_ENTER(env, that, glVertex3i_FUNC);
+	glVertex3i(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glVertex3i_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex3iv
+JNIEXPORT void JNICALL GL_NATIVE(glVertex3iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glVertex3iv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	}
+	glVertex3iv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glVertex3iv_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex3s
+JNIEXPORT void JNICALL GL_NATIVE(glVertex3s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
+{
+	GL_NATIVE_ENTER(env, that, glVertex3s_FUNC);
+	glVertex3s(arg0, arg1, arg2);
+	GL_NATIVE_EXIT(env, that, glVertex3s_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex3sv
+JNIEXPORT void JNICALL GL_NATIVE(glVertex3sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glVertex3sv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	}
+	glVertex3sv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glVertex3sv_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex4d
+JNIEXPORT void JNICALL GL_NATIVE(glVertex4d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	GL_NATIVE_ENTER(env, that, glVertex4d_FUNC);
+	glVertex4d(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glVertex4d_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex4dv
+JNIEXPORT void JNICALL GL_NATIVE(glVertex4dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glVertex4dv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	}
+	glVertex4dv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glVertex4dv_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex4f
+JNIEXPORT void JNICALL GL_NATIVE(glVertex4f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
+{
+	GL_NATIVE_ENTER(env, that, glVertex4f_FUNC);
+	glVertex4f(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glVertex4f_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex4fv
+JNIEXPORT void JNICALL GL_NATIVE(glVertex4fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glVertex4fv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	}
+	glVertex4fv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glVertex4fv_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex4i
+JNIEXPORT void JNICALL GL_NATIVE(glVertex4i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	GL_NATIVE_ENTER(env, that, glVertex4i_FUNC);
+	glVertex4i(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glVertex4i_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex4iv
+JNIEXPORT void JNICALL GL_NATIVE(glVertex4iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glVertex4iv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	}
+	glVertex4iv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glVertex4iv_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex4s
+JNIEXPORT void JNICALL GL_NATIVE(glVertex4s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
+{
+	GL_NATIVE_ENTER(env, that, glVertex4s_FUNC);
+	glVertex4s(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glVertex4s_FUNC);
+}
+#endif
+
+#ifndef NO_glVertex4sv
+JNIEXPORT void JNICALL GL_NATIVE(glVertex4sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+	GL_NATIVE_ENTER(env, that, glVertex4sv_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
+	} else
+#endif
+	{
+		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	}
+	glVertex4sv(lparg0);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
+	} else
+#endif
+	{
+		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glVertex4sv_FUNC);
+}
+#endif
+
+#ifndef NO_glVertexPointer
+JNIEXPORT void JNICALL GL_NATIVE(glVertexPointer)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)
+{
+	jint *lparg3=NULL;
+	GL_NATIVE_ENTER(env, that, glVertexPointer_FUNC);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
+	} else
+#endif
+	{
+		if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
+	}
+	glVertexPointer(arg0, arg1, arg2, lparg3);
+#ifdef JNI_VERSION_1_2
+	if (IS_JNI_1_2) {
+		if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
+	} else
+#endif
+	{
+		if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
+	}
+	GL_NATIVE_EXIT(env, that, glVertexPointer_FUNC);
+}
+#endif
+
+#ifndef NO_glViewport
+JNIEXPORT void JNICALL GL_NATIVE(glViewport)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	GL_NATIVE_ENTER(env, that, glViewport_FUNC);
+	glViewport(arg0, arg1, arg2, arg3);
+	GL_NATIVE_EXIT(env, that, glViewport_FUNC);
+}
+#endif
+
diff --git a/bundles/org.eclipse.swt.opengl/common/library/glu.c b/bundles/org.eclipse.swt.opengl/common/library/glu.c
index eabf63a9fa..5f49ee97e6 100644
--- a/bundles/org.eclipse.swt.opengl/common/library/glu.c
+++ b/bundles/org.eclipse.swt.opengl/common/library/glu.c
@@ -1,546 +1,546 @@
-/*******************************************************************************

- * 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"

-

-#define GLU_NATIVE(func) Java_org_eclipse_swt_opengl_GLU_##func

-

-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")

-}

-

-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")

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluBeginSurface)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "gluBeginSurface\n")

-	gluBeginSurface((GLUnurbs *)arg0);

-	NATIVE_EXIT(env, that, "gluBeginSurface\n")

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluBeginTrim)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "gluBeginTrim\n")

-	gluBeginTrim((GLUnurbs *)arg0);

-	NATIVE_EXIT(env, that, "gluBeginTrim\n")

-}

-

-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")

-	rc = (jint)gluBuild1DMipmaps(arg0, arg1, arg2, arg3, arg4, (const void *)arg5);

-	NATIVE_EXIT(env, that, "gluBuild1DMipmaps\n")

-	return rc;

-}

-

-/*

-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;

-}

-*/

-

-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")

-	return rc;

-}

-

-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")

-	gluCylinder((GLUquadric *)arg0, arg1, arg2, arg3, arg4, arg5);

-	NATIVE_EXIT(env, that, "gluCylinder\n")

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluDeleteNurbsRenderer)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "gluDeleteNurbsRenderer\n")

-	gluDeleteNurbsRenderer((GLUnurbs *)arg0);

-	NATIVE_EXIT(env, that, "gluDeleteNurbsRenderer\n")

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluDeleteQuadric)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "gluDeleteQuadric\n")

-	gluDeleteQuadric((GLUquadric *)arg0);

-	NATIVE_EXIT(env, that, "gluDeleteQuadric\n")

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluDeleteTess)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "gluDeleteTess\n")

-	gluDeleteTess((GLUtesselator *)arg0);

-	NATIVE_EXIT(env, that, "gluDeleteTess\n")

-}

-

-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")

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluEndCurve)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "gluEndCurve\n")

-	gluEndCurve((GLUnurbsObj *)arg0);

-	NATIVE_EXIT(env, that, "gluEndCurve\n")

-}

-

-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")

-}

-

-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")

-}

-

-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")

-}

-

-JNIEXPORT jint JNICALL GLU_NATIVE(gluErrorString)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-    jint rc;

-	NATIVE_ENTER(env, that, "gluErrorString\n")

-	rc = (jint)gluErrorString(arg0);

-	NATIVE_EXIT(env, that, "gluErrorString\n")

-	return rc;

-}

-

-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);

-	gluGetNurbsProperty((GLUnurbs *)arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "gluGetNurbsProperty\n")

-}

-

-JNIEXPORT jint JNICALL GLU_NATIVE(gluGetString)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-    jint rc;

-	NATIVE_ENTER(env, that, "gluGetString\n")

-	rc = (jint)gluGetString(arg0);

-	NATIVE_EXIT(env, that, "gluGetString\n")

-	return rc;

-}

-

-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);

-	gluGetTessProperty((GLUtesselator *)arg0, arg1, lparg2);

-	if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "gluGetTessProperty\n")

-}

-

-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")

-}

-

-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")

-	gluLookAt(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);

-	NATIVE_EXIT(env, that, "gluLookAt\n")

-}

-

-JNIEXPORT jint JNICALL GLU_NATIVE(gluNewNurbsRenderer)

-	(JNIEnv *env, jclass that)

-{

-    jint rc;

-	NATIVE_ENTER(env, that, "gluNewNurbsRenderer\n")

-	rc = (jint)gluNewNurbsRenderer();

-	NATIVE_EXIT(env, that, "gluNewNurbsRenderer\n")

-	return rc;

-}

-

-JNIEXPORT jint JNICALL GLU_NATIVE(gluNewQuadric)

-	(JNIEnv *env, jclass that)

-{

-    jint rc;

-	NATIVE_ENTER(env, that, "gluNewQuadric\n")

-	rc = (jint)gluNewQuadric();

-	NATIVE_EXIT(env, that, "gluNewQuadric\n")

-	return rc;

-}

-

-JNIEXPORT jint JNICALL GLU_NATIVE(gluNewTess)

-	(JNIEnv *env, jclass that)

-{

-    jint rc;

-	NATIVE_ENTER(env, that, "gluNewTess\n")

-	rc = (jint)gluNewTess();

-	NATIVE_EXIT(env, that, "gluNewTess\n")

-	return rc;

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluNextContour)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	NATIVE_ENTER(env, that, "gluNextContour\n")

-	gluNextContour((GLUtesselator *)arg0, arg1);

-	NATIVE_EXIT(env, that, "gluNextContour\n")

-}

-

-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")

-}

-

-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);

-	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")

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluNurbsProperty)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)

-{

-	NATIVE_ENTER(env, that, "gluNurbsProperty\n")

-	gluNurbsProperty((GLUnurbs *)arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "gluNurbsProperty\n")

-}

-

-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")

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluOrtho2D)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)

-{

-	NATIVE_ENTER(env, that, "gluOrtho2D\n")

-	gluOrtho2D(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "gluOrtho2D\n")

-}

-

-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")

-	gluPartialDisk((GLUquadric *)arg0, arg1, arg2, arg3, arg4, arg5, arg6);

-	NATIVE_EXIT(env, that, "gluPartialDisk\n")

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluPerspective)

-	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)

-{

-	NATIVE_ENTER(env, that, "gluPerspective\n")

-	gluPerspective(arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "gluPerspective\n")

-}

-

-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")

-}

-

-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)

-{

-	jdouble *lparg3=NULL;

-	jdouble *lparg4=NULL;

-	jint *lparg5=NULL;

-	jdouble *lparg6=NULL;

-	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")

-	return rc;

-}

-

-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);

-	gluPwlCurve((GLUnurbs *)arg0, arg1, lparg2, arg3, arg4);

-	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);

-	NATIVE_EXIT(env, that, "gluPwlCurve\n")

-}

-

-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")

-}

-

-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")

-}

-

-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")

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricOrientation)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	NATIVE_ENTER(env, that, "gluQuadricOrientation\n")

-	gluQuadricOrientation((GLUquadric *)arg0, arg1);

-	NATIVE_EXIT(env, that, "gluQuadricOrientation\n")

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricTexture)

-	(JNIEnv *env, jclass that, jint arg0, jboolean arg1)

-{

-	NATIVE_ENTER(env, that, "gluQuadricTexture\n")

-	gluQuadricTexture((GLUquadric *)arg0, arg1);

-	NATIVE_EXIT(env, that, "gluQuadricTexture\n")

-}

-

-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")

-	rc = (jint)gluScaleImage(arg0, arg1, arg2, arg3, (const void *)arg4, arg5, arg6, arg7, (void *)arg8);

-	NATIVE_EXIT(env, that, "gluScaleImage\n")

-	return rc;

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluSphere)

-	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jint arg2, jint arg3)

-{

-	NATIVE_ENTER(env, that, "gluSphere\n")

-	gluSphere((GLUquadric *)arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "gluSphere\n")

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluTessBeginContour)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "gluTessBeginContour\n")

-	gluTessBeginContour((GLUtesselator *)arg0);

-	NATIVE_EXIT(env, that, "gluTessBeginContour\n")

-}

-

-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")

-}

-

-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")

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluTessEndContour)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "gluTessEndContour\n")

-	gluTessEndContour((GLUtesselator *)arg0);

-	NATIVE_EXIT(env, that, "gluTessEndContour\n")

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluTessEndPolygon)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	NATIVE_ENTER(env, that, "gluTessEndPolygon\n")

-	gluTessEndPolygon((GLUtesselator *)arg0);

-	NATIVE_EXIT(env, that, "gluTessEndPolygon\n")

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluTessNormal)

-	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jdouble arg3)

-{

-	NATIVE_ENTER(env, that, "gluTessNormal\n")

-	gluTessNormal((GLUtesselator *)arg0, arg1, arg2, arg3);

-	NATIVE_EXIT(env, that, "gluTessNormal\n")

-}

-

-JNIEXPORT void JNICALL GLU_NATIVE(gluTessProperty)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)

-{

-	NATIVE_ENTER(env, that, "gluTessProperty\n")

-	gluTessProperty((GLUtesselator *)arg0, arg1, arg2);

-	NATIVE_EXIT(env, that, "gluTessProperty\n")

-}

-

-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")

-}

-

-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)

-{

-	jdouble *lparg3=NULL;

-	jdouble *lparg4=NULL;

-	jint *lparg5=NULL;

-	jdouble *lparg6=NULL;

-	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")

-	return rc;

-}

+/*******************************************************************************
+ * 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"
+
+#define GLU_NATIVE(func) Java_org_eclipse_swt_opengl_GLU_##func
+
+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")
+}
+
+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")
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluBeginSurface)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	NATIVE_ENTER(env, that, "gluBeginSurface\n")
+	gluBeginSurface((GLUnurbs *)arg0);
+	NATIVE_EXIT(env, that, "gluBeginSurface\n")
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluBeginTrim)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	NATIVE_ENTER(env, that, "gluBeginTrim\n")
+	gluBeginTrim((GLUnurbs *)arg0);
+	NATIVE_EXIT(env, that, "gluBeginTrim\n")
+}
+
+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")
+	rc = (jint)gluBuild1DMipmaps(arg0, arg1, arg2, arg3, arg4, (const void *)arg5);
+	NATIVE_EXIT(env, that, "gluBuild1DMipmaps\n")
+	return rc;
+}
+
+/*
+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;
+}
+*/
+
+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")
+	return rc;
+}
+
+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")
+	gluCylinder((GLUquadric *)arg0, arg1, arg2, arg3, arg4, arg5);
+	NATIVE_EXIT(env, that, "gluCylinder\n")
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluDeleteNurbsRenderer)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	NATIVE_ENTER(env, that, "gluDeleteNurbsRenderer\n")
+	gluDeleteNurbsRenderer((GLUnurbs *)arg0);
+	NATIVE_EXIT(env, that, "gluDeleteNurbsRenderer\n")
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluDeleteQuadric)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	NATIVE_ENTER(env, that, "gluDeleteQuadric\n")
+	gluDeleteQuadric((GLUquadric *)arg0);
+	NATIVE_EXIT(env, that, "gluDeleteQuadric\n")
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluDeleteTess)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	NATIVE_ENTER(env, that, "gluDeleteTess\n")
+	gluDeleteTess((GLUtesselator *)arg0);
+	NATIVE_EXIT(env, that, "gluDeleteTess\n")
+}
+
+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")
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluEndCurve)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	NATIVE_ENTER(env, that, "gluEndCurve\n")
+	gluEndCurve((GLUnurbsObj *)arg0);
+	NATIVE_EXIT(env, that, "gluEndCurve\n")
+}
+
+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")
+}
+
+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")
+}
+
+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")
+}
+
+JNIEXPORT jint JNICALL GLU_NATIVE(gluErrorString)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+    jint rc;
+	NATIVE_ENTER(env, that, "gluErrorString\n")
+	rc = (jint)gluErrorString(arg0);
+	NATIVE_EXIT(env, that, "gluErrorString\n")
+	return rc;
+}
+
+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);
+	gluGetNurbsProperty((GLUnurbs *)arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+	NATIVE_EXIT(env, that, "gluGetNurbsProperty\n")
+}
+
+JNIEXPORT jint JNICALL GLU_NATIVE(gluGetString)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+    jint rc;
+	NATIVE_ENTER(env, that, "gluGetString\n")
+	rc = (jint)gluGetString(arg0);
+	NATIVE_EXIT(env, that, "gluGetString\n")
+	return rc;
+}
+
+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);
+	gluGetTessProperty((GLUtesselator *)arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0);
+	NATIVE_EXIT(env, that, "gluGetTessProperty\n")
+}
+
+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")
+}
+
+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")
+	gluLookAt(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+	NATIVE_EXIT(env, that, "gluLookAt\n")
+}
+
+JNIEXPORT jint JNICALL GLU_NATIVE(gluNewNurbsRenderer)
+	(JNIEnv *env, jclass that)
+{
+    jint rc;
+	NATIVE_ENTER(env, that, "gluNewNurbsRenderer\n")
+	rc = (jint)gluNewNurbsRenderer();
+	NATIVE_EXIT(env, that, "gluNewNurbsRenderer\n")
+	return rc;
+}
+
+JNIEXPORT jint JNICALL GLU_NATIVE(gluNewQuadric)
+	(JNIEnv *env, jclass that)
+{
+    jint rc;
+	NATIVE_ENTER(env, that, "gluNewQuadric\n")
+	rc = (jint)gluNewQuadric();
+	NATIVE_EXIT(env, that, "gluNewQuadric\n")
+	return rc;
+}
+
+JNIEXPORT jint JNICALL GLU_NATIVE(gluNewTess)
+	(JNIEnv *env, jclass that)
+{
+    jint rc;
+	NATIVE_ENTER(env, that, "gluNewTess\n")
+	rc = (jint)gluNewTess();
+	NATIVE_EXIT(env, that, "gluNewTess\n")
+	return rc;
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluNextContour)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	NATIVE_ENTER(env, that, "gluNextContour\n")
+	gluNextContour((GLUtesselator *)arg0, arg1);
+	NATIVE_EXIT(env, that, "gluNextContour\n")
+}
+
+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")
+}
+
+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);
+	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")
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluNurbsProperty)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
+{
+	NATIVE_ENTER(env, that, "gluNurbsProperty\n")
+	gluNurbsProperty((GLUnurbs *)arg0, arg1, arg2);
+	NATIVE_EXIT(env, that, "gluNurbsProperty\n")
+}
+
+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")
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluOrtho2D)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	NATIVE_ENTER(env, that, "gluOrtho2D\n")
+	gluOrtho2D(arg0, arg1, arg2, arg3);
+	NATIVE_EXIT(env, that, "gluOrtho2D\n")
+}
+
+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")
+	gluPartialDisk((GLUquadric *)arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+	NATIVE_EXIT(env, that, "gluPartialDisk\n")
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluPerspective)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	NATIVE_ENTER(env, that, "gluPerspective\n")
+	gluPerspective(arg0, arg1, arg2, arg3);
+	NATIVE_EXIT(env, that, "gluPerspective\n")
+}
+
+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")
+}
+
+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)
+{
+	jdouble *lparg3=NULL;
+	jdouble *lparg4=NULL;
+	jint *lparg5=NULL;
+	jdouble *lparg6=NULL;
+	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")
+	return rc;
+}
+
+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);
+	gluPwlCurve((GLUnurbs *)arg0, arg1, lparg2, arg3, arg4);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+	NATIVE_EXIT(env, that, "gluPwlCurve\n")
+}
+
+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")
+}
+
+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")
+}
+
+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")
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricOrientation)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	NATIVE_ENTER(env, that, "gluQuadricOrientation\n")
+	gluQuadricOrientation((GLUquadric *)arg0, arg1);
+	NATIVE_EXIT(env, that, "gluQuadricOrientation\n")
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricTexture)
+	(JNIEnv *env, jclass that, jint arg0, jboolean arg1)
+{
+	NATIVE_ENTER(env, that, "gluQuadricTexture\n")
+	gluQuadricTexture((GLUquadric *)arg0, arg1);
+	NATIVE_EXIT(env, that, "gluQuadricTexture\n")
+}
+
+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")
+	rc = (jint)gluScaleImage(arg0, arg1, arg2, arg3, (const void *)arg4, arg5, arg6, arg7, (void *)arg8);
+	NATIVE_EXIT(env, that, "gluScaleImage\n")
+	return rc;
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluSphere)
+	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jint arg2, jint arg3)
+{
+	NATIVE_ENTER(env, that, "gluSphere\n")
+	gluSphere((GLUquadric *)arg0, arg1, arg2, arg3);
+	NATIVE_EXIT(env, that, "gluSphere\n")
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluTessBeginContour)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	NATIVE_ENTER(env, that, "gluTessBeginContour\n")
+	gluTessBeginContour((GLUtesselator *)arg0);
+	NATIVE_EXIT(env, that, "gluTessBeginContour\n")
+}
+
+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")
+}
+
+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")
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluTessEndContour)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	NATIVE_ENTER(env, that, "gluTessEndContour\n")
+	gluTessEndContour((GLUtesselator *)arg0);
+	NATIVE_EXIT(env, that, "gluTessEndContour\n")
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluTessEndPolygon)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	NATIVE_ENTER(env, that, "gluTessEndPolygon\n")
+	gluTessEndPolygon((GLUtesselator *)arg0);
+	NATIVE_EXIT(env, that, "gluTessEndPolygon\n")
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluTessNormal)
+	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	NATIVE_ENTER(env, that, "gluTessNormal\n")
+	gluTessNormal((GLUtesselator *)arg0, arg1, arg2, arg3);
+	NATIVE_EXIT(env, that, "gluTessNormal\n")
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluTessProperty)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
+{
+	NATIVE_ENTER(env, that, "gluTessProperty\n")
+	gluTessProperty((GLUtesselator *)arg0, arg1, arg2);
+	NATIVE_EXIT(env, that, "gluTessProperty\n")
+}
+
+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")
+}
+
+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)
+{
+	jdouble *lparg3=NULL;
+	jdouble *lparg4=NULL;
+	jint *lparg5=NULL;
+	jdouble *lparg6=NULL;
+	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")
+	return rc;
+}
diff --git a/bundles/org.eclipse.swt.opengl/common/library/swt.h b/bundles/org.eclipse.swt.opengl/common/library/swt.h
index 0d47c9e26e..0095fe654d 100644
--- a/bundles/org.eclipse.swt.opengl/common/library/swt.h
+++ b/bundles/org.eclipse.swt.opengl/common/library/swt.h
@@ -1,50 +1,50 @@
-/*******************************************************************************

- * 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

- *******************************************************************************/

-

-#ifndef INC_swt_H

-#define INC_swt_H

-

-#include "jni.h"

-

-/* For debugging */

-#define DEBUG_PRINTF(x)

-/*#define DEBUG_PRINTF(x) printf x; */

-

-/* define this to print out debug statements */

-/* #define DEBUG_CALL_PRINTS */

-/* #define DEBUG_CHECK_NULL_EXCEPTIONS */

-

-#ifdef DEBUG_CALL_PRINTS

-#define DEBUG_CALL(func) fprintf(stderr, func);

-#else

-#define DEBUG_CALL(func)

-#endif

-

-#ifdef DEBUG_CHECK_NULL_EXCEPTIONS

-#define DEBUG_CHECK_NULL(env, address) \

-	if (address == 0) { \

-		jclass clazz = (*env)->FindClass(env, "org/eclipse/swt/SWTError"); \

-		if (clazz != NULL) { \

-			(*env)->ThrowNew(env, clazz, "Argument cannot be NULL"); \

-		} \

-		return; \

-	}

-#else

-#define DEBUG_CHECK_NULL(env, address)

-#endif

-

-#define DECL_GLOB(pSym)

-#define PGLOB(x) x

-

-#define NATIVE_ENTER(env,clazz,func)

-#define NATIVE_EXIT(env,clazz,func)

-

-#endif /* ifndef INC_swt_H */

+/*******************************************************************************
+ * 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
+ *******************************************************************************/
+
+#ifndef INC_swt_H
+#define INC_swt_H
+
+#include "jni.h"
+
+/* For debugging */
+#define DEBUG_PRINTF(x)
+/*#define DEBUG_PRINTF(x) printf x; */
+
+/* define this to print out debug statements */
+/* #define DEBUG_CALL_PRINTS */
+/* #define DEBUG_CHECK_NULL_EXCEPTIONS */
+
+#ifdef DEBUG_CALL_PRINTS
+#define DEBUG_CALL(func) fprintf(stderr, func);
+#else
+#define DEBUG_CALL(func)
+#endif
+
+#ifdef DEBUG_CHECK_NULL_EXCEPTIONS
+#define DEBUG_CHECK_NULL(env, address) \
+	if (address == 0) { \
+		jclass clazz = (*env)->FindClass(env, "org/eclipse/swt/SWTError"); \
+		if (clazz != NULL) { \
+			(*env)->ThrowNew(env, clazz, "Argument cannot be NULL"); \
+		} \
+		return; \
+	}
+#else
+#define DEBUG_CHECK_NULL(env, address)
+#endif
+
+#define DECL_GLOB(pSym)
+#define PGLOB(x) x
+
+#define NATIVE_ENTER(env,clazz,func)
+#define NATIVE_EXIT(env,clazz,func)
+
+#endif /* ifndef INC_swt_H */
diff --git a/bundles/org.eclipse.swt.opengl/win32/library/build.bat b/bundles/org.eclipse.swt.opengl/win32/library/build.bat
index 7f343981b4..9d6a37a923 100644
--- a/bundles/org.eclipse.swt.opengl/win32/library/build.bat
+++ b/bundles/org.eclipse.swt.opengl/win32/library/build.bat
@@ -1,34 +1,34 @@
-rem *******************************************************************************

-rem  Copyright (c) 2000, 2003 IBM Corporation and others.

-rem  All rights reserved. This program and the accompanying materials 

-rem  are made available under the terms of the Common Public License v1.0

-rem  which accompanies this distribution, and is available at

-rem  http://www.eclipse.org/legal/cpl-v10.html

-rem  

-rem  Contributors:

-rem      IBM Corporation - initial API and implementation

-rem *******************************************************************************

-

-@echo off

-

-IF NOT "%JAVA_HOME%"=="" GOTO MAKE

-

-rem *****

-rem Javah

-rem *****

-set JAVA_HOME=j:\teamswt\swt-builddir\ive\bin

-set path=%JAVA_HOME%;%path%

-

-rem ********

-rem MSVC 6.0

-rem ********

-call k:\dev\products\msvc60\vc98\bin\vcvars32.bat

-

-rem ****** 

-rem MS-SDK

-rem ******

-set Mssdk=j:\teamswt\swt-builddir\mssdk

-call %mssdk%\setenv.bat

-

-:MAKE

-nmake -f make_win32.mak %1 %2 %3 %4

+rem *******************************************************************************
+rem  Copyright (c) 2000, 2003 IBM Corporation and others.
+rem  All rights reserved. This program and the accompanying materials 
+rem  are made available under the terms of the Common Public License v1.0
+rem  which accompanies this distribution, and is available at
+rem  http://www.eclipse.org/legal/cpl-v10.html
+rem  
+rem  Contributors:
+rem      IBM Corporation - initial API and implementation
+rem *******************************************************************************
+
+@echo off
+
+IF NOT "%JAVA_HOME%"=="" GOTO MAKE
+
+rem *****
+rem Javah
+rem *****
+set JAVA_HOME=j:\teamswt\swt-builddir\ive\bin
+set path=%JAVA_HOME%;%path%
+
+rem ********
+rem MSVC 6.0
+rem ********
+call k:\dev\products\msvc60\vc98\bin\vcvars32.bat
+
+rem ****** 
+rem MS-SDK
+rem ******
+set Mssdk=j:\teamswt\swt-builddir\mssdk
+call %mssdk%\setenv.bat
+
+:MAKE
+nmake -f make_win32.mak %1 %2 %3 %4
diff --git a/bundles/org.eclipse.swt.opengl/win32/library/glw.c b/bundles/org.eclipse.swt.opengl/win32/library/glw.c
index ebe0238cfc..bcad15db6b 100644
--- a/bundles/org.eclipse.swt.opengl/win32/library/glw.c
+++ b/bundles/org.eclipse.swt.opengl/win32/library/glw.c
@@ -1,283 +1,283 @@
-/*******************************************************************************

- * 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

- *******************************************************************************/

-#include <windows.h>

-#include <wingdi.h>

-#include "jni.h"

-#include "swt.h"

-#include "structs.h"

-

-#define WGL_NATIVE(func) Java_org_eclipse_swt_opengl_internal_win32_WGL_##func

-

-JNIEXPORT jint JNICALL WGL_NATIVE(ChoosePixelFormat)

-	(JNIEnv *env, jclass that, jint arg0, jobject arg1)

-{

-	PIXELFORMATDESCRIPTOR _arg1, *lparg1=NULL;

-	jint rc;

-

-	DEBUG_CALL("ChoosePixelFormat\n")

-

-	if (arg1) lparg1 = getPIXELFORMATDESCRIPTORFields(env, arg1, &_arg1);

-	rc = (jint)ChoosePixelFormat((HDC)arg0, (CONST PIXELFORMATDESCRIPTOR *)lparg1);

-	if (arg1) setPIXELFORMATDESCRIPTORFields(env, arg1, lparg1);

-	return rc;

-}

-

-JNIEXPORT jint JNICALL WGL_NATIVE(DescribePixelFormat)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jobject arg3)

-{

-	PIXELFORMATDESCRIPTOR _arg3, *lparg3=NULL;

-	jint rc;

-

-	DEBUG_CALL("DescribePixelFormat\n")

-

-	if (arg3) lparg3 = getPIXELFORMATDESCRIPTORFields(env, arg3, &_arg3);

-	rc = (jint)DescribePixelFormat((HDC)arg0, arg1, arg2, (LPPIXELFORMATDESCRIPTOR)lparg3);

-	if (arg3) setPIXELFORMATDESCRIPTORFields(env, arg3, lparg3);

-	return rc;

-}

-

-JNIEXPORT jint JNICALL WGL_NATIVE(GetPixelFormat)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	DEBUG_CALL("GetPixelFormat\n")

-

-	return (jint)GetPixelFormat((HDC)arg0);

-}

-

-JNIEXPORT jboolean JNICALL WGL_NATIVE(SetPixelFormat)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jobject arg2)

-{

-	PIXELFORMATDESCRIPTOR _arg2, *lparg2=NULL;

-	jboolean rc;

-

-	DEBUG_CALL("SetPixelFormat\n")

-

-	if (arg2) lparg2 = getPIXELFORMATDESCRIPTORFields(env, arg2, &_arg2);

-	rc = (jboolean)SetPixelFormat((HDC)arg0, arg1, (CONST PIXELFORMATDESCRIPTOR *)lparg2);

-	if (arg2) setPIXELFORMATDESCRIPTORFields(env, arg2, lparg2);

-	return rc;

-}

-

-JNIEXPORT jboolean JNICALL WGL_NATIVE(SwapBuffers)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	DEBUG_CALL("SwapBuffers\n")

-

-	return (jboolean)SwapBuffers((HDC)arg0);

-}

-

-JNIEXPORT jboolean JNICALL WGL_NATIVE(wglCopyContext)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)

-{

-	DEBUG_CALL("wglCopyContext\n")

-

-	return (jboolean)wglCopyContext((HGLRC)arg0, (HGLRC)arg1, (UINT)arg2);

-}

-

-JNIEXPORT jint JNICALL WGL_NATIVE(wglCreateContext)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	DEBUG_CALL("wglCreateContext\n")

-

-	return (jint)wglCreateContext((HDC)arg0);

-}

-

-JNIEXPORT jint JNICALL WGL_NATIVE(wglCreateLayerContext)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	DEBUG_CALL("wglCreateLayerContext\n")

-

-	return (jint)wglCreateLayerContext((HDC)arg0, arg1);

-}

-

-JNIEXPORT jboolean JNICALL WGL_NATIVE(wglDeleteContext)

-	(JNIEnv *env, jclass that, jint arg0)

-{

-	DEBUG_CALL("wglDeleteContext\n")

-

-	return (jboolean)wglDeleteContext((HGLRC)arg0);

-}

-

-JNIEXPORT jboolean JNICALL WGL_NATIVE(wglDescribeLayerPlane)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jobject arg4)

-{

-	LAYERPLANEDESCRIPTOR _arg4, *lparg4=NULL;

-	jboolean rc;

-

-	DEBUG_CALL("wglDescribeLayerPlane\n")

-

-	if (arg4) lparg4 = getLAYERPLANEDESCRIPTORFields(env, arg4, &_arg4);

-	rc = (jboolean)wglDescribeLayerPlane((HDC)arg0, arg1, arg2, arg3, (LPLAYERPLANEDESCRIPTOR)lparg4);

-	if (arg4) setLAYERPLANEDESCRIPTORFields(env, arg4, lparg4);

-	return rc;

-}

-

-JNIEXPORT jint JNICALL WGL_NATIVE(wglGetCurrentContext)

-	(JNIEnv *env, jclass that)

-{

-	DEBUG_CALL("wglGetCurrentContext\n")

-

-	return (jint)wglGetCurrentContext();

-}

-

-JNIEXPORT jint JNICALL WGL_NATIVE(wglGetCurrentDC)

-	(JNIEnv *env, jclass that)

-{

-	DEBUG_CALL("wglGetCurrentDC\n")

-

-	return (jint)wglGetCurrentDC();

-}

-

-JNIEXPORT jint JNICALL WGL_NATIVE(wglGetLayerPaletteEntries)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jintArray arg4)

-{

-	jint *lparg4=NULL;

-	jint rc;

-

-	DEBUG_CALL("wglGetLayerPaletteEntries\n")

-

-	if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL);

-	rc = (jint)wglGetLayerPaletteEntries((HDC)arg0, arg1, arg2, arg3, (COLORREF *)lparg4);

-	if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);

-	return rc;

-}

-

-JNIEXPORT jint JNICALL WGL_NATIVE(wglGetProcAddress)

-	(JNIEnv *env, jclass that, jbyteArray arg0)

-{

-	jbyte *lparg0=NULL;

-	jint rc;

-

-	DEBUG_CALL("wglGetProcAddress\n")

-

-	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);

-	rc = (jint)wglGetProcAddress((LPCSTR)lparg0);

-	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);

-	return rc;

-}

-

-JNIEXPORT jboolean JNICALL WGL_NATIVE(wglMakeCurrent)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	DEBUG_CALL("wglMakeCurrent\n")

-

-	return (jboolean)wglMakeCurrent((HDC)arg0, (HGLRC)arg1);

-}

-

-JNIEXPORT jboolean JNICALL WGL_NATIVE(wglRealizeLayerPalette)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jboolean arg2)

-{

-	DEBUG_CALL("wglRealizeLayerPalette\n")

-

-	return (jboolean)wglRealizeLayerPalette((HDC)arg0, arg1, (BOOL)arg2);

-}

-

-JNIEXPORT jint JNICALL WGL_NATIVE(wglSetLayerPaletteEntries)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jintArray arg4)

-{

-	jint *lparg4=NULL;

-	jint rc;

-

-	DEBUG_CALL("wglSetLayerPaletteEntries\n")

-

-	if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL);

-	rc = (jint)wglSetLayerPaletteEntries((HDC)arg0, arg1, arg2, arg3, (CONST COLORREF *)lparg4);

-	if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);

-	return rc;

-}

-

-JNIEXPORT jboolean JNICALL WGL_NATIVE(wglShareLists)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	DEBUG_CALL("wglShareLists\n")

-

-	return (jboolean)wglShareLists((HGLRC)arg0, (HGLRC)arg1);

-}

-

-JNIEXPORT jboolean JNICALL WGL_NATIVE(wglSwapLayerBuffers)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1)

-{

-	DEBUG_CALL("wglSwapLayerBuffers\n")

-

-	return (jboolean)wglSwapLayerBuffers((HDC)arg0, arg1);

-}

-

-JNIEXPORT jboolean JNICALL WGL_NATIVE(wglUseFontBitmapsA)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)

-{

-	DEBUG_CALL("wglUseFontBitmapsA\n")

-

-	return (jboolean)wglUseFontBitmapsA((HDC)arg0, arg1, arg2, arg3);

-}

-

-JNIEXPORT jboolean JNICALL WGL_NATIVE(wglUseFontBitmapsW)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)

-{

-	DEBUG_CALL("wglUseFontBitmapsW\n")

-

-	return (jboolean)wglUseFontBitmapsW((HDC)arg0, arg1, arg2, arg3);

-}

-

-JNIEXPORT jboolean JNICALL WGL_NATIVE(wglUseFontOutlinesA)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jfloat arg4, jfloat arg5, jint arg6, jobject arg7)

-{

-//	GLYPHMETRICSFLOAT _arg7, *lparg7=NULL;

-	jboolean rc;

-

-	DEBUG_CALL("wglUseFontOutlinesA\n")

-

-//	if (arg7) lparg7 = getGLYPHMETRICSFLOATFields(env, arg7, &_arg7);

-	rc = (jboolean)wglUseFontOutlinesA((HDC)arg0, arg1, arg2, arg3, (FLOAT)arg4, (FLOAT)arg5, arg6, (LPGLYPHMETRICSFLOAT)arg7);

-//	if (arg7) setGLYPHMETRICSFLOATFields(env, arg7, lparg7);

-	return rc;

-}

-

-JNIEXPORT jboolean JNICALL WGL_NATIVE(wglUseFontOutlinesW)

-	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jfloat arg4, jfloat arg5, jint arg6, jobject arg7)

-{

-//	GLYPHMETRICSFLOAT _arg7, *lparg7=NULL;

-	jboolean rc;

-

-	DEBUG_CALL("wglUseFontOutlinesW\n")

-

-//	if (arg7) lparg7 = getGLYPHMETRICSFLOATFields(env, arg7, &_arg7);

-	rc = (jboolean)wglUseFontOutlinesW((HDC)arg0, arg1, arg2, arg3, (FLOAT)arg4, (FLOAT)arg5, arg6, (LPGLYPHMETRICSFLOAT)arg7);

-//	if (arg7) setGLYPHMETRICSFLOATFields(env, arg7, lparg7);

-	return rc;

-}

-

-JNIEXPORT void JNICALL WGL_NATIVE(MoveMemoryW__Lorg_eclipse_swt_opengl_internal_win32_GLYPHMETRICSFLOAT_2II)

-	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)

-{

-	GLYPHMETRICSFLOAT _arg0, *lparg0=NULL;

-

-	DEBUG_CALL("MoveMemoryW__Lorg_eclipse_swt_opengl_internal_win32_GLYPHMETRICSFLOAT_2II\n")

-	DEBUG_CHECK_NULL(env, arg1)

-	

-	if (arg0) lparg0 = &_arg0;

-	MoveMemory((PVOID)lparg0, (CONST VOID *)arg1, arg2);

-	if (arg0) setGLYPHMETRICSFLOATFields(env, arg0, lparg0);

-}

-

-JNIEXPORT void JNICALL WGL_NATIVE(MoveMemoryA__Lorg_eclipse_swt_opengl_internal_win32_GLYPHMETRICSFLOAT_2II)

-	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)

-{

-	GLYPHMETRICSFLOAT _arg0, *lparg0=NULL;

-

-	DEBUG_CALL("MoveMemoryA__Lorg_eclipse_swt_opengl_internal_win32_GLYPHMETRICSFLOAT_2II\n")

-	DEBUG_CHECK_NULL(env, arg1)

-	

-	if (arg0) lparg0 = &_arg0;

-	MoveMemory((PVOID)lparg0, (CONST VOID *)arg1, arg2);

-	if (arg0) setGLYPHMETRICSFLOATFields(env, arg0, lparg0);

-}

-

-

+/*******************************************************************************
+ * 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
+ *******************************************************************************/
+#include <windows.h>
+#include <wingdi.h>
+#include "jni.h"
+#include "swt.h"
+#include "structs.h"
+
+#define WGL_NATIVE(func) Java_org_eclipse_swt_opengl_internal_win32_WGL_##func
+
+JNIEXPORT jint JNICALL WGL_NATIVE(ChoosePixelFormat)
+	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
+{
+	PIXELFORMATDESCRIPTOR _arg1, *lparg1=NULL;
+	jint rc;
+
+	DEBUG_CALL("ChoosePixelFormat\n")
+
+	if (arg1) lparg1 = getPIXELFORMATDESCRIPTORFields(env, arg1, &_arg1);
+	rc = (jint)ChoosePixelFormat((HDC)arg0, (CONST PIXELFORMATDESCRIPTOR *)lparg1);
+	if (arg1) setPIXELFORMATDESCRIPTORFields(env, arg1, lparg1);
+	return rc;
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(DescribePixelFormat)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jobject arg3)
+{
+	PIXELFORMATDESCRIPTOR _arg3, *lparg3=NULL;
+	jint rc;
+
+	DEBUG_CALL("DescribePixelFormat\n")
+
+	if (arg3) lparg3 = getPIXELFORMATDESCRIPTORFields(env, arg3, &_arg3);
+	rc = (jint)DescribePixelFormat((HDC)arg0, arg1, arg2, (LPPIXELFORMATDESCRIPTOR)lparg3);
+	if (arg3) setPIXELFORMATDESCRIPTORFields(env, arg3, lparg3);
+	return rc;
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(GetPixelFormat)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("GetPixelFormat\n")
+
+	return (jint)GetPixelFormat((HDC)arg0);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(SetPixelFormat)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jobject arg2)
+{
+	PIXELFORMATDESCRIPTOR _arg2, *lparg2=NULL;
+	jboolean rc;
+
+	DEBUG_CALL("SetPixelFormat\n")
+
+	if (arg2) lparg2 = getPIXELFORMATDESCRIPTORFields(env, arg2, &_arg2);
+	rc = (jboolean)SetPixelFormat((HDC)arg0, arg1, (CONST PIXELFORMATDESCRIPTOR *)lparg2);
+	if (arg2) setPIXELFORMATDESCRIPTORFields(env, arg2, lparg2);
+	return rc;
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(SwapBuffers)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("SwapBuffers\n")
+
+	return (jboolean)SwapBuffers((HDC)arg0);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglCopyContext)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("wglCopyContext\n")
+
+	return (jboolean)wglCopyContext((HGLRC)arg0, (HGLRC)arg1, (UINT)arg2);
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(wglCreateContext)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("wglCreateContext\n")
+
+	return (jint)wglCreateContext((HDC)arg0);
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(wglCreateLayerContext)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("wglCreateLayerContext\n")
+
+	return (jint)wglCreateLayerContext((HDC)arg0, arg1);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglDeleteContext)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("wglDeleteContext\n")
+
+	return (jboolean)wglDeleteContext((HGLRC)arg0);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglDescribeLayerPlane)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jobject arg4)
+{
+	LAYERPLANEDESCRIPTOR _arg4, *lparg4=NULL;
+	jboolean rc;
+
+	DEBUG_CALL("wglDescribeLayerPlane\n")
+
+	if (arg4) lparg4 = getLAYERPLANEDESCRIPTORFields(env, arg4, &_arg4);
+	rc = (jboolean)wglDescribeLayerPlane((HDC)arg0, arg1, arg2, arg3, (LPLAYERPLANEDESCRIPTOR)lparg4);
+	if (arg4) setLAYERPLANEDESCRIPTORFields(env, arg4, lparg4);
+	return rc;
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(wglGetCurrentContext)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("wglGetCurrentContext\n")
+
+	return (jint)wglGetCurrentContext();
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(wglGetCurrentDC)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("wglGetCurrentDC\n")
+
+	return (jint)wglGetCurrentDC();
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(wglGetLayerPaletteEntries)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jintArray arg4)
+{
+	jint *lparg4=NULL;
+	jint rc;
+
+	DEBUG_CALL("wglGetLayerPaletteEntries\n")
+
+	if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL);
+	rc = (jint)wglGetLayerPaletteEntries((HDC)arg0, arg1, arg2, arg3, (COLORREF *)lparg4);
+	if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
+	return rc;
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(wglGetProcAddress)
+	(JNIEnv *env, jclass that, jbyteArray arg0)
+{
+	jbyte *lparg0=NULL;
+	jint rc;
+
+	DEBUG_CALL("wglGetProcAddress\n")
+
+	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
+	rc = (jint)wglGetProcAddress((LPCSTR)lparg0);
+	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
+	return rc;
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglMakeCurrent)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("wglMakeCurrent\n")
+
+	return (jboolean)wglMakeCurrent((HDC)arg0, (HGLRC)arg1);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglRealizeLayerPalette)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jboolean arg2)
+{
+	DEBUG_CALL("wglRealizeLayerPalette\n")
+
+	return (jboolean)wglRealizeLayerPalette((HDC)arg0, arg1, (BOOL)arg2);
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(wglSetLayerPaletteEntries)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jintArray arg4)
+{
+	jint *lparg4=NULL;
+	jint rc;
+
+	DEBUG_CALL("wglSetLayerPaletteEntries\n")
+
+	if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL);
+	rc = (jint)wglSetLayerPaletteEntries((HDC)arg0, arg1, arg2, arg3, (CONST COLORREF *)lparg4);
+	if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
+	return rc;
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglShareLists)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("wglShareLists\n")
+
+	return (jboolean)wglShareLists((HGLRC)arg0, (HGLRC)arg1);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglSwapLayerBuffers)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("wglSwapLayerBuffers\n")
+
+	return (jboolean)wglSwapLayerBuffers((HDC)arg0, arg1);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglUseFontBitmapsA)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	DEBUG_CALL("wglUseFontBitmapsA\n")
+
+	return (jboolean)wglUseFontBitmapsA((HDC)arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglUseFontBitmapsW)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	DEBUG_CALL("wglUseFontBitmapsW\n")
+
+	return (jboolean)wglUseFontBitmapsW((HDC)arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglUseFontOutlinesA)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jfloat arg4, jfloat arg5, jint arg6, jobject arg7)
+{
+//	GLYPHMETRICSFLOAT _arg7, *lparg7=NULL;
+	jboolean rc;
+
+	DEBUG_CALL("wglUseFontOutlinesA\n")
+
+//	if (arg7) lparg7 = getGLYPHMETRICSFLOATFields(env, arg7, &_arg7);
+	rc = (jboolean)wglUseFontOutlinesA((HDC)arg0, arg1, arg2, arg3, (FLOAT)arg4, (FLOAT)arg5, arg6, (LPGLYPHMETRICSFLOAT)arg7);
+//	if (arg7) setGLYPHMETRICSFLOATFields(env, arg7, lparg7);
+	return rc;
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglUseFontOutlinesW)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jfloat arg4, jfloat arg5, jint arg6, jobject arg7)
+{
+//	GLYPHMETRICSFLOAT _arg7, *lparg7=NULL;
+	jboolean rc;
+
+	DEBUG_CALL("wglUseFontOutlinesW\n")
+
+//	if (arg7) lparg7 = getGLYPHMETRICSFLOATFields(env, arg7, &_arg7);
+	rc = (jboolean)wglUseFontOutlinesW((HDC)arg0, arg1, arg2, arg3, (FLOAT)arg4, (FLOAT)arg5, arg6, (LPGLYPHMETRICSFLOAT)arg7);
+//	if (arg7) setGLYPHMETRICSFLOATFields(env, arg7, lparg7);
+	return rc;
+}
+
+JNIEXPORT void JNICALL WGL_NATIVE(MoveMemoryW__Lorg_eclipse_swt_opengl_internal_win32_GLYPHMETRICSFLOAT_2II)
+	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
+{
+	GLYPHMETRICSFLOAT _arg0, *lparg0=NULL;
+
+	DEBUG_CALL("MoveMemoryW__Lorg_eclipse_swt_opengl_internal_win32_GLYPHMETRICSFLOAT_2II\n")
+	DEBUG_CHECK_NULL(env, arg1)
+	
+	if (arg0) lparg0 = &_arg0;
+	MoveMemory((PVOID)lparg0, (CONST VOID *)arg1, arg2);
+	if (arg0) setGLYPHMETRICSFLOATFields(env, arg0, lparg0);
+}
+
+JNIEXPORT void JNICALL WGL_NATIVE(MoveMemoryA__Lorg_eclipse_swt_opengl_internal_win32_GLYPHMETRICSFLOAT_2II)
+	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
+{
+	GLYPHMETRICSFLOAT _arg0, *lparg0=NULL;
+
+	DEBUG_CALL("MoveMemoryA__Lorg_eclipse_swt_opengl_internal_win32_GLYPHMETRICSFLOAT_2II\n")
+	DEBUG_CHECK_NULL(env, arg1)
+	
+	if (arg0) lparg0 = &_arg0;
+	MoveMemory((PVOID)lparg0, (CONST VOID *)arg1, arg2);
+	if (arg0) setGLYPHMETRICSFLOATFields(env, arg0, lparg0);
+}
+
+
diff --git a/bundles/org.eclipse.swt.opengl/win32/library/make_win32.mak b/bundles/org.eclipse.swt.opengl/win32/library/make_win32.mak
index 30df1a6cbe..3b90d867ce 100644
--- a/bundles/org.eclipse.swt.opengl/win32/library/make_win32.mak
+++ b/bundles/org.eclipse.swt.opengl/win32/library/make_win32.mak
@@ -1,56 +1,56 @@
-#*******************************************************************************

-# 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

-#*******************************************************************************

-

-# assumes JAVA_HOME is set in the environment from which nmake is run

-

-APPVER=5.0

-!include <win32.mak>

-

-pgm_ver_str="SWT $(maj_ver).$(min_ver) for Windows"

-timestamp_str=__DATE__\" \"__TIME__\" (EST)\"

-copyright = "Copyright (C) 1999, 2003 IBM Corp.  All rights reserved."

-

-SWT_PREFIX=gl

-WS_PREFIX=win32

-SWT_LIB     = $(SWT_PREFIX)-$(WS_PREFIX).dll

-

-LINK_LIBS = opengl32.lib glu32.lib gdi32.lib

-

-# note: thoroughly test all examples after changing any optimization flags

-SWT_CDEBUG = #-Zi -Odi

-SWT_LDEBUG = #/DEBUG /DEBUGTYPE:both

-CFLAGS = -c -W3 -G6 -GD -O1 $(SWT_CDEBUG) -nologo -D_X86_=1 -D_WIN32 -D_WIN95 -D_WIN32_WINDOWS=0x0400 -D_MT -MT -DWIN32 -D_WIN32_DCOM /I$(JAVA_HOME)\include /I.

-RCFLAGS = -DSWT_COMMA_VERSION=$(comma_ver)

-LFLAGS = /INCREMENTAL:NO /PDB:NONE /RELEASE /NOLOGO $(SWT_LDEBUG) -entry:_DllMainCRTStartup@12 -dll /BASE:0x10000000 /comment:$(pgm_ver_str) /comment:$(copyright) /DLL

-

-SWT_OBJS = gl.obj glu.obj glw.obj structs.obj

-

-all: $(SWT_LIB)

-

-.c.obj:

-	cl $(CFLAGS) $*.c

-

-$(SWT_LIB): $(SWT_OBJS) swt.res

-	echo $(LFLAGS) >templrf

-	echo $(LINK_LIBS) >>templrf

-	echo -machine:IX86 >>templrf

-	echo -subsystem:windows >>templrf

-	echo -out:$(SWT_LIB) >>templrf

-	echo $(SWT_OBJS) >>templrf

-	echo swt.res >>templrf

-	link @templrf

-	del templrf

-	

-swt.res:

-	rc $(RCFLAGS) -DSWT_ORG_FILENAME=\"$(SWT_LIB)\" -r -fo swt.res swt.rc

-	

-clean:

-    del *.obj *.res *.dll *.lib *.exp

+#*******************************************************************************
+# 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
+#*******************************************************************************
+
+# assumes JAVA_HOME is set in the environment from which nmake is run
+
+APPVER=5.0
+!include <win32.mak>
+
+pgm_ver_str="SWT $(maj_ver).$(min_ver) for Windows"
+timestamp_str=__DATE__\" \"__TIME__\" (EST)\"
+copyright = "Copyright (C) 1999, 2003 IBM Corp.  All rights reserved."
+
+SWT_PREFIX=gl
+WS_PREFIX=win32
+SWT_LIB     = $(SWT_PREFIX)-$(WS_PREFIX).dll
+
+LINK_LIBS = opengl32.lib glu32.lib gdi32.lib
+
+# note: thoroughly test all examples after changing any optimization flags
+SWT_CDEBUG = #-Zi -Odi
+SWT_LDEBUG = #/DEBUG /DEBUGTYPE:both
+CFLAGS = -c -W3 -G6 -GD -O1 $(SWT_CDEBUG) -nologo -D_X86_=1 -D_WIN32 -D_WIN95 -D_WIN32_WINDOWS=0x0400 -D_MT -MT -DWIN32 -D_WIN32_DCOM /I$(JAVA_HOME)\include /I.
+RCFLAGS = -DSWT_COMMA_VERSION=$(comma_ver)
+LFLAGS = /INCREMENTAL:NO /PDB:NONE /RELEASE /NOLOGO $(SWT_LDEBUG) -entry:_DllMainCRTStartup@12 -dll /BASE:0x10000000 /comment:$(pgm_ver_str) /comment:$(copyright) /DLL
+
+SWT_OBJS = swt.obj gl.obj glu.obj glw.obj structs.obj
+
+all: $(SWT_LIB)
+
+.c.obj:
+	cl $(CFLAGS) $*.c
+
+$(SWT_LIB): $(SWT_OBJS) swt.res
+	echo $(LFLAGS) >templrf
+	echo $(LINK_LIBS) >>templrf
+	echo -machine:IX86 >>templrf
+	echo -subsystem:windows >>templrf
+	echo -out:$(SWT_LIB) >>templrf
+	echo $(SWT_OBJS) >>templrf
+	echo swt.res >>templrf
+	link @templrf
+	del templrf
+	
+swt.res:
+	rc $(RCFLAGS) -DSWT_ORG_FILENAME=\"$(SWT_LIB)\" -r -fo swt.res swt.rc
+	
+clean:
+    del *.obj *.res *.dll *.lib *.exp
diff --git a/bundles/org.eclipse.swt.opengl/win32/library/structs.c b/bundles/org.eclipse.swt.opengl/win32/library/structs.c
index 7c1c26e1a7..a9c61dcf6f 100644
--- a/bundles/org.eclipse.swt.opengl/win32/library/structs.c
+++ b/bundles/org.eclipse.swt.opengl/win32/library/structs.c
@@ -1,304 +1,304 @@
-/*******************************************************************************

- * 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

- *******************************************************************************/

-

-#include "swt.h"

-#include "structs.h"

-

-typedef struct GLYPHMETRICSFLOAT_FID_CACHE {

-	int cached;

-	jclass clazz;

-	jfieldID gmfCellIncY, gmfCellIncX, gmfptGlyphOrigin_y, gmfptGlyphOrigin_x, gmfBlackBoxY, gmfBlackBoxX;

-} GLYPHMETRICSFLOAT_FID_CACHE;

-typedef GLYPHMETRICSFLOAT_FID_CACHE *PGLYPHMETRICSFLOAT_FID_CACHE;

-

-GLYPHMETRICSFLOAT_FID_CACHE GLYPHMETRICSFLOATFc;

-

-void cacheGLYPHMETRICSFLOATFids(JNIEnv *env, jobject lpObject, PGLYPHMETRICSFLOAT_FID_CACHE lpCache)

-{

-	if (lpCache->cached) return;

-	lpCache->clazz = (*env)->GetObjectClass(env, lpObject);

-	lpCache->gmfCellIncY = (*env)->GetFieldID(env, lpCache->clazz, "gmfCellIncY", "F");

-	lpCache->gmfCellIncX = (*env)->GetFieldID(env, lpCache->clazz, "gmfCellIncX", "F");

-	lpCache->gmfptGlyphOrigin_y = (*env)->GetFieldID(env, lpCache->clazz, "gmfptGlyphOrigin_y", "F");

-	lpCache->gmfptGlyphOrigin_x = (*env)->GetFieldID(env, lpCache->clazz, "gmfptGlyphOrigin_x", "F");

-	lpCache->gmfBlackBoxY = (*env)->GetFieldID(env, lpCache->clazz, "gmfBlackBoxY", "F");

-	lpCache->gmfBlackBoxX = (*env)->GetFieldID(env, lpCache->clazz, "gmfBlackBoxX", "F");

-	lpCache->cached = 1;

-}

-

-GLYPHMETRICSFLOAT *getGLYPHMETRICSFLOATFields(JNIEnv *env, jobject lpObject, GLYPHMETRICSFLOAT *lpStruct)

-{

-	PGLYPHMETRICSFLOAT_FID_CACHE lpCache = &GLYPHMETRICSFLOATFc;

-	if (!lpCache->cached) cacheGLYPHMETRICSFLOATFids(env, lpObject, lpCache);

-	lpStruct->gmfCellIncY = (*env)->GetFloatField(env, lpObject, lpCache->gmfCellIncY);

-	lpStruct->gmfCellIncX = (*env)->GetFloatField(env, lpObject, lpCache->gmfCellIncX);

-	lpStruct->gmfptGlyphOrigin.y = (*env)->GetFloatField(env, lpObject, lpCache->gmfptGlyphOrigin_y);

-	lpStruct->gmfptGlyphOrigin.x = (*env)->GetFloatField(env, lpObject, lpCache->gmfptGlyphOrigin_x);

-	lpStruct->gmfBlackBoxY = (*env)->GetFloatField(env, lpObject, lpCache->gmfBlackBoxY);

-	lpStruct->gmfBlackBoxX = (*env)->GetFloatField(env, lpObject, lpCache->gmfBlackBoxX);

-	return lpStruct;

-}

-

-void setGLYPHMETRICSFLOATFields(JNIEnv *env, jobject lpObject, GLYPHMETRICSFLOAT *lpStruct)

-{

-	PGLYPHMETRICSFLOAT_FID_CACHE lpCache = &GLYPHMETRICSFLOATFc;

-	if (!lpCache->cached) cacheGLYPHMETRICSFLOATFids(env, lpObject, lpCache);

-	(*env)->SetFloatField(env, lpObject, lpCache->gmfCellIncY, (jfloat)lpStruct->gmfCellIncY);

-	(*env)->SetFloatField(env, lpObject, lpCache->gmfCellIncX, (jfloat)lpStruct->gmfCellIncX);

-	(*env)->SetFloatField(env, lpObject, lpCache->gmfptGlyphOrigin_y, (jfloat)lpStruct->gmfptGlyphOrigin.y);

-	(*env)->SetFloatField(env, lpObject, lpCache->gmfptGlyphOrigin_x, (jfloat)lpStruct->gmfptGlyphOrigin.x);

-	(*env)->SetFloatField(env, lpObject, lpCache->gmfBlackBoxY, (jfloat)lpStruct->gmfBlackBoxY);

-	(*env)->SetFloatField(env, lpObject, lpCache->gmfBlackBoxX, (jfloat)lpStruct->gmfBlackBoxX);

-}

-

-typedef struct LAYERPLANEDESCRIPTOR_FID_CACHE {

-	int cached;

-	jclass clazz;

-	jfieldID crTransparent, bReserved, iLayerPlane, cAuxBuffers, cStencilBits, cDepthBits, cAccumAlphaBits, cAccumBlueBits, cAccumGreenBits, cAccumRedBits, cAccumBits, cAlphaShift, cAlphaBits, cBlueShift, cBlueBits, cGreenShift, cGreenBits, cRedShift, cRedBits, cColorBits, iPixelType, dwFlags, nVersion, nSize;

-} LAYERPLANEDESCRIPTOR_FID_CACHE;

-typedef LAYERPLANEDESCRIPTOR_FID_CACHE *PLAYERPLANEDESCRIPTOR_FID_CACHE;

-

-LAYERPLANEDESCRIPTOR_FID_CACHE LAYERPLANEDESCRIPTORFc;

-

-void cacheLAYERPLANEDESCRIPTORFids(JNIEnv *env, jobject lpObject, PLAYERPLANEDESCRIPTOR_FID_CACHE lpCache)

-{

-	if (lpCache->cached) return;

-	lpCache->clazz = (*env)->GetObjectClass(env, lpObject);

-	lpCache->crTransparent = (*env)->GetFieldID(env, lpCache->clazz, "crTransparent", "I");

-	lpCache->bReserved = (*env)->GetFieldID(env, lpCache->clazz, "bReserved", "B");

-	lpCache->iLayerPlane = (*env)->GetFieldID(env, lpCache->clazz, "iLayerPlane", "B");

-	lpCache->cAuxBuffers = (*env)->GetFieldID(env, lpCache->clazz, "cAuxBuffers", "B");

-	lpCache->cStencilBits = (*env)->GetFieldID(env, lpCache->clazz, "cStencilBits", "B");

-	lpCache->cDepthBits = (*env)->GetFieldID(env, lpCache->clazz, "cDepthBits", "B");

-	lpCache->cAccumAlphaBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumAlphaBits", "B");

-	lpCache->cAccumBlueBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumBlueBits", "B");

-	lpCache->cAccumGreenBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumGreenBits", "B");

-	lpCache->cAccumRedBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumRedBits", "B");

-	lpCache->cAccumBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumBits", "B");

-	lpCache->cAlphaShift = (*env)->GetFieldID(env, lpCache->clazz, "cAlphaShift", "B");

-	lpCache->cAlphaBits = (*env)->GetFieldID(env, lpCache->clazz, "cAlphaBits", "B");

-	lpCache->cBlueShift = (*env)->GetFieldID(env, lpCache->clazz, "cBlueShift", "B");

-	lpCache->cBlueBits = (*env)->GetFieldID(env, lpCache->clazz, "cBlueBits", "B");

-	lpCache->cGreenShift = (*env)->GetFieldID(env, lpCache->clazz, "cGreenShift", "B");

-	lpCache->cGreenBits = (*env)->GetFieldID(env, lpCache->clazz, "cGreenBits", "B");

-	lpCache->cRedShift = (*env)->GetFieldID(env, lpCache->clazz, "cRedShift", "B");

-	lpCache->cRedBits = (*env)->GetFieldID(env, lpCache->clazz, "cRedBits", "B");

-	lpCache->cColorBits = (*env)->GetFieldID(env, lpCache->clazz, "cColorBits", "B");

-	lpCache->iPixelType = (*env)->GetFieldID(env, lpCache->clazz, "iPixelType", "B");

-	lpCache->dwFlags = (*env)->GetFieldID(env, lpCache->clazz, "dwFlags", "I");

-	lpCache->nVersion = (*env)->GetFieldID(env, lpCache->clazz, "nVersion", "S");

-	lpCache->nSize = (*env)->GetFieldID(env, lpCache->clazz, "nSize", "S");

-	lpCache->cached = 1;

-}

-

-LAYERPLANEDESCRIPTOR *getLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject, LAYERPLANEDESCRIPTOR *lpStruct)

-{

-	PLAYERPLANEDESCRIPTOR_FID_CACHE lpCache = &LAYERPLANEDESCRIPTORFc;

-	if (!lpCache->cached) cacheLAYERPLANEDESCRIPTORFids(env, lpObject, lpCache);

-	lpStruct->crTransparent = (*env)->GetIntField(env, lpObject, lpCache->crTransparent);

-	lpStruct->bReserved = (*env)->GetByteField(env, lpObject, lpCache->bReserved);

-	lpStruct->iLayerPlane = (*env)->GetByteField(env, lpObject, lpCache->iLayerPlane);

-	lpStruct->cAuxBuffers = (*env)->GetByteField(env, lpObject, lpCache->cAuxBuffers);

-	lpStruct->cStencilBits = (*env)->GetByteField(env, lpObject, lpCache->cStencilBits);

-	lpStruct->cDepthBits = (*env)->GetByteField(env, lpObject, lpCache->cDepthBits);

-	lpStruct->cAccumAlphaBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumAlphaBits);

-	lpStruct->cAccumBlueBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumBlueBits);

-	lpStruct->cAccumGreenBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumGreenBits);

-	lpStruct->cAccumRedBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumRedBits);

-	lpStruct->cAccumBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumBits);

-	lpStruct->cAlphaShift = (*env)->GetByteField(env, lpObject, lpCache->cAlphaShift);

-	lpStruct->cAlphaBits = (*env)->GetByteField(env, lpObject, lpCache->cAlphaBits);

-	lpStruct->cBlueShift = (*env)->GetByteField(env, lpObject, lpCache->cBlueShift);

-	lpStruct->cBlueBits = (*env)->GetByteField(env, lpObject, lpCache->cBlueBits);

-	lpStruct->cGreenShift = (*env)->GetByteField(env, lpObject, lpCache->cGreenShift);

-	lpStruct->cGreenBits = (*env)->GetByteField(env, lpObject, lpCache->cGreenBits);

-	lpStruct->cRedShift = (*env)->GetByteField(env, lpObject, lpCache->cRedShift);

-	lpStruct->cRedBits = (*env)->GetByteField(env, lpObject, lpCache->cRedBits);

-	lpStruct->cColorBits = (*env)->GetByteField(env, lpObject, lpCache->cColorBits);

-	lpStruct->iPixelType = (*env)->GetByteField(env, lpObject, lpCache->iPixelType);

-	lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, lpCache->dwFlags);

-	lpStruct->nVersion = (*env)->GetShortField(env, lpObject, lpCache->nVersion);

-	lpStruct->nSize = (*env)->GetShortField(env, lpObject, lpCache->nSize);

-	return lpStruct;

-}

-

-void setLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject, LAYERPLANEDESCRIPTOR *lpStruct)

-{

-	PLAYERPLANEDESCRIPTOR_FID_CACHE lpCache = &LAYERPLANEDESCRIPTORFc;

-	if (!lpCache->cached) cacheLAYERPLANEDESCRIPTORFids(env, lpObject, lpCache);

-	(*env)->SetIntField(env, lpObject, lpCache->crTransparent, (jint)lpStruct->crTransparent);

-	(*env)->SetByteField(env, lpObject, lpCache->bReserved, (jbyte)lpStruct->bReserved);

-	(*env)->SetByteField(env, lpObject, lpCache->iLayerPlane, (jbyte)lpStruct->iLayerPlane);

-	(*env)->SetByteField(env, lpObject, lpCache->cAuxBuffers, (jbyte)lpStruct->cAuxBuffers);

-	(*env)->SetByteField(env, lpObject, lpCache->cStencilBits, (jbyte)lpStruct->cStencilBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cDepthBits, (jbyte)lpStruct->cDepthBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cAccumAlphaBits, (jbyte)lpStruct->cAccumAlphaBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cAccumBlueBits, (jbyte)lpStruct->cAccumBlueBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cAccumGreenBits, (jbyte)lpStruct->cAccumGreenBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cAccumRedBits, (jbyte)lpStruct->cAccumRedBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cAccumBits, (jbyte)lpStruct->cAccumBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cAlphaShift, (jbyte)lpStruct->cAlphaShift);

-	(*env)->SetByteField(env, lpObject, lpCache->cAlphaBits, (jbyte)lpStruct->cAlphaBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cBlueShift, (jbyte)lpStruct->cBlueShift);

-	(*env)->SetByteField(env, lpObject, lpCache->cBlueBits, (jbyte)lpStruct->cBlueBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cGreenShift, (jbyte)lpStruct->cGreenShift);

-	(*env)->SetByteField(env, lpObject, lpCache->cGreenBits, (jbyte)lpStruct->cGreenBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cRedShift, (jbyte)lpStruct->cRedShift);

-	(*env)->SetByteField(env, lpObject, lpCache->cRedBits, (jbyte)lpStruct->cRedBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cColorBits, (jbyte)lpStruct->cColorBits);

-	(*env)->SetByteField(env, lpObject, lpCache->iPixelType, (jbyte)lpStruct->iPixelType);

-	(*env)->SetIntField(env, lpObject, lpCache->dwFlags, (jint)lpStruct->dwFlags);

-	(*env)->SetShortField(env, lpObject, lpCache->nVersion, (jshort)lpStruct->nVersion);

-	(*env)->SetShortField(env, lpObject, lpCache->nSize, (jshort)lpStruct->nSize);

-}

-

-typedef struct POINTFLOAT_FID_CACHE {

-	int cached;

-	jclass clazz;

-	jfieldID y, x;

-} POINTFLOAT_FID_CACHE;

-typedef POINTFLOAT_FID_CACHE *PPOINTFLOAT_FID_CACHE;

-

-POINTFLOAT_FID_CACHE POINTFLOATFc;

-

-void cachePOINTFLOATFids(JNIEnv *env, jobject lpObject, PPOINTFLOAT_FID_CACHE lpCache)

-{

-	if (lpCache->cached) return;

-	lpCache->clazz = (*env)->GetObjectClass(env, lpObject);

-	lpCache->y = (*env)->GetFieldID(env, lpCache->clazz, "y", "F");

-	lpCache->x = (*env)->GetFieldID(env, lpCache->clazz, "x", "F");

-	lpCache->cached = 1;

-}

-

-POINTFLOAT *getPOINTFLOATFields(JNIEnv *env, jobject lpObject, POINTFLOAT *lpStruct)

-{

-	PPOINTFLOAT_FID_CACHE lpCache = &POINTFLOATFc;

-	if (!lpCache->cached) cachePOINTFLOATFids(env, lpObject, lpCache);

-	lpStruct->y = (*env)->GetFloatField(env, lpObject, lpCache->y);

-	lpStruct->x = (*env)->GetFloatField(env, lpObject, lpCache->x);

-	return lpStruct;

-}

-

-void setPOINTFLOATFields(JNIEnv *env, jobject lpObject, POINTFLOAT *lpStruct)

-{

-	PPOINTFLOAT_FID_CACHE lpCache = &POINTFLOATFc;

-	if (!lpCache->cached) cachePOINTFLOATFids(env, lpObject, lpCache);

-	(*env)->SetFloatField(env, lpObject, lpCache->y, (jfloat)lpStruct->y);

-	(*env)->SetFloatField(env, lpObject, lpCache->x, (jfloat)lpStruct->x);

-}

-

-typedef struct PIXELFORMATDESCRIPTOR_FID_CACHE {

-	int cached;

-	jclass clazz;

-	jfieldID dwDamageMask, dwVisibleMask, dwLayerMask, bReserved, iLayerType, cAuxBuffers, cStencilBits, cDepthBits, cAccumAlphaBits, cAccumBlueBits, cAccumGreenBits, cAccumRedBits, cAccumBits, cAlphaShift, cAlphaBits, cBlueShift, cBlueBits, cGreenShift, cGreenBits, cRedShift, cRedBits, cColorBits, iPixelType, dwFlags, nVersion, nSize;

-} PIXELFORMATDESCRIPTOR_FID_CACHE;

-typedef PIXELFORMATDESCRIPTOR_FID_CACHE *PPIXELFORMATDESCRIPTOR_FID_CACHE;

-

-PIXELFORMATDESCRIPTOR_FID_CACHE PIXELFORMATDESCRIPTORFc;

-

-void cachePIXELFORMATDESCRIPTORFids(JNIEnv *env, jobject lpObject, PPIXELFORMATDESCRIPTOR_FID_CACHE lpCache)

-{

-	if (lpCache->cached) return;

-	lpCache->clazz = (*env)->GetObjectClass(env, lpObject);

-	lpCache->dwDamageMask = (*env)->GetFieldID(env, lpCache->clazz, "dwDamageMask", "I");

-	lpCache->dwVisibleMask = (*env)->GetFieldID(env, lpCache->clazz, "dwVisibleMask", "I");

-	lpCache->dwLayerMask = (*env)->GetFieldID(env, lpCache->clazz, "dwLayerMask", "I");

-	lpCache->bReserved = (*env)->GetFieldID(env, lpCache->clazz, "bReserved", "B");

-	lpCache->iLayerType = (*env)->GetFieldID(env, lpCache->clazz, "iLayerType", "B");

-	lpCache->cAuxBuffers = (*env)->GetFieldID(env, lpCache->clazz, "cAuxBuffers", "B");

-	lpCache->cStencilBits = (*env)->GetFieldID(env, lpCache->clazz, "cStencilBits", "B");

-	lpCache->cDepthBits = (*env)->GetFieldID(env, lpCache->clazz, "cDepthBits", "B");

-	lpCache->cAccumAlphaBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumAlphaBits", "B");

-	lpCache->cAccumBlueBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumBlueBits", "B");

-	lpCache->cAccumGreenBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumGreenBits", "B");

-	lpCache->cAccumRedBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumRedBits", "B");

-	lpCache->cAccumBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumBits", "B");

-	lpCache->cAlphaShift = (*env)->GetFieldID(env, lpCache->clazz, "cAlphaShift", "B");

-	lpCache->cAlphaBits = (*env)->GetFieldID(env, lpCache->clazz, "cAlphaBits", "B");

-	lpCache->cBlueShift = (*env)->GetFieldID(env, lpCache->clazz, "cBlueShift", "B");

-	lpCache->cBlueBits = (*env)->GetFieldID(env, lpCache->clazz, "cBlueBits", "B");

-	lpCache->cGreenShift = (*env)->GetFieldID(env, lpCache->clazz, "cGreenShift", "B");

-	lpCache->cGreenBits = (*env)->GetFieldID(env, lpCache->clazz, "cGreenBits", "B");

-	lpCache->cRedShift = (*env)->GetFieldID(env, lpCache->clazz, "cRedShift", "B");

-	lpCache->cRedBits = (*env)->GetFieldID(env, lpCache->clazz, "cRedBits", "B");

-	lpCache->cColorBits = (*env)->GetFieldID(env, lpCache->clazz, "cColorBits", "B");

-	lpCache->iPixelType = (*env)->GetFieldID(env, lpCache->clazz, "iPixelType", "B");

-	lpCache->dwFlags = (*env)->GetFieldID(env, lpCache->clazz, "dwFlags", "I");

-	lpCache->nVersion = (*env)->GetFieldID(env, lpCache->clazz, "nVersion", "S");

-	lpCache->nSize = (*env)->GetFieldID(env, lpCache->clazz, "nSize", "S");

-	lpCache->cached = 1;

-}

-

-PIXELFORMATDESCRIPTOR *getPIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject, PIXELFORMATDESCRIPTOR *lpStruct)

-{

-	PPIXELFORMATDESCRIPTOR_FID_CACHE lpCache = &PIXELFORMATDESCRIPTORFc;

-	if (!lpCache->cached) cachePIXELFORMATDESCRIPTORFids(env, lpObject, lpCache);

-	lpStruct->dwDamageMask = (*env)->GetIntField(env, lpObject, lpCache->dwDamageMask);

-	lpStruct->dwVisibleMask = (*env)->GetIntField(env, lpObject, lpCache->dwVisibleMask);

-	lpStruct->dwLayerMask = (*env)->GetIntField(env, lpObject, lpCache->dwLayerMask);

-	lpStruct->bReserved = (*env)->GetByteField(env, lpObject, lpCache->bReserved);

-	lpStruct->iLayerType = (*env)->GetByteField(env, lpObject, lpCache->iLayerType);

-	lpStruct->cAuxBuffers = (*env)->GetByteField(env, lpObject, lpCache->cAuxBuffers);

-	lpStruct->cStencilBits = (*env)->GetByteField(env, lpObject, lpCache->cStencilBits);

-	lpStruct->cDepthBits = (*env)->GetByteField(env, lpObject, lpCache->cDepthBits);

-	lpStruct->cAccumAlphaBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumAlphaBits);

-	lpStruct->cAccumBlueBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumBlueBits);

-	lpStruct->cAccumGreenBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumGreenBits);

-	lpStruct->cAccumRedBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumRedBits);

-	lpStruct->cAccumBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumBits);

-	lpStruct->cAlphaShift = (*env)->GetByteField(env, lpObject, lpCache->cAlphaShift);

-	lpStruct->cAlphaBits = (*env)->GetByteField(env, lpObject, lpCache->cAlphaBits);

-	lpStruct->cBlueShift = (*env)->GetByteField(env, lpObject, lpCache->cBlueShift);

-	lpStruct->cBlueBits = (*env)->GetByteField(env, lpObject, lpCache->cBlueBits);

-	lpStruct->cGreenShift = (*env)->GetByteField(env, lpObject, lpCache->cGreenShift);

-	lpStruct->cGreenBits = (*env)->GetByteField(env, lpObject, lpCache->cGreenBits);

-	lpStruct->cRedShift = (*env)->GetByteField(env, lpObject, lpCache->cRedShift);

-	lpStruct->cRedBits = (*env)->GetByteField(env, lpObject, lpCache->cRedBits);

-	lpStruct->cColorBits = (*env)->GetByteField(env, lpObject, lpCache->cColorBits);

-	lpStruct->iPixelType = (*env)->GetByteField(env, lpObject, lpCache->iPixelType);

-	lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, lpCache->dwFlags);

-	lpStruct->nVersion = (*env)->GetShortField(env, lpObject, lpCache->nVersion);

-	lpStruct->nSize = (*env)->GetShortField(env, lpObject, lpCache->nSize);

-	return lpStruct;

-}

-

-void setPIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject, PIXELFORMATDESCRIPTOR *lpStruct)

-{

-	PPIXELFORMATDESCRIPTOR_FID_CACHE lpCache = &PIXELFORMATDESCRIPTORFc;

-	if (!lpCache->cached) cachePIXELFORMATDESCRIPTORFids(env, lpObject, lpCache);

-	(*env)->SetIntField(env, lpObject, lpCache->dwDamageMask, (jint)lpStruct->dwDamageMask);

-	(*env)->SetIntField(env, lpObject, lpCache->dwVisibleMask, (jint)lpStruct->dwVisibleMask);

-	(*env)->SetIntField(env, lpObject, lpCache->dwLayerMask, (jint)lpStruct->dwLayerMask);

-	(*env)->SetByteField(env, lpObject, lpCache->bReserved, (jbyte)lpStruct->bReserved);

-	(*env)->SetByteField(env, lpObject, lpCache->iLayerType, (jbyte)lpStruct->iLayerType);

-	(*env)->SetByteField(env, lpObject, lpCache->cAuxBuffers, (jbyte)lpStruct->cAuxBuffers);

-	(*env)->SetByteField(env, lpObject, lpCache->cStencilBits, (jbyte)lpStruct->cStencilBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cDepthBits, (jbyte)lpStruct->cDepthBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cAccumAlphaBits, (jbyte)lpStruct->cAccumAlphaBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cAccumBlueBits, (jbyte)lpStruct->cAccumBlueBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cAccumGreenBits, (jbyte)lpStruct->cAccumGreenBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cAccumRedBits, (jbyte)lpStruct->cAccumRedBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cAccumBits, (jbyte)lpStruct->cAccumBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cAlphaShift, (jbyte)lpStruct->cAlphaShift);

-	(*env)->SetByteField(env, lpObject, lpCache->cAlphaBits, (jbyte)lpStruct->cAlphaBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cBlueShift, (jbyte)lpStruct->cBlueShift);

-	(*env)->SetByteField(env, lpObject, lpCache->cBlueBits, (jbyte)lpStruct->cBlueBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cGreenShift, (jbyte)lpStruct->cGreenShift);

-	(*env)->SetByteField(env, lpObject, lpCache->cGreenBits, (jbyte)lpStruct->cGreenBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cRedShift, (jbyte)lpStruct->cRedShift);

-	(*env)->SetByteField(env, lpObject, lpCache->cRedBits, (jbyte)lpStruct->cRedBits);

-	(*env)->SetByteField(env, lpObject, lpCache->cColorBits, (jbyte)lpStruct->cColorBits);

-	(*env)->SetByteField(env, lpObject, lpCache->iPixelType, (jbyte)lpStruct->iPixelType);

-	(*env)->SetIntField(env, lpObject, lpCache->dwFlags, (jint)lpStruct->dwFlags);

-	(*env)->SetShortField(env, lpObject, lpCache->nVersion, (jshort)lpStruct->nVersion);

-	(*env)->SetShortField(env, lpObject, lpCache->nSize, (jshort)lpStruct->nSize);

-}

-

+/*******************************************************************************
+ * 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
+ *******************************************************************************/
+
+#include "swt.h"
+#include "structs.h"
+
+typedef struct GLYPHMETRICSFLOAT_FID_CACHE {
+	int cached;
+	jclass clazz;
+	jfieldID gmfCellIncY, gmfCellIncX, gmfptGlyphOrigin_y, gmfptGlyphOrigin_x, gmfBlackBoxY, gmfBlackBoxX;
+} GLYPHMETRICSFLOAT_FID_CACHE;
+typedef GLYPHMETRICSFLOAT_FID_CACHE *PGLYPHMETRICSFLOAT_FID_CACHE;
+
+GLYPHMETRICSFLOAT_FID_CACHE GLYPHMETRICSFLOATFc;
+
+void cacheGLYPHMETRICSFLOATFids(JNIEnv *env, jobject lpObject, PGLYPHMETRICSFLOAT_FID_CACHE lpCache)
+{
+	if (lpCache->cached) return;
+	lpCache->clazz = (*env)->GetObjectClass(env, lpObject);
+	lpCache->gmfCellIncY = (*env)->GetFieldID(env, lpCache->clazz, "gmfCellIncY", "F");
+	lpCache->gmfCellIncX = (*env)->GetFieldID(env, lpCache->clazz, "gmfCellIncX", "F");
+	lpCache->gmfptGlyphOrigin_y = (*env)->GetFieldID(env, lpCache->clazz, "gmfptGlyphOrigin_y", "F");
+	lpCache->gmfptGlyphOrigin_x = (*env)->GetFieldID(env, lpCache->clazz, "gmfptGlyphOrigin_x", "F");
+	lpCache->gmfBlackBoxY = (*env)->GetFieldID(env, lpCache->clazz, "gmfBlackBoxY", "F");
+	lpCache->gmfBlackBoxX = (*env)->GetFieldID(env, lpCache->clazz, "gmfBlackBoxX", "F");
+	lpCache->cached = 1;
+}
+
+GLYPHMETRICSFLOAT *getGLYPHMETRICSFLOATFields(JNIEnv *env, jobject lpObject, GLYPHMETRICSFLOAT *lpStruct)
+{
+	PGLYPHMETRICSFLOAT_FID_CACHE lpCache = &GLYPHMETRICSFLOATFc;
+	if (!lpCache->cached) cacheGLYPHMETRICSFLOATFids(env, lpObject, lpCache);
+	lpStruct->gmfCellIncY = (*env)->GetFloatField(env, lpObject, lpCache->gmfCellIncY);
+	lpStruct->gmfCellIncX = (*env)->GetFloatField(env, lpObject, lpCache->gmfCellIncX);
+	lpStruct->gmfptGlyphOrigin.y = (*env)->GetFloatField(env, lpObject, lpCache->gmfptGlyphOrigin_y);
+	lpStruct->gmfptGlyphOrigin.x = (*env)->GetFloatField(env, lpObject, lpCache->gmfptGlyphOrigin_x);
+	lpStruct->gmfBlackBoxY = (*env)->GetFloatField(env, lpObject, lpCache->gmfBlackBoxY);
+	lpStruct->gmfBlackBoxX = (*env)->GetFloatField(env, lpObject, lpCache->gmfBlackBoxX);
+	return lpStruct;
+}
+
+void setGLYPHMETRICSFLOATFields(JNIEnv *env, jobject lpObject, GLYPHMETRICSFLOAT *lpStruct)
+{
+	PGLYPHMETRICSFLOAT_FID_CACHE lpCache = &GLYPHMETRICSFLOATFc;
+	if (!lpCache->cached) cacheGLYPHMETRICSFLOATFids(env, lpObject, lpCache);
+	(*env)->SetFloatField(env, lpObject, lpCache->gmfCellIncY, (jfloat)lpStruct->gmfCellIncY);
+	(*env)->SetFloatField(env, lpObject, lpCache->gmfCellIncX, (jfloat)lpStruct->gmfCellIncX);
+	(*env)->SetFloatField(env, lpObject, lpCache->gmfptGlyphOrigin_y, (jfloat)lpStruct->gmfptGlyphOrigin.y);
+	(*env)->SetFloatField(env, lpObject, lpCache->gmfptGlyphOrigin_x, (jfloat)lpStruct->gmfptGlyphOrigin.x);
+	(*env)->SetFloatField(env, lpObject, lpCache->gmfBlackBoxY, (jfloat)lpStruct->gmfBlackBoxY);
+	(*env)->SetFloatField(env, lpObject, lpCache->gmfBlackBoxX, (jfloat)lpStruct->gmfBlackBoxX);
+}
+
+typedef struct LAYERPLANEDESCRIPTOR_FID_CACHE {
+	int cached;
+	jclass clazz;
+	jfieldID crTransparent, bReserved, iLayerPlane, cAuxBuffers, cStencilBits, cDepthBits, cAccumAlphaBits, cAccumBlueBits, cAccumGreenBits, cAccumRedBits, cAccumBits, cAlphaShift, cAlphaBits, cBlueShift, cBlueBits, cGreenShift, cGreenBits, cRedShift, cRedBits, cColorBits, iPixelType, dwFlags, nVersion, nSize;
+} LAYERPLANEDESCRIPTOR_FID_CACHE;
+typedef LAYERPLANEDESCRIPTOR_FID_CACHE *PLAYERPLANEDESCRIPTOR_FID_CACHE;
+
+LAYERPLANEDESCRIPTOR_FID_CACHE LAYERPLANEDESCRIPTORFc;
+
+void cacheLAYERPLANEDESCRIPTORFids(JNIEnv *env, jobject lpObject, PLAYERPLANEDESCRIPTOR_FID_CACHE lpCache)
+{
+	if (lpCache->cached) return;
+	lpCache->clazz = (*env)->GetObjectClass(env, lpObject);
+	lpCache->crTransparent = (*env)->GetFieldID(env, lpCache->clazz, "crTransparent", "I");
+	lpCache->bReserved = (*env)->GetFieldID(env, lpCache->clazz, "bReserved", "B");
+	lpCache->iLayerPlane = (*env)->GetFieldID(env, lpCache->clazz, "iLayerPlane", "B");
+	lpCache->cAuxBuffers = (*env)->GetFieldID(env, lpCache->clazz, "cAuxBuffers", "B");
+	lpCache->cStencilBits = (*env)->GetFieldID(env, lpCache->clazz, "cStencilBits", "B");
+	lpCache->cDepthBits = (*env)->GetFieldID(env, lpCache->clazz, "cDepthBits", "B");
+	lpCache->cAccumAlphaBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumAlphaBits", "B");
+	lpCache->cAccumBlueBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumBlueBits", "B");
+	lpCache->cAccumGreenBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumGreenBits", "B");
+	lpCache->cAccumRedBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumRedBits", "B");
+	lpCache->cAccumBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumBits", "B");
+	lpCache->cAlphaShift = (*env)->GetFieldID(env, lpCache->clazz, "cAlphaShift", "B");
+	lpCache->cAlphaBits = (*env)->GetFieldID(env, lpCache->clazz, "cAlphaBits", "B");
+	lpCache->cBlueShift = (*env)->GetFieldID(env, lpCache->clazz, "cBlueShift", "B");
+	lpCache->cBlueBits = (*env)->GetFieldID(env, lpCache->clazz, "cBlueBits", "B");
+	lpCache->cGreenShift = (*env)->GetFieldID(env, lpCache->clazz, "cGreenShift", "B");
+	lpCache->cGreenBits = (*env)->GetFieldID(env, lpCache->clazz, "cGreenBits", "B");
+	lpCache->cRedShift = (*env)->GetFieldID(env, lpCache->clazz, "cRedShift", "B");
+	lpCache->cRedBits = (*env)->GetFieldID(env, lpCache->clazz, "cRedBits", "B");
+	lpCache->cColorBits = (*env)->GetFieldID(env, lpCache->clazz, "cColorBits", "B");
+	lpCache->iPixelType = (*env)->GetFieldID(env, lpCache->clazz, "iPixelType", "B");
+	lpCache->dwFlags = (*env)->GetFieldID(env, lpCache->clazz, "dwFlags", "I");
+	lpCache->nVersion = (*env)->GetFieldID(env, lpCache->clazz, "nVersion", "S");
+	lpCache->nSize = (*env)->GetFieldID(env, lpCache->clazz, "nSize", "S");
+	lpCache->cached = 1;
+}
+
+LAYERPLANEDESCRIPTOR *getLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject, LAYERPLANEDESCRIPTOR *lpStruct)
+{
+	PLAYERPLANEDESCRIPTOR_FID_CACHE lpCache = &LAYERPLANEDESCRIPTORFc;
+	if (!lpCache->cached) cacheLAYERPLANEDESCRIPTORFids(env, lpObject, lpCache);
+	lpStruct->crTransparent = (*env)->GetIntField(env, lpObject, lpCache->crTransparent);
+	lpStruct->bReserved = (*env)->GetByteField(env, lpObject, lpCache->bReserved);
+	lpStruct->iLayerPlane = (*env)->GetByteField(env, lpObject, lpCache->iLayerPlane);
+	lpStruct->cAuxBuffers = (*env)->GetByteField(env, lpObject, lpCache->cAuxBuffers);
+	lpStruct->cStencilBits = (*env)->GetByteField(env, lpObject, lpCache->cStencilBits);
+	lpStruct->cDepthBits = (*env)->GetByteField(env, lpObject, lpCache->cDepthBits);
+	lpStruct->cAccumAlphaBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumAlphaBits);
+	lpStruct->cAccumBlueBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumBlueBits);
+	lpStruct->cAccumGreenBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumGreenBits);
+	lpStruct->cAccumRedBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumRedBits);
+	lpStruct->cAccumBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumBits);
+	lpStruct->cAlphaShift = (*env)->GetByteField(env, lpObject, lpCache->cAlphaShift);
+	lpStruct->cAlphaBits = (*env)->GetByteField(env, lpObject, lpCache->cAlphaBits);
+	lpStruct->cBlueShift = (*env)->GetByteField(env, lpObject, lpCache->cBlueShift);
+	lpStruct->cBlueBits = (*env)->GetByteField(env, lpObject, lpCache->cBlueBits);
+	lpStruct->cGreenShift = (*env)->GetByteField(env, lpObject, lpCache->cGreenShift);
+	lpStruct->cGreenBits = (*env)->GetByteField(env, lpObject, lpCache->cGreenBits);
+	lpStruct->cRedShift = (*env)->GetByteField(env, lpObject, lpCache->cRedShift);
+	lpStruct->cRedBits = (*env)->GetByteField(env, lpObject, lpCache->cRedBits);
+	lpStruct->cColorBits = (*env)->GetByteField(env, lpObject, lpCache->cColorBits);
+	lpStruct->iPixelType = (*env)->GetByteField(env, lpObject, lpCache->iPixelType);
+	lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, lpCache->dwFlags);
+	lpStruct->nVersion = (*env)->GetShortField(env, lpObject, lpCache->nVersion);
+	lpStruct->nSize = (*env)->GetShortField(env, lpObject, lpCache->nSize);
+	return lpStruct;
+}
+
+void setLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject, LAYERPLANEDESCRIPTOR *lpStruct)
+{
+	PLAYERPLANEDESCRIPTOR_FID_CACHE lpCache = &LAYERPLANEDESCRIPTORFc;
+	if (!lpCache->cached) cacheLAYERPLANEDESCRIPTORFids(env, lpObject, lpCache);
+	(*env)->SetIntField(env, lpObject, lpCache->crTransparent, (jint)lpStruct->crTransparent);
+	(*env)->SetByteField(env, lpObject, lpCache->bReserved, (jbyte)lpStruct->bReserved);
+	(*env)->SetByteField(env, lpObject, lpCache->iLayerPlane, (jbyte)lpStruct->iLayerPlane);
+	(*env)->SetByteField(env, lpObject, lpCache->cAuxBuffers, (jbyte)lpStruct->cAuxBuffers);
+	(*env)->SetByteField(env, lpObject, lpCache->cStencilBits, (jbyte)lpStruct->cStencilBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cDepthBits, (jbyte)lpStruct->cDepthBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumAlphaBits, (jbyte)lpStruct->cAccumAlphaBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumBlueBits, (jbyte)lpStruct->cAccumBlueBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumGreenBits, (jbyte)lpStruct->cAccumGreenBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumRedBits, (jbyte)lpStruct->cAccumRedBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumBits, (jbyte)lpStruct->cAccumBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAlphaShift, (jbyte)lpStruct->cAlphaShift);
+	(*env)->SetByteField(env, lpObject, lpCache->cAlphaBits, (jbyte)lpStruct->cAlphaBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cBlueShift, (jbyte)lpStruct->cBlueShift);
+	(*env)->SetByteField(env, lpObject, lpCache->cBlueBits, (jbyte)lpStruct->cBlueBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cGreenShift, (jbyte)lpStruct->cGreenShift);
+	(*env)->SetByteField(env, lpObject, lpCache->cGreenBits, (jbyte)lpStruct->cGreenBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cRedShift, (jbyte)lpStruct->cRedShift);
+	(*env)->SetByteField(env, lpObject, lpCache->cRedBits, (jbyte)lpStruct->cRedBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cColorBits, (jbyte)lpStruct->cColorBits);
+	(*env)->SetByteField(env, lpObject, lpCache->iPixelType, (jbyte)lpStruct->iPixelType);
+	(*env)->SetIntField(env, lpObject, lpCache->dwFlags, (jint)lpStruct->dwFlags);
+	(*env)->SetShortField(env, lpObject, lpCache->nVersion, (jshort)lpStruct->nVersion);
+	(*env)->SetShortField(env, lpObject, lpCache->nSize, (jshort)lpStruct->nSize);
+}
+
+typedef struct POINTFLOAT_FID_CACHE {
+	int cached;
+	jclass clazz;
+	jfieldID y, x;
+} POINTFLOAT_FID_CACHE;
+typedef POINTFLOAT_FID_CACHE *PPOINTFLOAT_FID_CACHE;
+
+POINTFLOAT_FID_CACHE POINTFLOATFc;
+
+void cachePOINTFLOATFids(JNIEnv *env, jobject lpObject, PPOINTFLOAT_FID_CACHE lpCache)
+{
+	if (lpCache->cached) return;
+	lpCache->clazz = (*env)->GetObjectClass(env, lpObject);
+	lpCache->y = (*env)->GetFieldID(env, lpCache->clazz, "y", "F");
+	lpCache->x = (*env)->GetFieldID(env, lpCache->clazz, "x", "F");
+	lpCache->cached = 1;
+}
+
+POINTFLOAT *getPOINTFLOATFields(JNIEnv *env, jobject lpObject, POINTFLOAT *lpStruct)
+{
+	PPOINTFLOAT_FID_CACHE lpCache = &POINTFLOATFc;
+	if (!lpCache->cached) cachePOINTFLOATFids(env, lpObject, lpCache);
+	lpStruct->y = (*env)->GetFloatField(env, lpObject, lpCache->y);
+	lpStruct->x = (*env)->GetFloatField(env, lpObject, lpCache->x);
+	return lpStruct;
+}
+
+void setPOINTFLOATFields(JNIEnv *env, jobject lpObject, POINTFLOAT *lpStruct)
+{
+	PPOINTFLOAT_FID_CACHE lpCache = &POINTFLOATFc;
+	if (!lpCache->cached) cachePOINTFLOATFids(env, lpObject, lpCache);
+	(*env)->SetFloatField(env, lpObject, lpCache->y, (jfloat)lpStruct->y);
+	(*env)->SetFloatField(env, lpObject, lpCache->x, (jfloat)lpStruct->x);
+}
+
+typedef struct PIXELFORMATDESCRIPTOR_FID_CACHE {
+	int cached;
+	jclass clazz;
+	jfieldID dwDamageMask, dwVisibleMask, dwLayerMask, bReserved, iLayerType, cAuxBuffers, cStencilBits, cDepthBits, cAccumAlphaBits, cAccumBlueBits, cAccumGreenBits, cAccumRedBits, cAccumBits, cAlphaShift, cAlphaBits, cBlueShift, cBlueBits, cGreenShift, cGreenBits, cRedShift, cRedBits, cColorBits, iPixelType, dwFlags, nVersion, nSize;
+} PIXELFORMATDESCRIPTOR_FID_CACHE;
+typedef PIXELFORMATDESCRIPTOR_FID_CACHE *PPIXELFORMATDESCRIPTOR_FID_CACHE;
+
+PIXELFORMATDESCRIPTOR_FID_CACHE PIXELFORMATDESCRIPTORFc;
+
+void cachePIXELFORMATDESCRIPTORFids(JNIEnv *env, jobject lpObject, PPIXELFORMATDESCRIPTOR_FID_CACHE lpCache)
+{
+	if (lpCache->cached) return;
+	lpCache->clazz = (*env)->GetObjectClass(env, lpObject);
+	lpCache->dwDamageMask = (*env)->GetFieldID(env, lpCache->clazz, "dwDamageMask", "I");
+	lpCache->dwVisibleMask = (*env)->GetFieldID(env, lpCache->clazz, "dwVisibleMask", "I");
+	lpCache->dwLayerMask = (*env)->GetFieldID(env, lpCache->clazz, "dwLayerMask", "I");
+	lpCache->bReserved = (*env)->GetFieldID(env, lpCache->clazz, "bReserved", "B");
+	lpCache->iLayerType = (*env)->GetFieldID(env, lpCache->clazz, "iLayerType", "B");
+	lpCache->cAuxBuffers = (*env)->GetFieldID(env, lpCache->clazz, "cAuxBuffers", "B");
+	lpCache->cStencilBits = (*env)->GetFieldID(env, lpCache->clazz, "cStencilBits", "B");
+	lpCache->cDepthBits = (*env)->GetFieldID(env, lpCache->clazz, "cDepthBits", "B");
+	lpCache->cAccumAlphaBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumAlphaBits", "B");
+	lpCache->cAccumBlueBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumBlueBits", "B");
+	lpCache->cAccumGreenBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumGreenBits", "B");
+	lpCache->cAccumRedBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumRedBits", "B");
+	lpCache->cAccumBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumBits", "B");
+	lpCache->cAlphaShift = (*env)->GetFieldID(env, lpCache->clazz, "cAlphaShift", "B");
+	lpCache->cAlphaBits = (*env)->GetFieldID(env, lpCache->clazz, "cAlphaBits", "B");
+	lpCache->cBlueShift = (*env)->GetFieldID(env, lpCache->clazz, "cBlueShift", "B");
+	lpCache->cBlueBits = (*env)->GetFieldID(env, lpCache->clazz, "cBlueBits", "B");
+	lpCache->cGreenShift = (*env)->GetFieldID(env, lpCache->clazz, "cGreenShift", "B");
+	lpCache->cGreenBits = (*env)->GetFieldID(env, lpCache->clazz, "cGreenBits", "B");
+	lpCache->cRedShift = (*env)->GetFieldID(env, lpCache->clazz, "cRedShift", "B");
+	lpCache->cRedBits = (*env)->GetFieldID(env, lpCache->clazz, "cRedBits", "B");
+	lpCache->cColorBits = (*env)->GetFieldID(env, lpCache->clazz, "cColorBits", "B");
+	lpCache->iPixelType = (*env)->GetFieldID(env, lpCache->clazz, "iPixelType", "B");
+	lpCache->dwFlags = (*env)->GetFieldID(env, lpCache->clazz, "dwFlags", "I");
+	lpCache->nVersion = (*env)->GetFieldID(env, lpCache->clazz, "nVersion", "S");
+	lpCache->nSize = (*env)->GetFieldID(env, lpCache->clazz, "nSize", "S");
+	lpCache->cached = 1;
+}
+
+PIXELFORMATDESCRIPTOR *getPIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject, PIXELFORMATDESCRIPTOR *lpStruct)
+{
+	PPIXELFORMATDESCRIPTOR_FID_CACHE lpCache = &PIXELFORMATDESCRIPTORFc;
+	if (!lpCache->cached) cachePIXELFORMATDESCRIPTORFids(env, lpObject, lpCache);
+	lpStruct->dwDamageMask = (*env)->GetIntField(env, lpObject, lpCache->dwDamageMask);
+	lpStruct->dwVisibleMask = (*env)->GetIntField(env, lpObject, lpCache->dwVisibleMask);
+	lpStruct->dwLayerMask = (*env)->GetIntField(env, lpObject, lpCache->dwLayerMask);
+	lpStruct->bReserved = (*env)->GetByteField(env, lpObject, lpCache->bReserved);
+	lpStruct->iLayerType = (*env)->GetByteField(env, lpObject, lpCache->iLayerType);
+	lpStruct->cAuxBuffers = (*env)->GetByteField(env, lpObject, lpCache->cAuxBuffers);
+	lpStruct->cStencilBits = (*env)->GetByteField(env, lpObject, lpCache->cStencilBits);
+	lpStruct->cDepthBits = (*env)->GetByteField(env, lpObject, lpCache->cDepthBits);
+	lpStruct->cAccumAlphaBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumAlphaBits);
+	lpStruct->cAccumBlueBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumBlueBits);
+	lpStruct->cAccumGreenBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumGreenBits);
+	lpStruct->cAccumRedBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumRedBits);
+	lpStruct->cAccumBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumBits);
+	lpStruct->cAlphaShift = (*env)->GetByteField(env, lpObject, lpCache->cAlphaShift);
+	lpStruct->cAlphaBits = (*env)->GetByteField(env, lpObject, lpCache->cAlphaBits);
+	lpStruct->cBlueShift = (*env)->GetByteField(env, lpObject, lpCache->cBlueShift);
+	lpStruct->cBlueBits = (*env)->GetByteField(env, lpObject, lpCache->cBlueBits);
+	lpStruct->cGreenShift = (*env)->GetByteField(env, lpObject, lpCache->cGreenShift);
+	lpStruct->cGreenBits = (*env)->GetByteField(env, lpObject, lpCache->cGreenBits);
+	lpStruct->cRedShift = (*env)->GetByteField(env, lpObject, lpCache->cRedShift);
+	lpStruct->cRedBits = (*env)->GetByteField(env, lpObject, lpCache->cRedBits);
+	lpStruct->cColorBits = (*env)->GetByteField(env, lpObject, lpCache->cColorBits);
+	lpStruct->iPixelType = (*env)->GetByteField(env, lpObject, lpCache->iPixelType);
+	lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, lpCache->dwFlags);
+	lpStruct->nVersion = (*env)->GetShortField(env, lpObject, lpCache->nVersion);
+	lpStruct->nSize = (*env)->GetShortField(env, lpObject, lpCache->nSize);
+	return lpStruct;
+}
+
+void setPIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject, PIXELFORMATDESCRIPTOR *lpStruct)
+{
+	PPIXELFORMATDESCRIPTOR_FID_CACHE lpCache = &PIXELFORMATDESCRIPTORFc;
+	if (!lpCache->cached) cachePIXELFORMATDESCRIPTORFids(env, lpObject, lpCache);
+	(*env)->SetIntField(env, lpObject, lpCache->dwDamageMask, (jint)lpStruct->dwDamageMask);
+	(*env)->SetIntField(env, lpObject, lpCache->dwVisibleMask, (jint)lpStruct->dwVisibleMask);
+	(*env)->SetIntField(env, lpObject, lpCache->dwLayerMask, (jint)lpStruct->dwLayerMask);
+	(*env)->SetByteField(env, lpObject, lpCache->bReserved, (jbyte)lpStruct->bReserved);
+	(*env)->SetByteField(env, lpObject, lpCache->iLayerType, (jbyte)lpStruct->iLayerType);
+	(*env)->SetByteField(env, lpObject, lpCache->cAuxBuffers, (jbyte)lpStruct->cAuxBuffers);
+	(*env)->SetByteField(env, lpObject, lpCache->cStencilBits, (jbyte)lpStruct->cStencilBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cDepthBits, (jbyte)lpStruct->cDepthBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumAlphaBits, (jbyte)lpStruct->cAccumAlphaBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumBlueBits, (jbyte)lpStruct->cAccumBlueBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumGreenBits, (jbyte)lpStruct->cAccumGreenBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumRedBits, (jbyte)lpStruct->cAccumRedBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumBits, (jbyte)lpStruct->cAccumBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAlphaShift, (jbyte)lpStruct->cAlphaShift);
+	(*env)->SetByteField(env, lpObject, lpCache->cAlphaBits, (jbyte)lpStruct->cAlphaBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cBlueShift, (jbyte)lpStruct->cBlueShift);
+	(*env)->SetByteField(env, lpObject, lpCache->cBlueBits, (jbyte)lpStruct->cBlueBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cGreenShift, (jbyte)lpStruct->cGreenShift);
+	(*env)->SetByteField(env, lpObject, lpCache->cGreenBits, (jbyte)lpStruct->cGreenBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cRedShift, (jbyte)lpStruct->cRedShift);
+	(*env)->SetByteField(env, lpObject, lpCache->cRedBits, (jbyte)lpStruct->cRedBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cColorBits, (jbyte)lpStruct->cColorBits);
+	(*env)->SetByteField(env, lpObject, lpCache->iPixelType, (jbyte)lpStruct->iPixelType);
+	(*env)->SetIntField(env, lpObject, lpCache->dwFlags, (jint)lpStruct->dwFlags);
+	(*env)->SetShortField(env, lpObject, lpCache->nVersion, (jshort)lpStruct->nVersion);
+	(*env)->SetShortField(env, lpObject, lpCache->nSize, (jshort)lpStruct->nSize);
+}
+
diff --git a/bundles/org.eclipse.swt.opengl/win32/library/structs.h b/bundles/org.eclipse.swt.opengl/win32/library/structs.h
index 031dadfc3b..63f8b7b109 100644
--- a/bundles/org.eclipse.swt.opengl/win32/library/structs.h
+++ b/bundles/org.eclipse.swt.opengl/win32/library/structs.h
@@ -1,24 +1,24 @@
-/*******************************************************************************

- * 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

- *******************************************************************************/

-#include <windows.h>

-

-GLYPHMETRICSFLOAT *getGLYPHMETRICSFLOATFields(JNIEnv *env, jobject lpObject, GLYPHMETRICSFLOAT *lpStruct);

-void setGLYPHMETRICSFLOATFields(JNIEnv *env, jobject lpObject, GLYPHMETRICSFLOAT *lpStruct);

-

-LAYERPLANEDESCRIPTOR *getLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject, LAYERPLANEDESCRIPTOR *lpStruct);

-void setLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject, LAYERPLANEDESCRIPTOR *lpStruct);

-

-POINTFLOAT *getPOINTFLOATFields(JNIEnv *env, jobject lpObject, POINTFLOAT *lpStruct);

-void setPOINTFLOATFields(JNIEnv *env, jobject lpObject, POINTFLOAT *lpStruct);

-

-PIXELFORMATDESCRIPTOR *getPIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject, PIXELFORMATDESCRIPTOR *lpStruct);

-void setPIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject, PIXELFORMATDESCRIPTOR *lpStruct);

-

+/*******************************************************************************
+ * 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
+ *******************************************************************************/
+#include <windows.h>
+
+GLYPHMETRICSFLOAT *getGLYPHMETRICSFLOATFields(JNIEnv *env, jobject lpObject, GLYPHMETRICSFLOAT *lpStruct);
+void setGLYPHMETRICSFLOATFields(JNIEnv *env, jobject lpObject, GLYPHMETRICSFLOAT *lpStruct);
+
+LAYERPLANEDESCRIPTOR *getLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject, LAYERPLANEDESCRIPTOR *lpStruct);
+void setLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject, LAYERPLANEDESCRIPTOR *lpStruct);
+
+POINTFLOAT *getPOINTFLOATFields(JNIEnv *env, jobject lpObject, POINTFLOAT *lpStruct);
+void setPOINTFLOATFields(JNIEnv *env, jobject lpObject, POINTFLOAT *lpStruct);
+
+PIXELFORMATDESCRIPTOR *getPIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject, PIXELFORMATDESCRIPTOR *lpStruct);
+void setPIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject, PIXELFORMATDESCRIPTOR *lpStruct);
+
diff --git a/bundles/org.eclipse.swt.opengl/win32/library/swt.rc b/bundles/org.eclipse.swt.opengl/win32/library/swt.rc
index 9cd71aad57..68b7074163 100644
--- a/bundles/org.eclipse.swt.opengl/win32/library/swt.rc
+++ b/bundles/org.eclipse.swt.opengl/win32/library/swt.rc
@@ -1,67 +1,67 @@
-/*******************************************************************************

- * 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

- *******************************************************************************/

- 

-#include "windows.h"

-

-VS_VERSION_INFO VERSIONINFO

- PRODUCTVERSION 0,0,0,0

- FILEFLAGSMASK 0x3fL

-#ifdef _DEBUG

- FILEFLAGS 0x1L

-#else

- FILEFLAGS 0x0L

-#endif

- FILEOS 0x40000L

- FILETYPE 0x2L

- FILESUBTYPE 0x0L

-BEGIN

-    BLOCK "StringFileInfo"

-    BEGIN

-        BLOCK "040904b0"

-        BEGIN

-            VALUE "CompanyName", "IBM Corporation\0"

-            VALUE "FileDescription", "Standard Widget Toolkit\0"

-            VALUE "InternalName", "SWT\0"

-            VALUE "LegalCopyright", "© Copyright 2000, 2003 IBM Corp.  All Rights Reserved.\0"

-            VALUE "OriginalFilename", SWT_ORG_FILENAME

-            VALUE "ProductName", "\0"

-            VALUE "ProductVersion", "0,0,0,0\0"

-        END

-    END

-    BLOCK "VarFileInfo"

-    BEGIN

-        VALUE "Translation", 0x409, 1200

-    END

-END

-

-/* SHMENUBAR Pocket PC 

- * ID_MENU SHMENUBAR DISCARDABLE

- * BEGIN

- * 	ID_MENU, 1,

- *  IMAGE_NONE, ID_MENU_ITEM1, 0, 0,

- *  0, 0, 0,

- * END

- * ID_MENU MENU DISCARDABLE

- * BEGIN

- *  MENUITEM "", ID_MENU_ITEM1

- * END

- */

-100 RCDATA DISCARDABLE 

-BEGIN

-    100, 1,

-    -2, 101, 0, 0, 

-    0, 0, 0,

-END

-

-100 MENU DISCARDABLE

-BEGIN

-	MENUITEM "", 101

+/*******************************************************************************
+ * 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
+ *******************************************************************************/
+ 
+#include "windows.h"
+
+VS_VERSION_INFO VERSIONINFO
+ PRODUCTVERSION 0,0,0,0
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x40000L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "CompanyName", "IBM Corporation\0"
+            VALUE "FileDescription", "Standard Widget Toolkit\0"
+            VALUE "InternalName", "SWT\0"
+            VALUE "LegalCopyright", "© Copyright 2000, 2003 IBM Corp.  All Rights Reserved.\0"
+            VALUE "OriginalFilename", SWT_ORG_FILENAME
+            VALUE "ProductName", "\0"
+            VALUE "ProductVersion", "0,0,0,0\0"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+/* SHMENUBAR Pocket PC 
+ * ID_MENU SHMENUBAR DISCARDABLE
+ * BEGIN
+ * 	ID_MENU, 1,
+ *  IMAGE_NONE, ID_MENU_ITEM1, 0, 0,
+ *  0, 0, 0,
+ * END
+ * ID_MENU MENU DISCARDABLE
+ * BEGIN
+ *  MENUITEM "", ID_MENU_ITEM1
+ * END
+ */
+100 RCDATA DISCARDABLE 
+BEGIN
+    100, 1,
+    -2, 101, 0, 0, 
+    0, 0, 0,
+END
+
+100 MENU DISCARDABLE
+BEGIN
+	MENUITEM "", 101
 END
\ No newline at end of file