/*******************************************************************************
 * 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")
}