| /******************************************************************************* |
| * Copyright (c) 2000, 2003 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Common Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/cpl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| #ifdef WIN32 |
| #include <windows.h> |
| #endif |
| #include <GL/gl.h> |
| #include "swt.h" |
| |
| #define GL_NATIVE(func) Java_org_eclipse_swt_opengl_GL_##func |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glAccum) |
| (JNIEnv *env, jclass that, jint arg0, jfloat arg1) |
| { |
| NATIVE_ENTER(env, that, "glAccum\n") |
| glAccum(arg0, arg1); |
| NATIVE_EXIT(env, that, "glAccum\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glAlphaFunc) |
| (JNIEnv *env, jclass that, jint arg0, jfloat arg1) |
| { |
| NATIVE_ENTER(env, that, "glAlphaFunc\n") |
| glAlphaFunc(arg0, arg1); |
| NATIVE_EXIT(env, that, "glAlphaFunc\n") |
| } |
| |
| JNIEXPORT jboolean JNICALL GL_NATIVE(glAreTexturesResident) |
| (JNIEnv *env, jclass that, jint arg0, jintArray arg1, jbooleanArray arg2) |
| { |
| jint *lparg1=NULL; |
| jboolean *lparg2=NULL; |
| jboolean rc; |
| |
| NATIVE_ENTER(env, that, "glAreTexturesResident\n") |
| if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL); |
| if (arg2) lparg2 = (*env)->GetBooleanArrayElements(env, arg2, NULL); |
| rc = (jboolean)glAreTexturesResident(arg0, (unsigned int *)lparg1, lparg2); |
| if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0); |
| if (arg2) (*env)->ReleaseBooleanArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glAreTexturesResident\n") |
| return rc; |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glArrayElement) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glArrayElement\n") |
| glArrayElement(arg0); |
| NATIVE_EXIT(env, that, "glArrayElement\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glBegin) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glBegin\n") |
| glBegin(arg0); |
| NATIVE_EXIT(env, that, "glBegin\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glBindTexture) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1) |
| { |
| NATIVE_ENTER(env, that, "glBindTexture\n") |
| glBindTexture(arg0, arg1); |
| NATIVE_EXIT(env, that, "glBindTexture\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glBitmap) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2, jfloat arg3, jfloat arg4, jfloat arg5, jbyteArray arg6) |
| { |
| jbyte *lparg6=NULL; |
| |
| NATIVE_ENTER(env, that, "glBitmap\n") |
| if (arg6) lparg6 = (*env)->GetByteArrayElements(env, arg6, NULL); |
| glBitmap(arg0, arg1, arg2, arg3, arg4, arg5, (unsigned char *)lparg6); |
| if (arg6) (*env)->ReleaseByteArrayElements(env, arg6, lparg6, 0); |
| NATIVE_EXIT(env, that, "glBitmap\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glBlendFunc) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1) |
| { |
| NATIVE_ENTER(env, that, "glBlendFunc\n") |
| glBlendFunc(arg0, arg1); |
| NATIVE_EXIT(env, that, "glBlendFunc\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glCallList) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glCallList\n") |
| glCallList(arg0); |
| NATIVE_EXIT(env, that, "glCallList\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glCallLists__II_3B) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jbyteArray arg2) |
| { |
| jbyte *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glCallLists__II_3B\n") |
| if (arg2) lparg2 = (*env)->GetByteArrayElements(env, arg2, NULL); |
| glCallLists(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseByteArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glCallLists__II_3B\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glCallLists__II_3C) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jcharArray arg2) |
| { |
| jchar *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glCallLists__II_3C\n") |
| if (arg2) lparg2 = (*env)->GetCharArrayElements(env, arg2, NULL); |
| glCallLists(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseCharArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glCallLists__II_3C\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glCallLists__II_3I) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2) |
| { |
| jint *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glCallLists__II_3I\n") |
| if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL); |
| glCallLists(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glCallLists__II_3I\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glClear) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glClear\n") |
| glClear(arg0); |
| NATIVE_EXIT(env, that, "glClear\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glClearAccum) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3) |
| { |
| NATIVE_ENTER(env, that, "glClearAccum\n") |
| glClearAccum(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glClearAccum\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glClearColor) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3) |
| { |
| NATIVE_ENTER(env, that, "glClearColor\n") |
| glClearColor(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glClearColor\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glClearDepth) |
| (JNIEnv *env, jclass that, jdouble arg0) |
| { |
| NATIVE_ENTER(env, that, "glClearDepth\n") |
| glClearDepth(arg0); |
| NATIVE_EXIT(env, that, "glClearDepth\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glClearIndex) |
| (JNIEnv *env, jclass that, jfloat arg0) |
| { |
| NATIVE_ENTER(env, that, "glClearIndex\n") |
| glClearIndex(arg0); |
| NATIVE_EXIT(env, that, "glClearIndex\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glClearStencil) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glClearStencil\n") |
| glClearStencil(arg0); |
| NATIVE_EXIT(env, that, "glClearStencil\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glClipPlane) |
| (JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1) |
| { |
| jdouble *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glClipPlane\n") |
| if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL); |
| glClipPlane(arg0, lparg1); |
| if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glClipPlane\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor3b) |
| (JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2) |
| { |
| NATIVE_ENTER(env, that, "glColor3b\n") |
| glColor3b(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glColor3b\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor3bv) |
| (JNIEnv *env, jclass that, jbyteArray arg0) |
| { |
| jbyte *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glColor3bv\n") |
| if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL); |
| glColor3bv(lparg0); |
| if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glColor3bv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor3d) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2) |
| { |
| NATIVE_ENTER(env, that, "glColor3d\n") |
| glColor3d(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glColor3d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor3dv) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glColor3dv\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glColor3dv(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glColor3dv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor3f) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2) |
| { |
| NATIVE_ENTER(env, that, "glColor3f\n") |
| glColor3f(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glColor3f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor3fv) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glColor3fv\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glColor3fv(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glColor3fv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor3i) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2) |
| { |
| NATIVE_ENTER(env, that, "glColor3i\n") |
| glColor3i(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glColor3i\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor3iv) |
| (JNIEnv *env, jclass that, jintArray arg0) |
| { |
| jint *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glColor3iv\n") |
| if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL); |
| glColor3iv((GLint *)lparg0); |
| if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glColor3iv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor3s) |
| (JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2) |
| { |
| NATIVE_ENTER(env, that, "glColor3s\n") |
| glColor3s(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glColor3s\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor3ub) |
| (JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2) |
| { |
| NATIVE_ENTER(env, that, "glColor3ub\n") |
| glColor3ub(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glColor3ub\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor3ubv) |
| (JNIEnv *env, jclass that, jbyteArray arg0) |
| { |
| jbyte *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glColor3ubv\n") |
| if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL); |
| glColor3ubv((unsigned char *)lparg0); |
| if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glColor3ubv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor3ui) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2) |
| { |
| NATIVE_ENTER(env, that, "glColor3ui\n") |
| glColor3ui(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glColor3ui\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor3uiv) |
| (JNIEnv *env, jclass that, jintArray arg0) |
| { |
| jint *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glColor3uiv\n") |
| if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL); |
| glColor3uiv((unsigned int *)lparg0); |
| if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glColor3uiv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor3us) |
| (JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2) |
| { |
| NATIVE_ENTER(env, that, "glColor3us\n") |
| glColor3us(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glColor3us\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor3usv) |
| (JNIEnv *env, jclass that, jshortArray arg0) |
| { |
| jshort *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glColor3usv\n") |
| if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL); |
| glColor3usv((unsigned short *)lparg0); |
| if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glColor3usv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor4b) |
| (JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2, jbyte arg3) |
| { |
| NATIVE_ENTER(env, that, "glColor4b\n") |
| glColor4b(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glColor4b\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor4bv) |
| (JNIEnv *env, jclass that, jbyteArray arg0) |
| { |
| jbyte *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glColor4bv\n") |
| if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL); |
| glColor4bv(lparg0); |
| if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glColor4bv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor4d) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3) |
| { |
| NATIVE_ENTER(env, that, "glColor4d\n") |
| glColor4d(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glColor4d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor4dv) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glColor4dv\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glColor4dv(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glColor4dv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor4f) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3) |
| { |
| NATIVE_ENTER(env, that, "glColor4f\n") |
| glColor4f(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glColor4f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor4fv) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glColor4fv\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glColor4fv(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glColor4fv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor4i) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3) |
| { |
| NATIVE_ENTER(env, that, "glColor4i\n") |
| glColor4i(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glColor4i\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor4iv) |
| (JNIEnv *env, jclass that, jintArray arg0) |
| { |
| jint *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glColor4iv\n") |
| if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL); |
| glColor4iv((GLint *)lparg0); |
| if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glColor4iv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor4s) |
| (JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3) |
| { |
| NATIVE_ENTER(env, that, "glColor4s\n") |
| glColor4s(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glColor4s\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor4ub) |
| (JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2, jbyte arg3) |
| { |
| NATIVE_ENTER(env, that, "glColor4ub\n") |
| glColor4ub(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glColor4ub\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor4ubv) |
| (JNIEnv *env, jclass that, jbyteArray arg0) |
| { |
| jbyte *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glColor4ubv\n") |
| if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL); |
| glColor4ubv((unsigned char *)lparg0); |
| if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glColor4ubv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor4ui) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3) |
| { |
| NATIVE_ENTER(env, that, "glColor4ui\n") |
| glColor4ui(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glColor4ui\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor4uiv) |
| (JNIEnv *env, jclass that, jintArray arg0) |
| { |
| jint *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glColor4uiv\n") |
| if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL); |
| glColor4uiv((unsigned int *)lparg0); |
| if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glColor4uiv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor4us) |
| (JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3) |
| { |
| NATIVE_ENTER(env, that, "glColor4us\n") |
| glColor4us(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glColor4us\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColor4usv) |
| (JNIEnv *env, jclass that, jshortArray arg0) |
| { |
| jshort *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glColor4usv\n") |
| if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL); |
| glColor4usv((unsigned short *)lparg0); |
| if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glColor4usv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColorMask) |
| (JNIEnv *env, jclass that, jboolean arg0, jboolean arg1, jboolean arg2, jboolean arg3) |
| { |
| NATIVE_ENTER(env, that, "glColorMask\n") |
| glColorMask(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glColorMask\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColorMaterial) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1) |
| { |
| NATIVE_ENTER(env, that, "glColorMaterial\n") |
| glColorMaterial(arg0, arg1); |
| NATIVE_EXIT(env, that, "glColorMaterial\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glColorPointer) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3) |
| { |
| jint *lparg3=NULL; |
| |
| NATIVE_ENTER(env, that, "glColorPointer\n") |
| if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL); |
| glColorPointer(arg0, arg1, arg2, lparg3); |
| if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0); |
| NATIVE_EXIT(env, that, "glColorPointer\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glCopyPixels) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4) |
| { |
| NATIVE_ENTER(env, that, "glCopyPixels\n") |
| glCopyPixels(arg0, arg1, arg2, arg3, arg4); |
| NATIVE_EXIT(env, that, "glCopyPixels\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glCopyTexImage1D) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6) |
| { |
| NATIVE_ENTER(env, that, "glCopyTexImage1D\n") |
| glCopyTexImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6); |
| NATIVE_EXIT(env, that, "glCopyTexImage1D\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glCopyTexImage2D) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7) |
| { |
| NATIVE_ENTER(env, that, "glCopyTexImage2D\n") |
| glCopyTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); |
| NATIVE_EXIT(env, that, "glCopyTexImage2D\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glCopyTexSubImage1D) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5) |
| { |
| NATIVE_ENTER(env, that, "glCopyTexSubImage1D\n") |
| glCopyTexSubImage1D(arg0, arg1, arg2, arg3, arg4, arg5); |
| NATIVE_EXIT(env, that, "glCopyTexSubImage1D\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glCopyTexSubImage2D) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7) |
| { |
| NATIVE_ENTER(env, that, "glCopyTexSubImage2D\n") |
| glCopyTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); |
| NATIVE_EXIT(env, that, "glCopyTexSubImage2D\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glCullFace) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glCullFace\n") |
| glCullFace(arg0); |
| NATIVE_EXIT(env, that, "glCullFace\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glDeleteLists) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1) |
| { |
| NATIVE_ENTER(env, that, "glDeleteLists\n") |
| glDeleteLists(arg0, arg1); |
| NATIVE_EXIT(env, that, "glDeleteLists\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glDeleteTextures) |
| (JNIEnv *env, jclass that, jint arg0, jintArray arg1) |
| { |
| jint *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glDeleteTextures\n") |
| if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL); |
| glDeleteTextures(arg0, (unsigned int *)lparg1); |
| if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glDeleteTextures\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glDepthFunc) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glDepthFunc\n") |
| glDepthFunc(arg0); |
| NATIVE_EXIT(env, that, "glDepthFunc\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glDepthMask) |
| (JNIEnv *env, jclass that, jboolean arg0) |
| { |
| NATIVE_ENTER(env, that, "glDepthMask\n") |
| glDepthMask(arg0); |
| NATIVE_EXIT(env, that, "glDepthMask\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glDepthRange) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1) |
| { |
| NATIVE_ENTER(env, that, "glDepthRange\n") |
| glDepthRange(arg0, arg1); |
| NATIVE_EXIT(env, that, "glDepthRange\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glDisable) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glDisable\n") |
| glDisable(arg0); |
| NATIVE_EXIT(env, that, "glDisable\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glDisableClientState) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glDisableClientState\n") |
| glDisableClientState(arg0); |
| NATIVE_EXIT(env, that, "glDisableClientState\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glDrawArrays) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2) |
| { |
| NATIVE_ENTER(env, that, "glDrawArrays\n") |
| glDrawArrays(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glDrawArrays\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glDrawBuffer) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glDrawBuffer\n") |
| glDrawBuffer(arg0); |
| NATIVE_EXIT(env, that, "glDrawBuffer\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glDrawElements) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3) |
| { |
| jint *lparg3=NULL; |
| |
| NATIVE_ENTER(env, that, "glDrawElements\n") |
| if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL); |
| glDrawElements(arg0, arg1, arg2, lparg3); |
| if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0); |
| NATIVE_EXIT(env, that, "glDrawElements\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glDrawPixels) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jintArray arg4) |
| { |
| jint *lparg4=NULL; |
| |
| NATIVE_ENTER(env, that, "glDrawPixels\n") |
| if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL); |
| glDrawPixels(arg0, arg1, arg2, arg3, lparg4); |
| if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0); |
| NATIVE_EXIT(env, that, "glDrawPixels\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEdgeFlag) |
| (JNIEnv *env, jclass that, jboolean arg0) |
| { |
| NATIVE_ENTER(env, that, "glEdgeFlag\n") |
| glEdgeFlag(arg0); |
| NATIVE_EXIT(env, that, "glEdgeFlag\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEdgeFlagPointer) |
| (JNIEnv *env, jclass that, jint arg0, jbooleanArray arg1) |
| { |
| jboolean *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glEdgeFlagPointer\n") |
| if (arg1) lparg1 = (*env)->GetBooleanArrayElements(env, arg1, NULL); |
| glEdgeFlagPointer(arg0, lparg1); |
| if (arg1) (*env)->ReleaseBooleanArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glEdgeFlagPointer\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEdgeFlagv) |
| (JNIEnv *env, jclass that, jbooleanArray arg0) |
| { |
| jboolean *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glEdgeFlagv\n") |
| if (arg0) lparg0 = (*env)->GetBooleanArrayElements(env, arg0, NULL); |
| glEdgeFlagv(lparg0); |
| if (arg0) (*env)->ReleaseBooleanArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glEdgeFlagv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEnable) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glEnable\n") |
| glEnable(arg0); |
| NATIVE_EXIT(env, that, "glEnable\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEnableClientState) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glEnableClientState\n") |
| glEnableClientState(arg0); |
| NATIVE_EXIT(env, that, "glEnableClientState\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEnd) |
| (JNIEnv *env, jclass that) |
| { |
| NATIVE_ENTER(env, that, "glEnd\n") |
| glEnd(); |
| NATIVE_EXIT(env, that, "glEnd\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEndList) |
| (JNIEnv *env, jclass that) |
| { |
| NATIVE_ENTER(env, that, "glEndList\n") |
| glEndList(); |
| NATIVE_EXIT(env, that, "glEndList\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1d) |
| (JNIEnv *env, jclass that, jdouble arg0) |
| { |
| NATIVE_ENTER(env, that, "glEvalCoord1d\n") |
| glEvalCoord1d(arg0); |
| NATIVE_EXIT(env, that, "glEvalCoord1d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1dv) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glEvalCoord1dv\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glEvalCoord1dv(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glEvalCoord1dv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1f) |
| (JNIEnv *env, jclass that, jfloat arg0) |
| { |
| NATIVE_ENTER(env, that, "glEvalCoord1f\n") |
| glEvalCoord1f(arg0); |
| NATIVE_EXIT(env, that, "glEvalCoord1f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1fv) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glEvalCoord1fv\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glEvalCoord1fv(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glEvalCoord1fv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2d) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1) |
| { |
| NATIVE_ENTER(env, that, "glEvalCoord2d\n") |
| glEvalCoord2d(arg0, arg1); |
| NATIVE_EXIT(env, that, "glEvalCoord2d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2dv) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glEvalCoord2dv\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glEvalCoord2dv(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glEvalCoord2dv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2f) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1) |
| { |
| NATIVE_ENTER(env, that, "glEvalCoord2f\n") |
| glEvalCoord2f(arg0, arg1); |
| NATIVE_EXIT(env, that, "glEvalCoord2f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2fv) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glEvalCoord2fv\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glEvalCoord2fv(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glEvalCoord2fv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEvalMesh1) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2) |
| { |
| NATIVE_ENTER(env, that, "glEvalMesh1\n") |
| glEvalMesh1(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glEvalMesh1\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEvalMesh2) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4) |
| { |
| NATIVE_ENTER(env, that, "glEvalMesh2\n") |
| glEvalMesh2(arg0, arg1, arg2, arg3, arg4); |
| NATIVE_EXIT(env, that, "glEvalMesh2\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEvalPoint1) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glEvalPoint1\n") |
| glEvalPoint1(arg0); |
| NATIVE_EXIT(env, that, "glEvalPoint1\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glEvalPoint2) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1) |
| { |
| NATIVE_ENTER(env, that, "glEvalPoint2\n") |
| glEvalPoint2(arg0, arg1); |
| NATIVE_EXIT(env, that, "glEvalPoint2\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glFeedbackBuffer) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2) |
| { |
| jfloat *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glFeedbackBuffer\n") |
| if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL); |
| glFeedbackBuffer(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glFeedbackBuffer\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glFinish) |
| (JNIEnv *env, jclass that) |
| { |
| NATIVE_ENTER(env, that, "glFinish\n") |
| glFinish(); |
| NATIVE_EXIT(env, that, "glFinish\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glFlush) |
| (JNIEnv *env, jclass that) |
| { |
| NATIVE_ENTER(env, that, "glFlush\n") |
| glFlush(); |
| NATIVE_EXIT(env, that, "glFlush\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glFogf) |
| (JNIEnv *env, jclass that, jint arg0, jfloat arg1) |
| { |
| NATIVE_ENTER(env, that, "glFogf\n") |
| glFogf(arg0, arg1); |
| NATIVE_EXIT(env, that, "glFogf\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glFogfv) |
| (JNIEnv *env, jclass that, jint arg0, jfloatArray arg1) |
| { |
| jfloat *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glFogfv\n") |
| if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL); |
| glFogfv(arg0, lparg1); |
| if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glFogfv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glFogi) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1) |
| { |
| NATIVE_ENTER(env, that, "glFogi\n") |
| glFogi(arg0, arg1); |
| NATIVE_EXIT(env, that, "glFogi\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glFogiv) |
| (JNIEnv *env, jclass that, jint arg0, jintArray arg1) |
| { |
| jint *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glFogiv\n") |
| if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL); |
| glFogiv(arg0, (GLint *)lparg1); |
| if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glFogiv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glFrontFace) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glFrontFace\n") |
| glFrontFace(arg0); |
| NATIVE_EXIT(env, that, "glFrontFace\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glFrustum) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3, jdouble arg4, jdouble arg5) |
| { |
| NATIVE_ENTER(env, that, "glFrustum\n") |
| glFrustum(arg0, arg1, arg2, arg3, arg4, arg5); |
| NATIVE_EXIT(env, that, "glFrustum\n") |
| } |
| |
| JNIEXPORT jint JNICALL GL_NATIVE(glGenLists) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| jint rc; |
| NATIVE_ENTER(env, that, "glGenLists\n") |
| rc = (jint)glGenLists(arg0); |
| NATIVE_EXIT(env, that, "glGenLists\n") |
| return rc; |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGenTextures) |
| (JNIEnv *env, jclass that, jint arg0, jintArray arg1) |
| { |
| jint *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glGenTextures\n") |
| if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL); |
| glGenTextures(arg0, (unsigned int *)lparg1); |
| if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glGenTextures\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetBooleanv) |
| (JNIEnv *env, jclass that, jint arg0, jbooleanArray arg1) |
| { |
| jboolean *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetBooleanv\n") |
| if (arg1) lparg1 = (*env)->GetBooleanArrayElements(env, arg1, NULL); |
| glGetBooleanv(arg0, lparg1); |
| if (arg1) (*env)->ReleaseBooleanArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glGetBooleanv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetClipPlane) |
| (JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1) |
| { |
| jdouble *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetClipPlane\n") |
| if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL); |
| glGetClipPlane(arg0, lparg1); |
| if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glGetClipPlane\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetDoublev) |
| (JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1) |
| { |
| jdouble *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetDoublev\n") |
| if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL); |
| glGetDoublev(arg0, lparg1); |
| if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glGetDoublev\n") |
| } |
| |
| JNIEXPORT jint JNICALL GL_NATIVE(glGetError) |
| (JNIEnv *env, jclass that) |
| { |
| jint rc; |
| NATIVE_ENTER(env, that, "glGetError\n") |
| rc = (jint)glGetError(); |
| NATIVE_EXIT(env, that, "glGetError\n") |
| return rc; |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetFloatv) |
| (JNIEnv *env, jclass that, jint arg0, jfloatArray arg1) |
| { |
| jfloat *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetFloatv\n") |
| if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL); |
| glGetFloatv(arg0, lparg1); |
| if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glGetFloatv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetIntegerv) |
| (JNIEnv *env, jclass that, jint arg0, jintArray arg1) |
| { |
| jint *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetIntegerv\n") |
| if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL); |
| glGetIntegerv(arg0, (GLint *)lparg1); |
| if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glGetIntegerv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetLightfv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2) |
| { |
| jfloat *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetLightfv\n") |
| if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL); |
| glGetLightfv(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glGetLightfv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetLightiv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2) |
| { |
| jint *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetLightiv\n") |
| if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL); |
| glGetLightiv(arg0, arg1, (GLint *)lparg2); |
| if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glGetLightiv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetMapdv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2) |
| { |
| jdouble *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetMapdv\n") |
| if (arg2) lparg2 = (*env)->GetDoubleArrayElements(env, arg2, NULL); |
| glGetMapdv(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glGetMapdv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetMapfv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2) |
| { |
| jfloat *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetMapfv\n") |
| if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL); |
| glGetMapfv(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glGetMapfv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetMapiv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2) |
| { |
| jint *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetMapiv\n") |
| if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL); |
| glGetMapiv(arg0, arg1, (GLint *)lparg2); |
| if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glGetMapiv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetMaterialfv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2) |
| { |
| jfloat *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetMaterialfv\n") |
| if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL); |
| glGetMaterialfv(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glGetMaterialfv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetMaterialiv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2) |
| { |
| jint *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetMaterialiv\n") |
| if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL); |
| glGetMaterialiv(arg0, arg1, (GLint *)lparg2); |
| if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glGetMaterialiv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetPixelMapfv) |
| (JNIEnv *env, jclass that, jint arg0, jfloatArray arg1) |
| { |
| jfloat *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetPixelMapfv\n") |
| if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL); |
| glGetPixelMapfv(arg0, lparg1); |
| if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glGetPixelMapfv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetPixelMapuiv) |
| (JNIEnv *env, jclass that, jint arg0, jintArray arg1) |
| { |
| jint *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetPixelMapuiv\n") |
| if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL); |
| glGetPixelMapuiv(arg0, (unsigned int *)lparg1); |
| if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glGetPixelMapuiv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetPixelMapusv) |
| (JNIEnv *env, jclass that, jint arg0, jshortArray arg1) |
| { |
| jshort *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetPixelMapusv\n") |
| if (arg1) lparg1 = (*env)->GetShortArrayElements(env, arg1, NULL); |
| glGetPixelMapusv(arg0, (unsigned short *)lparg1); |
| if (arg1) (*env)->ReleaseShortArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glGetPixelMapusv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetPointerv) |
| (JNIEnv *env, jclass that, jint arg0, jintArray arg1) |
| { |
| jint *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetPointerv\n") |
| if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL); |
| glGetPointerv(arg0, (void **)lparg1); |
| if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glGetPointerv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetPolygonStipple) |
| (JNIEnv *env, jclass that, jbyteArray arg0) |
| { |
| jbyte *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetPolygonStipple\n") |
| if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL); |
| glGetPolygonStipple((unsigned char *)lparg0); |
| if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glGetPolygonStipple\n") |
| } |
| |
| JNIEXPORT jint JNICALL GL_NATIVE(glGetString) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glGetString\n") |
| printf ("%s,\n",glGetString(arg0)); |
| NATIVE_EXIT(env, that, "glGetString\n") |
| return 1; |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetTexEnvfv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2) |
| { |
| jfloat *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetTexEnvfv\n") |
| if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL); |
| glGetTexEnvfv(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glGetTexEnvfv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetTexEnviv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2) |
| { |
| jint *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetTexEnviv\n") |
| if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL); |
| glGetTexEnviv(arg0, arg1, (GLint *)lparg2); |
| if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glGetTexEnviv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetTexGendv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2) |
| { |
| jdouble *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetTexGendv\n") |
| if (arg2) lparg2 = (*env)->GetDoubleArrayElements(env, arg2, NULL); |
| glGetTexGendv(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glGetTexGendv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetTexGenfv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2) |
| { |
| jfloat *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetTexGenfv\n") |
| if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL); |
| glGetTexGenfv(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glGetTexGenfv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetTexGeniv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2) |
| { |
| jint *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetTexGeniv\n") |
| if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL); |
| glGetTexGeniv(arg0, arg1, (GLint *)lparg2); |
| if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glGetTexGeniv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetTexImage) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jintArray arg4) |
| { |
| jint *lparg4=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetTexImage\n") |
| if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL); |
| glGetTexImage(arg0, arg1, arg2, arg3, lparg4); |
| if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0); |
| NATIVE_EXIT(env, that, "glGetTexImage\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetTexLevelParameterfv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jfloatArray arg3) |
| { |
| jfloat *lparg3=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetTexLevelParameterfv\n") |
| if (arg3) lparg3 = (*env)->GetFloatArrayElements(env, arg3, NULL); |
| glGetTexLevelParameterfv(arg0, arg1, arg2, lparg3); |
| if (arg3) (*env)->ReleaseFloatArrayElements(env, arg3, lparg3, 0); |
| NATIVE_EXIT(env, that, "glGetTexLevelParameterfv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetTexLevelParameteriv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3) |
| { |
| jint *lparg3=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetTexLevelParameteriv\n") |
| if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL); |
| glGetTexLevelParameteriv(arg0, arg1, arg2, (GLint *)lparg3); |
| if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0); |
| NATIVE_EXIT(env, that, "glGetTexLevelParameteriv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetTexParameterfv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2) |
| { |
| jfloat *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetTexParameterfv\n") |
| if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL); |
| glGetTexParameterfv(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glGetTexParameterfv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glGetTexParameteriv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2) |
| { |
| jint *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glGetTexParameteriv\n") |
| if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL); |
| glGetTexParameteriv(arg0, arg1, (GLint *)lparg2); |
| if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glGetTexParameteriv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glHint) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1) |
| { |
| NATIVE_ENTER(env, that, "glHint\n") |
| glHint(arg0, arg1); |
| NATIVE_EXIT(env, that, "glHint\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glIndexMask) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glIndexMask\n") |
| glIndexMask(arg0); |
| NATIVE_EXIT(env, that, "glIndexMask\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glIndexPointer) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2) |
| { |
| jint *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glIndexPointer\n") |
| if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL); |
| glIndexPointer(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glIndexPointer\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glIndexd) |
| (JNIEnv *env, jclass that, jdouble arg0) |
| { |
| NATIVE_ENTER(env, that, "glIndexd\n") |
| glIndexd(arg0); |
| NATIVE_EXIT(env, that, "glIndexd\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glIndexdv) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glIndexdv\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glIndexdv(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glIndexdv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glIndexf) |
| (JNIEnv *env, jclass that, jfloat arg0) |
| { |
| NATIVE_ENTER(env, that, "glIndexf\n") |
| glIndexf(arg0); |
| NATIVE_EXIT(env, that, "glIndexf\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glIndexfv) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glIndexfv\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glIndexfv(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glIndexfv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glIndexi) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glIndexi\n") |
| glIndexi(arg0); |
| NATIVE_EXIT(env, that, "glIndexi\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glIndexiv) |
| (JNIEnv *env, jclass that, jintArray arg0) |
| { |
| jint *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glIndexiv\n") |
| if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL); |
| glIndexiv((GLint *)lparg0); |
| if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glIndexiv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glIndexs) |
| (JNIEnv *env, jclass that, jshort arg0) |
| { |
| NATIVE_ENTER(env, that, "glIndexs\n") |
| glIndexs(arg0); |
| NATIVE_EXIT(env, that, "glIndexs\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glIndexsv) |
| (JNIEnv *env, jclass that, jshortArray arg0) |
| { |
| jshort *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glIndexsv\n") |
| if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL); |
| glIndexsv(lparg0); |
| if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glIndexsv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glInitNames) |
| (JNIEnv *env, jclass that) |
| { |
| NATIVE_ENTER(env, that, "glInitNames\n") |
| glInitNames(); |
| NATIVE_EXIT(env, that, "glInitNames\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glInterleavedArrays) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2) |
| { |
| jint *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glInterleavedArrays\n") |
| if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL); |
| glInterleavedArrays(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glInterleavedArrays\n") |
| } |
| |
| JNIEXPORT jboolean JNICALL GL_NATIVE(glIsEnabled) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| jboolean result; |
| NATIVE_ENTER(env, that, "glIsEnabled\n") |
| result = (jboolean)glIsEnabled(arg0); |
| NATIVE_EXIT(env, that, "glIsEnabled\n") |
| return result; |
| } |
| |
| JNIEXPORT jboolean JNICALL GL_NATIVE(glIsList) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| jboolean result; |
| NATIVE_ENTER(env, that, "glIsList\n") |
| result = (jboolean)glIsList(arg0); |
| NATIVE_EXIT(env, that, "glIsList\n") |
| return result; |
| } |
| |
| JNIEXPORT jboolean JNICALL GL_NATIVE(glIsTexture) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| jboolean result; |
| NATIVE_ENTER(env, that, "glIsTexture\n") |
| result = (jboolean)glIsTexture(arg0); |
| NATIVE_EXIT(env, that, "glIsTexture\n") |
| return result; |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glLightModelf) |
| (JNIEnv *env, jclass that, jint arg0, jfloat arg1) |
| { |
| NATIVE_ENTER(env, that, "glLightModelf\n") |
| glLightModelf(arg0, arg1); |
| NATIVE_EXIT(env, that, "glLightModelf\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glLightModelfv) |
| (JNIEnv *env, jclass that, jint arg0, jfloatArray arg1) |
| { |
| jfloat *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glLightModelfv\n") |
| if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL); |
| glLightModelfv(arg0, lparg1); |
| if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glLightModelfv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glLightModeli) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1) |
| { |
| NATIVE_ENTER(env, that, "glLightModeli\n") |
| glLightModeli(arg0, arg1); |
| NATIVE_EXIT(env, that, "glLightModeli\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glLightModeliv) |
| (JNIEnv *env, jclass that, jint arg0, jintArray arg1) |
| { |
| jint *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glLightModeliv\n") |
| if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL); |
| glLightModeliv(arg0, (GLint *)lparg1); |
| if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glLightModeliv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glLightf) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2) |
| { |
| NATIVE_ENTER(env, that, "glLightf\n") |
| glLightf(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glLightf\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glLightfv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2) |
| { |
| jfloat *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glLightfv\n") |
| if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL); |
| glLightfv(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glLightfv\n") |
| } |
| /* |
| JNIEXPORT void JNICALL GL_NATIVE(glLightfv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat *arg2) |
| { |
| NATIVE_ENTER(env, that, "glLightfv\n") |
| glLightfv(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glLightfv\n") |
| } |
| */ |
| JNIEXPORT void JNICALL GL_NATIVE(glLighti) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2) |
| { |
| NATIVE_ENTER(env, that, "glLighti\n") |
| glLighti(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glLighti\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glLightiv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2) |
| { |
| jint *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glLightiv\n") |
| if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL); |
| glLightiv(arg0, arg1, (GLint *)lparg2); |
| if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glLightiv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glLineStipple) |
| (JNIEnv *env, jclass that, jint arg0, jshort arg1) |
| { |
| NATIVE_ENTER(env, that, "glLineStipple\n") |
| glLineStipple(arg0, arg1); |
| NATIVE_EXIT(env, that, "glLineStipple\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glLineWidth) |
| (JNIEnv *env, jclass that, jfloat arg0) |
| { |
| NATIVE_ENTER(env, that, "glLineWidth\n") |
| glLineWidth(arg0); |
| NATIVE_EXIT(env, that, "glLineWidth\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glListBase) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glListBase\n") |
| glListBase(arg0); |
| NATIVE_EXIT(env, that, "glListBase\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glLoadIdentity) |
| (JNIEnv *env, jclass that) |
| { |
| NATIVE_ENTER(env, that, "glLoadIdentity\n") |
| glLoadIdentity(); |
| NATIVE_EXIT(env, that, "glLoadIdentity\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glLoadMatrixd) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glLoadMatrixd\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glLoadMatrixd(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glLoadMatrixd\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glLoadMatrixf) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glLoadMatrixf\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glLoadMatrixf(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glLoadMatrixf\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glLoadName) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glLoadName\n") |
| glLoadName(arg0); |
| NATIVE_EXIT(env, that, "glLoadName\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glLogicOp) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glLogicOp\n") |
| glLogicOp(arg0); |
| NATIVE_EXIT(env, that, "glLogicOp\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glMap2f) |
| (JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2, jint arg3, jint arg4, |
| jfloat arg5, jfloat arg6, jint arg7, jint arg8, jfloatArray arg9) |
| { |
| jfloat *lparg9=NULL; |
| |
| NATIVE_ENTER(env, that, "glMap2f\n") |
| if (arg9) lparg9 = (*env)->GetFloatArrayElements(env, arg9, NULL); |
| glMap2f(arg0, arg1, arg2, arg3, arg4 ,arg5, arg6, arg7, arg8, lparg9); |
| if (arg9) (*env)->ReleaseFloatArrayElements(env, arg9, lparg9, 0); |
| NATIVE_EXIT(env, that, "glMap2f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glMap2d) |
| (JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4, |
| jdouble arg5, jdouble arg6, jint arg7, jint arg8, jdoubleArray arg9) |
| { |
| jdouble *lparg9=NULL; |
| |
| NATIVE_ENTER(env, that, "glMap2d\n") |
| if (arg9) lparg9 = (*env)->GetDoubleArrayElements(env, arg9, NULL); |
| glMap2d(arg0, arg1, arg2, arg3, arg4 ,arg5, arg6, arg7, arg8, lparg9); |
| if (arg9) (*env)->ReleaseDoubleArrayElements(env, arg9, lparg9, 0); |
| NATIVE_EXIT(env, that, "glMap2d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glMap1d) |
| (JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4, jdoubleArray arg5) |
| { |
| jdouble *lparg5=NULL; |
| |
| NATIVE_ENTER(env, that, "glMap1d\n") |
| if (arg5) lparg5 = (*env)->GetDoubleArrayElements(env, arg5, NULL); |
| glMap1d(arg0, arg1, arg2, arg3, arg4, lparg5); |
| if (arg5) (*env)->ReleaseDoubleArrayElements(env, arg5, lparg5, 0); |
| NATIVE_EXIT(env, that, "glMap1d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glMap1f) |
| (JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2, jint arg3, jint arg4, jfloatArray arg5) |
| { |
| jfloat *lparg5=NULL; |
| |
| NATIVE_ENTER(env, that, "glMap1f\n") |
| if (arg5) lparg5 = (*env)->GetFloatArrayElements(env, arg5, NULL); |
| glMap1f(arg0, arg1, arg2, arg3, arg4, lparg5); |
| if (arg5) (*env)->ReleaseFloatArrayElements(env, arg5, lparg5, 0); |
| NATIVE_EXIT(env, that, "glMap1f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glMapGrid1d) |
| (JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2) |
| { |
| NATIVE_ENTER(env, that, "glMapGrid1d\n") |
| glMapGrid1d(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glMapGrid1d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glMapGrid1f) |
| (JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2) |
| { |
| NATIVE_ENTER(env, that, "glMapGrid1f\n") |
| glMapGrid1f(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glMapGrid1f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glMapGrid2d) |
| (JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jdouble arg4, jdouble arg5) |
| { |
| NATIVE_ENTER(env, that, "glMapGrid2d\n") |
| glMapGrid2d(arg0, arg1, arg2, arg3, arg4, arg5); |
| NATIVE_EXIT(env, that, "glMapGrid2d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glMapGrid2f) |
| (JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2, jint arg3, jfloat arg4, jfloat arg5) |
| { |
| NATIVE_ENTER(env, that, "glMapGrid2f\n") |
| glMapGrid2f(arg0, arg1, arg2, arg3, arg4, arg5); |
| NATIVE_EXIT(env, that, "glMapGrid2f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glMaterialf) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2) |
| { |
| NATIVE_ENTER(env, that, "glMaterialf\n") |
| glMaterialf(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glMaterialf\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glMaterialfv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2) |
| { |
| jfloat *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glMaterialfv\n") |
| if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL); |
| glMaterialfv(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glMaterialfv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glMateriali) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2) |
| { |
| NATIVE_ENTER(env, that, "glMateriali\n") |
| glMateriali(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glMateriali\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glMaterialiv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2) |
| { |
| jint *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glMaterialiv\n") |
| if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL); |
| glMaterialiv(arg0, arg1, (GLint *)lparg2); |
| if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glMaterialiv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glMatrixMode) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glMatrixMode\n") |
| glMatrixMode(arg0); |
| NATIVE_EXIT(env, that, "glMatrixMode\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glMultMatrixd) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glMultMatrixd\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glMultMatrixd(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glMultMatrixd\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glMultMatrixf) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glMultMatrixf\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glMultMatrixf(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glMultMatrixf\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glNewList) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1) |
| { |
| NATIVE_ENTER(env, that, "glNewList\n") |
| glNewList(arg0, arg1); |
| NATIVE_EXIT(env, that, "glNewList\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glNormal3b) |
| (JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2) |
| { |
| NATIVE_ENTER(env, that, "glNormal3b\n") |
| glNormal3b(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glNormal3b\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glNormal3bv) |
| (JNIEnv *env, jclass that, jbyteArray arg0) |
| { |
| jbyte *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glNormal3bv\n") |
| if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL); |
| glNormal3bv(lparg0); |
| if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glNormal3bv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glNormal3d) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2) |
| { |
| NATIVE_ENTER(env, that, "glNormal3d\n") |
| glNormal3d(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glNormal3d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glNormal3dv) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glNormal3dv\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glNormal3dv(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glNormal3dv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glNormal3f) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2) |
| { |
| NATIVE_ENTER(env, that, "glNormal3f\n") |
| glNormal3f(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glNormal3f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glNormal3fv) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glNormal3fv\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glNormal3fv(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glNormal3fv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glNormal3i) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2) |
| { |
| NATIVE_ENTER(env, that, "glNormal3i\n") |
| glNormal3i(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glNormal3i\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glNormal3iv) |
| (JNIEnv *env, jclass that, jintArray arg0) |
| { |
| jint *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glNormal3iv\n") |
| if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL); |
| glNormal3iv((GLint *)lparg0); |
| if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glNormal3iv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glNormal3s) |
| (JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2) |
| { |
| NATIVE_ENTER(env, that, "glNormal3s\n") |
| glNormal3s(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glNormal3s\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glNormal3sv) |
| (JNIEnv *env, jclass that, jshortArray arg0) |
| { |
| jshort *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glNormal3sv\n") |
| if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL); |
| glNormal3sv(lparg0); |
| if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glNormal3sv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glNormalPointer) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2) |
| { |
| jint *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glNormalPointer\n") |
| if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL); |
| glNormalPointer(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glNormalPointer\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glOrtho) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3, jdouble arg4, jdouble arg5) |
| { |
| NATIVE_ENTER(env, that, "glOrtho\n") |
| glOrtho(arg0, arg1, arg2, arg3, arg4, arg5); |
| NATIVE_EXIT(env, that, "glOrtho\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPassThrough) |
| (JNIEnv *env, jclass that, jfloat arg0) |
| { |
| NATIVE_ENTER(env, that, "glPassThrough\n") |
| glPassThrough(arg0); |
| NATIVE_EXIT(env, that, "glPassThrough\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPixelMapfv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2) |
| { |
| jfloat *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glPixelMapfv\n") |
| if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL); |
| glPixelMapfv(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glPixelMapfv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPixelMapuiv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2) |
| { |
| jint *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glPixelMapuiv\n") |
| if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL); |
| glPixelMapuiv(arg0, arg1, (unsigned int *)lparg2); |
| if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glPixelMapuiv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPixelMapusv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jshortArray arg2) |
| { |
| jshort *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glPixelMapusv\n") |
| if (arg2) lparg2 = (*env)->GetShortArrayElements(env, arg2, NULL); |
| glPixelMapusv(arg0, arg1, (unsigned short *)lparg2); |
| if (arg2) (*env)->ReleaseShortArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glPixelMapusv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPixelStoref) |
| (JNIEnv *env, jclass that, jint arg0, jfloat arg1) |
| { |
| NATIVE_ENTER(env, that, "glPixelStoref\n") |
| glPixelStoref(arg0, arg1); |
| NATIVE_EXIT(env, that, "glPixelStoref\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPixelStorei) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1) |
| { |
| NATIVE_ENTER(env, that, "glPixelStorei\n") |
| glPixelStorei(arg0, arg1); |
| NATIVE_EXIT(env, that, "glPixelStorei\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPixelTransferf) |
| (JNIEnv *env, jclass that, jint arg0, jfloat arg1) |
| { |
| NATIVE_ENTER(env, that, "glPixelTransferf\n") |
| glPixelTransferf(arg0, arg1); |
| NATIVE_EXIT(env, that, "glPixelTransferf\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPixelTransferi) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1) |
| { |
| NATIVE_ENTER(env, that, "glPixelTransferi\n") |
| glPixelTransferi(arg0, arg1); |
| NATIVE_EXIT(env, that, "glPixelTransferi\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPixelZoom) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1) |
| { |
| NATIVE_ENTER(env, that, "glPixelZoom\n") |
| glPixelZoom(arg0, arg1); |
| NATIVE_EXIT(env, that, "glPixelZoom\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPointSize) |
| (JNIEnv *env, jclass that, jfloat arg0) |
| { |
| NATIVE_ENTER(env, that, "glPointSize\n") |
| glPointSize(arg0); |
| NATIVE_EXIT(env, that, "glPointSize\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPolygonMode) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1) |
| { |
| NATIVE_ENTER(env, that, "glPolygonMode\n") |
| glPolygonMode(arg0, arg1); |
| NATIVE_EXIT(env, that, "glPolygonMode\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPolygonOffset) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1) |
| { |
| NATIVE_ENTER(env, that, "glPolygonOffset\n") |
| glPolygonOffset(arg0, arg1); |
| NATIVE_EXIT(env, that, "glPolygonOffset\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPolygonStipple) |
| (JNIEnv *env, jclass that, jbyteArray arg0) |
| { |
| jbyte *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glPolygonStipple\n") |
| if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL); |
| glPolygonStipple((unsigned char *)lparg0); |
| if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glPolygonStipple\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPopAttrib) |
| (JNIEnv *env, jclass that) |
| { |
| NATIVE_ENTER(env, that, "glPopAttrib\n") |
| glPopAttrib(); |
| NATIVE_EXIT(env, that, "glPopAttrib\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPopClientAttrib) |
| (JNIEnv *env, jclass that) |
| { |
| NATIVE_ENTER(env, that, "glPopClientAttrib\n") |
| glPopClientAttrib(); |
| NATIVE_EXIT(env, that, "glPopClientAttrib\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPopMatrix) |
| (JNIEnv *env, jclass that) |
| { |
| NATIVE_ENTER(env, that, "glPopMatrix\n") |
| glPopMatrix(); |
| NATIVE_EXIT(env, that, "glPopMatrix\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPopName) |
| (JNIEnv *env, jclass that) |
| { |
| NATIVE_ENTER(env, that, "glPopName\n") |
| glPopName(); |
| NATIVE_EXIT(env, that, "glPopName\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPrioritizeTextures) |
| (JNIEnv *env, jclass that, jint arg0, jintArray arg1, jfloatArray arg2) |
| { |
| jint *lparg1=NULL; |
| jfloat *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glPrioritizeTextures\n") |
| if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL); |
| if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL); |
| glPrioritizeTextures(arg0, (unsigned int *)lparg1, lparg2); |
| if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0); |
| if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glPrioritizeTextures\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPushAttrib) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glPushAttrib\n") |
| glPushAttrib(arg0); |
| NATIVE_EXIT(env, that, "glPushAttrib\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPushClientAttrib) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glPushClientAttrib\n") |
| glPushClientAttrib(arg0); |
| NATIVE_EXIT(env, that, "glPushClientAttrib\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPushMatrix) |
| (JNIEnv *env, jclass that) |
| { |
| NATIVE_ENTER(env, that, "glPushMatrix\n") |
| glPushMatrix(); |
| NATIVE_EXIT(env, that, "glPushMatrix\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glPushName) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glPushName\n") |
| glPushName(arg0); |
| NATIVE_EXIT(env, that, "glPushName\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2d) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1) |
| { |
| NATIVE_ENTER(env, that, "glRasterPos2d\n") |
| glRasterPos2d(arg0, arg1); |
| NATIVE_EXIT(env, that, "glRasterPos2d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2dv) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glRasterPos2dv\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glRasterPos2dv(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glRasterPos2dv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2f) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1) |
| { |
| NATIVE_ENTER(env, that, "glRasterPos2f\n") |
| glRasterPos2f(arg0, arg1); |
| NATIVE_EXIT(env, that, "glRasterPos2f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2fv) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glRasterPos2fv\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glRasterPos2fv(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glRasterPos2fv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2i) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1) |
| { |
| NATIVE_ENTER(env, that, "glRasterPos2i\n") |
| glRasterPos2i(arg0, arg1); |
| NATIVE_EXIT(env, that, "glRasterPos2i\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2iv) |
| (JNIEnv *env, jclass that, jintArray arg0) |
| { |
| jint *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glRasterPos2iv\n") |
| if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL); |
| glRasterPos2iv((GLint *)lparg0); |
| if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glRasterPos2iv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2s) |
| (JNIEnv *env, jclass that, jshort arg0, jshort arg1) |
| { |
| NATIVE_ENTER(env, that, "glRasterPos2s\n") |
| glRasterPos2s(arg0, arg1); |
| NATIVE_EXIT(env, that, "glRasterPos2s\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2sv) |
| (JNIEnv *env, jclass that, jshortArray arg0) |
| { |
| jshort *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glRasterPos2sv\n") |
| if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL); |
| glRasterPos2sv(lparg0); |
| if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glRasterPos2sv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3d) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2) |
| { |
| NATIVE_ENTER(env, that, "glRasterPos3d\n") |
| glRasterPos3d(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glRasterPos3d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3dv) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glRasterPos3dv\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glRasterPos3dv(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glRasterPos3dv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3f) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2) |
| { |
| NATIVE_ENTER(env, that, "glRasterPos3f\n") |
| glRasterPos3f(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glRasterPos3f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3fv) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glRasterPos3fv\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glRasterPos3fv(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glRasterPos3fv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3i) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2) |
| { |
| NATIVE_ENTER(env, that, "glRasterPos3i\n") |
| glRasterPos3i(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glRasterPos3i\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3iv) |
| (JNIEnv *env, jclass that, jintArray arg0) |
| { |
| jint *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glRasterPos3iv\n") |
| if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL); |
| glRasterPos3iv((GLint *)lparg0); |
| if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glRasterPos3iv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3s) |
| (JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2) |
| { |
| NATIVE_ENTER(env, that, "glRasterPos3s\n") |
| glRasterPos3s(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glRasterPos3s\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3sv) |
| (JNIEnv *env, jclass that, jshortArray arg0) |
| { |
| jshort *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glRasterPos3sv\n") |
| if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL); |
| glRasterPos3sv(lparg0); |
| if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glRasterPos3sv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4d) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3) |
| { |
| NATIVE_ENTER(env, that, "glRasterPos4d\n") |
| glRasterPos4d(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glRasterPos4d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4dv) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glRasterPos4dv\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glRasterPos4dv(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glRasterPos4dv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4f) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3) |
| { |
| NATIVE_ENTER(env, that, "glRasterPos4f\n") |
| glRasterPos4f(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glRasterPos4f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4fv) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glRasterPos4fv\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glRasterPos4fv(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glRasterPos4fv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4i) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3) |
| { |
| NATIVE_ENTER(env, that, "glRasterPos4i\n") |
| glRasterPos4i(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glRasterPos4i\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4iv) |
| (JNIEnv *env, jclass that, jintArray arg0) |
| { |
| jint *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glRasterPos4iv\n") |
| if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL); |
| glRasterPos4iv((GLint *)lparg0); |
| if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glRasterPos4iv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4s) |
| (JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3) |
| { |
| NATIVE_ENTER(env, that, "glRasterPos4s\n") |
| glRasterPos4s(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glRasterPos4s\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4sv) |
| (JNIEnv *env, jclass that, jshortArray arg0) |
| { |
| jshort *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glRasterPos4sv\n") |
| if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL); |
| glRasterPos4sv(lparg0); |
| if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glRasterPos4sv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glReadBuffer) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glReadBuffer\n") |
| glReadBuffer(arg0); |
| NATIVE_EXIT(env, that, "glReadBuffer\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glReadPixels) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jintArray arg6) |
| { |
| jint *lparg6=NULL; |
| |
| NATIVE_ENTER(env, that, "glReadPixels\n") |
| if (arg6) lparg6 = (*env)->GetIntArrayElements(env, arg6, NULL); |
| glReadPixels(arg0, arg1, arg2, arg3, arg4, arg5, lparg6); |
| if (arg6) (*env)->ReleaseIntArrayElements(env, arg6, lparg6, 0); |
| NATIVE_EXIT(env, that, "glReadPixels\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRectd) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3) |
| { |
| NATIVE_ENTER(env, that, "glRectd\n") |
| glRectd(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glRectd\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRectdv) |
| (JNIEnv *env, jclass that, jdoubleArray arg0, jdoubleArray arg1) |
| { |
| jdouble *lparg0=NULL; |
| jdouble *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glRectdv\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL); |
| glRectdv(lparg0, lparg1); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glRectdv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRectf) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3) |
| { |
| NATIVE_ENTER(env, that, "glRectf\n") |
| glRectf(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glRectf\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRectfv) |
| (JNIEnv *env, jclass that, jfloatArray arg0, jfloatArray arg1) |
| { |
| jfloat *lparg0=NULL; |
| jfloat *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glRectfv\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL); |
| glRectfv(lparg0, lparg1); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glRectfv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRecti) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3) |
| { |
| NATIVE_ENTER(env, that, "glRecti\n") |
| glRecti(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glRecti\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRectiv) |
| (JNIEnv *env, jclass that, jintArray arg0, jintArray arg1) |
| { |
| jint *lparg0=NULL; |
| jint *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glRectiv\n") |
| if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL); |
| if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL); |
| glRectiv((GLint *)lparg0, (GLint *)lparg1); |
| if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0); |
| if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glRectiv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRects) |
| (JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3) |
| { |
| NATIVE_ENTER(env, that, "glRects\n") |
| glRects(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glRects\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRectsv) |
| (JNIEnv *env, jclass that, jshortArray arg0, jshortArray arg1) |
| { |
| jshort *lparg0=NULL; |
| jshort *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glRectsv\n") |
| if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL); |
| if (arg1) lparg1 = (*env)->GetShortArrayElements(env, arg1, NULL); |
| glRectsv(lparg0, lparg1); |
| if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0); |
| if (arg1) (*env)->ReleaseShortArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glRectsv\n") |
| } |
| |
| JNIEXPORT jint JNICALL GL_NATIVE(glRenderMode) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| jint rc; |
| NATIVE_ENTER(env, that, "glRenderMode\n") |
| rc = (jint)glRenderMode(arg0); |
| NATIVE_EXIT(env, that, "glRenderMode\n") |
| return rc; |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRotated) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3) |
| { |
| NATIVE_ENTER(env, that, "glRotated\n") |
| glRotated(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glRotated\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glRotatef) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3) |
| { |
| NATIVE_ENTER(env, that, "glRotatef\n") |
| glRotatef(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glRotatef\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glScaled) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2) |
| { |
| NATIVE_ENTER(env, that, "glScaled\n") |
| glScaled(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glScaled\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glScalef) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2) |
| { |
| NATIVE_ENTER(env, that, "glScalef\n") |
| glScalef(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glScalef\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glScissor) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3) |
| { |
| NATIVE_ENTER(env, that, "glScissor\n") |
| glScissor(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glScissor\n") |
| } |
| |
| /* |
| JNIEXPORT void JNICALL GL_NATIVE(glSelectBuffer) |
| (JNIEnv *env, jclass that, jint arg0, jintArray arg1) |
| { |
| jint *lparg1=NULL; |
| |
| NATIVE_ENTER(env, that, "glSelectBuffer\n") |
| if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL); |
| glSelectBuffer(arg0, lparg1); |
| if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0); |
| NATIVE_EXIT(env, that, "glSelectBuffer\n") |
| } |
| */ |
| |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glSelectBuffer) |
| (JNIEnv *env, jclass that, jint arg0, jint *arg1) |
| { |
| NATIVE_ENTER(env, that, "glSelectBuffer\n") |
| glSelectBuffer(arg0, (unsigned int *)arg1); |
| NATIVE_EXIT(env, that, "glSelectBuffer\n") |
| } |
| |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glShadeModel) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glShadeModel\n") |
| glShadeModel(arg0); |
| NATIVE_EXIT(env, that, "glShadeModel\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glStencilFunc) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2) |
| { |
| NATIVE_ENTER(env, that, "glStencilFunc\n") |
| glStencilFunc(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glStencilFunc\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glStencilMask) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glStencilMask\n") |
| glStencilMask(arg0); |
| NATIVE_EXIT(env, that, "glStencilMask\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glStencilOp) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2) |
| { |
| NATIVE_ENTER(env, that, "glStencilOp\n") |
| glStencilOp(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glStencilOp\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1d) |
| (JNIEnv *env, jclass that, jdouble arg0) |
| { |
| NATIVE_ENTER(env, that, "glTexCoord1d\n") |
| glTexCoord1d(arg0); |
| NATIVE_EXIT(env, that, "glTexCoord1d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1dv) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexCoord1dv\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glTexCoord1dv(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glTexCoord1dv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1f) |
| (JNIEnv *env, jclass that, jfloat arg0) |
| { |
| NATIVE_ENTER(env, that, "glTexCoord1f\n") |
| glTexCoord1f(arg0); |
| NATIVE_EXIT(env, that, "glTexCoord1f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1fv) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexCoord1fv\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glTexCoord1fv(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glTexCoord1fv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1i) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glTexCoord1i\n") |
| glTexCoord1i(arg0); |
| NATIVE_EXIT(env, that, "glTexCoord1i\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1iv) |
| (JNIEnv *env, jclass that, jintArray arg0) |
| { |
| jint *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexCoord1iv\n") |
| if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL); |
| glTexCoord1iv((GLint *)lparg0); |
| if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glTexCoord1iv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1s) |
| (JNIEnv *env, jclass that, jshort arg0) |
| { |
| NATIVE_ENTER(env, that, "glTexCoord1s\n") |
| glTexCoord1s(arg0); |
| NATIVE_EXIT(env, that, "glTexCoord1s\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1sv) |
| (JNIEnv *env, jclass that, jshortArray arg0) |
| { |
| jshort *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexCoord1sv\n") |
| if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL); |
| glTexCoord1sv(lparg0); |
| if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glTexCoord1sv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2d) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1) |
| { |
| NATIVE_ENTER(env, that, "glTexCoord2d\n") |
| glTexCoord2d(arg0, arg1); |
| NATIVE_EXIT(env, that, "glTexCoord2d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2dv) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexCoord2dv\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glTexCoord2dv(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glTexCoord2dv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2f) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1) |
| { |
| NATIVE_ENTER(env, that, "glTexCoord2f\n") |
| glTexCoord2f(arg0, arg1); |
| NATIVE_EXIT(env, that, "glTexCoord2f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2fv) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexCoord2fv\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glTexCoord2fv(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glTexCoord2fv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2i) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1) |
| { |
| NATIVE_ENTER(env, that, "glTexCoord2i\n") |
| glTexCoord2i(arg0, arg1); |
| NATIVE_EXIT(env, that, "glTexCoord2i\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2iv) |
| (JNIEnv *env, jclass that, jintArray arg0) |
| { |
| jint *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexCoord2iv\n") |
| if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL); |
| glTexCoord2iv((GLint *)lparg0); |
| if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glTexCoord2iv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2s) |
| (JNIEnv *env, jclass that, jshort arg0, jshort arg1) |
| { |
| NATIVE_ENTER(env, that, "glTexCoord2s\n") |
| glTexCoord2s(arg0, arg1); |
| NATIVE_EXIT(env, that, "glTexCoord2s\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2sv) |
| (JNIEnv *env, jclass that, jshortArray arg0) |
| { |
| jshort *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexCoord2sv\n") |
| if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL); |
| glTexCoord2sv(lparg0); |
| if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glTexCoord2sv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3d) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2) |
| { |
| NATIVE_ENTER(env, that, "glTexCoord3d\n") |
| glTexCoord3d(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glTexCoord3d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3dv) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexCoord3dv\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glTexCoord3dv(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glTexCoord3dv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3f) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2) |
| { |
| NATIVE_ENTER(env, that, "glTexCoord3f\n") |
| glTexCoord3f(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glTexCoord3f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3fv) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexCoord3fv\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glTexCoord3fv(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glTexCoord3fv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3i) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2) |
| { |
| NATIVE_ENTER(env, that, "glTexCoord3i\n") |
| glTexCoord3i(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glTexCoord3i\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3iv) |
| (JNIEnv *env, jclass that, jintArray arg0) |
| { |
| jint *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexCoord3iv\n") |
| if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL); |
| glTexCoord3iv((GLint *)lparg0); |
| if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glTexCoord3iv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3s) |
| (JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2) |
| { |
| NATIVE_ENTER(env, that, "glTexCoord3s\n") |
| glTexCoord3s(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glTexCoord3s\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3sv) |
| (JNIEnv *env, jclass that, jshortArray arg0) |
| { |
| jshort *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexCoord3sv\n") |
| if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL); |
| glTexCoord3sv(lparg0); |
| if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glTexCoord3sv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4d) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3) |
| { |
| NATIVE_ENTER(env, that, "glTexCoord4d\n") |
| glTexCoord4d(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glTexCoord4d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4dv) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexCoord4dv\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glTexCoord4dv(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glTexCoord4dv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4f) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3) |
| { |
| NATIVE_ENTER(env, that, "glTexCoord4f\n") |
| glTexCoord4f(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glTexCoord4f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4fv) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexCoord4fv\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glTexCoord4fv(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glTexCoord4fv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4i) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3) |
| { |
| NATIVE_ENTER(env, that, "glTexCoord4i\n") |
| glTexCoord4i(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glTexCoord4i\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4iv) |
| (JNIEnv *env, jclass that, jintArray arg0) |
| { |
| jint *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexCoord4iv\n") |
| if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL); |
| glTexCoord4iv((GLint *)lparg0); |
| if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glTexCoord4iv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4s) |
| (JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3) |
| { |
| NATIVE_ENTER(env, that, "glTexCoord4s\n") |
| glTexCoord4s(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glTexCoord4s\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4sv) |
| (JNIEnv *env, jclass that, jshortArray arg0) |
| { |
| jshort *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexCoord4sv\n") |
| if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL); |
| glTexCoord4sv(lparg0); |
| if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glTexCoord4sv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexCoordPointer) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3) |
| { |
| jint *lparg3=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexCoordPointer\n") |
| if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL); |
| glTexCoordPointer(arg0, arg1, arg2, lparg3); |
| if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0); |
| NATIVE_EXIT(env, that, "glTexCoordPointer\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexEnvf) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2) |
| { |
| NATIVE_ENTER(env, that, "glTexEnvf\n") |
| glTexEnvf(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glTexEnvf\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexEnvfv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2) |
| { |
| jfloat *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexEnvfv\n") |
| if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL); |
| glTexEnvfv(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glTexEnvfv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexEnvi) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2) |
| { |
| NATIVE_ENTER(env, that, "glTexEnvi\n") |
| glTexEnvi(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glTexEnvi\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexEnviv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2) |
| { |
| jint *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexEnviv\n") |
| if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL); |
| glTexEnviv(arg0, arg1, (GLint *)lparg2); |
| if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glTexEnviv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexGend) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jdouble arg2) |
| { |
| NATIVE_ENTER(env, that, "glTexGend\n") |
| glTexGend(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glTexGend\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexGendv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2) |
| { |
| jdouble *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexGendv\n") |
| if (arg2) lparg2 = (*env)->GetDoubleArrayElements(env, arg2, NULL); |
| glTexGendv(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glTexGendv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexGenf) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2) |
| { |
| NATIVE_ENTER(env, that, "glTexGenf\n") |
| glTexGenf(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glTexGenf\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexGenfv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2) |
| { |
| jfloat *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexGenfv\n") |
| if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL); |
| glTexGenfv(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glTexGenfv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexGeni) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2) |
| { |
| NATIVE_ENTER(env, that, "glTexGeni\n") |
| glTexGeni(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glTexGeni\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexGeniv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2) |
| { |
| jint *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexGeniv\n") |
| if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL); |
| glTexGeniv(arg0, arg1, (GLint *)lparg2); |
| if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glTexGeniv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexImage1D) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jintArray arg7) |
| { |
| jint *lparg7=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexImage1D\n") |
| if (arg7) lparg7 = (*env)->GetIntArrayElements(env, arg7, NULL); |
| glTexImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, lparg7); |
| if (arg7) (*env)->ReleaseIntArrayElements(env, arg7, lparg7, 0); |
| NATIVE_EXIT(env, that, "glTexImage1D\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexImage2D) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7, jbyteArray arg8) |
| { |
| jbyte *lparg8=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexImage2D\n") |
| if (arg8) lparg8 = (*env)->GetByteArrayElements(env, arg8, NULL); |
| glTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, lparg8); |
| if (arg8) (*env)->ReleaseByteArrayElements(env, arg8, lparg8, 0); |
| NATIVE_EXIT(env, that, "glTexImage2D\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexParameterf) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2) |
| { |
| NATIVE_ENTER(env, that, "glTexParameterf\n") |
| glTexParameterf(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glTexParameterf\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexParameterfv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2) |
| { |
| jfloat *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexParameterfv\n") |
| if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL); |
| glTexParameterfv(arg0, arg1, lparg2); |
| if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glTexParameterfv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexParameteri) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2) |
| { |
| NATIVE_ENTER(env, that, "glTexParameteri\n") |
| glTexParameteri(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glTexParameteri\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexParameteriv) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2) |
| { |
| jint *lparg2=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexParameteriv\n") |
| if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL); |
| glTexParameteriv(arg0, arg1, (GLint *)lparg2); |
| if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0); |
| NATIVE_EXIT(env, that, "glTexParameteriv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexSubImage1D) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jintArray arg6) |
| { |
| jint *lparg6=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexSubImage1D\n") |
| if (arg6) lparg6 = (*env)->GetIntArrayElements(env, arg6, NULL); |
| glTexSubImage1D(arg0, arg1, arg2, arg3, arg4, arg5, lparg6); |
| if (arg6) (*env)->ReleaseIntArrayElements(env, arg6, lparg6, 0); |
| NATIVE_EXIT(env, that, "glTexSubImage1D\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTexSubImage2D) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7, jintArray arg8) |
| { |
| jint *lparg8=NULL; |
| |
| NATIVE_ENTER(env, that, "glTexSubImage2D\n") |
| if (arg8) lparg8 = (*env)->GetIntArrayElements(env, arg8, NULL); |
| glTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, lparg8); |
| if (arg8) (*env)->ReleaseIntArrayElements(env, arg8, lparg8, 0); |
| NATIVE_EXIT(env, that, "glTexSubImage2D\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTranslated) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2) |
| { |
| NATIVE_ENTER(env, that, "glTranslated\n") |
| glTranslated(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glTranslated\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glTranslatef) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2) |
| { |
| NATIVE_ENTER(env, that, "glTranslatef\n") |
| glTranslatef(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glTranslatef\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex2d) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1) |
| { |
| NATIVE_ENTER(env, that, "glVertex2d\n") |
| glVertex2d(arg0, arg1); |
| NATIVE_EXIT(env, that, "glVertex2d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex2dv) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glVertex2dv\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glVertex2dv(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glVertex2dv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex2f) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1) |
| { |
| NATIVE_ENTER(env, that, "glVertex2f\n") |
| glVertex2f(arg0, arg1); |
| NATIVE_EXIT(env, that, "glVertex2f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex2fv) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glVertex2fv\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glVertex2fv(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glVertex2fv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex2i) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1) |
| { |
| NATIVE_ENTER(env, that, "glVertex2i\n") |
| glVertex2i(arg0, arg1); |
| NATIVE_EXIT(env, that, "glVertex2i\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex2iv) |
| (JNIEnv *env, jclass that, jintArray arg0) |
| { |
| jint *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glVertex2iv\n") |
| if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL); |
| glVertex2iv((GLint *)lparg0); |
| if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glVertex2iv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex2s) |
| (JNIEnv *env, jclass that, jshort arg0, jshort arg1) |
| { |
| NATIVE_ENTER(env, that, "glVertex2s\n") |
| glVertex2s(arg0, arg1); |
| NATIVE_EXIT(env, that, "glVertex2s\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex2sv) |
| (JNIEnv *env, jclass that, jshortArray arg0) |
| { |
| jshort *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glVertex2sv\n") |
| if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL); |
| glVertex2sv(lparg0); |
| if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glVertex2sv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex3d) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2) |
| { |
| NATIVE_ENTER(env, that, "glVertex3d\n") |
| glVertex3d(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glVertex3d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex3dv__I) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glVertex3dv\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glVertex3dv(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glVertex3dv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex3dv) |
| (JNIEnv *env, jclass that, jint arg0) |
| { |
| NATIVE_ENTER(env, that, "glVertex3dv\n") |
| glVertex3dv((double*)arg0); |
| NATIVE_EXIT(env, that, "glVertex3dv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex3f) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2) |
| { |
| NATIVE_ENTER(env, that, "glVertex3f\n") |
| glVertex3f(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glVertex3f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex3fv) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glVertex3fv\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glVertex3fv(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glVertex3fv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex3i) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2) |
| { |
| NATIVE_ENTER(env, that, "glVertex3i\n") |
| glVertex3i(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glVertex3i\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex3iv) |
| (JNIEnv *env, jclass that, jintArray arg0) |
| { |
| jint *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glVertex3iv\n") |
| if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL); |
| glVertex3iv((GLint *)lparg0); |
| if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glVertex3iv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex3s) |
| (JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2) |
| { |
| NATIVE_ENTER(env, that, "glVertex3s\n") |
| glVertex3s(arg0, arg1, arg2); |
| NATIVE_EXIT(env, that, "glVertex3s\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex3sv) |
| (JNIEnv *env, jclass that, jshortArray arg0) |
| { |
| jshort *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glVertex3sv\n") |
| if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL); |
| glVertex3sv(lparg0); |
| if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glVertex3sv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex4d) |
| (JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3) |
| { |
| NATIVE_ENTER(env, that, "glVertex4d\n") |
| glVertex4d(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glVertex4d\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex4dv) |
| (JNIEnv *env, jclass that, jdoubleArray arg0) |
| { |
| jdouble *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glVertex4dv\n") |
| if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL); |
| glVertex4dv(lparg0); |
| if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glVertex4dv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex4f) |
| (JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3) |
| { |
| NATIVE_ENTER(env, that, "glVertex4f\n") |
| glVertex4f(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glVertex4f\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex4fv) |
| (JNIEnv *env, jclass that, jfloatArray arg0) |
| { |
| jfloat *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glVertex4fv\n") |
| if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL); |
| glVertex4fv(lparg0); |
| if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glVertex4fv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex4i) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3) |
| { |
| NATIVE_ENTER(env, that, "glVertex4i\n") |
| glVertex4i(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glVertex4i\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex4iv) |
| (JNIEnv *env, jclass that, jintArray arg0) |
| { |
| jint *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glVertex4iv\n") |
| if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL); |
| glVertex4iv((GLint *)lparg0); |
| if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glVertex4iv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex4s) |
| (JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3) |
| { |
| NATIVE_ENTER(env, that, "glVertex4s\n") |
| glVertex4s(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glVertex4s\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertex4sv) |
| (JNIEnv *env, jclass that, jshortArray arg0) |
| { |
| jshort *lparg0=NULL; |
| |
| NATIVE_ENTER(env, that, "glVertex4sv\n") |
| if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL); |
| glVertex4sv(lparg0); |
| if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0); |
| NATIVE_EXIT(env, that, "glVertex4sv\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glVertexPointer) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3) |
| { |
| jint *lparg3=NULL; |
| |
| NATIVE_ENTER(env, that, "glVertexPointer\n") |
| if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL); |
| glVertexPointer(arg0, arg1, arg2, lparg3); |
| if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0); |
| NATIVE_EXIT(env, that, "glVertexPointer\n") |
| } |
| |
| JNIEXPORT void JNICALL GL_NATIVE(glViewport) |
| (JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3) |
| { |
| NATIVE_ENTER(env, that, "glViewport\n") |
| glViewport(arg0, arg1, arg2, arg3); |
| NATIVE_EXIT(env, that, "glViewport\n") |
| } |