diff options
Diffstat (limited to 'bundles/org.eclipse.swt.opengl/common/library/glu.c')
| -rw-r--r-- | bundles/org.eclipse.swt.opengl/common/library/glu.c | 688 |
1 files changed, 470 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 + |