Skip to main content
aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--bundles/org.eclipse.swt.opengl/common/library/glu.c688
-rw-r--r--bundles/org.eclipse.swt.opengl/common/library/glu.h6
-rw-r--r--bundles/org.eclipse.swt.opengl/common/library/glu_stats.c82
-rw-r--r--bundles/org.eclipse.swt.opengl/common/library/glu_stats.h64
-rw-r--r--bundles/org.eclipse.swt.opengl/common/library/glu_structs.c3
-rw-r--r--bundles/org.eclipse.swt.opengl/common/library/glu_structs.h2
-rw-r--r--bundles/org.eclipse.swt.tools/JNI Generation/org/eclipse/swt/tools/internal/org.eclipse.swt.opengl.GLU.properties1745
7 files changed, 2372 insertions, 218 deletions
diff --git a/bundles/org.eclipse.swt.opengl/common/library/glu.c b/bundles/org.eclipse.swt.opengl/common/library/glu.c
index 5f49ee97e6..f83c1ec1be 100644
--- a/bundles/org.eclipse.swt.opengl/common/library/glu.c
+++ b/bundles/org.eclipse.swt.opengl/common/library/glu.c
@@ -1,354 +1,498 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2003 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Common Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/cpl-v10.html
- *
- * Contributors:
- * IBM Corporation - initial API and implementation
- *******************************************************************************/
-#ifdef WIN32
-#include <windows.h>
-#endif
-#include <GL/glu.h>
#include "swt.h"
+#include "glu_structs.h"
+#include "glu_stats.h"
#define GLU_NATIVE(func) Java_org_eclipse_swt_opengl_GLU_##func
+#ifndef NO_gluBeginCurve
JNIEXPORT void JNICALL GLU_NATIVE(gluBeginCurve)
(JNIEnv *env, jclass that, jint arg0)
{
- NATIVE_ENTER(env, that, "gluBeginCurve\n")
- gluBeginCurve((GLUnurbsObj *)arg0);
- NATIVE_EXIT(env, that, "gluBeginCurve\n")
+ GLU_NATIVE_ENTER(env, that, gluBeginCurve_FUNC);
+ gluBeginCurve((GLUnurbs *)arg0);
+ GLU_NATIVE_EXIT(env, that, gluBeginCurve_FUNC);
}
+#endif
+#ifndef NO_gluBeginPolygon
JNIEXPORT void JNICALL GLU_NATIVE(gluBeginPolygon)
(JNIEnv *env, jclass that, jint arg0)
{
- NATIVE_ENTER(env, that, "gluBeginPolygon\n")
- gluBeginPolygon((GLUtesselator *)arg0);
- NATIVE_EXIT(env, that, "gluBeginPolygon\n")
+ GLU_NATIVE_ENTER(env, that, gluBeginPolygon_FUNC);
+ gluBeginPolygon((GLUtesselator*)arg0);
+ GLU_NATIVE_EXIT(env, that, gluBeginPolygon_FUNC);
}
+#endif
+#ifndef NO_gluBeginSurface
JNIEXPORT void JNICALL GLU_NATIVE(gluBeginSurface)
(JNIEnv *env, jclass that, jint arg0)
{
- NATIVE_ENTER(env, that, "gluBeginSurface\n")
+ GLU_NATIVE_ENTER(env, that, gluBeginSurface_FUNC);
gluBeginSurface((GLUnurbs *)arg0);
- NATIVE_EXIT(env, that, "gluBeginSurface\n")
+ GLU_NATIVE_EXIT(env, that, gluBeginSurface_FUNC);
}
+#endif
+#ifndef NO_gluBeginTrim
JNIEXPORT void JNICALL GLU_NATIVE(gluBeginTrim)
(JNIEnv *env, jclass that, jint arg0)
{
- NATIVE_ENTER(env, that, "gluBeginTrim\n")
+ GLU_NATIVE_ENTER(env, that, gluBeginTrim_FUNC);
gluBeginTrim((GLUnurbs *)arg0);
- NATIVE_EXIT(env, that, "gluBeginTrim\n")
+ GLU_NATIVE_EXIT(env, that, gluBeginTrim_FUNC);
}
+#endif
+#ifndef NO_gluBuild1DMipmaps
JNIEXPORT jint JNICALL GLU_NATIVE(gluBuild1DMipmaps)
(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5)
{
- jint rc;
- NATIVE_ENTER(env, that, "gluBuild1DMipmaps\n")
+ jint rc;
+ GLU_NATIVE_ENTER(env, that, gluBuild1DMipmaps_FUNC);
rc = (jint)gluBuild1DMipmaps(arg0, arg1, arg2, arg3, arg4, (const void *)arg5);
- NATIVE_EXIT(env, that, "gluBuild1DMipmaps\n")
+ GLU_NATIVE_EXIT(env, that, gluBuild1DMipmaps_FUNC);
return rc;
}
+#endif
-/*
-JNIEXPORT jint JNICALL GLU_NATIVE(gluBuild2DMipmaps)
- (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6)
-{
- jint rc;
- NATIVE_ENTER(env, that, "gluBuild2DMipmaps\n")
- rc = (jint)gluBuild2DMipmaps(arg0, arg1, arg2, arg3, arg4, arg5, (const void *)arg6);
- NATIVE_EXIT(env, that, "gluBuild2DMipmaps\n")
- return rc;
-}
-*/
-
+#ifndef NO_gluBuild2DMipmaps
JNIEXPORT jint JNICALL GLU_NATIVE(gluBuild2DMipmaps)
(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jbyteArray arg6)
{
jbyte *lparg6=NULL;
jint rc;
-
- NATIVE_ENTER(env, that, "gluBuild2DMipmaps\n")
- if (arg6) lparg6 = (*env)->GetByteArrayElements(env, arg6, NULL);
- rc = (jint)gluBuild2DMipmaps(arg0, arg1, arg2, arg3, arg4, arg5, (const void *)lparg6);
- if (arg6) (*env)->ReleaseByteArrayElements(env, arg6, lparg6, 0);
- NATIVE_EXIT(env, that, "gluBuild2DMipmaps\n")
+ GLU_NATIVE_ENTER(env, that, gluBuild2DMipmaps_FUNC);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg6) lparg6 = (*env)->GetPrimitiveArrayCritical(env, arg6, NULL);
+ } else
+#endif
+ {
+ if (arg6) lparg6 = (*env)->GetByteArrayElements(env, arg6, NULL);
+ }
+ rc = (jint)gluBuild2DMipmaps(arg0, arg1, arg2, arg3, arg4, arg5, lparg6);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg6) (*env)->ReleasePrimitiveArrayCritical(env, arg6, lparg6, 0);
+ } else
+#endif
+ {
+ if (arg6) (*env)->ReleaseByteArrayElements(env, arg6, lparg6, 0);
+ }
+ GLU_NATIVE_EXIT(env, that, gluBuild2DMipmaps_FUNC);
return rc;
}
+#endif
+#ifndef NO_gluCylinder
JNIEXPORT void JNICALL GLU_NATIVE(gluCylinder)
(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jdouble arg3, jint arg4, jint arg5)
{
- NATIVE_ENTER(env, that, "gluCylinder\n")
+ GLU_NATIVE_ENTER(env, that, gluCylinder_FUNC);
gluCylinder((GLUquadric *)arg0, arg1, arg2, arg3, arg4, arg5);
- NATIVE_EXIT(env, that, "gluCylinder\n")
+ GLU_NATIVE_EXIT(env, that, gluCylinder_FUNC);
}
+#endif
+#ifndef NO_gluDeleteNurbsRenderer
JNIEXPORT void JNICALL GLU_NATIVE(gluDeleteNurbsRenderer)
(JNIEnv *env, jclass that, jint arg0)
{
- NATIVE_ENTER(env, that, "gluDeleteNurbsRenderer\n")
+ GLU_NATIVE_ENTER(env, that, gluDeleteNurbsRenderer_FUNC);
gluDeleteNurbsRenderer((GLUnurbs *)arg0);
- NATIVE_EXIT(env, that, "gluDeleteNurbsRenderer\n")
+ GLU_NATIVE_EXIT(env, that, gluDeleteNurbsRenderer_FUNC);
}
+#endif
+#ifndef NO_gluDeleteQuadric
JNIEXPORT void JNICALL GLU_NATIVE(gluDeleteQuadric)
(JNIEnv *env, jclass that, jint arg0)
{
- NATIVE_ENTER(env, that, "gluDeleteQuadric\n")
+ GLU_NATIVE_ENTER(env, that, gluDeleteQuadric_FUNC);
gluDeleteQuadric((GLUquadric *)arg0);
- NATIVE_EXIT(env, that, "gluDeleteQuadric\n")
+ GLU_NATIVE_EXIT(env, that, gluDeleteQuadric_FUNC);
}
+#endif
+#ifndef NO_gluDeleteTess
JNIEXPORT void JNICALL GLU_NATIVE(gluDeleteTess)
(JNIEnv *env, jclass that, jint arg0)
{
- NATIVE_ENTER(env, that, "gluDeleteTess\n")
+ GLU_NATIVE_ENTER(env, that, gluDeleteTess_FUNC);
gluDeleteTess((GLUtesselator *)arg0);
- NATIVE_EXIT(env, that, "gluDeleteTess\n")
+ GLU_NATIVE_EXIT(env, that, gluDeleteTess_FUNC);
}
+#endif
+#ifndef NO_gluDisk
JNIEXPORT void JNICALL GLU_NATIVE(gluDisk)
(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4)
{
- NATIVE_ENTER(env, that, "gluDisk\n")
- gluDisk((GLUquadric *)arg0, arg1, arg2, arg3, arg4);
- NATIVE_EXIT(env, that, "gluDisk\n")
+ GLU_NATIVE_ENTER(env, that, gluDisk_FUNC);
+ gluDisk((GLUquadricObj *)arg0, arg1, arg2, arg3, arg4);
+ GLU_NATIVE_EXIT(env, that, gluDisk_FUNC);
}
+#endif
+#ifndef NO_gluEndCurve
JNIEXPORT void JNICALL GLU_NATIVE(gluEndCurve)
(JNIEnv *env, jclass that, jint arg0)
{
- NATIVE_ENTER(env, that, "gluEndCurve\n")
+ GLU_NATIVE_ENTER(env, that, gluEndCurve_FUNC);
gluEndCurve((GLUnurbsObj *)arg0);
- NATIVE_EXIT(env, that, "gluEndCurve\n")
+ GLU_NATIVE_EXIT(env, that, gluEndCurve_FUNC);
}
+#endif
+#ifndef NO_gluEndPolygon
JNIEXPORT void JNICALL GLU_NATIVE(gluEndPolygon)
(JNIEnv *env, jclass that, jint arg0)
{
- NATIVE_ENTER(env, that, "gluEndPolygon\n")
- gluEndPolygon((GLUtesselator *)arg0);
- NATIVE_EXIT(env, that, "gluEndPolygon\n")
+ GLU_NATIVE_ENTER(env, that, gluEndPolygon_FUNC);
+ gluEndPolygon((GLUtriangulatorObj *)arg0);
+ GLU_NATIVE_EXIT(env, that, gluEndPolygon_FUNC);
}
+#endif
+#ifndef NO_gluEndSurface
JNIEXPORT void JNICALL GLU_NATIVE(gluEndSurface)
(JNIEnv *env, jclass that, jint arg0)
{
- NATIVE_ENTER(env, that, "gluEndSurface\n")
- gluEndSurface((GLUnurbs *)arg0);
- NATIVE_EXIT(env, that, "gluEndSurface\n")
+ GLU_NATIVE_ENTER(env, that, gluEndSurface_FUNC);
+ gluEndSurface((GLUnurbsObj *)arg0);
+ GLU_NATIVE_EXIT(env, that, gluEndSurface_FUNC);
}
+#endif
+#ifndef NO_gluEndTrim
JNIEXPORT void JNICALL GLU_NATIVE(gluEndTrim)
(JNIEnv *env, jclass that, jint arg0)
{
- NATIVE_ENTER(env, that, "gluEndTrim\n")
- gluEndTrim((GLUnurbs *)arg0);
- NATIVE_EXIT(env, that, "gluEndTrim\n")
+ GLU_NATIVE_ENTER(env, that, gluEndTrim_FUNC);
+ gluEndTrim((GLUnurbsObj *)arg0);
+ GLU_NATIVE_EXIT(env, that, gluEndTrim_FUNC);
}
+#endif
+#ifndef NO_gluErrorString
JNIEXPORT jint JNICALL GLU_NATIVE(gluErrorString)
(JNIEnv *env, jclass that, jint arg0)
{
- jint rc;
- NATIVE_ENTER(env, that, "gluErrorString\n")
+ jint rc;
+ GLU_NATIVE_ENTER(env, that, gluErrorString_FUNC);
rc = (jint)gluErrorString(arg0);
- NATIVE_EXIT(env, that, "gluErrorString\n")
+ GLU_NATIVE_EXIT(env, that, gluErrorString_FUNC);
return rc;
}
+#endif
+#ifndef NO_gluGetNurbsProperty
JNIEXPORT void JNICALL GLU_NATIVE(gluGetNurbsProperty)
(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
{
jfloat *lparg2=NULL;
-
- NATIVE_ENTER(env, that, "gluGetNurbsProperty\n")
- if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+ GLU_NATIVE_ENTER(env, that, gluGetNurbsProperty_FUNC);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
+ } else
+#endif
+ {
+ if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+ }
gluGetNurbsProperty((GLUnurbs *)arg0, arg1, lparg2);
- if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
- NATIVE_EXIT(env, that, "gluGetNurbsProperty\n")
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+ } else
+#endif
+ {
+ if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+ }
+ GLU_NATIVE_EXIT(env, that, gluGetNurbsProperty_FUNC);
}
+#endif
+#ifndef NO_gluGetString
JNIEXPORT jint JNICALL GLU_NATIVE(gluGetString)
(JNIEnv *env, jclass that, jint arg0)
{
- jint rc;
- NATIVE_ENTER(env, that, "gluGetString\n")
+ jint rc;
+ GLU_NATIVE_ENTER(env, that, gluGetString_FUNC);
rc = (jint)gluGetString(arg0);
- NATIVE_EXIT(env, that, "gluGetString\n")
+ GLU_NATIVE_EXIT(env, that, gluGetString_FUNC);
return rc;
}
+#endif
+#ifndef NO_gluGetTessProperty
JNIEXPORT void JNICALL GLU_NATIVE(gluGetTessProperty)
(JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2)
{
jdouble *lparg2=NULL;
-
- NATIVE_ENTER(env, that, "gluGetTessProperty\n")
- if (arg2) lparg2 = (*env)->GetDoubleArrayElements(env, arg2, NULL);
+ GLU_NATIVE_ENTER(env, that, gluGetTessProperty_FUNC);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
+ } else
+#endif
+ {
+ if (arg2) lparg2 = (*env)->GetDoubleArrayElements(env, arg2, NULL);
+ }
gluGetTessProperty((GLUtesselator *)arg0, arg1, lparg2);
- if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0);
- NATIVE_EXIT(env, that, "gluGetTessProperty\n")
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+ } else
+#endif
+ {
+ if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0);
+ }
+ GLU_NATIVE_EXIT(env, that, gluGetTessProperty_FUNC);
}
+#endif
+#ifndef NO_gluLoadSamplingMatrices
JNIEXPORT void JNICALL GLU_NATIVE(gluLoadSamplingMatrices)
(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1, jfloatArray arg2, jintArray arg3)
{
jfloat *lparg1=NULL;
jfloat *lparg2=NULL;
jint *lparg3=NULL;
-
- NATIVE_ENTER(env, that, "gluLoadSamplingMatrices\n")
- if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);
- if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
- if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
- gluLoadSamplingMatrices((GLUnurbs *)arg0, lparg1, lparg2, (GLint *)lparg3);
- if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
- if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
- if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
- NATIVE_EXIT(env, that, "gluLoadSamplingMatrices\n")
+ GLU_NATIVE_ENTER(env, that, gluLoadSamplingMatrices_FUNC);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
+ if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
+ if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
+ } else
+#endif
+ {
+ if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);
+ if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+ if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
+ }
+ gluLoadSamplingMatrices((GLUnurbs *)arg0, lparg1, lparg2, lparg3);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
+ if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+ if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+ } else
+#endif
+ {
+ if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
+ if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+ if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
+ }
+ GLU_NATIVE_EXIT(env, that, gluLoadSamplingMatrices_FUNC);
}
+#endif
+#ifndef NO_gluLookAt
JNIEXPORT void JNICALL GLU_NATIVE(gluLookAt)
(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3, jdouble arg4, jdouble arg5, jdouble arg6, jdouble arg7, jdouble arg8)
{
- NATIVE_ENTER(env, that, "gluLookAt\n")
+ GLU_NATIVE_ENTER(env, that, gluLookAt_FUNC);
gluLookAt(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
- NATIVE_EXIT(env, that, "gluLookAt\n")
+ GLU_NATIVE_EXIT(env, that, gluLookAt_FUNC);
}
+#endif
+#ifndef NO_gluNewNurbsRenderer
JNIEXPORT jint JNICALL GLU_NATIVE(gluNewNurbsRenderer)
(JNIEnv *env, jclass that)
{
- jint rc;
- NATIVE_ENTER(env, that, "gluNewNurbsRenderer\n")
+ jint rc;
+ GLU_NATIVE_ENTER(env, that, gluNewNurbsRenderer_FUNC);
rc = (jint)gluNewNurbsRenderer();
- NATIVE_EXIT(env, that, "gluNewNurbsRenderer\n")
+ GLU_NATIVE_EXIT(env, that, gluNewNurbsRenderer_FUNC);
return rc;
}
+#endif
+#ifndef NO_gluNewQuadric
JNIEXPORT jint JNICALL GLU_NATIVE(gluNewQuadric)
(JNIEnv *env, jclass that)
{
- jint rc;
- NATIVE_ENTER(env, that, "gluNewQuadric\n")
+ jint rc;
+ GLU_NATIVE_ENTER(env, that, gluNewQuadric_FUNC);
rc = (jint)gluNewQuadric();
- NATIVE_EXIT(env, that, "gluNewQuadric\n")
+ GLU_NATIVE_EXIT(env, that, gluNewQuadric_FUNC);
return rc;
}
+#endif
+#ifndef NO_gluNewTess
JNIEXPORT jint JNICALL GLU_NATIVE(gluNewTess)
(JNIEnv *env, jclass that)
{
- jint rc;
- NATIVE_ENTER(env, that, "gluNewTess\n")
+ jint rc;
+ GLU_NATIVE_ENTER(env, that, gluNewTess_FUNC);
rc = (jint)gluNewTess();
- NATIVE_EXIT(env, that, "gluNewTess\n")
+ GLU_NATIVE_EXIT(env, that, gluNewTess_FUNC);
return rc;
}
+#endif
+#ifndef NO_gluNextContour
JNIEXPORT void JNICALL GLU_NATIVE(gluNextContour)
(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
- NATIVE_ENTER(env, that, "gluNextContour\n")
+ GLU_NATIVE_ENTER(env, that, gluNextContour_FUNC);
gluNextContour((GLUtesselator *)arg0, arg1);
- NATIVE_EXIT(env, that, "gluNextContour\n")
+ GLU_NATIVE_EXIT(env, that, gluNextContour_FUNC);
}
+#endif
+#ifndef NO_gluNurbsCallback
JNIEXPORT void JNICALL GLU_NATIVE(gluNurbsCallback)
(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
- NATIVE_ENTER(env, that, "gluNurbsCallback\n")
- gluNurbsCallback((GLUnurbs *)arg0, arg1, (GLvoid(*))arg2);
- NATIVE_EXIT(env, that, "gluNurbsCallback\n")
+ GLU_NATIVE_ENTER(env, that, gluNurbsCallback_FUNC);
+ gluNurbsCallback((GLUnurbs *)arg0, arg1, (void (__stdcall *)())arg2);
+ GLU_NATIVE_EXIT(env, that, gluNurbsCallback_FUNC);
}
+#endif
+#ifndef NO_gluNurbsCurve
JNIEXPORT void JNICALL GLU_NATIVE(gluNurbsCurve)
(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2, jint arg3, jfloatArray arg4, jint arg5, jint arg6)
{
jfloat *lparg2=NULL;
jfloat *lparg4=NULL;
-
- NATIVE_ENTER(env, that, "gluNurbsCurve\n")
- if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
- if (arg4) lparg4 = (*env)->GetFloatArrayElements(env, arg4, NULL);
+ GLU_NATIVE_ENTER(env, that, gluNurbsCurve_FUNC);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
+ if (arg4) lparg4 = (*env)->GetPrimitiveArrayCritical(env, arg4, NULL);
+ } else
+#endif
+ {
+ if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+ if (arg4) lparg4 = (*env)->GetFloatArrayElements(env, arg4, NULL);
+ }
gluNurbsCurve((GLUnurbs *)arg0, arg1, lparg2, arg3, lparg4, arg5, arg6);
- if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
- if (arg4) (*env)->ReleaseFloatArrayElements(env, arg4, lparg4, 0);
- NATIVE_EXIT(env, that, "gluNurbsCurve\n")
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg4) (*env)->ReleasePrimitiveArrayCritical(env, arg4, lparg4, 0);
+ if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+ } else
+#endif
+ {
+ if (arg4) (*env)->ReleaseFloatArrayElements(env, arg4, lparg4, 0);
+ if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+ }
+ GLU_NATIVE_EXIT(env, that, gluNurbsCurve_FUNC);
}
+#endif
+#ifndef NO_gluNurbsProperty
JNIEXPORT void JNICALL GLU_NATIVE(gluNurbsProperty)
(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
{
- NATIVE_ENTER(env, that, "gluNurbsProperty\n")
+ GLU_NATIVE_ENTER(env, that, gluNurbsProperty_FUNC);
gluNurbsProperty((GLUnurbs *)arg0, arg1, arg2);
- NATIVE_EXIT(env, that, "gluNurbsProperty\n")
+ GLU_NATIVE_EXIT(env, that, gluNurbsProperty_FUNC);
}
+#endif
+#ifndef NO_gluNurbsSurface
JNIEXPORT void JNICALL GLU_NATIVE(gluNurbsSurface)
(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2, jint arg3, jfloatArray arg4, jint arg5, jint arg6, jfloatArray arg7, jint arg8, jint arg9, jint arg10)
{
jfloat *lparg2=NULL;
jfloat *lparg4=NULL;
jfloat *lparg7=NULL;
-
- NATIVE_ENTER(env, that, "gluNurbsSurface\n")
- if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
- if (arg4) lparg4 = (*env)->GetFloatArrayElements(env, arg4, NULL);
- if (arg7) lparg7 = (*env)->GetFloatArrayElements(env, arg7, NULL);
- gluNurbsSurface((GLUnurbs *)arg0, arg1, lparg2, arg3, lparg4, arg5, arg6, lparg7, arg8, arg9, arg10);
- if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
- if (arg4) (*env)->ReleaseFloatArrayElements(env, arg4, lparg4, 0);
- if (arg7) (*env)->ReleaseFloatArrayElements(env, arg7, lparg7, 0);
- NATIVE_EXIT(env, that, "gluNurbsSurface\n")
+ GLU_NATIVE_ENTER(env, that, gluNurbsSurface_FUNC);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
+ if (arg4) lparg4 = (*env)->GetPrimitiveArrayCritical(env, arg4, NULL);
+ if (arg7) lparg7 = (*env)->GetPrimitiveArrayCritical(env, arg7, NULL);
+ } else
+#endif
+ {
+ if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+ if (arg4) lparg4 = (*env)->GetFloatArrayElements(env, arg4, NULL);
+ if (arg7) lparg7 = (*env)->GetFloatArrayElements(env, arg7, NULL);
+ }
+ gluNurbsSurface((GLUnurbsObj *)arg0, arg1, lparg2, arg3, lparg4, arg5, arg6, lparg7, arg8, arg9, arg10);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg7) (*env)->ReleasePrimitiveArrayCritical(env, arg7, lparg7, 0);
+ if (arg4) (*env)->ReleasePrimitiveArrayCritical(env, arg4, lparg4, 0);
+ if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+ } else
+#endif
+ {
+ if (arg7) (*env)->ReleaseFloatArrayElements(env, arg7, lparg7, 0);
+ if (arg4) (*env)->ReleaseFloatArrayElements(env, arg4, lparg4, 0);
+ if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+ }
+ GLU_NATIVE_EXIT(env, that, gluNurbsSurface_FUNC);
}
+#endif
+#ifndef NO_gluOrtho2D
JNIEXPORT void JNICALL GLU_NATIVE(gluOrtho2D)
(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
{
- NATIVE_ENTER(env, that, "gluOrtho2D\n")
+ GLU_NATIVE_ENTER(env, that, gluOrtho2D_FUNC);
gluOrtho2D(arg0, arg1, arg2, arg3);
- NATIVE_EXIT(env, that, "gluOrtho2D\n")
+ GLU_NATIVE_EXIT(env, that, gluOrtho2D_FUNC);
}
+#endif
+#ifndef NO_gluPartialDisk
JNIEXPORT void JNICALL GLU_NATIVE(gluPartialDisk)
(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4, jdouble arg5, jdouble arg6)
{
- NATIVE_ENTER(env, that, "gluPartialDisk\n")
+ GLU_NATIVE_ENTER(env, that, gluPartialDisk_FUNC);
gluPartialDisk((GLUquadric *)arg0, arg1, arg2, arg3, arg4, arg5, arg6);
- NATIVE_EXIT(env, that, "gluPartialDisk\n")
+ GLU_NATIVE_EXIT(env, that, gluPartialDisk_FUNC);
}
+#endif
+#ifndef NO_gluPerspective
JNIEXPORT void JNICALL GLU_NATIVE(gluPerspective)
(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
{
- NATIVE_ENTER(env, that, "gluPerspective\n")
+ GLU_NATIVE_ENTER(env, that, gluPerspective_FUNC);
gluPerspective(arg0, arg1, arg2, arg3);
- NATIVE_EXIT(env, that, "gluPerspective\n")
+ GLU_NATIVE_EXIT(env, that, gluPerspective_FUNC);
}
+#endif
+#ifndef NO_gluPickMatrix
JNIEXPORT void JNICALL GLU_NATIVE(gluPickMatrix)
(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3, jintArray arg4)
{
jint *lparg4=NULL;
-
- NATIVE_ENTER(env, that, "gluPickMatrix\n")
- if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL);
- gluPickMatrix(arg0, arg1, arg2, arg3, (GLint *)lparg4);
- if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
- NATIVE_EXIT(env, that, "gluPickMatrix\n")
+ GLU_NATIVE_ENTER(env, that, gluPickMatrix_FUNC);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg4) lparg4 = (*env)->GetPrimitiveArrayCritical(env, arg4, NULL);
+ } else
+#endif
+ {
+ if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL);
+ }
+ gluPickMatrix(arg0, arg1, arg2, arg3, lparg4);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg4) (*env)->ReleasePrimitiveArrayCritical(env, arg4, lparg4, 0);
+ } else
+#endif
+ {
+ if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
+ }
+ GLU_NATIVE_EXIT(env, that, gluPickMatrix_FUNC);
}
+#endif
+#ifndef NO_gluProject
JNIEXPORT jint JNICALL GLU_NATIVE(gluProject)
(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdoubleArray arg3, jdoubleArray arg4, jintArray arg5, jdoubleArray arg6, jdoubleArray arg7, jdoubleArray arg8)
{
@@ -359,163 +503,246 @@ JNIEXPORT jint JNICALL GLU_NATIVE(gluProject)
jdouble *lparg7=NULL;
jdouble *lparg8=NULL;
jint rc;
-
- NATIVE_ENTER(env, that, "gluProject\n")
- if (arg3) lparg3 = (*env)->GetDoubleArrayElements(env, arg3, NULL);
- if (arg4) lparg4 = (*env)->GetDoubleArrayElements(env, arg4, NULL);
- if (arg5) lparg5 = (*env)->GetIntArrayElements(env, arg5, NULL);
- if (arg6) lparg6 = (*env)->GetDoubleArrayElements(env, arg6, NULL);
- if (arg7) lparg7 = (*env)->GetDoubleArrayElements(env, arg7, NULL);
- if (arg8) lparg8 = (*env)->GetDoubleArrayElements(env, arg8, NULL);
- rc = (jint)gluProject(arg0, arg1, arg2, lparg3, lparg4, (GLint *)lparg5, lparg6, lparg7, lparg8);
- if (arg3) (*env)->ReleaseDoubleArrayElements(env, arg3, lparg3, 0);
- if (arg4) (*env)->ReleaseDoubleArrayElements(env, arg4, lparg4, 0);
- if (arg5) (*env)->ReleaseIntArrayElements(env, arg5, lparg5, 0);
- if (arg6) (*env)->ReleaseDoubleArrayElements(env, arg6, lparg6, 0);
- if (arg7) (*env)->ReleaseDoubleArrayElements(env, arg7, lparg7, 0);
- if (arg8) (*env)->ReleaseDoubleArrayElements(env, arg8, lparg8, 0);
- NATIVE_EXIT(env, that, "gluProject\n")
+ GLU_NATIVE_ENTER(env, that, gluProject_FUNC);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
+ if (arg4) lparg4 = (*env)->GetPrimitiveArrayCritical(env, arg4, NULL);
+ if (arg5) lparg5 = (*env)->GetPrimitiveArrayCritical(env, arg5, NULL);
+ if (arg6) lparg6 = (*env)->GetPrimitiveArrayCritical(env, arg6, NULL);
+ if (arg7) lparg7 = (*env)->GetPrimitiveArrayCritical(env, arg7, NULL);
+ if (arg8) lparg8 = (*env)->GetPrimitiveArrayCritical(env, arg8, NULL);
+ } else
+#endif
+ {
+ if (arg3) lparg3 = (*env)->GetDoubleArrayElements(env, arg3, NULL);
+ if (arg4) lparg4 = (*env)->GetDoubleArrayElements(env, arg4, NULL);
+ if (arg5) lparg5 = (*env)->GetIntArrayElements(env, arg5, NULL);
+ if (arg6) lparg6 = (*env)->GetDoubleArrayElements(env, arg6, NULL);
+ if (arg7) lparg7 = (*env)->GetDoubleArrayElements(env, arg7, NULL);
+ if (arg8) lparg8 = (*env)->GetDoubleArrayElements(env, arg8, NULL);
+ }
+ rc = (jint)gluProject(arg0, arg1, arg2, lparg3, lparg4, lparg5, lparg6, lparg7, lparg8);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg8) (*env)->ReleasePrimitiveArrayCritical(env, arg8, lparg8, 0);
+ if (arg7) (*env)->ReleasePrimitiveArrayCritical(env, arg7, lparg7, 0);
+ if (arg6) (*env)->ReleasePrimitiveArrayCritical(env, arg6, lparg6, 0);
+ if (arg5) (*env)->ReleasePrimitiveArrayCritical(env, arg5, lparg5, 0);
+ if (arg4) (*env)->ReleasePrimitiveArrayCritical(env, arg4, lparg4, 0);
+ if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
+ } else
+#endif
+ {
+ if (arg8) (*env)->ReleaseDoubleArrayElements(env, arg8, lparg8, 0);
+ if (arg7) (*env)->ReleaseDoubleArrayElements(env, arg7, lparg7, 0);
+ if (arg6) (*env)->ReleaseDoubleArrayElements(env, arg6, lparg6, 0);
+ if (arg5) (*env)->ReleaseIntArrayElements(env, arg5, lparg5, 0);
+ if (arg4) (*env)->ReleaseDoubleArrayElements(env, arg4, lparg4, 0);
+ if (arg3) (*env)->ReleaseDoubleArrayElements(env, arg3, lparg3, 0);
+ }
+ GLU_NATIVE_EXIT(env, that, gluProject_FUNC);
return rc;
}
+#endif
+#ifndef NO_gluPwlCurve
JNIEXPORT void JNICALL GLU_NATIVE(gluPwlCurve)
(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2, jint arg3, jint arg4)
{
jfloat *lparg2=NULL;
-
- NATIVE_ENTER(env, that, "gluPwlCurve\n")
- if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+ GLU_NATIVE_ENTER(env, that, gluPwlCurve_FUNC);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
+ } else
+#endif
+ {
+ if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+ }
gluPwlCurve((GLUnurbs *)arg0, arg1, lparg2, arg3, arg4);
- if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
- NATIVE_EXIT(env, that, "gluPwlCurve\n")
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
+ } else
+#endif
+ {
+ if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+ }
+ GLU_NATIVE_EXIT(env, that, gluPwlCurve_FUNC);
}
+#endif
+#ifndef NO_gluQuadricCallback
JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricCallback)
(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
- NATIVE_ENTER(env, that, "gluQuadricCallback\n")
- gluQuadricCallback((GLUquadric *)arg0, arg1, (GLvoid(*))arg2);
- NATIVE_EXIT(env, that, "gluQuadricCallback\n")
+ GLU_NATIVE_ENTER(env, that, gluQuadricCallback_FUNC);
+ gluQuadricCallback((GLUquadricObj *)arg0, arg1, (void (__stdcall *)())arg2);
+ GLU_NATIVE_EXIT(env, that, gluQuadricCallback_FUNC);
}
+#endif
+#ifndef NO_gluQuadricDrawStyle
JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricDrawStyle)
(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
- NATIVE_ENTER(env, that, "gluQuadricDrawStyle\n")
- gluQuadricDrawStyle((GLUquadric *)arg0, arg1);
- NATIVE_EXIT(env, that, "gluQuadricDrawStyle\n")
+ GLU_NATIVE_ENTER(env, that, gluQuadricDrawStyle_FUNC);
+ gluQuadricDrawStyle((GLUquadricObj *)arg0, arg1);
+ GLU_NATIVE_EXIT(env, that, gluQuadricDrawStyle_FUNC);
}
+#endif
+#ifndef NO_gluQuadricNormals
JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricNormals)
(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
- NATIVE_ENTER(env, that, "gluQuadricNormals\n")
- gluQuadricNormals((GLUquadric *)arg0, arg1);
- NATIVE_EXIT(env, that, "gluQuadricNormals\n")
+ GLU_NATIVE_ENTER(env, that, gluQuadricNormals_FUNC);
+ gluQuadricNormals((GLUquadricObj *)arg0, arg1);
+ GLU_NATIVE_EXIT(env, that, gluQuadricNormals_FUNC);
}
+#endif
+#ifndef NO_gluQuadricOrientation
JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricOrientation)
(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
- NATIVE_ENTER(env, that, "gluQuadricOrientation\n")
+ GLU_NATIVE_ENTER(env, that, gluQuadricOrientation_FUNC);
gluQuadricOrientation((GLUquadric *)arg0, arg1);
- NATIVE_EXIT(env, that, "gluQuadricOrientation\n")
+ GLU_NATIVE_EXIT(env, that, gluQuadricOrientation_FUNC);
}
+#endif
+#ifndef NO_gluQuadricTexture
JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricTexture)
(JNIEnv *env, jclass that, jint arg0, jboolean arg1)
{
- NATIVE_ENTER(env, that, "gluQuadricTexture\n")
+ GLU_NATIVE_ENTER(env, that, gluQuadricTexture_FUNC);
gluQuadricTexture((GLUquadric *)arg0, arg1);
- NATIVE_EXIT(env, that, "gluQuadricTexture\n")
+ GLU_NATIVE_EXIT(env, that, gluQuadricTexture_FUNC);
}
+#endif
+#ifndef NO_gluScaleImage
JNIEXPORT jint JNICALL GLU_NATIVE(gluScaleImage)
(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7, jint arg8)
{
- jint rc;
- NATIVE_ENTER(env, that, "gluScaleImage\n")
+ jint rc;
+ GLU_NATIVE_ENTER(env, that, gluScaleImage_FUNC);
rc = (jint)gluScaleImage(arg0, arg1, arg2, arg3, (const void *)arg4, arg5, arg6, arg7, (void *)arg8);
- NATIVE_EXIT(env, that, "gluScaleImage\n")
+ GLU_NATIVE_EXIT(env, that, gluScaleImage_FUNC);
return rc;
}
+#endif
+#ifndef NO_gluSphere
JNIEXPORT void JNICALL GLU_NATIVE(gluSphere)
(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jint arg2, jint arg3)
{
- NATIVE_ENTER(env, that, "gluSphere\n")
+ GLU_NATIVE_ENTER(env, that, gluSphere_FUNC);
gluSphere((GLUquadric *)arg0, arg1, arg2, arg3);
- NATIVE_EXIT(env, that, "gluSphere\n")
+ GLU_NATIVE_EXIT(env, that, gluSphere_FUNC);
}
+#endif
+#ifndef NO_gluTessBeginContour
JNIEXPORT void JNICALL GLU_NATIVE(gluTessBeginContour)
(JNIEnv *env, jclass that, jint arg0)
{
- NATIVE_ENTER(env, that, "gluTessBeginContour\n")
+ GLU_NATIVE_ENTER(env, that, gluTessBeginContour_FUNC);
gluTessBeginContour((GLUtesselator *)arg0);
- NATIVE_EXIT(env, that, "gluTessBeginContour\n")
+ GLU_NATIVE_EXIT(env, that, gluTessBeginContour_FUNC);
}
+#endif
+#ifndef NO_gluTessBeginPolygon
JNIEXPORT void JNICALL GLU_NATIVE(gluTessBeginPolygon)
(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
- NATIVE_ENTER(env, that, "gluTessBeginPolygon\n")
- gluTessBeginPolygon((GLUtesselator *)arg0, (void *)arg1);
- NATIVE_EXIT(env, that, "gluTessBeginPolygon\n")
+ GLU_NATIVE_ENTER(env, that, gluTessBeginPolygon_FUNC);
+ gluTessBeginPolygon((GLUtesselator *)arg0, (GLvoid *)arg1);
+ GLU_NATIVE_EXIT(env, that, gluTessBeginPolygon_FUNC);
}
+#endif
+#ifndef NO_gluTessCallback
JNIEXPORT void JNICALL GLU_NATIVE(gluTessCallback)
(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
- NATIVE_ENTER(env, that, "gluTessCallback\n")
- gluTessCallback((GLUtesselator *)arg0, arg1, (GLvoid(*))arg2);
- NATIVE_EXIT(env, that, "gluTessCallback\n")
+ GLU_NATIVE_ENTER(env, that, gluTessCallback_FUNC);
+ gluTessCallback((GLUtesselator *)arg0, arg1, (void (__stdcall *)())arg2);
+ GLU_NATIVE_EXIT(env, that, gluTessCallback_FUNC);
}
+#endif
+#ifndef NO_gluTessEndContour
JNIEXPORT void JNICALL GLU_NATIVE(gluTessEndContour)
(JNIEnv *env, jclass that, jint arg0)
{
- NATIVE_ENTER(env, that, "gluTessEndContour\n")
+ GLU_NATIVE_ENTER(env, that, gluTessEndContour_FUNC);
gluTessEndContour((GLUtesselator *)arg0);
- NATIVE_EXIT(env, that, "gluTessEndContour\n")
+ GLU_NATIVE_EXIT(env, that, gluTessEndContour_FUNC);
}
+#endif
+#ifndef NO_gluTessEndPolygon
JNIEXPORT void JNICALL GLU_NATIVE(gluTessEndPolygon)
(JNIEnv *env, jclass that, jint arg0)
{
- NATIVE_ENTER(env, that, "gluTessEndPolygon\n")
+ GLU_NATIVE_ENTER(env, that, gluTessEndPolygon_FUNC);
gluTessEndPolygon((GLUtesselator *)arg0);
- NATIVE_EXIT(env, that, "gluTessEndPolygon\n")
+ GLU_NATIVE_EXIT(env, that, gluTessEndPolygon_FUNC);
}
+#endif
+#ifndef NO_gluTessNormal
JNIEXPORT void JNICALL GLU_NATIVE(gluTessNormal)
(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jdouble arg3)
{
- NATIVE_ENTER(env, that, "gluTessNormal\n")
+ GLU_NATIVE_ENTER(env, that, gluTessNormal_FUNC);
gluTessNormal((GLUtesselator *)arg0, arg1, arg2, arg3);
- NATIVE_EXIT(env, that, "gluTessNormal\n")
+ GLU_NATIVE_EXIT(env, that, gluTessNormal_FUNC);
}
+#endif
+#ifndef NO_gluTessProperty
JNIEXPORT void JNICALL GLU_NATIVE(gluTessProperty)
- (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
+ (JNIEnv *env, jclass that, jint arg0, jint arg1, jdouble arg2)
{
- NATIVE_ENTER(env, that, "gluTessProperty\n")
+ GLU_NATIVE_ENTER(env, that, gluTessProperty_FUNC);
gluTessProperty((GLUtesselator *)arg0, arg1, arg2);
- NATIVE_EXIT(env, that, "gluTessProperty\n")
+ GLU_NATIVE_EXIT(env, that, gluTessProperty_FUNC);
}
+#endif
+#ifndef NO_gluTessVertex
JNIEXPORT void JNICALL GLU_NATIVE(gluTessVertex)
(JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1, jint arg2)
{
jdouble *lparg1=NULL;
-
- NATIVE_ENTER(env, that, "gluTessVertex\n")
- if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);
- gluTessVertex((GLUtesselator *)arg0, lparg1, (void *)arg2);
- if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);
- NATIVE_EXIT(env, that, "gluTessVertex\n")
+ GLU_NATIVE_ENTER(env, that, gluTessVertex_FUNC);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
+ } else
+#endif
+ {
+ if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);
+ }
+ gluTessVertex((GLUtesselator *)arg0, lparg1, (GLvoid *)arg2);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
+ } else
+#endif
+ {
+ if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);
+ }
+ GLU_NATIVE_EXIT(env, that, gluTessVertex_FUNC);
}
+#endif
+#ifndef NO_gluUnProject
JNIEXPORT jint JNICALL GLU_NATIVE(gluUnProject)
(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdoubleArray arg3, jdoubleArray arg4, jintArray arg5, jdoubleArray arg6, jdoubleArray arg7, jdoubleArray arg8)
{
@@ -526,21 +753,46 @@ JNIEXPORT jint JNICALL GLU_NATIVE(gluUnProject)
jdouble *lparg7=NULL;
jdouble *lparg8=NULL;
jint rc;
-
- NATIVE_ENTER(env, that, "gluUnProject\n")
- if (arg3) lparg3 = (*env)->GetDoubleArrayElements(env, arg3, NULL);
- if (arg4) lparg4 = (*env)->GetDoubleArrayElements(env, arg4, NULL);
- if (arg5) lparg5 = (*env)->GetIntArrayElements(env, arg5, NULL);
- if (arg6) lparg6 = (*env)->GetDoubleArrayElements(env, arg6, NULL);
- if (arg7) lparg7 = (*env)->GetDoubleArrayElements(env, arg7, NULL);
- if (arg8) lparg8 = (*env)->GetDoubleArrayElements(env, arg8, NULL);
- rc = (jint)gluUnProject(arg0, arg1, arg2, lparg3, lparg4, (GLint *)lparg5, lparg6, lparg7, lparg8);
- if (arg3) (*env)->ReleaseDoubleArrayElements(env, arg3, lparg3, 0);
- if (arg4) (*env)->ReleaseDoubleArrayElements(env, arg4, lparg4, 0);
- if (arg5) (*env)->ReleaseIntArrayElements(env, arg5, lparg5, 0);
- if (arg6) (*env)->ReleaseDoubleArrayElements(env, arg6, lparg6, 0);
- if (arg7) (*env)->ReleaseDoubleArrayElements(env, arg7, lparg7, 0);
- if (arg8) (*env)->ReleaseDoubleArrayElements(env, arg8, lparg8, 0);
- NATIVE_EXIT(env, that, "gluUnProject\n")
+ GLU_NATIVE_ENTER(env, that, gluUnProject_FUNC);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
+ if (arg4) lparg4 = (*env)->GetPrimitiveArrayCritical(env, arg4, NULL);
+ if (arg5) lparg5 = (*env)->GetPrimitiveArrayCritical(env, arg5, NULL);
+ if (arg6) lparg6 = (*env)->GetPrimitiveArrayCritical(env, arg6, NULL);
+ if (arg7) lparg7 = (*env)->GetPrimitiveArrayCritical(env, arg7, NULL);
+ if (arg8) lparg8 = (*env)->GetPrimitiveArrayCritical(env, arg8, NULL);
+ } else
+#endif
+ {
+ if (arg3) lparg3 = (*env)->GetDoubleArrayElements(env, arg3, NULL);
+ if (arg4) lparg4 = (*env)->GetDoubleArrayElements(env, arg4, NULL);
+ if (arg5) lparg5 = (*env)->GetIntArrayElements(env, arg5, NULL);
+ if (arg6) lparg6 = (*env)->GetDoubleArrayElements(env, arg6, NULL);
+ if (arg7) lparg7 = (*env)->GetDoubleArrayElements(env, arg7, NULL);
+ if (arg8) lparg8 = (*env)->GetDoubleArrayElements(env, arg8, NULL);
+ }
+ rc = (jint)gluUnProject(arg0, arg1, arg2, lparg3, lparg4, lparg5, lparg6, lparg7, lparg8);
+#ifdef JNI_VERSION_1_2
+ if (IS_JNI_1_2) {
+ if (arg8) (*env)->ReleasePrimitiveArrayCritical(env, arg8, lparg8, 0);
+ if (arg7) (*env)->ReleasePrimitiveArrayCritical(env, arg7, lparg7, 0);
+ if (arg6) (*env)->ReleasePrimitiveArrayCritical(env, arg6, lparg6, 0);
+ if (arg5) (*env)->ReleasePrimitiveArrayCritical(env, arg5, lparg5, 0);
+ if (arg4) (*env)->ReleasePrimitiveArrayCritical(env, arg4, lparg4, 0);
+ if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
+ } else
+#endif
+ {
+ if (arg8) (*env)->ReleaseDoubleArrayElements(env, arg8, lparg8, 0);
+ if (arg7) (*env)->ReleaseDoubleArrayElements(env, arg7, lparg7, 0);
+ if (arg6) (*env)->ReleaseDoubleArrayElements(env, arg6, lparg6, 0);
+ if (arg5) (*env)->ReleaseIntArrayElements(env, arg5, lparg5, 0);
+ if (arg4) (*env)->ReleaseDoubleArrayElements(env, arg4, lparg4, 0);
+ if (arg3) (*env)->ReleaseDoubleArrayElements(env, arg3, lparg3, 0);
+ }
+ GLU_NATIVE_EXIT(env, that, gluUnProject_FUNC);
return rc;
}
+#endif
+
diff --git a/bundles/org.eclipse.swt.opengl/common/library/glu.h b/bundles/org.eclipse.swt.opengl/common/library/glu.h
new file mode 100644
index 0000000000..9ec3bbb147
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/library/glu.h
@@ -0,0 +1,6 @@
+#ifdef WIN32
+#include <windows.h>
+#endif
+#include <GL/glu.h>
+
+extern int IS_JNI_1_2;
diff --git a/bundles/org.eclipse.swt.opengl/common/library/glu_stats.c b/bundles/org.eclipse.swt.opengl/common/library/glu_stats.c
new file mode 100644
index 0000000000..3befc268da
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/library/glu_stats.c
@@ -0,0 +1,82 @@
+#include "swt.h"
+#include "glu_stats.h"
+
+#ifdef NATIVE_STATS
+
+int GLU_nativeFunctionCount = 51;
+int GLU_nativeFunctionCallCount[51];
+char * GLU_nativeFunctionNames[] = {
+ "gluBeginCurve",
+ "gluBeginPolygon",
+ "gluBeginSurface",
+ "gluBeginTrim",
+ "gluBuild1DMipmaps",
+ "gluBuild2DMipmaps",
+ "gluCylinder",
+ "gluDeleteNurbsRenderer",
+ "gluDeleteQuadric",
+ "gluDeleteTess",
+ "gluDisk",
+ "gluEndCurve",
+ "gluEndPolygon",
+ "gluEndSurface",
+ "gluEndTrim",
+ "gluErrorString",
+ "gluGetNurbsProperty",
+ "gluGetString",
+ "gluGetTessProperty",
+ "gluLoadSamplingMatrices",
+ "gluLookAt",
+ "gluNewNurbsRenderer",
+ "gluNewQuadric",
+ "gluNewTess",
+ "gluNextContour",
+ "gluNurbsCallback",
+ "gluNurbsCurve",
+ "gluNurbsProperty",
+ "gluNurbsSurface",
+ "gluOrtho2D",
+ "gluPartialDisk",
+ "gluPerspective",
+ "gluPickMatrix",
+ "gluProject",
+ "gluPwlCurve",
+ "gluQuadricCallback",
+ "gluQuadricDrawStyle",
+ "gluQuadricNormals",
+ "gluQuadricOrientation",
+ "gluQuadricTexture",
+ "gluScaleImage",
+ "gluSphere",
+ "gluTessBeginContour",
+ "gluTessBeginPolygon",
+ "gluTessCallback",
+ "gluTessEndContour",
+ "gluTessEndPolygon",
+ "gluTessNormal",
+ "gluTessProperty",
+ "gluTessVertex",
+ "gluUnProject",
+};
+
+#define STATS_NATIVE(func) Java_org_eclipse_swt_tools_internal_NativeStats_##func
+
+JNIEXPORT jint JNICALL STATS_NATIVE(GLU_1GetFunctionCount)
+ (JNIEnv *env, jclass that)
+{
+ return GLU_nativeFunctionCount;
+}
+
+JNIEXPORT jstring JNICALL STATS_NATIVE(GLU_1GetFunctionName)
+ (JNIEnv *env, jclass that, jint index)
+{
+ return (*env)->NewStringUTF(env, GLU_nativeFunctionNames[index]);
+}
+
+JNIEXPORT jint JNICALL STATS_NATIVE(GLU_1GetFunctionCallCount)
+ (JNIEnv *env, jclass that, jint index)
+{
+ return GLU_nativeFunctionCallCount[index];
+}
+
+#endif
diff --git a/bundles/org.eclipse.swt.opengl/common/library/glu_stats.h b/bundles/org.eclipse.swt.opengl/common/library/glu_stats.h
new file mode 100644
index 0000000000..99173e6713
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/library/glu_stats.h
@@ -0,0 +1,64 @@
+#ifdef NATIVE_STATS
+extern int GLU_nativeFunctionCount;
+extern int GLU_nativeFunctionCallCount[];
+extern char* GLU_nativeFunctionNames[];
+#define GLU_NATIVE_ENTER(env, that, func) GLU_nativeFunctionCallCount[func]++;
+#define GLU_NATIVE_EXIT(env, that, func)
+#else
+#define GLU_NATIVE_ENTER(env, that, func)
+#define GLU_NATIVE_EXIT(env, that, func)
+#endif
+
+typedef enum {
+ gluBeginCurve_FUNC,
+ gluBeginPolygon_FUNC,
+ gluBeginSurface_FUNC,
+ gluBeginTrim_FUNC,
+ gluBuild1DMipmaps_FUNC,
+ gluBuild2DMipmaps_FUNC,
+ gluCylinder_FUNC,
+ gluDeleteNurbsRenderer_FUNC,
+ gluDeleteQuadric_FUNC,
+ gluDeleteTess_FUNC,
+ gluDisk_FUNC,
+ gluEndCurve_FUNC,
+ gluEndPolygon_FUNC,
+ gluEndSurface_FUNC,
+ gluEndTrim_FUNC,
+ gluErrorString_FUNC,
+ gluGetNurbsProperty_FUNC,
+ gluGetString_FUNC,
+ gluGetTessProperty_FUNC,
+ gluLoadSamplingMatrices_FUNC,
+ gluLookAt_FUNC,
+ gluNewNurbsRenderer_FUNC,
+ gluNewQuadric_FUNC,
+ gluNewTess_FUNC,
+ gluNextContour_FUNC,
+ gluNurbsCallback_FUNC,
+ gluNurbsCurve_FUNC,
+ gluNurbsProperty_FUNC,
+ gluNurbsSurface_FUNC,
+ gluOrtho2D_FUNC,
+ gluPartialDisk_FUNC,
+ gluPerspective_FUNC,
+ gluPickMatrix_FUNC,
+ gluProject_FUNC,
+ gluPwlCurve_FUNC,
+ gluQuadricCallback_FUNC,
+ gluQuadricDrawStyle_FUNC,
+ gluQuadricNormals_FUNC,
+ gluQuadricOrientation_FUNC,
+ gluQuadricTexture_FUNC,
+ gluScaleImage_FUNC,
+ gluSphere_FUNC,
+ gluTessBeginContour_FUNC,
+ gluTessBeginPolygon_FUNC,
+ gluTessCallback_FUNC,
+ gluTessEndContour_FUNC,
+ gluTessEndPolygon_FUNC,
+ gluTessNormal_FUNC,
+ gluTessProperty_FUNC,
+ gluTessVertex_FUNC,
+ gluUnProject_FUNC,
+} GLU_FUNCS;
diff --git a/bundles/org.eclipse.swt.opengl/common/library/glu_structs.c b/bundles/org.eclipse.swt.opengl/common/library/glu_structs.c
new file mode 100644
index 0000000000..620ce43b12
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/library/glu_structs.c
@@ -0,0 +1,3 @@
+#include "swt.h"
+#include "glu_structs.h"
+
diff --git a/bundles/org.eclipse.swt.opengl/common/library/glu_structs.h b/bundles/org.eclipse.swt.opengl/common/library/glu_structs.h
new file mode 100644
index 0000000000..5d11acf289
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/library/glu_structs.h
@@ -0,0 +1,2 @@
+#include "glu.h"
+
diff --git a/bundles/org.eclipse.swt.tools/JNI Generation/org/eclipse/swt/tools/internal/org.eclipse.swt.opengl.GLU.properties b/bundles/org.eclipse.swt.tools/JNI Generation/org/eclipse/swt/tools/internal/org.eclipse.swt.opengl.GLU.properties
new file mode 100644
index 0000000000..b1610a2dac
--- /dev/null
+++ b/bundles/org.eclipse.swt.tools/JNI Generation/org/eclipse/swt/tools/internal/org.eclipse.swt.opengl.GLU.properties
@@ -0,0 +1,1745 @@
+org_eclipse_swt_opengl_GL=flags=no_gen
+GL_glAccum=
+GL_glAccum_0=
+GL_glAccum_1=
+
+GL_glAlphaFunc=
+GL_glAlphaFunc_0=
+GL_glAlphaFunc_1=
+
+GL_glAreTexturesResident=
+GL_glAreTexturesResident_0=
+GL_glAreTexturesResident_1=
+GL_glAreTexturesResident_2=
+
+GL_glArrayElement=
+GL_glArrayElement_0=
+
+GL_glBegin=
+GL_glBegin_0=
+
+GL_glBindTexture=
+GL_glBindTexture_0=
+GL_glBindTexture_1=
+
+GL_glBitmap=
+GL_glBitmap_0=
+GL_glBitmap_1=
+GL_glBitmap_2=
+GL_glBitmap_3=
+GL_glBitmap_4=
+GL_glBitmap_5=
+GL_glBitmap_6=
+
+GL_glBlendFunc=
+GL_glBlendFunc_0=
+GL_glBlendFunc_1=
+
+GL_glCallList=
+GL_glCallList_0=
+
+GL_glCallLists__II_3B=
+GL_glCallLists__II_3B_0=
+GL_glCallLists__II_3B_1=
+GL_glCallLists__II_3B_2=
+
+GL_glCallLists__II_3C=
+GL_glCallLists__II_3C_0=
+GL_glCallLists__II_3C_1=
+GL_glCallLists__II_3C_2=
+
+GL_glCallLists__II_3I=
+GL_glCallLists__II_3I_0=
+GL_glCallLists__II_3I_1=
+GL_glCallLists__II_3I_2=
+
+GL_glClear=
+GL_glClear_0=
+
+GL_glClearAccum=
+GL_glClearAccum_0=
+GL_glClearAccum_1=
+GL_glClearAccum_2=
+GL_glClearAccum_3=
+
+GL_glClearColor=
+GL_glClearColor_0=
+GL_glClearColor_1=
+GL_glClearColor_2=
+GL_glClearColor_3=
+
+GL_glClearDepth=
+GL_glClearDepth_0=
+
+GL_glClearIndex=
+GL_glClearIndex_0=
+
+GL_glClearStencil=
+GL_glClearStencil_0=
+
+GL_glClipPlane=
+GL_glClipPlane_0=
+GL_glClipPlane_1=
+
+GL_glColor3b=
+GL_glColor3b_0=
+GL_glColor3b_1=
+GL_glColor3b_2=
+
+GL_glColor3bv=
+GL_glColor3bv_0=
+
+GL_glColor3d=
+GL_glColor3d_0=
+GL_glColor3d_1=
+GL_glColor3d_2=
+
+GL_glColor3dv=
+GL_glColor3dv_0=
+
+GL_glColor3f=
+GL_glColor3f_0=
+GL_glColor3f_1=
+GL_glColor3f_2=
+
+GL_glColor3fv=
+GL_glColor3fv_0=
+
+GL_glColor3i=
+GL_glColor3i_0=
+GL_glColor3i_1=
+GL_glColor3i_2=
+
+GL_glColor3iv=
+GL_glColor3iv_0=
+
+GL_glColor3s=
+GL_glColor3s_0=
+GL_glColor3s_1=
+GL_glColor3s_2=
+
+GL_glColor3sv=
+GL_glColor3sv_0=
+
+GL_glColor3ub=
+GL_glColor3ub_0=
+GL_glColor3ub_1=
+GL_glColor3ub_2=
+
+GL_glColor3ubv=
+GL_glColor3ubv_0=
+
+GL_glColor3ui=
+GL_glColor3ui_0=
+GL_glColor3ui_1=
+GL_glColor3ui_2=
+
+GL_glColor3uiv=
+GL_glColor3uiv_0=
+
+GL_glColor3us=
+GL_glColor3us_0=
+GL_glColor3us_1=
+GL_glColor3us_2=
+
+GL_glColor3usv=
+GL_glColor3usv_0=
+
+GL_glColor4b=
+GL_glColor4b_0=
+GL_glColor4b_1=
+GL_glColor4b_2=
+GL_glColor4b_3=
+
+GL_glColor4bv=
+GL_glColor4bv_0=
+
+GL_glColor4d=
+GL_glColor4d_0=
+GL_glColor4d_1=
+GL_glColor4d_2=
+GL_glColor4d_3=
+
+GL_glColor4dv=
+GL_glColor4dv_0=
+
+GL_glColor4f=
+GL_glColor4f_0=
+GL_glColor4f_1=
+GL_glColor4f_2=
+GL_glColor4f_3=
+
+GL_glColor4fv=
+GL_glColor4fv_0=
+
+GL_glColor4i=
+GL_glColor4i_0=
+GL_glColor4i_1=
+GL_glColor4i_2=
+GL_glColor4i_3=
+
+GL_glColor4iv=
+GL_glColor4iv_0=
+
+GL_glColor4s=
+GL_glColor4s_0=
+GL_glColor4s_1=
+GL_glColor4s_2=
+GL_glColor4s_3=
+
+GL_glColor4ub=
+GL_glColor4ub_0=
+GL_glColor4ub_1=
+GL_glColor4ub_2=
+GL_glColor4ub_3=
+
+GL_glColor4ubv=
+GL_glColor4ubv_0=
+
+GL_glColor4ui=
+GL_glColor4ui_0=
+GL_glColor4ui_1=
+GL_glColor4ui_2=
+GL_glColor4ui_3=
+
+GL_glColor4uiv=
+GL_glColor4uiv_0=
+
+GL_glColor4us=
+GL_glColor4us_0=
+GL_glColor4us_1=
+GL_glColor4us_2=
+GL_glColor4us_3=
+
+GL_glColor4usv=
+GL_glColor4usv_0=
+
+GL_glColorMask=
+GL_glColorMask_0=
+GL_glColorMask_1=
+GL_glColorMask_2=
+GL_glColorMask_3=
+
+GL_glColorMaterial=
+GL_glColorMaterial_0=
+GL_glColorMaterial_1=
+
+GL_glColorPointer=
+GL_glColorPointer_0=
+GL_glColorPointer_1=
+GL_glColorPointer_2=
+GL_glColorPointer_3=
+
+GL_glCopyPixels=
+GL_glCopyPixels_0=
+GL_glCopyPixels_1=
+GL_glCopyPixels_2=
+GL_glCopyPixels_3=
+GL_glCopyPixels_4=
+
+GL_glCopyTexImage1D=
+GL_glCopyTexImage1D_0=
+GL_glCopyTexImage1D_1=
+GL_glCopyTexImage1D_2=
+GL_glCopyTexImage1D_3=
+GL_glCopyTexImage1D_4=
+GL_glCopyTexImage1D_5=
+GL_glCopyTexImage1D_6=
+
+GL_glCopyTexImage2D=
+GL_glCopyTexImage2D_0=
+GL_glCopyTexImage2D_1=
+GL_glCopyTexImage2D_2=
+GL_glCopyTexImage2D_3=
+GL_glCopyTexImage2D_4=
+GL_glCopyTexImage2D_5=
+GL_glCopyTexImage2D_6=
+GL_glCopyTexImage2D_7=
+
+GL_glCopyTexSubImage1D=
+GL_glCopyTexSubImage1D_0=
+GL_glCopyTexSubImage1D_1=
+GL_glCopyTexSubImage1D_2=
+GL_glCopyTexSubImage1D_3=
+GL_glCopyTexSubImage1D_4=
+GL_glCopyTexSubImage1D_5=
+
+GL_glCopyTexSubImage2D=
+GL_glCopyTexSubImage2D_0=
+GL_glCopyTexSubImage2D_1=
+GL_glCopyTexSubImage2D_2=
+GL_glCopyTexSubImage2D_3=
+GL_glCopyTexSubImage2D_4=
+GL_glCopyTexSubImage2D_5=
+GL_glCopyTexSubImage2D_6=
+GL_glCopyTexSubImage2D_7=
+
+GL_glCullFace=
+GL_glCullFace_0=
+
+GL_glDeleteLists=
+GL_glDeleteLists_0=
+GL_glDeleteLists_1=
+
+GL_glDeleteTextures=
+GL_glDeleteTextures_0=
+GL_glDeleteTextures_1=
+
+GL_glDepthFunc=
+GL_glDepthFunc_0=
+
+GL_glDepthMask=
+GL_glDepthMask_0=
+
+GL_glDepthRange=
+GL_glDepthRange_0=
+GL_glDepthRange_1=
+
+GL_glDisable=
+GL_glDisable_0=
+
+GL_glDisableClientState=
+GL_glDisableClientState_0=
+
+GL_glDrawArrays=
+GL_glDrawArrays_0=
+GL_glDrawArrays_1=
+GL_glDrawArrays_2=
+
+GL_glDrawBuffer=
+GL_glDrawBuffer_0=
+
+GL_glDrawElements=
+GL_glDrawElements_0=
+GL_glDrawElements_1=
+GL_glDrawElements_2=
+GL_glDrawElements_3=
+
+GL_glDrawPixels=
+GL_glDrawPixels_0=
+GL_glDrawPixels_1=
+GL_glDrawPixels_2=
+GL_glDrawPixels_3=
+GL_glDrawPixels_4=
+
+GL_glEdgeFlag=
+GL_glEdgeFlag_0=
+
+GL_glEdgeFlagPointer=
+GL_glEdgeFlagPointer_0=
+GL_glEdgeFlagPointer_1=
+
+GL_glEdgeFlagv=
+GL_glEdgeFlagv_0=
+
+GL_glEnable=
+GL_glEnable_0=
+
+GL_glEnableClientState=
+GL_glEnableClientState_0=
+
+GL_glEnd=
+
+GL_glEndList=
+
+GL_glEvalCoord1d=
+GL_glEvalCoord1d_0=
+
+GL_glEvalCoord1dv=
+GL_glEvalCoord1dv_0=
+
+GL_glEvalCoord1f=
+GL_glEvalCoord1f_0=
+
+GL_glEvalCoord1fv=
+GL_glEvalCoord1fv_0=
+
+GL_glEvalCoord2d=
+GL_glEvalCoord2d_0=
+GL_glEvalCoord2d_1=
+
+GL_glEvalCoord2dv=
+GL_glEvalCoord2dv_0=
+
+GL_glEvalCoord2f=
+GL_glEvalCoord2f_0=
+GL_glEvalCoord2f_1=
+
+GL_glEvalCoord2fv=
+GL_glEvalCoord2fv_0=
+
+GL_glEvalMesh1=
+GL_glEvalMesh1_0=
+GL_glEvalMesh1_1=
+GL_glEvalMesh1_2=
+
+GL_glEvalMesh2=
+GL_glEvalMesh2_0=
+GL_glEvalMesh2_1=
+GL_glEvalMesh2_2=
+GL_glEvalMesh2_3=
+GL_glEvalMesh2_4=
+
+GL_glEvalPoint1=
+GL_glEvalPoint1_0=
+
+GL_glEvalPoint2=
+GL_glEvalPoint2_0=
+GL_glEvalPoint2_1=
+
+GL_glFeedbackBuffer=
+GL_glFeedbackBuffer_0=
+GL_glFeedbackBuffer_1=
+GL_glFeedbackBuffer_2=
+
+GL_glFinish=
+
+GL_glFlush=
+
+GL_glFogf=
+GL_glFogf_0=
+GL_glFogf_1=
+
+GL_glFogfv=
+GL_glFogfv_0=
+GL_glFogfv_1=
+
+GL_glFogi=
+GL_glFogi_0=
+GL_glFogi_1=
+
+GL_glFogiv=
+GL_glFogiv_0=
+GL_glFogiv_1=
+
+GL_glFrontFace=
+GL_glFrontFace_0=
+
+GL_glFrustum=
+GL_glFrustum_0=
+GL_glFrustum_1=
+GL_glFrustum_2=
+GL_glFrustum_3=
+GL_glFrustum_4=
+GL_glFrustum_5=
+
+GL_glGenLists=
+GL_glGenLists_0=
+
+GL_glGenTextures=
+GL_glGenTextures_0=
+GL_glGenTextures_1=
+
+GL_glGetBooleanv=
+GL_glGetBooleanv_0=
+GL_glGetBooleanv_1=
+
+GL_glGetClipPlane=
+GL_glGetClipPlane_0=
+GL_glGetClipPlane_1=
+
+GL_glGetDoublev=
+GL_glGetDoublev_0=
+GL_glGetDoublev_1=
+
+GL_glGetError=
+
+GL_glGetFloatv=
+GL_glGetFloatv_0=
+GL_glGetFloatv_1=
+
+GL_glGetIntegerv=
+GL_glGetIntegerv_0=
+GL_glGetIntegerv_1=
+
+GL_glGetLightfv=
+GL_glGetLightfv_0=
+GL_glGetLightfv_1=
+GL_glGetLightfv_2=
+
+GL_glGetLightiv=
+GL_glGetLightiv_0=
+GL_glGetLightiv_1=
+GL_glGetLightiv_2=
+
+GL_glGetMapdv=
+GL_glGetMapdv_0=
+GL_glGetMapdv_1=
+GL_glGetMapdv_2=
+
+GL_glGetMapfv=
+GL_glGetMapfv_0=
+GL_glGetMapfv_1=
+GL_glGetMapfv_2=
+
+GL_glGetMapiv=
+GL_glGetMapiv_0=
+GL_glGetMapiv_1=
+GL_glGetMapiv_2=
+
+GL_glGetMaterialfv=
+GL_glGetMaterialfv_0=
+GL_glGetMaterialfv_1=
+GL_glGetMaterialfv_2=
+
+GL_glGetMaterialiv=
+GL_glGetMaterialiv_0=
+GL_glGetMaterialiv_1=
+GL_glGetMaterialiv_2=
+
+GL_glGetPixelMapfv=
+GL_glGetPixelMapfv_0=
+GL_glGetPixelMapfv_1=
+
+GL_glGetPixelMapuiv=
+GL_glGetPixelMapuiv_0=
+GL_glGetPixelMapuiv_1=
+
+GL_glGetPixelMapusv=
+GL_glGetPixelMapusv_0=
+GL_glGetPixelMapusv_1=
+
+GL_glGetPointerv=
+GL_glGetPointerv_0=
+GL_glGetPointerv_1=
+
+GL_glGetPolygonStipple=
+GL_glGetPolygonStipple_0=
+
+GL_glGetString=
+GL_glGetString_0=
+
+GL_glGetTexEnvfv=
+GL_glGetTexEnvfv_0=
+GL_glGetTexEnvfv_1=
+GL_glGetTexEnvfv_2=
+
+GL_glGetTexEnviv=
+GL_glGetTexEnviv_0=
+GL_glGetTexEnviv_1=
+GL_glGetTexEnviv_2=
+
+GL_glGetTexGendv=
+GL_glGetTexGendv_0=
+GL_glGetTexGendv_1=
+GL_glGetTexGendv_2=
+
+GL_glGetTexGenfv=
+GL_glGetTexGenfv_0=
+GL_glGetTexGenfv_1=
+GL_glGetTexGenfv_2=
+
+GL_glGetTexGeniv=
+GL_glGetTexGeniv_0=
+GL_glGetTexGeniv_1=
+GL_glGetTexGeniv_2=
+
+GL_glGetTexImage=
+GL_glGetTexImage_0=
+GL_glGetTexImage_1=
+GL_glGetTexImage_2=
+GL_glGetTexImage_3=
+GL_glGetTexImage_4=
+
+GL_glGetTexLevelParameterfv=
+GL_glGetTexLevelParameterfv_0=
+GL_glGetTexLevelParameterfv_1=
+GL_glGetTexLevelParameterfv_2=
+GL_glGetTexLevelParameterfv_3=
+
+GL_glGetTexLevelParameteriv=
+GL_glGetTexLevelParameteriv_0=
+GL_glGetTexLevelParameteriv_1=
+GL_glGetTexLevelParameteriv_2=
+GL_glGetTexLevelParameteriv_3=
+
+GL_glGetTexParameterfv=
+GL_glGetTexParameterfv_0=
+GL_glGetTexParameterfv_1=
+GL_glGetTexParameterfv_2=
+
+GL_glGetTexParameteriv=
+GL_glGetTexParameteriv_0=
+GL_glGetTexParameteriv_1=
+GL_glGetTexParameteriv_2=
+
+GL_glHint=
+GL_glHint_0=
+GL_glHint_1=
+
+GL_glIndexMask=
+GL_glIndexMask_0=
+
+GL_glIndexPointer=
+GL_glIndexPointer_0=
+GL_glIndexPointer_1=
+GL_glIndexPointer_2=
+
+GL_glIndexd=
+GL_glIndexd_0=
+
+GL_glIndexdv=
+GL_glIndexdv_0=
+
+GL_glIndexf=
+GL_glIndexf_0=
+
+GL_glIndexfv=
+GL_glIndexfv_0=
+
+GL_glIndexi=
+GL_glIndexi_0=
+
+GL_glIndexiv=
+GL_glIndexiv_0=
+
+GL_glIndexs=
+GL_glIndexs_0=
+
+GL_glIndexsv=
+GL_glIndexsv_0=
+
+GL_glInitNames=
+
+GL_glInterleavedArrays=
+GL_glInterleavedArrays_0=
+GL_glInterleavedArrays_1=
+GL_glInterleavedArrays_2=
+
+GL_glIsEnabled=
+GL_glIsEnabled_0=
+
+GL_glIsList=
+GL_glIsList_0=
+
+GL_glIsTexture=
+GL_glIsTexture_0=
+
+GL_glLightModelf=
+GL_glLightModelf_0=
+GL_glLightModelf_1=
+
+GL_glLightModelfv=
+GL_glLightModelfv_0=
+GL_glLightModelfv_1=
+
+GL_glLightModeli=
+GL_glLightModeli_0=
+GL_glLightModeli_1=
+
+GL_glLightModeliv=
+GL_glLightModeliv_0=
+GL_glLightModeliv_1=
+
+GL_glLightf=
+GL_glLightf_0=
+GL_glLightf_1=
+GL_glLightf_2=
+
+GL_glLightfv=
+GL_glLightfv_0=
+GL_glLightfv_1=
+GL_glLightfv_2=
+
+GL_glLighti=
+GL_glLighti_0=
+GL_glLighti_1=
+GL_glLighti_2=
+
+GL_glLightiv=
+GL_glLightiv_0=
+GL_glLightiv_1=
+GL_glLightiv_2=
+
+GL_glLineStipple=
+GL_glLineStipple_0=
+GL_glLineStipple_1=
+
+GL_glLineWidth=
+GL_glLineWidth_0=
+
+GL_glListBase=
+GL_glListBase_0=
+
+GL_glLoadIdentity=
+
+GL_glLoadMatrixd=
+GL_glLoadMatrixd_0=
+
+GL_glLoadMatrixf=
+GL_glLoadMatrixf_0=
+
+GL_glLoadName=
+GL_glLoadName_0=
+
+GL_glLogicOp=
+GL_glLogicOp_0=
+
+GL_glMap1d=
+GL_glMap1d_0=
+GL_glMap1d_1=
+GL_glMap1d_2=
+GL_glMap1d_3=
+GL_glMap1d_4=
+GL_glMap1d_5=
+
+GL_glMap1f=
+GL_glMap1f_0=
+GL_glMap1f_1=
+GL_glMap1f_2=
+GL_glMap1f_3=
+GL_glMap1f_4=
+GL_glMap1f_5=
+
+GL_glMap2d=
+GL_glMap2d_0=
+GL_glMap2d_1=
+GL_glMap2d_2=
+GL_glMap2d_3=
+GL_glMap2d_4=
+GL_glMap2d_5=
+GL_glMap2d_6=
+GL_glMap2d_7=
+GL_glMap2d_8=
+GL_glMap2d_9=
+
+GL_glMap2f=
+GL_glMap2f_0=
+GL_glMap2f_1=
+GL_glMap2f_2=
+GL_glMap2f_3=
+GL_glMap2f_4=
+GL_glMap2f_5=
+GL_glMap2f_6=
+GL_glMap2f_7=
+GL_glMap2f_8=
+GL_glMap2f_9=
+
+GL_glMapGrid1d=
+GL_glMapGrid1d_0=
+GL_glMapGrid1d_1=
+GL_glMapGrid1d_2=
+
+GL_glMapGrid1f=
+GL_glMapGrid1f_0=
+GL_glMapGrid1f_1=
+GL_glMapGrid1f_2=
+
+GL_glMapGrid2d=
+GL_glMapGrid2d_0=
+GL_glMapGrid2d_1=
+GL_glMapGrid2d_2=
+GL_glMapGrid2d_3=
+GL_glMapGrid2d_4=
+GL_glMapGrid2d_5=
+
+GL_glMapGrid2f=
+GL_glMapGrid2f_0=
+GL_glMapGrid2f_1=
+GL_glMapGrid2f_2=
+GL_glMapGrid2f_3=
+GL_glMapGrid2f_4=
+GL_glMapGrid2f_5=
+
+GL_glMaterialf=
+GL_glMaterialf_0=
+GL_glMaterialf_1=
+GL_glMaterialf_2=
+
+GL_glMaterialfv=
+GL_glMaterialfv_0=
+GL_glMaterialfv_1=
+GL_glMaterialfv_2=
+
+GL_glMateriali=
+GL_glMateriali_0=
+GL_glMateriali_1=
+GL_glMateriali_2=
+
+GL_glMaterialiv=
+GL_glMaterialiv_0=
+GL_glMaterialiv_1=
+GL_glMaterialiv_2=
+
+GL_glMatrixMode=
+GL_glMatrixMode_0=
+
+GL_glMultMatrixd=
+GL_glMultMatrixd_0=
+
+GL_glMultMatrixf=
+GL_glMultMatrixf_0=
+
+GL_glNewList=
+GL_glNewList_0=
+GL_glNewList_1=
+
+GL_glNormal3b=
+GL_glNormal3b_0=
+GL_glNormal3b_1=
+GL_glNormal3b_2=
+
+GL_glNormal3bv=
+GL_glNormal3bv_0=
+
+GL_glNormal3d=
+GL_glNormal3d_0=
+GL_glNormal3d_1=
+GL_glNormal3d_2=
+
+GL_glNormal3dv=
+GL_glNormal3dv_0=
+
+GL_glNormal3f=
+GL_glNormal3f_0=
+GL_glNormal3f_1=
+GL_glNormal3f_2=
+
+GL_glNormal3fv=
+GL_glNormal3fv_0=
+
+GL_glNormal3i=
+GL_glNormal3i_0=
+GL_glNormal3i_1=
+GL_glNormal3i_2=
+
+GL_glNormal3iv=
+GL_glNormal3iv_0=
+
+GL_glNormal3s=
+GL_glNormal3s_0=
+GL_glNormal3s_1=
+GL_glNormal3s_2=
+
+GL_glNormal3sv=
+GL_glNormal3sv_0=
+
+GL_glNormalPointer=
+GL_glNormalPointer_0=
+GL_glNormalPointer_1=
+GL_glNormalPointer_2=
+
+GL_glOrtho=
+GL_glOrtho_0=
+GL_glOrtho_1=
+GL_glOrtho_2=
+GL_glOrtho_3=
+GL_glOrtho_4=
+GL_glOrtho_5=
+
+GL_glPassThrough=
+GL_glPassThrough_0=
+
+GL_glPixelMapfv=
+GL_glPixelMapfv_0=
+GL_glPixelMapfv_1=
+GL_glPixelMapfv_2=
+
+GL_glPixelMapuiv=
+GL_glPixelMapuiv_0=
+GL_glPixelMapuiv_1=
+GL_glPixelMapuiv_2=
+
+GL_glPixelMapusv=
+GL_glPixelMapusv_0=
+GL_glPixelMapusv_1=
+GL_glPixelMapusv_2=
+
+GL_glPixelStoref=
+GL_glPixelStoref_0=
+GL_glPixelStoref_1=
+
+GL_glPixelStorei=
+GL_glPixelStorei_0=
+GL_glPixelStorei_1=
+
+GL_glPixelTransferf=
+GL_glPixelTransferf_0=
+GL_glPixelTransferf_1=
+
+GL_glPixelTransferi=
+GL_glPixelTransferi_0=
+GL_glPixelTransferi_1=
+
+GL_glPixelZoom=
+GL_glPixelZoom_0=
+GL_glPixelZoom_1=
+
+GL_glPointSize=
+GL_glPointSize_0=
+
+GL_glPolygonMode=
+GL_glPolygonMode_0=
+GL_glPolygonMode_1=
+
+GL_glPolygonOffset=
+GL_glPolygonOffset_0=
+GL_glPolygonOffset_1=
+
+GL_glPolygonStipple=
+GL_glPolygonStipple_0=
+
+GL_glPopAttrib=
+
+GL_glPopClientAttrib=
+
+GL_glPopMatrix=
+
+GL_glPopName=
+
+GL_glPrioritizeTextures=
+GL_glPrioritizeTextures_0=
+GL_glPrioritizeTextures_1=
+GL_glPrioritizeTextures_2=
+
+GL_glPushAttrib=
+GL_glPushAttrib_0=
+
+GL_glPushClientAttrib=
+GL_glPushClientAttrib_0=
+
+GL_glPushMatrix=
+
+GL_glPushName=
+GL_glPushName_0=
+
+GL_glRasterPos2d=
+GL_glRasterPos2d_0=
+GL_glRasterPos2d_1=
+
+GL_glRasterPos2dv=
+GL_glRasterPos2dv_0=
+
+GL_glRasterPos2f=
+GL_glRasterPos2f_0=
+GL_glRasterPos2f_1=
+
+GL_glRasterPos2fv=
+GL_glRasterPos2fv_0=
+
+GL_glRasterPos2i=
+GL_glRasterPos2i_0=
+GL_glRasterPos2i_1=
+
+GL_glRasterPos2iv=
+GL_glRasterPos2iv_0=
+
+GL_glRasterPos2s=
+GL_glRasterPos2s_0=
+GL_glRasterPos2s_1=
+
+GL_glRasterPos2sv=
+GL_glRasterPos2sv_0=
+
+GL_glRasterPos3d=
+GL_glRasterPos3d_0=
+GL_glRasterPos3d_1=
+GL_glRasterPos3d_2=
+
+GL_glRasterPos3dv=
+GL_glRasterPos3dv_0=
+
+GL_glRasterPos3f=
+GL_glRasterPos3f_0=
+GL_glRasterPos3f_1=
+GL_glRasterPos3f_2=
+
+GL_glRasterPos3fv=
+GL_glRasterPos3fv_0=
+
+GL_glRasterPos3i=
+GL_glRasterPos3i_0=
+GL_glRasterPos3i_1=
+GL_glRasterPos3i_2=
+
+GL_glRasterPos3iv=
+GL_glRasterPos3iv_0=
+
+GL_glRasterPos3s=
+GL_glRasterPos3s_0=
+GL_glRasterPos3s_1=
+GL_glRasterPos3s_2=
+
+GL_glRasterPos3sv=
+GL_glRasterPos3sv_0=
+
+GL_glRasterPos4d=
+GL_glRasterPos4d_0=
+GL_glRasterPos4d_1=
+GL_glRasterPos4d_2=
+GL_glRasterPos4d_3=
+
+GL_glRasterPos4dv=
+GL_glRasterPos4dv_0=
+
+GL_glRasterPos4f=
+GL_glRasterPos4f_0=
+GL_glRasterPos4f_1=
+GL_glRasterPos4f_2=
+GL_glRasterPos4f_3=
+
+GL_glRasterPos4fv=
+GL_glRasterPos4fv_0=
+
+GL_glRasterPos4i=
+GL_glRasterPos4i_0=
+GL_glRasterPos4i_1=
+GL_glRasterPos4i_2=
+GL_glRasterPos4i_3=
+
+GL_glRasterPos4iv=
+GL_glRasterPos4iv_0=
+
+GL_glRasterPos4s=
+GL_glRasterPos4s_0=
+GL_glRasterPos4s_1=
+GL_glRasterPos4s_2=
+GL_glRasterPos4s_3=
+
+GL_glRasterPos4sv=
+GL_glRasterPos4sv_0=
+
+GL_glReadBuffer=
+GL_glReadBuffer_0=
+
+GL_glReadPixels=
+GL_glReadPixels_0=
+GL_glReadPixels_1=
+GL_glReadPixels_2=
+GL_glReadPixels_3=
+GL_glReadPixels_4=
+GL_glReadPixels_5=
+GL_glReadPixels_6=
+
+GL_glRectd=
+GL_glRectd_0=
+GL_glRectd_1=
+GL_glRectd_2=
+GL_glRectd_3=
+
+GL_glRectdv=
+GL_glRectdv_0=
+GL_glRectdv_1=
+
+GL_glRectf=
+GL_glRectf_0=
+GL_glRectf_1=
+GL_glRectf_2=
+GL_glRectf_3=
+
+GL_glRectfv=
+GL_glRectfv_0=
+GL_glRectfv_1=
+
+GL_glRecti=
+GL_glRecti_0=
+GL_glRecti_1=
+GL_glRecti_2=
+GL_glRecti_3=
+
+GL_glRectiv=
+GL_glRectiv_0=
+GL_glRectiv_1=
+
+GL_glRects=
+GL_glRects_0=
+GL_glRects_1=
+GL_glRects_2=
+GL_glRects_3=
+
+GL_glRectsv=
+GL_glRectsv_0=
+GL_glRectsv_1=
+
+GL_glRenderMode=
+GL_glRenderMode_0=
+
+GL_glRotated=
+GL_glRotated_0=
+GL_glRotated_1=
+GL_glRotated_2=
+GL_glRotated_3=
+
+GL_glRotatef=
+GL_glRotatef_0=
+GL_glRotatef_1=
+GL_glRotatef_2=
+GL_glRotatef_3=
+
+GL_glScaled=
+GL_glScaled_0=
+GL_glScaled_1=
+GL_glScaled_2=
+
+GL_glScalef=
+GL_glScalef_0=
+GL_glScalef_1=
+GL_glScalef_2=
+
+GL_glScissor=
+GL_glScissor_0=
+GL_glScissor_1=
+GL_glScissor_2=
+GL_glScissor_3=
+
+GL_glSelectBuffer=
+GL_glSelectBuffer_0=
+GL_glSelectBuffer_1=
+
+GL_glShadeModel=
+GL_glShadeModel_0=
+
+GL_glStencilFunc=
+GL_glStencilFunc_0=
+GL_glStencilFunc_1=
+GL_glStencilFunc_2=
+
+GL_glStencilMask=
+GL_glStencilMask_0=
+
+GL_glStencilOp=
+GL_glStencilOp_0=
+GL_glStencilOp_1=
+GL_glStencilOp_2=
+
+GL_glTexCoord1d=
+GL_glTexCoord1d_0=
+
+GL_glTexCoord1dv=
+GL_glTexCoord1dv_0=
+
+GL_glTexCoord1f=
+GL_glTexCoord1f_0=
+
+GL_glTexCoord1fv=
+GL_glTexCoord1fv_0=
+
+GL_glTexCoord1i=
+GL_glTexCoord1i_0=
+
+GL_glTexCoord1iv=
+GL_glTexCoord1iv_0=
+
+GL_glTexCoord1s=
+GL_glTexCoord1s_0=
+
+GL_glTexCoord1sv=
+GL_glTexCoord1sv_0=
+
+GL_glTexCoord2d=
+GL_glTexCoord2d_0=
+GL_glTexCoord2d_1=
+
+GL_glTexCoord2dv=
+GL_glTexCoord2dv_0=
+
+GL_glTexCoord2f=
+GL_glTexCoord2f_0=
+GL_glTexCoord2f_1=
+
+GL_glTexCoord2fv=
+GL_glTexCoord2fv_0=
+
+GL_glTexCoord2i=
+GL_glTexCoord2i_0=
+GL_glTexCoord2i_1=
+
+GL_glTexCoord2iv=
+GL_glTexCoord2iv_0=
+
+GL_glTexCoord2s=
+GL_glTexCoord2s_0=
+GL_glTexCoord2s_1=
+
+GL_glTexCoord2sv=
+GL_glTexCoord2sv_0=
+
+GL_glTexCoord3d=
+GL_glTexCoord3d_0=
+GL_glTexCoord3d_1=
+GL_glTexCoord3d_2=
+
+GL_glTexCoord3dv=
+GL_glTexCoord3dv_0=
+
+GL_glTexCoord3f=
+GL_glTexCoord3f_0=
+GL_glTexCoord3f_1=
+GL_glTexCoord3f_2=
+
+GL_glTexCoord3fv=
+GL_glTexCoord3fv_0=
+
+GL_glTexCoord3i=
+GL_glTexCoord3i_0=
+GL_glTexCoord3i_1=
+GL_glTexCoord3i_2=
+
+GL_glTexCoord3iv=
+GL_glTexCoord3iv_0=
+
+GL_glTexCoord3s=
+GL_glTexCoord3s_0=
+GL_glTexCoord3s_1=
+GL_glTexCoord3s_2=
+
+GL_glTexCoord3sv=
+GL_glTexCoord3sv_0=
+
+GL_glTexCoord4d=
+GL_glTexCoord4d_0=
+GL_glTexCoord4d_1=
+GL_glTexCoord4d_2=
+GL_glTexCoord4d_3=
+
+GL_glTexCoord4dv=
+GL_glTexCoord4dv_0=
+
+GL_glTexCoord4f=
+GL_glTexCoord4f_0=
+GL_glTexCoord4f_1=
+GL_glTexCoord4f_2=
+GL_glTexCoord4f_3=
+
+GL_glTexCoord4fv=
+GL_glTexCoord4fv_0=
+
+GL_glTexCoord4i=
+GL_glTexCoord4i_0=
+GL_glTexCoord4i_1=
+GL_glTexCoord4i_2=
+GL_glTexCoord4i_3=
+
+GL_glTexCoord4iv=
+GL_glTexCoord4iv_0=
+
+GL_glTexCoord4s=
+GL_glTexCoord4s_0=
+GL_glTexCoord4s_1=
+GL_glTexCoord4s_2=
+GL_glTexCoord4s_3=
+
+GL_glTexCoord4sv=
+GL_glTexCoord4sv_0=
+
+GL_glTexCoordPointer=
+GL_glTexCoordPointer_0=
+GL_glTexCoordPointer_1=
+GL_glTexCoordPointer_2=
+GL_glTexCoordPointer_3=
+
+GL_glTexEnvf=
+GL_glTexEnvf_0=
+GL_glTexEnvf_1=
+GL_glTexEnvf_2=
+
+GL_glTexEnvfv=
+GL_glTexEnvfv_0=
+GL_glTexEnvfv_1=
+GL_glTexEnvfv_2=
+
+GL_glTexEnvi=
+GL_glTexEnvi_0=
+GL_glTexEnvi_1=
+GL_glTexEnvi_2=
+
+GL_glTexEnviv=
+GL_glTexEnviv_0=
+GL_glTexEnviv_1=
+GL_glTexEnviv_2=
+
+GL_glTexGend=
+GL_glTexGend_0=
+GL_glTexGend_1=
+GL_glTexGend_2=
+
+GL_glTexGendv=
+GL_glTexGendv_0=
+GL_glTexGendv_1=
+GL_glTexGendv_2=
+
+GL_glTexGenf=
+GL_glTexGenf_0=
+GL_glTexGenf_1=
+GL_glTexGenf_2=
+
+GL_glTexGenfv=
+GL_glTexGenfv_0=
+GL_glTexGenfv_1=
+GL_glTexGenfv_2=
+
+GL_glTexGeni=
+GL_glTexGeni_0=
+GL_glTexGeni_1=
+GL_glTexGeni_2=
+
+GL_glTexGeniv=
+GL_glTexGeniv_0=
+GL_glTexGeniv_1=
+GL_glTexGeniv_2=
+
+GL_glTexImage1D=
+GL_glTexImage1D_0=
+GL_glTexImage1D_1=
+GL_glTexImage1D_2=
+GL_glTexImage1D_3=
+GL_glTexImage1D_4=
+GL_glTexImage1D_5=
+GL_glTexImage1D_6=
+GL_glTexImage1D_7=
+
+GL_glTexImage2D=
+GL_glTexImage2D_0=
+GL_glTexImage2D_1=
+GL_glTexImage2D_2=
+GL_glTexImage2D_3=
+GL_glTexImage2D_4=
+GL_glTexImage2D_5=
+GL_glTexImage2D_6=
+GL_glTexImage2D_7=
+GL_glTexImage2D_8=
+
+GL_glTexParameterf=
+GL_glTexParameterf_0=
+GL_glTexParameterf_1=
+GL_glTexParameterf_2=
+
+GL_glTexParameterfv=
+GL_glTexParameterfv_0=
+GL_glTexParameterfv_1=
+GL_glTexParameterfv_2=
+
+GL_glTexParameteri=
+GL_glTexParameteri_0=
+GL_glTexParameteri_1=
+GL_glTexParameteri_2=
+
+GL_glTexParameteriv=
+GL_glTexParameteriv_0=
+GL_glTexParameteriv_1=
+GL_glTexParameteriv_2=
+
+GL_glTexSubImage1D=
+GL_glTexSubImage1D_0=
+GL_glTexSubImage1D_1=
+GL_glTexSubImage1D_2=
+GL_glTexSubImage1D_3=
+GL_glTexSubImage1D_4=
+GL_glTexSubImage1D_5=
+GL_glTexSubImage1D_6=
+
+GL_glTexSubImage2D=
+GL_glTexSubImage2D_0=
+GL_glTexSubImage2D_1=
+GL_glTexSubImage2D_2=
+GL_glTexSubImage2D_3=
+GL_glTexSubImage2D_4=
+GL_glTexSubImage2D_5=
+GL_glTexSubImage2D_6=
+GL_glTexSubImage2D_7=
+GL_glTexSubImage2D_8=
+
+GL_glTranslated=
+GL_glTranslated_0=
+GL_glTranslated_1=
+GL_glTranslated_2=
+
+GL_glTranslatef=
+GL_glTranslatef_0=
+GL_glTranslatef_1=
+GL_glTranslatef_2=
+
+GL_glVertex2d=
+GL_glVertex2d_0=
+GL_glVertex2d_1=
+
+GL_glVertex2dv=
+GL_glVertex2dv_0=
+
+GL_glVertex2f=
+GL_glVertex2f_0=
+GL_glVertex2f_1=
+
+GL_glVertex2fv=
+GL_glVertex2fv_0=
+
+GL_glVertex2i=
+GL_glVertex2i_0=
+GL_glVertex2i_1=
+
+GL_glVertex2iv=
+GL_glVertex2iv_0=
+
+GL_glVertex2s=
+GL_glVertex2s_0=
+GL_glVertex2s_1=
+
+GL_glVertex2sv=
+GL_glVertex2sv_0=
+
+GL_glVertex3d=
+GL_glVertex3d_0=
+GL_glVertex3d_1=
+GL_glVertex3d_2=
+
+GL_glVertex3dv=
+GL_glVertex3dv_0=
+
+GL_glVertex3f=
+GL_glVertex3f_0=
+GL_glVertex3f_1=
+GL_glVertex3f_2=
+
+GL_glVertex3fv=
+GL_glVertex3fv_0=
+
+GL_glVertex3i=
+GL_glVertex3i_0=
+GL_glVertex3i_1=
+GL_glVertex3i_2=
+
+GL_glVertex3iv=
+GL_glVertex3iv_0=
+
+GL_glVertex3s=
+GL_glVertex3s_0=
+GL_glVertex3s_1=
+GL_glVertex3s_2=
+
+GL_glVertex3sv=
+GL_glVertex3sv_0=
+
+GL_glVertex4d=
+GL_glVertex4d_0=
+GL_glVertex4d_1=
+GL_glVertex4d_2=
+GL_glVertex4d_3=
+
+GL_glVertex4dv=
+GL_glVertex4dv_0=
+
+GL_glVertex4f=
+GL_glVertex4f_0=
+GL_glVertex4f_1=
+GL_glVertex4f_2=
+GL_glVertex4f_3=
+
+GL_glVertex4fv=
+GL_glVertex4fv_0=
+
+GL_glVertex4i=
+GL_glVertex4i_0=
+GL_glVertex4i_1=
+GL_glVertex4i_2=
+GL_glVertex4i_3=
+
+GL_glVertex4iv=
+GL_glVertex4iv_0=
+
+GL_glVertex4s=
+GL_glVertex4s_0=
+GL_glVertex4s_1=
+GL_glVertex4s_2=
+GL_glVertex4s_3=
+
+GL_glVertex4sv=
+GL_glVertex4sv_0=
+
+GL_glVertexPointer=
+GL_glVertexPointer_0=
+GL_glVertexPointer_1=
+GL_glVertexPointer_2=
+GL_glVertexPointer_3=
+
+GL_glViewport=
+GL_glViewport_0=
+GL_glViewport_1=
+GL_glViewport_2=
+GL_glViewport_3=
+
+
+org_eclipse_swt_opengl_GLContext=flags=no_gen
+
+org_eclipse_swt_opengl_GLU=
+GLU_gluBeginCurve=
+GLU_gluBeginCurve_0=cast=(GLUnurbs *)
+
+GLU_gluBeginPolygon=
+GLU_gluBeginPolygon_0=cast=(GLUtesselator*)
+
+GLU_gluBeginSurface=
+GLU_gluBeginSurface_0=cast=(GLUnurbs *)
+
+GLU_gluBeginTrim=
+GLU_gluBeginTrim_0=cast=(GLUnurbs *)
+
+GLU_gluBuild1DMipmaps=
+GLU_gluBuild1DMipmaps_0=
+GLU_gluBuild1DMipmaps_1=
+GLU_gluBuild1DMipmaps_2=
+GLU_gluBuild1DMipmaps_3=
+GLU_gluBuild1DMipmaps_4=
+GLU_gluBuild1DMipmaps_5=cast=(const void *)
+
+GLU_gluBuild2DMipmaps=
+GLU_gluBuild2DMipmaps_0=
+GLU_gluBuild2DMipmaps_1=
+GLU_gluBuild2DMipmaps_2=
+GLU_gluBuild2DMipmaps_3=
+GLU_gluBuild2DMipmaps_4=
+GLU_gluBuild2DMipmaps_5=
+GLU_gluBuild2DMipmaps_6=flags=critical
+
+GLU_gluCylinder=
+GLU_gluCylinder_0=cast=(GLUquadric *)
+GLU_gluCylinder_1=
+GLU_gluCylinder_2=
+GLU_gluCylinder_3=
+GLU_gluCylinder_4=
+GLU_gluCylinder_5=
+
+GLU_gluDeleteNurbsRenderer=
+GLU_gluDeleteNurbsRenderer_0=cast=(GLUnurbs *)
+
+GLU_gluDeleteQuadric=
+GLU_gluDeleteQuadric_0=cast=(GLUquadric *)
+
+GLU_gluDeleteTess=
+GLU_gluDeleteTess_0=cast=(GLUtesselator *)
+
+GLU_gluDisk=
+GLU_gluDisk_0=cast=(GLUquadricObj *)
+GLU_gluDisk_1=
+GLU_gluDisk_2=
+GLU_gluDisk_3=
+GLU_gluDisk_4=
+
+GLU_gluEndCurve=
+GLU_gluEndCurve_0=cast=(GLUnurbsObj *)
+
+GLU_gluEndPolygon=
+GLU_gluEndPolygon_0=cast=(GLUtriangulatorObj *)
+
+GLU_gluEndSurface=
+GLU_gluEndSurface_0=cast=(GLUnurbsObj *)
+
+GLU_gluEndTrim=
+GLU_gluEndTrim_0=cast=(GLUnurbsObj *)
+
+GLU_gluErrorString=
+GLU_gluErrorString_0=
+
+GLU_gluGetNurbsProperty=
+GLU_gluGetNurbsProperty_0=cast=(GLUnurbs *)
+GLU_gluGetNurbsProperty_1=
+GLU_gluGetNurbsProperty_2=flags=critical
+
+GLU_gluGetString=
+GLU_gluGetString_0=
+
+GLU_gluGetTessProperty=
+GLU_gluGetTessProperty_0=cast=(GLUtesselator *)
+GLU_gluGetTessProperty_1=
+GLU_gluGetTessProperty_2=flags=critical
+
+GLU_gluLoadSamplingMatrices=
+GLU_gluLoadSamplingMatrices_0=cast=(GLUnurbs *)
+GLU_gluLoadSamplingMatrices_1=flags=critical
+GLU_gluLoadSamplingMatrices_2=flags=critical
+GLU_gluLoadSamplingMatrices_3=flags=critical
+
+GLU_gluLookAt=
+GLU_gluLookAt_0=
+GLU_gluLookAt_1=
+GLU_gluLookAt_2=
+GLU_gluLookAt_3=
+GLU_gluLookAt_4=
+GLU_gluLookAt_5=
+GLU_gluLookAt_6=
+GLU_gluLookAt_7=
+GLU_gluLookAt_8=
+
+GLU_gluNewNurbsRenderer=
+
+GLU_gluNewQuadric=
+
+GLU_gluNewTess=
+
+GLU_gluNextContour=
+GLU_gluNextContour_0=cast=(GLUtesselator *)
+GLU_gluNextContour_1=
+
+GLU_gluNurbsCallback=
+GLU_gluNurbsCallback_0=cast=(GLUnurbs *)
+GLU_gluNurbsCallback_1=
+GLU_gluNurbsCallback_2=cast=(void (__stdcall *)())
+
+GLU_gluNurbsCurve=
+GLU_gluNurbsCurve_0=cast=(GLUnurbs *)
+GLU_gluNurbsCurve_1=
+GLU_gluNurbsCurve_2=flags=critical
+GLU_gluNurbsCurve_3=
+GLU_gluNurbsCurve_4=flags=critical
+GLU_gluNurbsCurve_5=
+GLU_gluNurbsCurve_6=
+
+GLU_gluNurbsProperty=
+GLU_gluNurbsProperty_0=cast=(GLUnurbs *)
+GLU_gluNurbsProperty_1=
+GLU_gluNurbsProperty_2=
+
+GLU_gluNurbsSurface=
+GLU_gluNurbsSurface_0=cast=(GLUnurbsObj *)
+GLU_gluNurbsSurface_1=
+GLU_gluNurbsSurface_2=flags=critical
+GLU_gluNurbsSurface_3=
+GLU_gluNurbsSurface_4=flags=critical
+GLU_gluNurbsSurface_5=
+GLU_gluNurbsSurface_6=
+GLU_gluNurbsSurface_7=flags=critical
+GLU_gluNurbsSurface_8=
+GLU_gluNurbsSurface_9=
+GLU_gluNurbsSurface_10=
+
+GLU_gluOrtho2D=
+GLU_gluOrtho2D_0=
+GLU_gluOrtho2D_1=
+GLU_gluOrtho2D_2=
+GLU_gluOrtho2D_3=
+
+GLU_gluPartialDisk=
+GLU_gluPartialDisk_0=cast=(GLUquadric *)
+GLU_gluPartialDisk_1=
+GLU_gluPartialDisk_2=
+GLU_gluPartialDisk_3=
+GLU_gluPartialDisk_4=
+GLU_gluPartialDisk_5=
+GLU_gluPartialDisk_6=
+
+GLU_gluPerspective=
+GLU_gluPerspective_0=
+GLU_gluPerspective_1=
+GLU_gluPerspective_2=
+GLU_gluPerspective_3=
+
+GLU_gluPickMatrix=
+GLU_gluPickMatrix_0=
+GLU_gluPickMatrix_1=
+GLU_gluPickMatrix_2=
+GLU_gluPickMatrix_3=
+GLU_gluPickMatrix_4=flags=critical
+
+GLU_gluProject=
+GLU_gluProject_0=
+GLU_gluProject_1=
+GLU_gluProject_2=
+GLU_gluProject_3=flags=critical
+GLU_gluProject_4=flags=critical
+GLU_gluProject_5=flags=critical
+GLU_gluProject_6=flags=critical
+GLU_gluProject_7=flags=critical
+GLU_gluProject_8=flags=critical
+
+GLU_gluPwlCurve=
+GLU_gluPwlCurve_0=cast=(GLUnurbs *)
+GLU_gluPwlCurve_1=
+GLU_gluPwlCurve_2=flags=critical
+GLU_gluPwlCurve_3=
+GLU_gluPwlCurve_4=
+
+GLU_gluQuadricCallback=
+GLU_gluQuadricCallback_0=cast=(GLUquadricObj *)
+GLU_gluQuadricCallback_1=
+GLU_gluQuadricCallback_2=cast=(void (__stdcall *)())
+
+GLU_gluQuadricDrawStyle=
+GLU_gluQuadricDrawStyle_0=cast=(GLUquadricObj *)
+GLU_gluQuadricDrawStyle_1=
+
+GLU_gluQuadricNormals=
+GLU_gluQuadricNormals_0=cast=(GLUquadricObj *)
+GLU_gluQuadricNormals_1=
+
+GLU_gluQuadricOrientation=
+GLU_gluQuadricOrientation_0=cast=(GLUquadric *)
+GLU_gluQuadricOrientation_1=
+
+GLU_gluQuadricTexture=
+GLU_gluQuadricTexture_0=cast=(GLUquadric *)
+GLU_gluQuadricTexture_1=
+
+GLU_gluScaleImage=
+GLU_gluScaleImage_0=
+GLU_gluScaleImage_1=
+GLU_gluScaleImage_2=
+GLU_gluScaleImage_3=
+GLU_gluScaleImage_4=cast=(const void *)
+GLU_gluScaleImage_5=
+GLU_gluScaleImage_6=
+GLU_gluScaleImage_7=
+GLU_gluScaleImage_8=cast=(void *)
+
+GLU_gluSphere=
+GLU_gluSphere_0=cast=(GLUquadric *)
+GLU_gluSphere_1=
+GLU_gluSphere_2=
+GLU_gluSphere_3=
+
+GLU_gluTessBeginContour=
+GLU_gluTessBeginContour_0=cast=(GLUtesselator *)
+
+GLU_gluTessBeginPolygon=
+GLU_gluTessBeginPolygon_0=cast=(GLUtesselator *)
+GLU_gluTessBeginPolygon_1=cast=(GLvoid *)
+
+GLU_gluTessCallback=
+GLU_gluTessCallback_0=cast=(GLUtesselator *)
+GLU_gluTessCallback_1=
+GLU_gluTessCallback_2=cast=(void (__stdcall *)())
+
+GLU_gluTessEndContour=
+GLU_gluTessEndContour_0=cast=(GLUtesselator *)
+
+GLU_gluTessEndPolygon=
+GLU_gluTessEndPolygon_0=cast=(GLUtesselator *)
+
+GLU_gluTessNormal=
+GLU_gluTessNormal_0=cast=(GLUtesselator *)
+GLU_gluTessNormal_1=
+GLU_gluTessNormal_2=
+GLU_gluTessNormal_3=
+
+GLU_gluTessProperty=
+GLU_gluTessProperty_0=cast=(GLUtesselator *)
+GLU_gluTessProperty_1=
+GLU_gluTessProperty_2=
+
+GLU_gluTessVertex=
+GLU_gluTessVertex_0=cast=(GLUtesselator *)
+GLU_gluTessVertex_1=flags=critical
+GLU_gluTessVertex_2=cast=(GLvoid *)
+
+GLU_gluUnProject=
+GLU_gluUnProject_0=
+GLU_gluUnProject_1=
+GLU_gluUnProject_2=
+GLU_gluUnProject_3=flags=critical
+GLU_gluUnProject_4=flags=critical
+GLU_gluUnProject_5=flags=critical
+GLU_gluUnProject_6=flags=critical
+GLU_gluUnProject_7=flags=critical
+GLU_gluUnProject_8=flags=critical
+
+
+org_eclipse_swt_opengl_GLYPHMETRICSFLOAT=flags=no_gen
+GLYPHMETRICSFLOAT_gmfBlackBoxX=
+GLYPHMETRICSFLOAT_gmfBlackBoxY=
+GLYPHMETRICSFLOAT_gmfptGlyphOrigin_x=
+GLYPHMETRICSFLOAT_gmfptGlyphOrigin_y=
+GLYPHMETRICSFLOAT_gmfCellIncX=
+GLYPHMETRICSFLOAT_gmfCellIncY=
+
+org_eclipse_swt_opengl_ImageDataUtil=flags=no_gen
+
+org_eclipse_swt_opengl_Library=flags=no_gen
+

Back to the top