Home | History | Annotate | Download | only in jni
      1 /*
      2 **
      3 ** Copyright 2009, The Android Open Source Project
      4 **
      5 ** Licensed under the Apache License, Version 2.0 (the "License");
      6 ** you may not use this file except in compliance with the License.
      7 ** You may obtain a copy of the License at
      8 **
      9 **     http://www.apache.org/licenses/LICENSE-2.0
     10 **
     11 ** Unless required by applicable law or agreed to in writing, software
     12 ** distributed under the License is distributed on an "AS IS" BASIS,
     13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14 ** See the License for the specific language governing permissions and
     15 ** limitations under the License.
     16 */
     17 
     18 // This source file is automatically generated
     19 
     20 #include <GLES/gl.h>
     21 #include <GLES/glext.h>
     22 
     23 #include "jni.h"
     24 #include "JNIHelp.h"
     25 #include <android_runtime/AndroidRuntime.h>
     26 #include <utils/misc.h>
     27 #include <assert.h>
     28 
     29 static int initialized = 0;
     30 
     31 static jclass nioAccessClass;
     32 static jclass bufferClass;
     33 static jmethodID getBasePointerID;
     34 static jmethodID getBaseArrayID;
     35 static jmethodID getBaseArrayOffsetID;
     36 static jfieldID positionID;
     37 static jfieldID limitID;
     38 static jfieldID elementSizeShiftID;
     39 
     40 
     41 /* special calls implemented in Android's GLES wrapper used to more
     42  * efficiently bound-check passed arrays */
     43 extern "C" {
     44 #ifdef GL_VERSION_ES_CM_1_1
     45 GL_API void GL_APIENTRY glColorPointerBounds(GLint size, GLenum type, GLsizei stride,
     46         const GLvoid *ptr, GLsizei count);
     47 GL_API void GL_APIENTRY glNormalPointerBounds(GLenum type, GLsizei stride,
     48         const GLvoid *pointer, GLsizei count);
     49 GL_API void GL_APIENTRY glTexCoordPointerBounds(GLint size, GLenum type,
     50         GLsizei stride, const GLvoid *pointer, GLsizei count);
     51 GL_API void GL_APIENTRY glVertexPointerBounds(GLint size, GLenum type,
     52         GLsizei stride, const GLvoid *pointer, GLsizei count);
     53 GL_API void GL_APIENTRY glPointSizePointerOESBounds(GLenum type,
     54         GLsizei stride, const GLvoid *pointer, GLsizei count);
     55 GL_API void GL_APIENTRY glMatrixIndexPointerOESBounds(GLint size, GLenum type,
     56         GLsizei stride, const GLvoid *pointer, GLsizei count);
     57 GL_API void GL_APIENTRY glWeightPointerOESBounds(GLint size, GLenum type,
     58         GLsizei stride, const GLvoid *pointer, GLsizei count);
     59 #endif
     60 #ifdef GL_ES_VERSION_2_0
     61 static void glVertexAttribPointerBounds(GLuint indx, GLint size, GLenum type,
     62         GLboolean normalized, GLsizei stride, const GLvoid *pointer, GLsizei count) {
     63     glVertexAttribPointer(indx, size, type, normalized, stride, pointer);
     64 }
     65 #endif
     66 }
     67 
     68 /* Cache method IDs each time the class is loaded. */
     69 
     70 static void
     71 nativeClassInit(JNIEnv *_env, jclass glImplClass)
     72 {
     73     jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess");
     74     nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal);
     75 
     76     jclass bufferClassLocal = _env->FindClass("java/nio/Buffer");
     77     bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal);
     78 
     79     getBasePointerID = _env->GetStaticMethodID(nioAccessClass,
     80             "getBasePointer", "(Ljava/nio/Buffer;)J");
     81     getBaseArrayID = _env->GetStaticMethodID(nioAccessClass,
     82             "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;");
     83     getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass,
     84             "getBaseArrayOffset", "(Ljava/nio/Buffer;)I");
     85 
     86     positionID = _env->GetFieldID(bufferClass, "position", "I");
     87     limitID = _env->GetFieldID(bufferClass, "limit", "I");
     88     elementSizeShiftID =
     89         _env->GetFieldID(bufferClass, "_elementSizeShift", "I");
     90 }
     91 
     92 static void *
     93 getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining, jint *offset)
     94 {
     95     jint position;
     96     jint limit;
     97     jint elementSizeShift;
     98     jlong pointer;
     99 
    100     position = _env->GetIntField(buffer, positionID);
    101     limit = _env->GetIntField(buffer, limitID);
    102     elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
    103     *remaining = (limit - position) << elementSizeShift;
    104     pointer = _env->CallStaticLongMethod(nioAccessClass,
    105             getBasePointerID, buffer);
    106     if (pointer != 0L) {
    107         *array = NULL;
    108         return (void *) (jint) pointer;
    109     }
    110 
    111     *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass,
    112             getBaseArrayID, buffer);
    113     *offset = _env->CallStaticIntMethod(nioAccessClass,
    114             getBaseArrayOffsetID, buffer);
    115 
    116     return NULL;
    117 }
    118 
    119 static void
    120 releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit)
    121 {
    122     _env->ReleasePrimitiveArrayCritical(array, data,
    123                        commit ? 0 : JNI_ABORT);
    124 }
    125 
    126 static void *
    127 getDirectBufferPointer(JNIEnv *_env, jobject buffer) {
    128     char* buf = (char*) _env->GetDirectBufferAddress(buffer);
    129     if (buf) {
    130         jint position = _env->GetIntField(buffer, positionID);
    131         jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
    132         buf += position << elementSizeShift;
    133     } else {
    134         jniThrowException(_env, "java/lang/IllegalArgumentException",
    135                           "Must use a native order direct Buffer");
    136     }
    137     return (void*) buf;
    138 }
    139 
    140 // --------------------------------------------------------------------------
    141 
    142 /*
    143  * returns the number of values glGet returns for a given pname.
    144  *
    145  * The code below is written such that pnames requiring only one values
    146  * are the default (and are not explicitely tested for). This makes the
    147  * checking code much shorter/readable/efficient.
    148  *
    149  * This means that unknown pnames (e.g.: extensions) will default to 1. If
    150  * that unknown pname needs more than 1 value, then the validation check
    151  * is incomplete and the app may crash if it passed the wrong number params.
    152  */
    153 static int getNeededCount(GLint pname) {
    154     int needed = 1;
    155 #ifdef GL_ES_VERSION_2_0
    156     // GLES 2.x pnames
    157     switch (pname) {
    158         case GL_ALIASED_LINE_WIDTH_RANGE:
    159         case GL_ALIASED_POINT_SIZE_RANGE:
    160             needed = 2;
    161             break;
    162 
    163         case GL_BLEND_COLOR:
    164         case GL_COLOR_CLEAR_VALUE:
    165         case GL_COLOR_WRITEMASK:
    166         case GL_SCISSOR_BOX:
    167         case GL_VIEWPORT:
    168             needed = 4;
    169             break;
    170 
    171         case GL_COMPRESSED_TEXTURE_FORMATS:
    172             glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed);
    173             break;
    174 
    175         case GL_SHADER_BINARY_FORMATS:
    176             glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &needed);
    177             break;
    178     }
    179 #endif
    180 
    181 #ifdef GL_VERSION_ES_CM_1_1
    182     // GLES 1.x pnames
    183     switch (pname) {
    184         case GL_ALIASED_LINE_WIDTH_RANGE:
    185         case GL_ALIASED_POINT_SIZE_RANGE:
    186         case GL_DEPTH_RANGE:
    187         case GL_SMOOTH_LINE_WIDTH_RANGE:
    188         case GL_SMOOTH_POINT_SIZE_RANGE:
    189             needed = 2;
    190             break;
    191 
    192         case GL_CURRENT_NORMAL:
    193         case GL_POINT_DISTANCE_ATTENUATION:
    194             needed = 3;
    195             break;
    196 
    197         case GL_COLOR_CLEAR_VALUE:
    198         case GL_COLOR_WRITEMASK:
    199         case GL_CURRENT_COLOR:
    200         case GL_CURRENT_TEXTURE_COORDS:
    201         case GL_FOG_COLOR:
    202         case GL_LIGHT_MODEL_AMBIENT:
    203         case GL_SCISSOR_BOX:
    204         case GL_VIEWPORT:
    205             needed = 4;
    206             break;
    207 
    208         case GL_MODELVIEW_MATRIX:
    209         case GL_PROJECTION_MATRIX:
    210         case GL_TEXTURE_MATRIX:
    211             needed = 16;
    212             break;
    213 
    214         case GL_COMPRESSED_TEXTURE_FORMATS:
    215             glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed);
    216             break;
    217     }
    218 #endif
    219     return needed;
    220 }
    221 
    222 template <typename JTYPEARRAY, typename CTYPE, void GET(GLenum, CTYPE*)>
    223 static void
    224 get
    225   (JNIEnv *_env, jobject _this, jint pname, JTYPEARRAY params_ref, jint offset) {
    226     jint _exception = 0;
    227     const char * _exceptionType;
    228     const char * _exceptionMessage;
    229     CTYPE *params_base = (CTYPE *) 0;
    230     jint _remaining;
    231     CTYPE *params = (CTYPE *) 0;
    232     int _needed = 0;
    233 
    234     if (!params_ref) {
    235         _exception = 1;
    236         _exceptionType = "java/lang/IllegalArgumentException";
    237         _exceptionMessage = "params == null";
    238         goto exit;
    239     }
    240     if (offset < 0) {
    241         _exception = 1;
    242         _exceptionType = "java/lang/IllegalArgumentException";
    243         _exceptionMessage = "offset < 0";
    244         goto exit;
    245     }
    246     _remaining = _env->GetArrayLength(params_ref) - offset;
    247     _needed = getNeededCount(pname);
    248     // if we didn't find this pname, we just assume the user passed
    249     // an array of the right size -- this might happen with extensions
    250     // or if we forget an enum here.
    251     if (_remaining < _needed) {
    252         _exception = 1;
    253         _exceptionType = "java/lang/IllegalArgumentException";
    254         _exceptionMessage = "length - offset < needed";
    255         goto exit;
    256     }
    257     params_base = (CTYPE *)
    258         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
    259     params = params_base + offset;
    260 
    261     GET(
    262         (GLenum)pname,
    263         (CTYPE *)params
    264     );
    265 
    266 exit:
    267     if (params_base) {
    268         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
    269             _exception ? JNI_ABORT: 0);
    270     }
    271     if (_exception) {
    272         jniThrowException(_env, _exceptionType, _exceptionMessage);
    273     }
    274 }
    275 
    276 
    277 template <typename CTYPE, void GET(GLenum, CTYPE*)>
    278 static void
    279 getarray
    280   (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
    281     jint _exception = 0;
    282     const char * _exceptionType;
    283     const char * _exceptionMessage;
    284     jarray _array = (jarray) 0;
    285     jint _bufferOffset = (jint) 0;
    286     jint _remaining;
    287     CTYPE *params = (CTYPE *) 0;
    288     int _needed = 0;
    289 
    290     params = (CTYPE *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
    291     _needed = getNeededCount(pname);
    292     // if we didn't find this pname, we just assume the user passed
    293     // an array of the right size -- this might happen with extensions
    294     // or if we forget an enum here.
    295     if (_needed>0 && _remaining < _needed) {
    296         _exception = 1;
    297         _exceptionType = "java/lang/IllegalArgumentException";
    298         _exceptionMessage = "remaining() < needed";
    299         goto exit;
    300     }
    301     if (params == NULL) {
    302         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
    303         params = (CTYPE *) (_paramsBase + _bufferOffset);
    304     }
    305     GET(
    306         (GLenum)pname,
    307         (CTYPE *)params
    308     );
    309 
    310 exit:
    311     if (_array) {
    312         releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
    313     }
    314     if (_exception) {
    315         jniThrowException(_env, _exceptionType, _exceptionMessage);
    316     }
    317 }
    318 
    319 // --------------------------------------------------------------------------
    320 /* void glBlendEquationSeparateOES ( GLenum modeRGB, GLenum modeAlpha ) */
    321 static void
    322 android_glBlendEquationSeparateOES__II
    323   (JNIEnv *_env, jobject _this, jint modeRGB, jint modeAlpha) {
    324     glBlendEquationSeparateOES(
    325         (GLenum)modeRGB,
    326         (GLenum)modeAlpha
    327     );
    328 }
    329 
    330 /* void glBlendFuncSeparateOES ( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) */
    331 static void
    332 android_glBlendFuncSeparateOES__IIII
    333   (JNIEnv *_env, jobject _this, jint srcRGB, jint dstRGB, jint srcAlpha, jint dstAlpha) {
    334     glBlendFuncSeparateOES(
    335         (GLenum)srcRGB,
    336         (GLenum)dstRGB,
    337         (GLenum)srcAlpha,
    338         (GLenum)dstAlpha
    339     );
    340 }
    341 
    342 /* void glBlendEquationOES ( GLenum mode ) */
    343 static void
    344 android_glBlendEquationOES__I
    345   (JNIEnv *_env, jobject _this, jint mode) {
    346     glBlendEquationOES(
    347         (GLenum)mode
    348     );
    349 }
    350 
    351 /* void glDrawTexsOES ( GLshort x, GLshort y, GLshort z, GLshort width, GLshort height ) */
    352 static void
    353 android_glDrawTexsOES__SSSSS
    354   (JNIEnv *_env, jobject _this, jshort x, jshort y, jshort z, jshort width, jshort height) {
    355     glDrawTexsOES(
    356         (GLshort)x,
    357         (GLshort)y,
    358         (GLshort)z,
    359         (GLshort)width,
    360         (GLshort)height
    361     );
    362 }
    363 
    364 /* void glDrawTexiOES ( GLint x, GLint y, GLint z, GLint width, GLint height ) */
    365 static void
    366 android_glDrawTexiOES__IIIII
    367   (JNIEnv *_env, jobject _this, jint x, jint y, jint z, jint width, jint height) {
    368     glDrawTexiOES(
    369         (GLint)x,
    370         (GLint)y,
    371         (GLint)z,
    372         (GLint)width,
    373         (GLint)height
    374     );
    375 }
    376 
    377 /* void glDrawTexxOES ( GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height ) */
    378 static void
    379 android_glDrawTexxOES__IIIII
    380   (JNIEnv *_env, jobject _this, jint x, jint y, jint z, jint width, jint height) {
    381     glDrawTexxOES(
    382         (GLfixed)x,
    383         (GLfixed)y,
    384         (GLfixed)z,
    385         (GLfixed)width,
    386         (GLfixed)height
    387     );
    388 }
    389 
    390 /* void glDrawTexsvOES ( const GLshort *coords ) */
    391 static void
    392 android_glDrawTexsvOES___3SI
    393   (JNIEnv *_env, jobject _this, jshortArray coords_ref, jint offset) {
    394     jint _exception = 0;
    395     const char * _exceptionType = NULL;
    396     const char * _exceptionMessage = NULL;
    397     GLshort *coords_base = (GLshort *) 0;
    398     jint _remaining;
    399     GLshort *coords = (GLshort *) 0;
    400 
    401     if (!coords_ref) {
    402         _exception = 1;
    403         _exceptionType = "java/lang/IllegalArgumentException";
    404         _exceptionMessage = "coords == null";
    405         goto exit;
    406     }
    407     if (offset < 0) {
    408         _exception = 1;
    409         _exceptionType = "java/lang/IllegalArgumentException";
    410         _exceptionMessage = "offset < 0";
    411         goto exit;
    412     }
    413     _remaining = _env->GetArrayLength(coords_ref) - offset;
    414     if (_remaining < 5) {
    415         _exception = 1;
    416         _exceptionType = "java/lang/IllegalArgumentException";
    417         _exceptionMessage = "length - offset < 5 < needed";
    418         goto exit;
    419     }
    420     coords_base = (GLshort *)
    421         _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0);
    422     coords = coords_base + offset;
    423 
    424     glDrawTexsvOES(
    425         (GLshort *)coords
    426     );
    427 
    428 exit:
    429     if (coords_base) {
    430         _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base,
    431             JNI_ABORT);
    432     }
    433     if (_exception) {
    434         jniThrowException(_env, _exceptionType, _exceptionMessage);
    435     }
    436 }
    437 
    438 /* void glDrawTexsvOES ( const GLshort *coords ) */
    439 static void
    440 android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2
    441   (JNIEnv *_env, jobject _this, jobject coords_buf) {
    442     jint _exception = 0;
    443     const char * _exceptionType = NULL;
    444     const char * _exceptionMessage = NULL;
    445     jarray _array = (jarray) 0;
    446     jint _bufferOffset = (jint) 0;
    447     jint _remaining;
    448     GLshort *coords = (GLshort *) 0;
    449 
    450     coords = (GLshort *)getPointer(_env, coords_buf, &_array, &_remaining, &_bufferOffset);
    451     if (_remaining < 5) {
    452         _exception = 1;
    453         _exceptionType = "java/lang/IllegalArgumentException";
    454         _exceptionMessage = "remaining() < 5 < needed";
    455         goto exit;
    456     }
    457     if (coords == NULL) {
    458         char * _coordsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
    459         coords = (GLshort *) (_coordsBase + _bufferOffset);
    460     }
    461     glDrawTexsvOES(
    462         (GLshort *)coords
    463     );
    464 
    465 exit:
    466     if (_array) {
    467         releasePointer(_env, _array, coords, JNI_FALSE);
    468     }
    469     if (_exception) {
    470         jniThrowException(_env, _exceptionType, _exceptionMessage);
    471     }
    472 }
    473 
    474 /* void glDrawTexivOES ( const GLint *coords ) */
    475 static void
    476 android_glDrawTexivOES___3II
    477   (JNIEnv *_env, jobject _this, jintArray coords_ref, jint offset) {
    478     jint _exception = 0;
    479     const char * _exceptionType = NULL;
    480     const char * _exceptionMessage = NULL;
    481     GLint *coords_base = (GLint *) 0;
    482     jint _remaining;
    483     GLint *coords = (GLint *) 0;
    484 
    485     if (!coords_ref) {
    486         _exception = 1;
    487         _exceptionType = "java/lang/IllegalArgumentException";
    488         _exceptionMessage = "coords == null";
    489         goto exit;
    490     }
    491     if (offset < 0) {
    492         _exception = 1;
    493         _exceptionType = "java/lang/IllegalArgumentException";
    494         _exceptionMessage = "offset < 0";
    495         goto exit;
    496     }
    497     _remaining = _env->GetArrayLength(coords_ref) - offset;
    498     if (_remaining < 5) {
    499         _exception = 1;
    500         _exceptionType = "java/lang/IllegalArgumentException";
    501         _exceptionMessage = "length - offset < 5 < needed";
    502         goto exit;
    503     }
    504     coords_base = (GLint *)
    505         _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0);
    506     coords = coords_base + offset;
    507 
    508     glDrawTexivOES(
    509         (GLint *)coords
    510     );
    511 
    512 exit:
    513     if (coords_base) {
    514         _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base,
    515             JNI_ABORT);
    516     }
    517     if (_exception) {
    518         jniThrowException(_env, _exceptionType, _exceptionMessage);
    519     }
    520 }
    521 
    522 /* void glDrawTexivOES ( const GLint *coords ) */
    523 static void
    524 android_glDrawTexivOES__Ljava_nio_IntBuffer_2
    525   (JNIEnv *_env, jobject _this, jobject coords_buf) {
    526     jint _exception = 0;
    527     const char * _exceptionType = NULL;
    528     const char * _exceptionMessage = NULL;
    529     jarray _array = (jarray) 0;
    530     jint _bufferOffset = (jint) 0;
    531     jint _remaining;
    532     GLint *coords = (GLint *) 0;
    533 
    534     coords = (GLint *)getPointer(_env, coords_buf, &_array, &_remaining, &_bufferOffset);
    535     if (_remaining < 5) {
    536         _exception = 1;
    537         _exceptionType = "java/lang/IllegalArgumentException";
    538         _exceptionMessage = "remaining() < 5 < needed";
    539         goto exit;
    540     }
    541     if (coords == NULL) {
    542         char * _coordsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
    543         coords = (GLint *) (_coordsBase + _bufferOffset);
    544     }
    545     glDrawTexivOES(
    546         (GLint *)coords
    547     );
    548 
    549 exit:
    550     if (_array) {
    551         releasePointer(_env, _array, coords, JNI_FALSE);
    552     }
    553     if (_exception) {
    554         jniThrowException(_env, _exceptionType, _exceptionMessage);
    555     }
    556 }
    557 
    558 /* void glDrawTexxvOES ( const GLfixed *coords ) */
    559 static void
    560 android_glDrawTexxvOES___3II
    561   (JNIEnv *_env, jobject _this, jintArray coords_ref, jint offset) {
    562     jint _exception = 0;
    563     const char * _exceptionType = NULL;
    564     const char * _exceptionMessage = NULL;
    565     GLfixed *coords_base = (GLfixed *) 0;
    566     jint _remaining;
    567     GLfixed *coords = (GLfixed *) 0;
    568 
    569     if (!coords_ref) {
    570         _exception = 1;
    571         _exceptionType = "java/lang/IllegalArgumentException";
    572         _exceptionMessage = "coords == null";
    573         goto exit;
    574     }
    575     if (offset < 0) {
    576         _exception = 1;
    577         _exceptionType = "java/lang/IllegalArgumentException";
    578         _exceptionMessage = "offset < 0";
    579         goto exit;
    580     }
    581     _remaining = _env->GetArrayLength(coords_ref) - offset;
    582     if (_remaining < 5) {
    583         _exception = 1;
    584         _exceptionType = "java/lang/IllegalArgumentException";
    585         _exceptionMessage = "length - offset < 5 < needed";
    586         goto exit;
    587     }
    588     coords_base = (GLfixed *)
    589         _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0);
    590     coords = coords_base + offset;
    591 
    592     glDrawTexxvOES(
    593         (GLfixed *)coords
    594     );
    595 
    596 exit:
    597     if (coords_base) {
    598         _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base,
    599             JNI_ABORT);
    600     }
    601     if (_exception) {
    602         jniThrowException(_env, _exceptionType, _exceptionMessage);
    603     }
    604 }
    605 
    606 /* void glDrawTexxvOES ( const GLfixed *coords ) */
    607 static void
    608 android_glDrawTexxvOES__Ljava_nio_IntBuffer_2
    609   (JNIEnv *_env, jobject _this, jobject coords_buf) {
    610     jint _exception = 0;
    611     const char * _exceptionType = NULL;
    612     const char * _exceptionMessage = NULL;
    613     jarray _array = (jarray) 0;
    614     jint _bufferOffset = (jint) 0;
    615     jint _remaining;
    616     GLfixed *coords = (GLfixed *) 0;
    617 
    618     coords = (GLfixed *)getPointer(_env, coords_buf, &_array, &_remaining, &_bufferOffset);
    619     if (_remaining < 5) {
    620         _exception = 1;
    621         _exceptionType = "java/lang/IllegalArgumentException";
    622         _exceptionMessage = "remaining() < 5 < needed";
    623         goto exit;
    624     }
    625     if (coords == NULL) {
    626         char * _coordsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
    627         coords = (GLfixed *) (_coordsBase + _bufferOffset);
    628     }
    629     glDrawTexxvOES(
    630         (GLfixed *)coords
    631     );
    632 
    633 exit:
    634     if (_array) {
    635         releasePointer(_env, _array, coords, JNI_FALSE);
    636     }
    637     if (_exception) {
    638         jniThrowException(_env, _exceptionType, _exceptionMessage);
    639     }
    640 }
    641 
    642 /* void glDrawTexfOES ( GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height ) */
    643 static void
    644 android_glDrawTexfOES__FFFFF
    645   (JNIEnv *_env, jobject _this, jfloat x, jfloat y, jfloat z, jfloat width, jfloat height) {
    646     glDrawTexfOES(
    647         (GLfloat)x,
    648         (GLfloat)y,
    649         (GLfloat)z,
    650         (GLfloat)width,
    651         (GLfloat)height
    652     );
    653 }
    654 
    655 /* void glDrawTexfvOES ( const GLfloat *coords ) */
    656 static void
    657 android_glDrawTexfvOES___3FI
    658   (JNIEnv *_env, jobject _this, jfloatArray coords_ref, jint offset) {
    659     jint _exception = 0;
    660     const char * _exceptionType = NULL;
    661     const char * _exceptionMessage = NULL;
    662     GLfloat *coords_base = (GLfloat *) 0;
    663     jint _remaining;
    664     GLfloat *coords = (GLfloat *) 0;
    665 
    666     if (!coords_ref) {
    667         _exception = 1;
    668         _exceptionType = "java/lang/IllegalArgumentException";
    669         _exceptionMessage = "coords == null";
    670         goto exit;
    671     }
    672     if (offset < 0) {
    673         _exception = 1;
    674         _exceptionType = "java/lang/IllegalArgumentException";
    675         _exceptionMessage = "offset < 0";
    676         goto exit;
    677     }
    678     _remaining = _env->GetArrayLength(coords_ref) - offset;
    679     if (_remaining < 5) {
    680         _exception = 1;
    681         _exceptionType = "java/lang/IllegalArgumentException";
    682         _exceptionMessage = "length - offset < 5 < needed";
    683         goto exit;
    684     }
    685     coords_base = (GLfloat *)
    686         _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0);
    687     coords = coords_base + offset;
    688 
    689     glDrawTexfvOES(
    690         (GLfloat *)coords
    691     );
    692 
    693 exit:
    694     if (coords_base) {
    695         _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base,
    696             JNI_ABORT);
    697     }
    698     if (_exception) {
    699         jniThrowException(_env, _exceptionType, _exceptionMessage);
    700     }
    701 }
    702 
    703 /* void glDrawTexfvOES ( const GLfloat *coords ) */
    704 static void
    705 android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2
    706   (JNIEnv *_env, jobject _this, jobject coords_buf) {
    707     jint _exception = 0;
    708     const char * _exceptionType = NULL;
    709     const char * _exceptionMessage = NULL;
    710     jarray _array = (jarray) 0;
    711     jint _bufferOffset = (jint) 0;
    712     jint _remaining;
    713     GLfloat *coords = (GLfloat *) 0;
    714 
    715     coords = (GLfloat *)getPointer(_env, coords_buf, &_array, &_remaining, &_bufferOffset);
    716     if (_remaining < 5) {
    717         _exception = 1;
    718         _exceptionType = "java/lang/IllegalArgumentException";
    719         _exceptionMessage = "remaining() < 5 < needed";
    720         goto exit;
    721     }
    722     if (coords == NULL) {
    723         char * _coordsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
    724         coords = (GLfloat *) (_coordsBase + _bufferOffset);
    725     }
    726     glDrawTexfvOES(
    727         (GLfloat *)coords
    728     );
    729 
    730 exit:
    731     if (_array) {
    732         releasePointer(_env, _array, coords, JNI_FALSE);
    733     }
    734     if (_exception) {
    735         jniThrowException(_env, _exceptionType, _exceptionMessage);
    736     }
    737 }
    738 
    739 /* void glEGLImageTargetTexture2DOES ( GLenum target, GLeglImageOES image ) */
    740 static void
    741 android_glEGLImageTargetTexture2DOES__ILjava_nio_Buffer_2
    742   (JNIEnv *_env, jobject _this, jint target, jobject image_buf) {
    743     jarray _array = (jarray) 0;
    744     jint _bufferOffset = (jint) 0;
    745     jint _remaining;
    746     GLeglImageOES image = (GLeglImageOES) 0;
    747 
    748     image = (GLeglImageOES)getPointer(_env, image_buf, &_array, &_remaining, &_bufferOffset);
    749     if (image == NULL) {
    750         char * _imageBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
    751         image = (GLeglImageOES) (_imageBase + _bufferOffset);
    752     }
    753     glEGLImageTargetTexture2DOES(
    754         (GLenum)target,
    755         (GLeglImageOES)image
    756     );
    757     if (_array) {
    758         releasePointer(_env, _array, image, JNI_TRUE);
    759     }
    760 }
    761 
    762 /* void glEGLImageTargetRenderbufferStorageOES ( GLenum target, GLeglImageOES image ) */
    763 static void
    764 android_glEGLImageTargetRenderbufferStorageOES__ILjava_nio_Buffer_2
    765   (JNIEnv *_env, jobject _this, jint target, jobject image_buf) {
    766     jarray _array = (jarray) 0;
    767     jint _bufferOffset = (jint) 0;
    768     jint _remaining;
    769     GLeglImageOES image = (GLeglImageOES) 0;
    770 
    771     image = (GLeglImageOES)getPointer(_env, image_buf, &_array, &_remaining, &_bufferOffset);
    772     if (image == NULL) {
    773         char * _imageBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
    774         image = (GLeglImageOES) (_imageBase + _bufferOffset);
    775     }
    776     glEGLImageTargetRenderbufferStorageOES(
    777         (GLenum)target,
    778         (GLeglImageOES)image
    779     );
    780     if (_array) {
    781         releasePointer(_env, _array, image, JNI_TRUE);
    782     }
    783 }
    784 
    785 /* void glAlphaFuncxOES ( GLenum func, GLclampx ref ) */
    786 static void
    787 android_glAlphaFuncxOES__II
    788   (JNIEnv *_env, jobject _this, jint func, jint ref) {
    789     glAlphaFuncxOES(
    790         (GLenum)func,
    791         (GLclampx)ref
    792     );
    793 }
    794 
    795 /* void glClearColorxOES ( GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha ) */
    796 static void
    797 android_glClearColorxOES__IIII
    798   (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) {
    799     glClearColorxOES(
    800         (GLclampx)red,
    801         (GLclampx)green,
    802         (GLclampx)blue,
    803         (GLclampx)alpha
    804     );
    805 }
    806 
    807 /* void glClearDepthxOES ( GLclampx depth ) */
    808 static void
    809 android_glClearDepthxOES__I
    810   (JNIEnv *_env, jobject _this, jint depth) {
    811     glClearDepthxOES(
    812         (GLclampx)depth
    813     );
    814 }
    815 
    816 /* void glClipPlanexOES ( GLenum plane, const GLfixed *equation ) */
    817 static void
    818 android_glClipPlanexOES__I_3II
    819   (JNIEnv *_env, jobject _this, jint plane, jintArray equation_ref, jint offset) {
    820     jint _exception = 0;
    821     const char * _exceptionType = NULL;
    822     const char * _exceptionMessage = NULL;
    823     GLfixed *equation_base = (GLfixed *) 0;
    824     jint _remaining;
    825     GLfixed *equation = (GLfixed *) 0;
    826 
    827     if (!equation_ref) {
    828         _exception = 1;
    829         _exceptionType = "java/lang/IllegalArgumentException";
    830         _exceptionMessage = "equation == null";
    831         goto exit;
    832     }
    833     if (offset < 0) {
    834         _exception = 1;
    835         _exceptionType = "java/lang/IllegalArgumentException";
    836         _exceptionMessage = "offset < 0";
    837         goto exit;
    838     }
    839     _remaining = _env->GetArrayLength(equation_ref) - offset;
    840     equation_base = (GLfixed *)
    841         _env->GetPrimitiveArrayCritical(equation_ref, (jboolean *)0);
    842     equation = equation_base + offset;
    843 
    844     glClipPlanexOES(
    845         (GLenum)plane,
    846         (GLfixed *)equation
    847     );
    848 
    849 exit:
    850     if (equation_base) {
    851         _env->ReleasePrimitiveArrayCritical(equation_ref, equation_base,
    852             JNI_ABORT);
    853     }
    854     if (_exception) {
    855         jniThrowException(_env, _exceptionType, _exceptionMessage);
    856     }
    857 }
    858 
    859 /* void glClipPlanexOES ( GLenum plane, const GLfixed *equation ) */
    860 static void
    861 android_glClipPlanexOES__ILjava_nio_IntBuffer_2
    862   (JNIEnv *_env, jobject _this, jint plane, jobject equation_buf) {
    863     jarray _array = (jarray) 0;
    864     jint _bufferOffset = (jint) 0;
    865     jint _remaining;
    866     GLfixed *equation = (GLfixed *) 0;
    867 
    868     equation = (GLfixed *)getPointer(_env, equation_buf, &_array, &_remaining, &_bufferOffset);
    869     if (equation == NULL) {
    870         char * _equationBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
    871         equation = (GLfixed *) (_equationBase + _bufferOffset);
    872     }
    873     glClipPlanexOES(
    874         (GLenum)plane,
    875         (GLfixed *)equation
    876     );
    877     if (_array) {
    878         releasePointer(_env, _array, equation, JNI_FALSE);
    879     }
    880 }
    881 
    882 /* void glColor4xOES ( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) */
    883 static void
    884 android_glColor4xOES__IIII
    885   (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) {
    886     glColor4xOES(
    887         (GLfixed)red,
    888         (GLfixed)green,
    889         (GLfixed)blue,
    890         (GLfixed)alpha
    891     );
    892 }
    893 
    894 /* void glDepthRangexOES ( GLclampx zNear, GLclampx zFar ) */
    895 static void
    896 android_glDepthRangexOES__II
    897   (JNIEnv *_env, jobject _this, jint zNear, jint zFar) {
    898     glDepthRangexOES(
    899         (GLclampx)zNear,
    900         (GLclampx)zFar
    901     );
    902 }
    903 
    904 /* void glFogxOES ( GLenum pname, GLfixed param ) */
    905 static void
    906 android_glFogxOES__II
    907   (JNIEnv *_env, jobject _this, jint pname, jint param) {
    908     glFogxOES(
    909         (GLenum)pname,
    910         (GLfixed)param
    911     );
    912 }
    913 
    914 /* void glFogxvOES ( GLenum pname, const GLfixed *params ) */
    915 static void
    916 android_glFogxvOES__I_3II
    917   (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
    918     jint _exception = 0;
    919     const char * _exceptionType = NULL;
    920     const char * _exceptionMessage = NULL;
    921     GLfixed *params_base = (GLfixed *) 0;
    922     jint _remaining;
    923     GLfixed *params = (GLfixed *) 0;
    924 
    925     if (!params_ref) {
    926         _exception = 1;
    927         _exceptionType = "java/lang/IllegalArgumentException";
    928         _exceptionMessage = "params == null";
    929         goto exit;
    930     }
    931     if (offset < 0) {
    932         _exception = 1;
    933         _exceptionType = "java/lang/IllegalArgumentException";
    934         _exceptionMessage = "offset < 0";
    935         goto exit;
    936     }
    937     _remaining = _env->GetArrayLength(params_ref) - offset;
    938     params_base = (GLfixed *)
    939         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
    940     params = params_base + offset;
    941 
    942     glFogxvOES(
    943         (GLenum)pname,
    944         (GLfixed *)params
    945     );
    946 
    947 exit:
    948     if (params_base) {
    949         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
    950             JNI_ABORT);
    951     }
    952     if (_exception) {
    953         jniThrowException(_env, _exceptionType, _exceptionMessage);
    954     }
    955 }
    956 
    957 /* void glFogxvOES ( GLenum pname, const GLfixed *params ) */
    958 static void
    959 android_glFogxvOES__ILjava_nio_IntBuffer_2
    960   (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
    961     jarray _array = (jarray) 0;
    962     jint _bufferOffset = (jint) 0;
    963     jint _remaining;
    964     GLfixed *params = (GLfixed *) 0;
    965 
    966     params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
    967     if (params == NULL) {
    968         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
    969         params = (GLfixed *) (_paramsBase + _bufferOffset);
    970     }
    971     glFogxvOES(
    972         (GLenum)pname,
    973         (GLfixed *)params
    974     );
    975     if (_array) {
    976         releasePointer(_env, _array, params, JNI_FALSE);
    977     }
    978 }
    979 
    980 /* void glFrustumxOES ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */
    981 static void
    982 android_glFrustumxOES__IIIIII
    983   (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) {
    984     glFrustumxOES(
    985         (GLfixed)left,
    986         (GLfixed)right,
    987         (GLfixed)bottom,
    988         (GLfixed)top,
    989         (GLfixed)zNear,
    990         (GLfixed)zFar
    991     );
    992 }
    993 
    994 /* void glGetClipPlanexOES ( GLenum pname, GLfixed *eqn ) */
    995 static void
    996 android_glGetClipPlanexOES__I_3II
    997   (JNIEnv *_env, jobject _this, jint pname, jintArray eqn_ref, jint offset) {
    998     jint _exception = 0;
    999     const char * _exceptionType = NULL;
   1000     const char * _exceptionMessage = NULL;
   1001     GLfixed *eqn_base = (GLfixed *) 0;
   1002     jint _remaining;
   1003     GLfixed *eqn = (GLfixed *) 0;
   1004 
   1005     if (!eqn_ref) {
   1006         _exception = 1;
   1007         _exceptionType = "java/lang/IllegalArgumentException";
   1008         _exceptionMessage = "eqn == null";
   1009         goto exit;
   1010     }
   1011     if (offset < 0) {
   1012         _exception = 1;
   1013         _exceptionType = "java/lang/IllegalArgumentException";
   1014         _exceptionMessage = "offset < 0";
   1015         goto exit;
   1016     }
   1017     _remaining = _env->GetArrayLength(eqn_ref) - offset;
   1018     if (_remaining < 4) {
   1019         _exception = 1;
   1020         _exceptionType = "java/lang/IllegalArgumentException";
   1021         _exceptionMessage = "length - offset < 4 < needed";
   1022         goto exit;
   1023     }
   1024     eqn_base = (GLfixed *)
   1025         _env->GetPrimitiveArrayCritical(eqn_ref, (jboolean *)0);
   1026     eqn = eqn_base + offset;
   1027 
   1028     glGetClipPlanexOES(
   1029         (GLenum)pname,
   1030         (GLfixed *)eqn
   1031     );
   1032 
   1033 exit:
   1034     if (eqn_base) {
   1035         _env->ReleasePrimitiveArrayCritical(eqn_ref, eqn_base,
   1036             _exception ? JNI_ABORT: 0);
   1037     }
   1038     if (_exception) {
   1039         jniThrowException(_env, _exceptionType, _exceptionMessage);
   1040     }
   1041 }
   1042 
   1043 /* void glGetClipPlanexOES ( GLenum pname, GLfixed *eqn ) */
   1044 static void
   1045 android_glGetClipPlanexOES__ILjava_nio_IntBuffer_2
   1046   (JNIEnv *_env, jobject _this, jint pname, jobject eqn_buf) {
   1047     jint _exception = 0;
   1048     const char * _exceptionType = NULL;
   1049     const char * _exceptionMessage = NULL;
   1050     jarray _array = (jarray) 0;
   1051     jint _bufferOffset = (jint) 0;
   1052     jint _remaining;
   1053     GLfixed *eqn = (GLfixed *) 0;
   1054 
   1055     eqn = (GLfixed *)getPointer(_env, eqn_buf, &_array, &_remaining, &_bufferOffset);
   1056     if (_remaining < 4) {
   1057         _exception = 1;
   1058         _exceptionType = "java/lang/IllegalArgumentException";
   1059         _exceptionMessage = "remaining() < 4 < needed";
   1060         goto exit;
   1061     }
   1062     if (eqn == NULL) {
   1063         char * _eqnBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   1064         eqn = (GLfixed *) (_eqnBase + _bufferOffset);
   1065     }
   1066     glGetClipPlanexOES(
   1067         (GLenum)pname,
   1068         (GLfixed *)eqn
   1069     );
   1070 
   1071 exit:
   1072     if (_array) {
   1073         releasePointer(_env, _array, eqn, _exception ? JNI_FALSE : JNI_TRUE);
   1074     }
   1075     if (_exception) {
   1076         jniThrowException(_env, _exceptionType, _exceptionMessage);
   1077     }
   1078 }
   1079 
   1080 /* void glGetFixedvOES ( GLenum pname, GLfixed *params ) */
   1081 static void
   1082 android_glGetFixedvOES__I_3II
   1083   (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
   1084     jint _exception = 0;
   1085     const char * _exceptionType = NULL;
   1086     const char * _exceptionMessage = NULL;
   1087     GLfixed *params_base = (GLfixed *) 0;
   1088     jint _remaining;
   1089     GLfixed *params = (GLfixed *) 0;
   1090 
   1091     if (!params_ref) {
   1092         _exception = 1;
   1093         _exceptionType = "java/lang/IllegalArgumentException";
   1094         _exceptionMessage = "params == null";
   1095         goto exit;
   1096     }
   1097     if (offset < 0) {
   1098         _exception = 1;
   1099         _exceptionType = "java/lang/IllegalArgumentException";
   1100         _exceptionMessage = "offset < 0";
   1101         goto exit;
   1102     }
   1103     _remaining = _env->GetArrayLength(params_ref) - offset;
   1104     params_base = (GLfixed *)
   1105         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   1106     params = params_base + offset;
   1107 
   1108     glGetFixedvOES(
   1109         (GLenum)pname,
   1110         (GLfixed *)params
   1111     );
   1112 
   1113 exit:
   1114     if (params_base) {
   1115         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   1116             _exception ? JNI_ABORT: 0);
   1117     }
   1118     if (_exception) {
   1119         jniThrowException(_env, _exceptionType, _exceptionMessage);
   1120     }
   1121 }
   1122 
   1123 /* void glGetFixedvOES ( GLenum pname, GLfixed *params ) */
   1124 static void
   1125 android_glGetFixedvOES__ILjava_nio_IntBuffer_2
   1126   (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
   1127     jarray _array = (jarray) 0;
   1128     jint _bufferOffset = (jint) 0;
   1129     jint _remaining;
   1130     GLfixed *params = (GLfixed *) 0;
   1131 
   1132     params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   1133     if (params == NULL) {
   1134         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   1135         params = (GLfixed *) (_paramsBase + _bufferOffset);
   1136     }
   1137     glGetFixedvOES(
   1138         (GLenum)pname,
   1139         (GLfixed *)params
   1140     );
   1141     if (_array) {
   1142         releasePointer(_env, _array, params, JNI_TRUE);
   1143     }
   1144 }
   1145 
   1146 /* void glGetLightxvOES ( GLenum light, GLenum pname, GLfixed *params ) */
   1147 static void
   1148 android_glGetLightxvOES__II_3II
   1149   (JNIEnv *_env, jobject _this, jint light, jint pname, jintArray params_ref, jint offset) {
   1150     jint _exception = 0;
   1151     const char * _exceptionType = NULL;
   1152     const char * _exceptionMessage = NULL;
   1153     GLfixed *params_base = (GLfixed *) 0;
   1154     jint _remaining;
   1155     GLfixed *params = (GLfixed *) 0;
   1156 
   1157     if (!params_ref) {
   1158         _exception = 1;
   1159         _exceptionType = "java/lang/IllegalArgumentException";
   1160         _exceptionMessage = "params == null";
   1161         goto exit;
   1162     }
   1163     if (offset < 0) {
   1164         _exception = 1;
   1165         _exceptionType = "java/lang/IllegalArgumentException";
   1166         _exceptionMessage = "offset < 0";
   1167         goto exit;
   1168     }
   1169     _remaining = _env->GetArrayLength(params_ref) - offset;
   1170     params_base = (GLfixed *)
   1171         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   1172     params = params_base + offset;
   1173 
   1174     glGetLightxvOES(
   1175         (GLenum)light,
   1176         (GLenum)pname,
   1177         (GLfixed *)params
   1178     );
   1179 
   1180 exit:
   1181     if (params_base) {
   1182         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   1183             _exception ? JNI_ABORT: 0);
   1184     }
   1185     if (_exception) {
   1186         jniThrowException(_env, _exceptionType, _exceptionMessage);
   1187     }
   1188 }
   1189 
   1190 /* void glGetLightxvOES ( GLenum light, GLenum pname, GLfixed *params ) */
   1191 static void
   1192 android_glGetLightxvOES__IILjava_nio_IntBuffer_2
   1193   (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) {
   1194     jarray _array = (jarray) 0;
   1195     jint _bufferOffset = (jint) 0;
   1196     jint _remaining;
   1197     GLfixed *params = (GLfixed *) 0;
   1198 
   1199     params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   1200     if (params == NULL) {
   1201         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   1202         params = (GLfixed *) (_paramsBase + _bufferOffset);
   1203     }
   1204     glGetLightxvOES(
   1205         (GLenum)light,
   1206         (GLenum)pname,
   1207         (GLfixed *)params
   1208     );
   1209     if (_array) {
   1210         releasePointer(_env, _array, params, JNI_TRUE);
   1211     }
   1212 }
   1213 
   1214 /* void glGetMaterialxvOES ( GLenum face, GLenum pname, GLfixed *params ) */
   1215 static void
   1216 android_glGetMaterialxvOES__II_3II
   1217   (JNIEnv *_env, jobject _this, jint face, jint pname, jintArray params_ref, jint offset) {
   1218     jint _exception = 0;
   1219     const char * _exceptionType = NULL;
   1220     const char * _exceptionMessage = NULL;
   1221     GLfixed *params_base = (GLfixed *) 0;
   1222     jint _remaining;
   1223     GLfixed *params = (GLfixed *) 0;
   1224 
   1225     if (!params_ref) {
   1226         _exception = 1;
   1227         _exceptionType = "java/lang/IllegalArgumentException";
   1228         _exceptionMessage = "params == null";
   1229         goto exit;
   1230     }
   1231     if (offset < 0) {
   1232         _exception = 1;
   1233         _exceptionType = "java/lang/IllegalArgumentException";
   1234         _exceptionMessage = "offset < 0";
   1235         goto exit;
   1236     }
   1237     _remaining = _env->GetArrayLength(params_ref) - offset;
   1238     params_base = (GLfixed *)
   1239         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   1240     params = params_base + offset;
   1241 
   1242     glGetMaterialxvOES(
   1243         (GLenum)face,
   1244         (GLenum)pname,
   1245         (GLfixed *)params
   1246     );
   1247 
   1248 exit:
   1249     if (params_base) {
   1250         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   1251             _exception ? JNI_ABORT: 0);
   1252     }
   1253     if (_exception) {
   1254         jniThrowException(_env, _exceptionType, _exceptionMessage);
   1255     }
   1256 }
   1257 
   1258 /* void glGetMaterialxvOES ( GLenum face, GLenum pname, GLfixed *params ) */
   1259 static void
   1260 android_glGetMaterialxvOES__IILjava_nio_IntBuffer_2
   1261   (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) {
   1262     jarray _array = (jarray) 0;
   1263     jint _bufferOffset = (jint) 0;
   1264     jint _remaining;
   1265     GLfixed *params = (GLfixed *) 0;
   1266 
   1267     params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   1268     if (params == NULL) {
   1269         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   1270         params = (GLfixed *) (_paramsBase + _bufferOffset);
   1271     }
   1272     glGetMaterialxvOES(
   1273         (GLenum)face,
   1274         (GLenum)pname,
   1275         (GLfixed *)params
   1276     );
   1277     if (_array) {
   1278         releasePointer(_env, _array, params, JNI_TRUE);
   1279     }
   1280 }
   1281 
   1282 /* void glGetTexEnvxvOES ( GLenum env, GLenum pname, GLfixed *params ) */
   1283 static void
   1284 android_glGetTexEnvxvOES__II_3II
   1285   (JNIEnv *_env, jobject _this, jint env, jint pname, jintArray params_ref, jint offset) {
   1286     jint _exception = 0;
   1287     const char * _exceptionType = NULL;
   1288     const char * _exceptionMessage = NULL;
   1289     GLfixed *params_base = (GLfixed *) 0;
   1290     jint _remaining;
   1291     GLfixed *params = (GLfixed *) 0;
   1292 
   1293     if (!params_ref) {
   1294         _exception = 1;
   1295         _exceptionType = "java/lang/IllegalArgumentException";
   1296         _exceptionMessage = "params == null";
   1297         goto exit;
   1298     }
   1299     if (offset < 0) {
   1300         _exception = 1;
   1301         _exceptionType = "java/lang/IllegalArgumentException";
   1302         _exceptionMessage = "offset < 0";
   1303         goto exit;
   1304     }
   1305     _remaining = _env->GetArrayLength(params_ref) - offset;
   1306     params_base = (GLfixed *)
   1307         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   1308     params = params_base + offset;
   1309 
   1310     glGetTexEnvxvOES(
   1311         (GLenum)env,
   1312         (GLenum)pname,
   1313         (GLfixed *)params
   1314     );
   1315 
   1316 exit:
   1317     if (params_base) {
   1318         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   1319             _exception ? JNI_ABORT: 0);
   1320     }
   1321     if (_exception) {
   1322         jniThrowException(_env, _exceptionType, _exceptionMessage);
   1323     }
   1324 }
   1325 
   1326 /* void glGetTexEnvxvOES ( GLenum env, GLenum pname, GLfixed *params ) */
   1327 static void
   1328 android_glGetTexEnvxvOES__IILjava_nio_IntBuffer_2
   1329   (JNIEnv *_env, jobject _this, jint env, jint pname, jobject params_buf) {
   1330     jarray _array = (jarray) 0;
   1331     jint _bufferOffset = (jint) 0;
   1332     jint _remaining;
   1333     GLfixed *params = (GLfixed *) 0;
   1334 
   1335     params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   1336     if (params == NULL) {
   1337         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   1338         params = (GLfixed *) (_paramsBase + _bufferOffset);
   1339     }
   1340     glGetTexEnvxvOES(
   1341         (GLenum)env,
   1342         (GLenum)pname,
   1343         (GLfixed *)params
   1344     );
   1345     if (_array) {
   1346         releasePointer(_env, _array, params, JNI_TRUE);
   1347     }
   1348 }
   1349 
   1350 /* void glGetTexParameterxvOES ( GLenum target, GLenum pname, GLfixed *params ) */
   1351 static void
   1352 android_glGetTexParameterxvOES__II_3II
   1353   (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
   1354     jint _exception = 0;
   1355     const char * _exceptionType = NULL;
   1356     const char * _exceptionMessage = NULL;
   1357     GLfixed *params_base = (GLfixed *) 0;
   1358     jint _remaining;
   1359     GLfixed *params = (GLfixed *) 0;
   1360 
   1361     if (!params_ref) {
   1362         _exception = 1;
   1363         _exceptionType = "java/lang/IllegalArgumentException";
   1364         _exceptionMessage = "params == null";
   1365         goto exit;
   1366     }
   1367     if (offset < 0) {
   1368         _exception = 1;
   1369         _exceptionType = "java/lang/IllegalArgumentException";
   1370         _exceptionMessage = "offset < 0";
   1371         goto exit;
   1372     }
   1373     _remaining = _env->GetArrayLength(params_ref) - offset;
   1374     params_base = (GLfixed *)
   1375         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   1376     params = params_base + offset;
   1377 
   1378     glGetTexParameterxvOES(
   1379         (GLenum)target,
   1380         (GLenum)pname,
   1381         (GLfixed *)params
   1382     );
   1383 
   1384 exit:
   1385     if (params_base) {
   1386         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   1387             _exception ? JNI_ABORT: 0);
   1388     }
   1389     if (_exception) {
   1390         jniThrowException(_env, _exceptionType, _exceptionMessage);
   1391     }
   1392 }
   1393 
   1394 /* void glGetTexParameterxvOES ( GLenum target, GLenum pname, GLfixed *params ) */
   1395 static void
   1396 android_glGetTexParameterxvOES__IILjava_nio_IntBuffer_2
   1397   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
   1398     jarray _array = (jarray) 0;
   1399     jint _bufferOffset = (jint) 0;
   1400     jint _remaining;
   1401     GLfixed *params = (GLfixed *) 0;
   1402 
   1403     params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   1404     if (params == NULL) {
   1405         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   1406         params = (GLfixed *) (_paramsBase + _bufferOffset);
   1407     }
   1408     glGetTexParameterxvOES(
   1409         (GLenum)target,
   1410         (GLenum)pname,
   1411         (GLfixed *)params
   1412     );
   1413     if (_array) {
   1414         releasePointer(_env, _array, params, JNI_TRUE);
   1415     }
   1416 }
   1417 
   1418 /* void glLightModelxOES ( GLenum pname, GLfixed param ) */
   1419 static void
   1420 android_glLightModelxOES__II
   1421   (JNIEnv *_env, jobject _this, jint pname, jint param) {
   1422     glLightModelxOES(
   1423         (GLenum)pname,
   1424         (GLfixed)param
   1425     );
   1426 }
   1427 
   1428 /* void glLightModelxvOES ( GLenum pname, const GLfixed *params ) */
   1429 static void
   1430 android_glLightModelxvOES__I_3II
   1431   (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
   1432     jint _exception = 0;
   1433     const char * _exceptionType = NULL;
   1434     const char * _exceptionMessage = NULL;
   1435     GLfixed *params_base = (GLfixed *) 0;
   1436     jint _remaining;
   1437     GLfixed *params = (GLfixed *) 0;
   1438 
   1439     if (!params_ref) {
   1440         _exception = 1;
   1441         _exceptionType = "java/lang/IllegalArgumentException";
   1442         _exceptionMessage = "params == null";
   1443         goto exit;
   1444     }
   1445     if (offset < 0) {
   1446         _exception = 1;
   1447         _exceptionType = "java/lang/IllegalArgumentException";
   1448         _exceptionMessage = "offset < 0";
   1449         goto exit;
   1450     }
   1451     _remaining = _env->GetArrayLength(params_ref) - offset;
   1452     params_base = (GLfixed *)
   1453         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   1454     params = params_base + offset;
   1455 
   1456     glLightModelxvOES(
   1457         (GLenum)pname,
   1458         (GLfixed *)params
   1459     );
   1460 
   1461 exit:
   1462     if (params_base) {
   1463         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   1464             JNI_ABORT);
   1465     }
   1466     if (_exception) {
   1467         jniThrowException(_env, _exceptionType, _exceptionMessage);
   1468     }
   1469 }
   1470 
   1471 /* void glLightModelxvOES ( GLenum pname, const GLfixed *params ) */
   1472 static void
   1473 android_glLightModelxvOES__ILjava_nio_IntBuffer_2
   1474   (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
   1475     jarray _array = (jarray) 0;
   1476     jint _bufferOffset = (jint) 0;
   1477     jint _remaining;
   1478     GLfixed *params = (GLfixed *) 0;
   1479 
   1480     params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   1481     if (params == NULL) {
   1482         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   1483         params = (GLfixed *) (_paramsBase + _bufferOffset);
   1484     }
   1485     glLightModelxvOES(
   1486         (GLenum)pname,
   1487         (GLfixed *)params
   1488     );
   1489     if (_array) {
   1490         releasePointer(_env, _array, params, JNI_FALSE);
   1491     }
   1492 }
   1493 
   1494 /* void glLightxOES ( GLenum light, GLenum pname, GLfixed param ) */
   1495 static void
   1496 android_glLightxOES__III
   1497   (JNIEnv *_env, jobject _this, jint light, jint pname, jint param) {
   1498     glLightxOES(
   1499         (GLenum)light,
   1500         (GLenum)pname,
   1501         (GLfixed)param
   1502     );
   1503 }
   1504 
   1505 /* void glLightxvOES ( GLenum light, GLenum pname, const GLfixed *params ) */
   1506 static void
   1507 android_glLightxvOES__II_3II
   1508   (JNIEnv *_env, jobject _this, jint light, jint pname, jintArray params_ref, jint offset) {
   1509     jint _exception = 0;
   1510     const char * _exceptionType = NULL;
   1511     const char * _exceptionMessage = NULL;
   1512     GLfixed *params_base = (GLfixed *) 0;
   1513     jint _remaining;
   1514     GLfixed *params = (GLfixed *) 0;
   1515 
   1516     if (!params_ref) {
   1517         _exception = 1;
   1518         _exceptionType = "java/lang/IllegalArgumentException";
   1519         _exceptionMessage = "params == null";
   1520         goto exit;
   1521     }
   1522     if (offset < 0) {
   1523         _exception = 1;
   1524         _exceptionType = "java/lang/IllegalArgumentException";
   1525         _exceptionMessage = "offset < 0";
   1526         goto exit;
   1527     }
   1528     _remaining = _env->GetArrayLength(params_ref) - offset;
   1529     params_base = (GLfixed *)
   1530         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   1531     params = params_base + offset;
   1532 
   1533     glLightxvOES(
   1534         (GLenum)light,
   1535         (GLenum)pname,
   1536         (GLfixed *)params
   1537     );
   1538 
   1539 exit:
   1540     if (params_base) {
   1541         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   1542             JNI_ABORT);
   1543     }
   1544     if (_exception) {
   1545         jniThrowException(_env, _exceptionType, _exceptionMessage);
   1546     }
   1547 }
   1548 
   1549 /* void glLightxvOES ( GLenum light, GLenum pname, const GLfixed *params ) */
   1550 static void
   1551 android_glLightxvOES__IILjava_nio_IntBuffer_2
   1552   (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) {
   1553     jarray _array = (jarray) 0;
   1554     jint _bufferOffset = (jint) 0;
   1555     jint _remaining;
   1556     GLfixed *params = (GLfixed *) 0;
   1557 
   1558     params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   1559     if (params == NULL) {
   1560         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   1561         params = (GLfixed *) (_paramsBase + _bufferOffset);
   1562     }
   1563     glLightxvOES(
   1564         (GLenum)light,
   1565         (GLenum)pname,
   1566         (GLfixed *)params
   1567     );
   1568     if (_array) {
   1569         releasePointer(_env, _array, params, JNI_FALSE);
   1570     }
   1571 }
   1572 
   1573 /* void glLineWidthxOES ( GLfixed width ) */
   1574 static void
   1575 android_glLineWidthxOES__I
   1576   (JNIEnv *_env, jobject _this, jint width) {
   1577     glLineWidthxOES(
   1578         (GLfixed)width
   1579     );
   1580 }
   1581 
   1582 /* void glLoadMatrixxOES ( const GLfixed *m ) */
   1583 static void
   1584 android_glLoadMatrixxOES___3II
   1585   (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) {
   1586     jint _exception = 0;
   1587     const char * _exceptionType = NULL;
   1588     const char * _exceptionMessage = NULL;
   1589     GLfixed *m_base = (GLfixed *) 0;
   1590     jint _remaining;
   1591     GLfixed *m = (GLfixed *) 0;
   1592 
   1593     if (!m_ref) {
   1594         _exception = 1;
   1595         _exceptionType = "java/lang/IllegalArgumentException";
   1596         _exceptionMessage = "m == null";
   1597         goto exit;
   1598     }
   1599     if (offset < 0) {
   1600         _exception = 1;
   1601         _exceptionType = "java/lang/IllegalArgumentException";
   1602         _exceptionMessage = "offset < 0";
   1603         goto exit;
   1604     }
   1605     _remaining = _env->GetArrayLength(m_ref) - offset;
   1606     m_base = (GLfixed *)
   1607         _env->GetPrimitiveArrayCritical(m_ref, (jboolean *)0);
   1608     m = m_base + offset;
   1609 
   1610     glLoadMatrixxOES(
   1611         (GLfixed *)m
   1612     );
   1613 
   1614 exit:
   1615     if (m_base) {
   1616         _env->ReleasePrimitiveArrayCritical(m_ref, m_base,
   1617             JNI_ABORT);
   1618     }
   1619     if (_exception) {
   1620         jniThrowException(_env, _exceptionType, _exceptionMessage);
   1621     }
   1622 }
   1623 
   1624 /* void glLoadMatrixxOES ( const GLfixed *m ) */
   1625 static void
   1626 android_glLoadMatrixxOES__Ljava_nio_IntBuffer_2
   1627   (JNIEnv *_env, jobject _this, jobject m_buf) {
   1628     jarray _array = (jarray) 0;
   1629     jint _bufferOffset = (jint) 0;
   1630     jint _remaining;
   1631     GLfixed *m = (GLfixed *) 0;
   1632 
   1633     m = (GLfixed *)getPointer(_env, m_buf, &_array, &_remaining, &_bufferOffset);
   1634     if (m == NULL) {
   1635         char * _mBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   1636         m = (GLfixed *) (_mBase + _bufferOffset);
   1637     }
   1638     glLoadMatrixxOES(
   1639         (GLfixed *)m
   1640     );
   1641     if (_array) {
   1642         releasePointer(_env, _array, m, JNI_FALSE);
   1643     }
   1644 }
   1645 
   1646 /* void glMaterialxOES ( GLenum face, GLenum pname, GLfixed param ) */
   1647 static void
   1648 android_glMaterialxOES__III
   1649   (JNIEnv *_env, jobject _this, jint face, jint pname, jint param) {
   1650     glMaterialxOES(
   1651         (GLenum)face,
   1652         (GLenum)pname,
   1653         (GLfixed)param
   1654     );
   1655 }
   1656 
   1657 /* void glMaterialxvOES ( GLenum face, GLenum pname, const GLfixed *params ) */
   1658 static void
   1659 android_glMaterialxvOES__II_3II
   1660   (JNIEnv *_env, jobject _this, jint face, jint pname, jintArray params_ref, jint offset) {
   1661     jint _exception = 0;
   1662     const char * _exceptionType = NULL;
   1663     const char * _exceptionMessage = NULL;
   1664     GLfixed *params_base = (GLfixed *) 0;
   1665     jint _remaining;
   1666     GLfixed *params = (GLfixed *) 0;
   1667 
   1668     if (!params_ref) {
   1669         _exception = 1;
   1670         _exceptionType = "java/lang/IllegalArgumentException";
   1671         _exceptionMessage = "params == null";
   1672         goto exit;
   1673     }
   1674     if (offset < 0) {
   1675         _exception = 1;
   1676         _exceptionType = "java/lang/IllegalArgumentException";
   1677         _exceptionMessage = "offset < 0";
   1678         goto exit;
   1679     }
   1680     _remaining = _env->GetArrayLength(params_ref) - offset;
   1681     params_base = (GLfixed *)
   1682         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   1683     params = params_base + offset;
   1684 
   1685     glMaterialxvOES(
   1686         (GLenum)face,
   1687         (GLenum)pname,
   1688         (GLfixed *)params
   1689     );
   1690 
   1691 exit:
   1692     if (params_base) {
   1693         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   1694             JNI_ABORT);
   1695     }
   1696     if (_exception) {
   1697         jniThrowException(_env, _exceptionType, _exceptionMessage);
   1698     }
   1699 }
   1700 
   1701 /* void glMaterialxvOES ( GLenum face, GLenum pname, const GLfixed *params ) */
   1702 static void
   1703 android_glMaterialxvOES__IILjava_nio_IntBuffer_2
   1704   (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) {
   1705     jarray _array = (jarray) 0;
   1706     jint _bufferOffset = (jint) 0;
   1707     jint _remaining;
   1708     GLfixed *params = (GLfixed *) 0;
   1709 
   1710     params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   1711     if (params == NULL) {
   1712         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   1713         params = (GLfixed *) (_paramsBase + _bufferOffset);
   1714     }
   1715     glMaterialxvOES(
   1716         (GLenum)face,
   1717         (GLenum)pname,
   1718         (GLfixed *)params
   1719     );
   1720     if (_array) {
   1721         releasePointer(_env, _array, params, JNI_FALSE);
   1722     }
   1723 }
   1724 
   1725 /* void glMultMatrixxOES ( const GLfixed *m ) */
   1726 static void
   1727 android_glMultMatrixxOES___3II
   1728   (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) {
   1729     jint _exception = 0;
   1730     const char * _exceptionType = NULL;
   1731     const char * _exceptionMessage = NULL;
   1732     GLfixed *m_base = (GLfixed *) 0;
   1733     jint _remaining;
   1734     GLfixed *m = (GLfixed *) 0;
   1735 
   1736     if (!m_ref) {
   1737         _exception = 1;
   1738         _exceptionType = "java/lang/IllegalArgumentException";
   1739         _exceptionMessage = "m == null";
   1740         goto exit;
   1741     }
   1742     if (offset < 0) {
   1743         _exception = 1;
   1744         _exceptionType = "java/lang/IllegalArgumentException";
   1745         _exceptionMessage = "offset < 0";
   1746         goto exit;
   1747     }
   1748     _remaining = _env->GetArrayLength(m_ref) - offset;
   1749     m_base = (GLfixed *)
   1750         _env->GetPrimitiveArrayCritical(m_ref, (jboolean *)0);
   1751     m = m_base + offset;
   1752 
   1753     glMultMatrixxOES(
   1754         (GLfixed *)m
   1755     );
   1756 
   1757 exit:
   1758     if (m_base) {
   1759         _env->ReleasePrimitiveArrayCritical(m_ref, m_base,
   1760             JNI_ABORT);
   1761     }
   1762     if (_exception) {
   1763         jniThrowException(_env, _exceptionType, _exceptionMessage);
   1764     }
   1765 }
   1766 
   1767 /* void glMultMatrixxOES ( const GLfixed *m ) */
   1768 static void
   1769 android_glMultMatrixxOES__Ljava_nio_IntBuffer_2
   1770   (JNIEnv *_env, jobject _this, jobject m_buf) {
   1771     jarray _array = (jarray) 0;
   1772     jint _bufferOffset = (jint) 0;
   1773     jint _remaining;
   1774     GLfixed *m = (GLfixed *) 0;
   1775 
   1776     m = (GLfixed *)getPointer(_env, m_buf, &_array, &_remaining, &_bufferOffset);
   1777     if (m == NULL) {
   1778         char * _mBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   1779         m = (GLfixed *) (_mBase + _bufferOffset);
   1780     }
   1781     glMultMatrixxOES(
   1782         (GLfixed *)m
   1783     );
   1784     if (_array) {
   1785         releasePointer(_env, _array, m, JNI_FALSE);
   1786     }
   1787 }
   1788 
   1789 /* void glMultiTexCoord4xOES ( GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q ) */
   1790 static void
   1791 android_glMultiTexCoord4xOES__IIIII
   1792   (JNIEnv *_env, jobject _this, jint target, jint s, jint t, jint r, jint q) {
   1793     glMultiTexCoord4xOES(
   1794         (GLenum)target,
   1795         (GLfixed)s,
   1796         (GLfixed)t,
   1797         (GLfixed)r,
   1798         (GLfixed)q
   1799     );
   1800 }
   1801 
   1802 /* void glNormal3xOES ( GLfixed nx, GLfixed ny, GLfixed nz ) */
   1803 static void
   1804 android_glNormal3xOES__III
   1805   (JNIEnv *_env, jobject _this, jint nx, jint ny, jint nz) {
   1806     glNormal3xOES(
   1807         (GLfixed)nx,
   1808         (GLfixed)ny,
   1809         (GLfixed)nz
   1810     );
   1811 }
   1812 
   1813 /* void glOrthoxOES ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */
   1814 static void
   1815 android_glOrthoxOES__IIIIII
   1816   (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) {
   1817     glOrthoxOES(
   1818         (GLfixed)left,
   1819         (GLfixed)right,
   1820         (GLfixed)bottom,
   1821         (GLfixed)top,
   1822         (GLfixed)zNear,
   1823         (GLfixed)zFar
   1824     );
   1825 }
   1826 
   1827 /* void glPointParameterxOES ( GLenum pname, GLfixed param ) */
   1828 static void
   1829 android_glPointParameterxOES__II
   1830   (JNIEnv *_env, jobject _this, jint pname, jint param) {
   1831     glPointParameterxOES(
   1832         (GLenum)pname,
   1833         (GLfixed)param
   1834     );
   1835 }
   1836 
   1837 /* void glPointParameterxvOES ( GLenum pname, const GLfixed *params ) */
   1838 static void
   1839 android_glPointParameterxvOES__I_3II
   1840   (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
   1841     jint _exception = 0;
   1842     const char * _exceptionType = NULL;
   1843     const char * _exceptionMessage = NULL;
   1844     GLfixed *params_base = (GLfixed *) 0;
   1845     jint _remaining;
   1846     GLfixed *params = (GLfixed *) 0;
   1847 
   1848     if (!params_ref) {
   1849         _exception = 1;
   1850         _exceptionType = "java/lang/IllegalArgumentException";
   1851         _exceptionMessage = "params == null";
   1852         goto exit;
   1853     }
   1854     if (offset < 0) {
   1855         _exception = 1;
   1856         _exceptionType = "java/lang/IllegalArgumentException";
   1857         _exceptionMessage = "offset < 0";
   1858         goto exit;
   1859     }
   1860     _remaining = _env->GetArrayLength(params_ref) - offset;
   1861     params_base = (GLfixed *)
   1862         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   1863     params = params_base + offset;
   1864 
   1865     glPointParameterxvOES(
   1866         (GLenum)pname,
   1867         (GLfixed *)params
   1868     );
   1869 
   1870 exit:
   1871     if (params_base) {
   1872         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   1873             JNI_ABORT);
   1874     }
   1875     if (_exception) {
   1876         jniThrowException(_env, _exceptionType, _exceptionMessage);
   1877     }
   1878 }
   1879 
   1880 /* void glPointParameterxvOES ( GLenum pname, const GLfixed *params ) */
   1881 static void
   1882 android_glPointParameterxvOES__ILjava_nio_IntBuffer_2
   1883   (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
   1884     jarray _array = (jarray) 0;
   1885     jint _bufferOffset = (jint) 0;
   1886     jint _remaining;
   1887     GLfixed *params = (GLfixed *) 0;
   1888 
   1889     params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   1890     if (params == NULL) {
   1891         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   1892         params = (GLfixed *) (_paramsBase + _bufferOffset);
   1893     }
   1894     glPointParameterxvOES(
   1895         (GLenum)pname,
   1896         (GLfixed *)params
   1897     );
   1898     if (_array) {
   1899         releasePointer(_env, _array, params, JNI_FALSE);
   1900     }
   1901 }
   1902 
   1903 /* void glPointSizexOES ( GLfixed size ) */
   1904 static void
   1905 android_glPointSizexOES__I
   1906   (JNIEnv *_env, jobject _this, jint size) {
   1907     glPointSizexOES(
   1908         (GLfixed)size
   1909     );
   1910 }
   1911 
   1912 /* void glPolygonOffsetxOES ( GLfixed factor, GLfixed units ) */
   1913 static void
   1914 android_glPolygonOffsetxOES__II
   1915   (JNIEnv *_env, jobject _this, jint factor, jint units) {
   1916     glPolygonOffsetxOES(
   1917         (GLfixed)factor,
   1918         (GLfixed)units
   1919     );
   1920 }
   1921 
   1922 /* void glRotatexOES ( GLfixed angle, GLfixed x, GLfixed y, GLfixed z ) */
   1923 static void
   1924 android_glRotatexOES__IIII
   1925   (JNIEnv *_env, jobject _this, jint angle, jint x, jint y, jint z) {
   1926     glRotatexOES(
   1927         (GLfixed)angle,
   1928         (GLfixed)x,
   1929         (GLfixed)y,
   1930         (GLfixed)z
   1931     );
   1932 }
   1933 
   1934 /* void glSampleCoveragexOES ( GLclampx value, GLboolean invert ) */
   1935 static void
   1936 android_glSampleCoveragexOES__IZ
   1937   (JNIEnv *_env, jobject _this, jint value, jboolean invert) {
   1938     glSampleCoveragexOES(
   1939         (GLclampx)value,
   1940         (GLboolean)invert
   1941     );
   1942 }
   1943 
   1944 /* void glScalexOES ( GLfixed x, GLfixed y, GLfixed z ) */
   1945 static void
   1946 android_glScalexOES__III
   1947   (JNIEnv *_env, jobject _this, jint x, jint y, jint z) {
   1948     glScalexOES(
   1949         (GLfixed)x,
   1950         (GLfixed)y,
   1951         (GLfixed)z
   1952     );
   1953 }
   1954 
   1955 /* void glTexEnvxOES ( GLenum target, GLenum pname, GLfixed param ) */
   1956 static void
   1957 android_glTexEnvxOES__III
   1958   (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) {
   1959     glTexEnvxOES(
   1960         (GLenum)target,
   1961         (GLenum)pname,
   1962         (GLfixed)param
   1963     );
   1964 }
   1965 
   1966 /* void glTexEnvxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */
   1967 static void
   1968 android_glTexEnvxvOES__II_3II
   1969   (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
   1970     jint _exception = 0;
   1971     const char * _exceptionType = NULL;
   1972     const char * _exceptionMessage = NULL;
   1973     GLfixed *params_base = (GLfixed *) 0;
   1974     jint _remaining;
   1975     GLfixed *params = (GLfixed *) 0;
   1976 
   1977     if (!params_ref) {
   1978         _exception = 1;
   1979         _exceptionType = "java/lang/IllegalArgumentException";
   1980         _exceptionMessage = "params == null";
   1981         goto exit;
   1982     }
   1983     if (offset < 0) {
   1984         _exception = 1;
   1985         _exceptionType = "java/lang/IllegalArgumentException";
   1986         _exceptionMessage = "offset < 0";
   1987         goto exit;
   1988     }
   1989     _remaining = _env->GetArrayLength(params_ref) - offset;
   1990     params_base = (GLfixed *)
   1991         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   1992     params = params_base + offset;
   1993 
   1994     glTexEnvxvOES(
   1995         (GLenum)target,
   1996         (GLenum)pname,
   1997         (GLfixed *)params
   1998     );
   1999 
   2000 exit:
   2001     if (params_base) {
   2002         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   2003             JNI_ABORT);
   2004     }
   2005     if (_exception) {
   2006         jniThrowException(_env, _exceptionType, _exceptionMessage);
   2007     }
   2008 }
   2009 
   2010 /* void glTexEnvxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */
   2011 static void
   2012 android_glTexEnvxvOES__IILjava_nio_IntBuffer_2
   2013   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
   2014     jarray _array = (jarray) 0;
   2015     jint _bufferOffset = (jint) 0;
   2016     jint _remaining;
   2017     GLfixed *params = (GLfixed *) 0;
   2018 
   2019     params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   2020     if (params == NULL) {
   2021         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   2022         params = (GLfixed *) (_paramsBase + _bufferOffset);
   2023     }
   2024     glTexEnvxvOES(
   2025         (GLenum)target,
   2026         (GLenum)pname,
   2027         (GLfixed *)params
   2028     );
   2029     if (_array) {
   2030         releasePointer(_env, _array, params, JNI_FALSE);
   2031     }
   2032 }
   2033 
   2034 /* void glTexParameterxOES ( GLenum target, GLenum pname, GLfixed param ) */
   2035 static void
   2036 android_glTexParameterxOES__III
   2037   (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) {
   2038     glTexParameterxOES(
   2039         (GLenum)target,
   2040         (GLenum)pname,
   2041         (GLfixed)param
   2042     );
   2043 }
   2044 
   2045 /* void glTexParameterxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */
   2046 static void
   2047 android_glTexParameterxvOES__II_3II
   2048   (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
   2049     jint _exception = 0;
   2050     const char * _exceptionType = NULL;
   2051     const char * _exceptionMessage = NULL;
   2052     GLfixed *params_base = (GLfixed *) 0;
   2053     jint _remaining;
   2054     GLfixed *params = (GLfixed *) 0;
   2055 
   2056     if (!params_ref) {
   2057         _exception = 1;
   2058         _exceptionType = "java/lang/IllegalArgumentException";
   2059         _exceptionMessage = "params == null";
   2060         goto exit;
   2061     }
   2062     if (offset < 0) {
   2063         _exception = 1;
   2064         _exceptionType = "java/lang/IllegalArgumentException";
   2065         _exceptionMessage = "offset < 0";
   2066         goto exit;
   2067     }
   2068     _remaining = _env->GetArrayLength(params_ref) - offset;
   2069     params_base = (GLfixed *)
   2070         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   2071     params = params_base + offset;
   2072 
   2073     glTexParameterxvOES(
   2074         (GLenum)target,
   2075         (GLenum)pname,
   2076         (GLfixed *)params
   2077     );
   2078 
   2079 exit:
   2080     if (params_base) {
   2081         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   2082             JNI_ABORT);
   2083     }
   2084     if (_exception) {
   2085         jniThrowException(_env, _exceptionType, _exceptionMessage);
   2086     }
   2087 }
   2088 
   2089 /* void glTexParameterxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */
   2090 static void
   2091 android_glTexParameterxvOES__IILjava_nio_IntBuffer_2
   2092   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
   2093     jarray _array = (jarray) 0;
   2094     jint _bufferOffset = (jint) 0;
   2095     jint _remaining;
   2096     GLfixed *params = (GLfixed *) 0;
   2097 
   2098     params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   2099     if (params == NULL) {
   2100         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   2101         params = (GLfixed *) (_paramsBase + _bufferOffset);
   2102     }
   2103     glTexParameterxvOES(
   2104         (GLenum)target,
   2105         (GLenum)pname,
   2106         (GLfixed *)params
   2107     );
   2108     if (_array) {
   2109         releasePointer(_env, _array, params, JNI_FALSE);
   2110     }
   2111 }
   2112 
   2113 /* void glTranslatexOES ( GLfixed x, GLfixed y, GLfixed z ) */
   2114 static void
   2115 android_glTranslatexOES__III
   2116   (JNIEnv *_env, jobject _this, jint x, jint y, jint z) {
   2117     glTranslatexOES(
   2118         (GLfixed)x,
   2119         (GLfixed)y,
   2120         (GLfixed)z
   2121     );
   2122 }
   2123 
   2124 /* GLboolean glIsRenderbufferOES ( GLuint renderbuffer ) */
   2125 static jboolean
   2126 android_glIsRenderbufferOES__I
   2127   (JNIEnv *_env, jobject _this, jint renderbuffer) {
   2128     GLboolean _returnValue;
   2129     _returnValue = glIsRenderbufferOES(
   2130         (GLuint)renderbuffer
   2131     );
   2132     return _returnValue;
   2133 }
   2134 
   2135 /* void glBindRenderbufferOES ( GLenum target, GLuint renderbuffer ) */
   2136 static void
   2137 android_glBindRenderbufferOES__II
   2138   (JNIEnv *_env, jobject _this, jint target, jint renderbuffer) {
   2139     glBindRenderbufferOES(
   2140         (GLenum)target,
   2141         (GLuint)renderbuffer
   2142     );
   2143 }
   2144 
   2145 /* void glDeleteRenderbuffersOES ( GLsizei n, const GLuint *renderbuffers ) */
   2146 static void
   2147 android_glDeleteRenderbuffersOES__I_3II
   2148   (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) {
   2149     jint _exception = 0;
   2150     const char * _exceptionType = NULL;
   2151     const char * _exceptionMessage = NULL;
   2152     GLuint *renderbuffers_base = (GLuint *) 0;
   2153     jint _remaining;
   2154     GLuint *renderbuffers = (GLuint *) 0;
   2155 
   2156     if (!renderbuffers_ref) {
   2157         _exception = 1;
   2158         _exceptionType = "java/lang/IllegalArgumentException";
   2159         _exceptionMessage = "renderbuffers == null";
   2160         goto exit;
   2161     }
   2162     if (offset < 0) {
   2163         _exception = 1;
   2164         _exceptionType = "java/lang/IllegalArgumentException";
   2165         _exceptionMessage = "offset < 0";
   2166         goto exit;
   2167     }
   2168     _remaining = _env->GetArrayLength(renderbuffers_ref) - offset;
   2169     if (_remaining < n) {
   2170         _exception = 1;
   2171         _exceptionType = "java/lang/IllegalArgumentException";
   2172         _exceptionMessage = "length - offset < n < needed";
   2173         goto exit;
   2174     }
   2175     renderbuffers_base = (GLuint *)
   2176         _env->GetPrimitiveArrayCritical(renderbuffers_ref, (jboolean *)0);
   2177     renderbuffers = renderbuffers_base + offset;
   2178 
   2179     glDeleteRenderbuffersOES(
   2180         (GLsizei)n,
   2181         (GLuint *)renderbuffers
   2182     );
   2183 
   2184 exit:
   2185     if (renderbuffers_base) {
   2186         _env->ReleasePrimitiveArrayCritical(renderbuffers_ref, renderbuffers_base,
   2187             JNI_ABORT);
   2188     }
   2189     if (_exception) {
   2190         jniThrowException(_env, _exceptionType, _exceptionMessage);
   2191     }
   2192 }
   2193 
   2194 /* void glDeleteRenderbuffersOES ( GLsizei n, const GLuint *renderbuffers ) */
   2195 static void
   2196 android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2
   2197   (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) {
   2198     jint _exception = 0;
   2199     const char * _exceptionType = NULL;
   2200     const char * _exceptionMessage = NULL;
   2201     jarray _array = (jarray) 0;
   2202     jint _bufferOffset = (jint) 0;
   2203     jint _remaining;
   2204     GLuint *renderbuffers = (GLuint *) 0;
   2205 
   2206     renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, &_array, &_remaining, &_bufferOffset);
   2207     if (_remaining < n) {
   2208         _exception = 1;
   2209         _exceptionType = "java/lang/IllegalArgumentException";
   2210         _exceptionMessage = "remaining() < n < needed";
   2211         goto exit;
   2212     }
   2213     if (renderbuffers == NULL) {
   2214         char * _renderbuffersBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   2215         renderbuffers = (GLuint *) (_renderbuffersBase + _bufferOffset);
   2216     }
   2217     glDeleteRenderbuffersOES(
   2218         (GLsizei)n,
   2219         (GLuint *)renderbuffers
   2220     );
   2221 
   2222 exit:
   2223     if (_array) {
   2224         releasePointer(_env, _array, renderbuffers, JNI_FALSE);
   2225     }
   2226     if (_exception) {
   2227         jniThrowException(_env, _exceptionType, _exceptionMessage);
   2228     }
   2229 }
   2230 
   2231 /* void glGenRenderbuffersOES ( GLsizei n, GLuint *renderbuffers ) */
   2232 static void
   2233 android_glGenRenderbuffersOES__I_3II
   2234   (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) {
   2235     jint _exception = 0;
   2236     const char * _exceptionType = NULL;
   2237     const char * _exceptionMessage = NULL;
   2238     GLuint *renderbuffers_base = (GLuint *) 0;
   2239     jint _remaining;
   2240     GLuint *renderbuffers = (GLuint *) 0;
   2241 
   2242     if (!renderbuffers_ref) {
   2243         _exception = 1;
   2244         _exceptionType = "java/lang/IllegalArgumentException";
   2245         _exceptionMessage = "renderbuffers == null";
   2246         goto exit;
   2247     }
   2248     if (offset < 0) {
   2249         _exception = 1;
   2250         _exceptionType = "java/lang/IllegalArgumentException";
   2251         _exceptionMessage = "offset < 0";
   2252         goto exit;
   2253     }
   2254     _remaining = _env->GetArrayLength(renderbuffers_ref) - offset;
   2255     if (_remaining < n) {
   2256         _exception = 1;
   2257         _exceptionType = "java/lang/IllegalArgumentException";
   2258         _exceptionMessage = "length - offset < n < needed";
   2259         goto exit;
   2260     }
   2261     renderbuffers_base = (GLuint *)
   2262         _env->GetPrimitiveArrayCritical(renderbuffers_ref, (jboolean *)0);
   2263     renderbuffers = renderbuffers_base + offset;
   2264 
   2265     glGenRenderbuffersOES(
   2266         (GLsizei)n,
   2267         (GLuint *)renderbuffers
   2268     );
   2269 
   2270 exit:
   2271     if (renderbuffers_base) {
   2272         _env->ReleasePrimitiveArrayCritical(renderbuffers_ref, renderbuffers_base,
   2273             _exception ? JNI_ABORT: 0);
   2274     }
   2275     if (_exception) {
   2276         jniThrowException(_env, _exceptionType, _exceptionMessage);
   2277     }
   2278 }
   2279 
   2280 /* void glGenRenderbuffersOES ( GLsizei n, GLuint *renderbuffers ) */
   2281 static void
   2282 android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2
   2283   (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) {
   2284     jint _exception = 0;
   2285     const char * _exceptionType = NULL;
   2286     const char * _exceptionMessage = NULL;
   2287     jarray _array = (jarray) 0;
   2288     jint _bufferOffset = (jint) 0;
   2289     jint _remaining;
   2290     GLuint *renderbuffers = (GLuint *) 0;
   2291 
   2292     renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, &_array, &_remaining, &_bufferOffset);
   2293     if (_remaining < n) {
   2294         _exception = 1;
   2295         _exceptionType = "java/lang/IllegalArgumentException";
   2296         _exceptionMessage = "remaining() < n < needed";
   2297         goto exit;
   2298     }
   2299     if (renderbuffers == NULL) {
   2300         char * _renderbuffersBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   2301         renderbuffers = (GLuint *) (_renderbuffersBase + _bufferOffset);
   2302     }
   2303     glGenRenderbuffersOES(
   2304         (GLsizei)n,
   2305         (GLuint *)renderbuffers
   2306     );
   2307 
   2308 exit:
   2309     if (_array) {
   2310         releasePointer(_env, _array, renderbuffers, _exception ? JNI_FALSE : JNI_TRUE);
   2311     }
   2312     if (_exception) {
   2313         jniThrowException(_env, _exceptionType, _exceptionMessage);
   2314     }
   2315 }
   2316 
   2317 /* void glRenderbufferStorageOES ( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) */
   2318 static void
   2319 android_glRenderbufferStorageOES__IIII
   2320   (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint width, jint height) {
   2321     glRenderbufferStorageOES(
   2322         (GLenum)target,
   2323         (GLenum)internalformat,
   2324         (GLsizei)width,
   2325         (GLsizei)height
   2326     );
   2327 }
   2328 
   2329 /* void glGetRenderbufferParameterivOES ( GLenum target, GLenum pname, GLint *params ) */
   2330 static void
   2331 android_glGetRenderbufferParameterivOES__II_3II
   2332   (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
   2333     jint _exception = 0;
   2334     const char * _exceptionType = NULL;
   2335     const char * _exceptionMessage = NULL;
   2336     GLint *params_base = (GLint *) 0;
   2337     jint _remaining;
   2338     GLint *params = (GLint *) 0;
   2339 
   2340     if (!params_ref) {
   2341         _exception = 1;
   2342         _exceptionType = "java/lang/IllegalArgumentException";
   2343         _exceptionMessage = "params == null";
   2344         goto exit;
   2345     }
   2346     if (offset < 0) {
   2347         _exception = 1;
   2348         _exceptionType = "java/lang/IllegalArgumentException";
   2349         _exceptionMessage = "offset < 0";
   2350         goto exit;
   2351     }
   2352     _remaining = _env->GetArrayLength(params_ref) - offset;
   2353     if (_remaining < 1) {
   2354         _exception = 1;
   2355         _exceptionType = "java/lang/IllegalArgumentException";
   2356         _exceptionMessage = "length - offset < 1 < needed";
   2357         goto exit;
   2358     }
   2359     params_base = (GLint *)
   2360         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   2361     params = params_base + offset;
   2362 
   2363     glGetRenderbufferParameterivOES(
   2364         (GLenum)target,
   2365         (GLenum)pname,
   2366         (GLint *)params
   2367     );
   2368 
   2369 exit:
   2370     if (params_base) {
   2371         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   2372             _exception ? JNI_ABORT: 0);
   2373     }
   2374     if (_exception) {
   2375         jniThrowException(_env, _exceptionType, _exceptionMessage);
   2376     }
   2377 }
   2378 
   2379 /* void glGetRenderbufferParameterivOES ( GLenum target, GLenum pname, GLint *params ) */
   2380 static void
   2381 android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2
   2382   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
   2383     jint _exception = 0;
   2384     const char * _exceptionType = NULL;
   2385     const char * _exceptionMessage = NULL;
   2386     jarray _array = (jarray) 0;
   2387     jint _bufferOffset = (jint) 0;
   2388     jint _remaining;
   2389     GLint *params = (GLint *) 0;
   2390 
   2391     params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   2392     if (_remaining < 1) {
   2393         _exception = 1;
   2394         _exceptionType = "java/lang/IllegalArgumentException";
   2395         _exceptionMessage = "remaining() < 1 < needed";
   2396         goto exit;
   2397     }
   2398     if (params == NULL) {
   2399         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   2400         params = (GLint *) (_paramsBase + _bufferOffset);
   2401     }
   2402     glGetRenderbufferParameterivOES(
   2403         (GLenum)target,
   2404         (GLenum)pname,
   2405         (GLint *)params
   2406     );
   2407 
   2408 exit:
   2409     if (_array) {
   2410         releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
   2411     }
   2412     if (_exception) {
   2413         jniThrowException(_env, _exceptionType, _exceptionMessage);
   2414     }
   2415 }
   2416 
   2417 /* GLboolean glIsFramebufferOES ( GLuint framebuffer ) */
   2418 static jboolean
   2419 android_glIsFramebufferOES__I
   2420   (JNIEnv *_env, jobject _this, jint framebuffer) {
   2421     GLboolean _returnValue;
   2422     _returnValue = glIsFramebufferOES(
   2423         (GLuint)framebuffer
   2424     );
   2425     return _returnValue;
   2426 }
   2427 
   2428 /* void glBindFramebufferOES ( GLenum target, GLuint framebuffer ) */
   2429 static void
   2430 android_glBindFramebufferOES__II
   2431   (JNIEnv *_env, jobject _this, jint target, jint framebuffer) {
   2432     glBindFramebufferOES(
   2433         (GLenum)target,
   2434         (GLuint)framebuffer
   2435     );
   2436 }
   2437 
   2438 /* void glDeleteFramebuffersOES ( GLsizei n, const GLuint *framebuffers ) */
   2439 static void
   2440 android_glDeleteFramebuffersOES__I_3II
   2441   (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) {
   2442     jint _exception = 0;
   2443     const char * _exceptionType = NULL;
   2444     const char * _exceptionMessage = NULL;
   2445     GLuint *framebuffers_base = (GLuint *) 0;
   2446     jint _remaining;
   2447     GLuint *framebuffers = (GLuint *) 0;
   2448 
   2449     if (!framebuffers_ref) {
   2450         _exception = 1;
   2451         _exceptionType = "java/lang/IllegalArgumentException";
   2452         _exceptionMessage = "framebuffers == null";
   2453         goto exit;
   2454     }
   2455     if (offset < 0) {
   2456         _exception = 1;
   2457         _exceptionType = "java/lang/IllegalArgumentException";
   2458         _exceptionMessage = "offset < 0";
   2459         goto exit;
   2460     }
   2461     _remaining = _env->GetArrayLength(framebuffers_ref) - offset;
   2462     if (_remaining < n) {
   2463         _exception = 1;
   2464         _exceptionType = "java/lang/IllegalArgumentException";
   2465         _exceptionMessage = "length - offset < n < needed";
   2466         goto exit;
   2467     }
   2468     framebuffers_base = (GLuint *)
   2469         _env->GetPrimitiveArrayCritical(framebuffers_ref, (jboolean *)0);
   2470     framebuffers = framebuffers_base + offset;
   2471 
   2472     glDeleteFramebuffersOES(
   2473         (GLsizei)n,
   2474         (GLuint *)framebuffers
   2475     );
   2476 
   2477 exit:
   2478     if (framebuffers_base) {
   2479         _env->ReleasePrimitiveArrayCritical(framebuffers_ref, framebuffers_base,
   2480             JNI_ABORT);
   2481     }
   2482     if (_exception) {
   2483         jniThrowException(_env, _exceptionType, _exceptionMessage);
   2484     }
   2485 }
   2486 
   2487 /* void glDeleteFramebuffersOES ( GLsizei n, const GLuint *framebuffers ) */
   2488 static void
   2489 android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2
   2490   (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) {
   2491     jint _exception = 0;
   2492     const char * _exceptionType = NULL;
   2493     const char * _exceptionMessage = NULL;
   2494     jarray _array = (jarray) 0;
   2495     jint _bufferOffset = (jint) 0;
   2496     jint _remaining;
   2497     GLuint *framebuffers = (GLuint *) 0;
   2498 
   2499     framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, &_array, &_remaining, &_bufferOffset);
   2500     if (_remaining < n) {
   2501         _exception = 1;
   2502         _exceptionType = "java/lang/IllegalArgumentException";
   2503         _exceptionMessage = "remaining() < n < needed";
   2504         goto exit;
   2505     }
   2506     if (framebuffers == NULL) {
   2507         char * _framebuffersBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   2508         framebuffers = (GLuint *) (_framebuffersBase + _bufferOffset);
   2509     }
   2510     glDeleteFramebuffersOES(
   2511         (GLsizei)n,
   2512         (GLuint *)framebuffers
   2513     );
   2514 
   2515 exit:
   2516     if (_array) {
   2517         releasePointer(_env, _array, framebuffers, JNI_FALSE);
   2518     }
   2519     if (_exception) {
   2520         jniThrowException(_env, _exceptionType, _exceptionMessage);
   2521     }
   2522 }
   2523 
   2524 /* void glGenFramebuffersOES ( GLsizei n, GLuint *framebuffers ) */
   2525 static void
   2526 android_glGenFramebuffersOES__I_3II
   2527   (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) {
   2528     jint _exception = 0;
   2529     const char * _exceptionType = NULL;
   2530     const char * _exceptionMessage = NULL;
   2531     GLuint *framebuffers_base = (GLuint *) 0;
   2532     jint _remaining;
   2533     GLuint *framebuffers = (GLuint *) 0;
   2534 
   2535     if (!framebuffers_ref) {
   2536         _exception = 1;
   2537         _exceptionType = "java/lang/IllegalArgumentException";
   2538         _exceptionMessage = "framebuffers == null";
   2539         goto exit;
   2540     }
   2541     if (offset < 0) {
   2542         _exception = 1;
   2543         _exceptionType = "java/lang/IllegalArgumentException";
   2544         _exceptionMessage = "offset < 0";
   2545         goto exit;
   2546     }
   2547     _remaining = _env->GetArrayLength(framebuffers_ref) - offset;
   2548     if (_remaining < n) {
   2549         _exception = 1;
   2550         _exceptionType = "java/lang/IllegalArgumentException";
   2551         _exceptionMessage = "length - offset < n < needed";
   2552         goto exit;
   2553     }
   2554     framebuffers_base = (GLuint *)
   2555         _env->GetPrimitiveArrayCritical(framebuffers_ref, (jboolean *)0);
   2556     framebuffers = framebuffers_base + offset;
   2557 
   2558     glGenFramebuffersOES(
   2559         (GLsizei)n,
   2560         (GLuint *)framebuffers
   2561     );
   2562 
   2563 exit:
   2564     if (framebuffers_base) {
   2565         _env->ReleasePrimitiveArrayCritical(framebuffers_ref, framebuffers_base,
   2566             _exception ? JNI_ABORT: 0);
   2567     }
   2568     if (_exception) {
   2569         jniThrowException(_env, _exceptionType, _exceptionMessage);
   2570     }
   2571 }
   2572 
   2573 /* void glGenFramebuffersOES ( GLsizei n, GLuint *framebuffers ) */
   2574 static void
   2575 android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2
   2576   (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) {
   2577     jint _exception = 0;
   2578     const char * _exceptionType = NULL;
   2579     const char * _exceptionMessage = NULL;
   2580     jarray _array = (jarray) 0;
   2581     jint _bufferOffset = (jint) 0;
   2582     jint _remaining;
   2583     GLuint *framebuffers = (GLuint *) 0;
   2584 
   2585     framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, &_array, &_remaining, &_bufferOffset);
   2586     if (_remaining < n) {
   2587         _exception = 1;
   2588         _exceptionType = "java/lang/IllegalArgumentException";
   2589         _exceptionMessage = "remaining() < n < needed";
   2590         goto exit;
   2591     }
   2592     if (framebuffers == NULL) {
   2593         char * _framebuffersBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   2594         framebuffers = (GLuint *) (_framebuffersBase + _bufferOffset);
   2595     }
   2596     glGenFramebuffersOES(
   2597         (GLsizei)n,
   2598         (GLuint *)framebuffers
   2599     );
   2600 
   2601 exit:
   2602     if (_array) {
   2603         releasePointer(_env, _array, framebuffers, _exception ? JNI_FALSE : JNI_TRUE);
   2604     }
   2605     if (_exception) {
   2606         jniThrowException(_env, _exceptionType, _exceptionMessage);
   2607     }
   2608 }
   2609 
   2610 /* GLenum glCheckFramebufferStatusOES ( GLenum target ) */
   2611 static jint
   2612 android_glCheckFramebufferStatusOES__I
   2613   (JNIEnv *_env, jobject _this, jint target) {
   2614     GLenum _returnValue;
   2615     _returnValue = glCheckFramebufferStatusOES(
   2616         (GLenum)target
   2617     );
   2618     return _returnValue;
   2619 }
   2620 
   2621 /* void glFramebufferRenderbufferOES ( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) */
   2622 static void
   2623 android_glFramebufferRenderbufferOES__IIII
   2624   (JNIEnv *_env, jobject _this, jint target, jint attachment, jint renderbuffertarget, jint renderbuffer) {
   2625     glFramebufferRenderbufferOES(
   2626         (GLenum)target,
   2627         (GLenum)attachment,
   2628         (GLenum)renderbuffertarget,
   2629         (GLuint)renderbuffer
   2630     );
   2631 }
   2632 
   2633 /* void glFramebufferTexture2DOES ( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) */
   2634 static void
   2635 android_glFramebufferTexture2DOES__IIIII
   2636   (JNIEnv *_env, jobject _this, jint target, jint attachment, jint textarget, jint texture, jint level) {
   2637     glFramebufferTexture2DOES(
   2638         (GLenum)target,
   2639         (GLenum)attachment,
   2640         (GLenum)textarget,
   2641         (GLuint)texture,
   2642         (GLint)level
   2643     );
   2644 }
   2645 
   2646 /* void glGetFramebufferAttachmentParameterivOES ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */
   2647 static void
   2648 android_glGetFramebufferAttachmentParameterivOES__III_3II
   2649   (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jintArray params_ref, jint offset) {
   2650     jint _exception = 0;
   2651     const char * _exceptionType = NULL;
   2652     const char * _exceptionMessage = NULL;
   2653     GLint *params_base = (GLint *) 0;
   2654     jint _remaining;
   2655     GLint *params = (GLint *) 0;
   2656 
   2657     if (!params_ref) {
   2658         _exception = 1;
   2659         _exceptionType = "java/lang/IllegalArgumentException";
   2660         _exceptionMessage = "params == null";
   2661         goto exit;
   2662     }
   2663     if (offset < 0) {
   2664         _exception = 1;
   2665         _exceptionType = "java/lang/IllegalArgumentException";
   2666         _exceptionMessage = "offset < 0";
   2667         goto exit;
   2668     }
   2669     _remaining = _env->GetArrayLength(params_ref) - offset;
   2670     if (_remaining < 1) {
   2671         _exception = 1;
   2672         _exceptionType = "java/lang/IllegalArgumentException";
   2673         _exceptionMessage = "length - offset < 1 < needed";
   2674         goto exit;
   2675     }
   2676     params_base = (GLint *)
   2677         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   2678     params = params_base + offset;
   2679 
   2680     glGetFramebufferAttachmentParameterivOES(
   2681         (GLenum)target,
   2682         (GLenum)attachment,
   2683         (GLenum)pname,
   2684         (GLint *)params
   2685     );
   2686 
   2687 exit:
   2688     if (params_base) {
   2689         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   2690             _exception ? JNI_ABORT: 0);
   2691     }
   2692     if (_exception) {
   2693         jniThrowException(_env, _exceptionType, _exceptionMessage);
   2694     }
   2695 }
   2696 
   2697 /* void glGetFramebufferAttachmentParameterivOES ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */
   2698 static void
   2699 android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2
   2700   (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jobject params_buf) {
   2701     jint _exception = 0;
   2702     const char * _exceptionType = NULL;
   2703     const char * _exceptionMessage = NULL;
   2704     jarray _array = (jarray) 0;
   2705     jint _bufferOffset = (jint) 0;
   2706     jint _remaining;
   2707     GLint *params = (GLint *) 0;
   2708 
   2709     params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   2710     if (_remaining < 1) {
   2711         _exception = 1;
   2712         _exceptionType = "java/lang/IllegalArgumentException";
   2713         _exceptionMessage = "remaining() < 1 < needed";
   2714         goto exit;
   2715     }
   2716     if (params == NULL) {
   2717         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   2718         params = (GLint *) (_paramsBase + _bufferOffset);
   2719     }
   2720     glGetFramebufferAttachmentParameterivOES(
   2721         (GLenum)target,
   2722         (GLenum)attachment,
   2723         (GLenum)pname,
   2724         (GLint *)params
   2725     );
   2726 
   2727 exit:
   2728     if (_array) {
   2729         releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
   2730     }
   2731     if (_exception) {
   2732         jniThrowException(_env, _exceptionType, _exceptionMessage);
   2733     }
   2734 }
   2735 
   2736 /* void glGenerateMipmapOES ( GLenum target ) */
   2737 static void
   2738 android_glGenerateMipmapOES__I
   2739   (JNIEnv *_env, jobject _this, jint target) {
   2740     glGenerateMipmapOES(
   2741         (GLenum)target
   2742     );
   2743 }
   2744 
   2745 /* void glCurrentPaletteMatrixOES ( GLuint matrixpaletteindex ) */
   2746 static void
   2747 android_glCurrentPaletteMatrixOES__I
   2748   (JNIEnv *_env, jobject _this, jint matrixpaletteindex) {
   2749     glCurrentPaletteMatrixOES(
   2750         (GLuint)matrixpaletteindex
   2751     );
   2752 }
   2753 
   2754 /* void glLoadPaletteFromModelViewMatrixOES ( void ) */
   2755 static void
   2756 android_glLoadPaletteFromModelViewMatrixOES__
   2757   (JNIEnv *_env, jobject _this) {
   2758     glLoadPaletteFromModelViewMatrixOES();
   2759 }
   2760 
   2761 /* void glMatrixIndexPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
   2762 static void
   2763 android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I
   2764   (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
   2765     jarray _array = (jarray) 0;
   2766     jint _bufferOffset = (jint) 0;
   2767     jint _remaining;
   2768     GLvoid *pointer = (GLvoid *) 0;
   2769 
   2770     if (pointer_buf) {
   2771         pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
   2772         if ( ! pointer ) {
   2773             return;
   2774         }
   2775     }
   2776     glMatrixIndexPointerOESBounds(
   2777         (GLint)size,
   2778         (GLenum)type,
   2779         (GLsizei)stride,
   2780         (GLvoid *)pointer,
   2781         (GLsizei)remaining
   2782     );
   2783 }
   2784 
   2785 /* void glWeightPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
   2786 static void
   2787 android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I
   2788   (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
   2789     jarray _array = (jarray) 0;
   2790     jint _bufferOffset = (jint) 0;
   2791     jint _remaining;
   2792     GLvoid *pointer = (GLvoid *) 0;
   2793 
   2794     if (pointer_buf) {
   2795         pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
   2796         if ( ! pointer ) {
   2797             return;
   2798         }
   2799     }
   2800     glWeightPointerOESBounds(
   2801         (GLint)size,
   2802         (GLenum)type,
   2803         (GLsizei)stride,
   2804         (GLvoid *)pointer,
   2805         (GLsizei)remaining
   2806     );
   2807 }
   2808 
   2809 /* void glDepthRangefOES ( GLclampf zNear, GLclampf zFar ) */
   2810 static void
   2811 android_glDepthRangefOES__FF
   2812   (JNIEnv *_env, jobject _this, jfloat zNear, jfloat zFar) {
   2813     glDepthRangefOES(
   2814         (GLclampf)zNear,
   2815         (GLclampf)zFar
   2816     );
   2817 }
   2818 
   2819 /* void glFrustumfOES ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */
   2820 static void
   2821 android_glFrustumfOES__FFFFFF
   2822   (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) {
   2823     glFrustumfOES(
   2824         (GLfloat)left,
   2825         (GLfloat)right,
   2826         (GLfloat)bottom,
   2827         (GLfloat)top,
   2828         (GLfloat)zNear,
   2829         (GLfloat)zFar
   2830     );
   2831 }
   2832 
   2833 /* void glOrthofOES ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */
   2834 static void
   2835 android_glOrthofOES__FFFFFF
   2836   (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) {
   2837     glOrthofOES(
   2838         (GLfloat)left,
   2839         (GLfloat)right,
   2840         (GLfloat)bottom,
   2841         (GLfloat)top,
   2842         (GLfloat)zNear,
   2843         (GLfloat)zFar
   2844     );
   2845 }
   2846 
   2847 /* void glClipPlanefOES ( GLenum plane, const GLfloat *equation ) */
   2848 static void
   2849 android_glClipPlanefOES__I_3FI
   2850   (JNIEnv *_env, jobject _this, jint plane, jfloatArray equation_ref, jint offset) {
   2851     jint _exception = 0;
   2852     const char * _exceptionType = NULL;
   2853     const char * _exceptionMessage = NULL;
   2854     GLfloat *equation_base = (GLfloat *) 0;
   2855     jint _remaining;
   2856     GLfloat *equation = (GLfloat *) 0;
   2857 
   2858     if (!equation_ref) {
   2859         _exception = 1;
   2860         _exceptionType = "java/lang/IllegalArgumentException";
   2861         _exceptionMessage = "equation == null";
   2862         goto exit;
   2863     }
   2864     if (offset < 0) {
   2865         _exception = 1;
   2866         _exceptionType = "java/lang/IllegalArgumentException";
   2867         _exceptionMessage = "offset < 0";
   2868         goto exit;
   2869     }
   2870     _remaining = _env->GetArrayLength(equation_ref) - offset;
   2871     equation_base = (GLfloat *)
   2872         _env->GetPrimitiveArrayCritical(equation_ref, (jboolean *)0);
   2873     equation = equation_base + offset;
   2874 
   2875     glClipPlanefOES(
   2876         (GLenum)plane,
   2877         (GLfloat *)equation
   2878     );
   2879 
   2880 exit:
   2881     if (equation_base) {
   2882         _env->ReleasePrimitiveArrayCritical(equation_ref, equation_base,
   2883             JNI_ABORT);
   2884     }
   2885     if (_exception) {
   2886         jniThrowException(_env, _exceptionType, _exceptionMessage);
   2887     }
   2888 }
   2889 
   2890 /* void glClipPlanefOES ( GLenum plane, const GLfloat *equation ) */
   2891 static void
   2892 android_glClipPlanefOES__ILjava_nio_FloatBuffer_2
   2893   (JNIEnv *_env, jobject _this, jint plane, jobject equation_buf) {
   2894     jarray _array = (jarray) 0;
   2895     jint _bufferOffset = (jint) 0;
   2896     jint _remaining;
   2897     GLfloat *equation = (GLfloat *) 0;
   2898 
   2899     equation = (GLfloat *)getPointer(_env, equation_buf, &_array, &_remaining, &_bufferOffset);
   2900     if (equation == NULL) {
   2901         char * _equationBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   2902         equation = (GLfloat *) (_equationBase + _bufferOffset);
   2903     }
   2904     glClipPlanefOES(
   2905         (GLenum)plane,
   2906         (GLfloat *)equation
   2907     );
   2908     if (_array) {
   2909         releasePointer(_env, _array, equation, JNI_FALSE);
   2910     }
   2911 }
   2912 
   2913 /* void glGetClipPlanefOES ( GLenum pname, GLfloat *eqn ) */
   2914 static void
   2915 android_glGetClipPlanefOES__I_3FI
   2916   (JNIEnv *_env, jobject _this, jint pname, jfloatArray eqn_ref, jint offset) {
   2917     jint _exception = 0;
   2918     const char * _exceptionType = NULL;
   2919     const char * _exceptionMessage = NULL;
   2920     GLfloat *eqn_base = (GLfloat *) 0;
   2921     jint _remaining;
   2922     GLfloat *eqn = (GLfloat *) 0;
   2923 
   2924     if (!eqn_ref) {
   2925         _exception = 1;
   2926         _exceptionType = "java/lang/IllegalArgumentException";
   2927         _exceptionMessage = "eqn == null";
   2928         goto exit;
   2929     }
   2930     if (offset < 0) {
   2931         _exception = 1;
   2932         _exceptionType = "java/lang/IllegalArgumentException";
   2933         _exceptionMessage = "offset < 0";
   2934         goto exit;
   2935     }
   2936     _remaining = _env->GetArrayLength(eqn_ref) - offset;
   2937     if (_remaining < 4) {
   2938         _exception = 1;
   2939         _exceptionType = "java/lang/IllegalArgumentException";
   2940         _exceptionMessage = "length - offset < 4 < needed";
   2941         goto exit;
   2942     }
   2943     eqn_base = (GLfloat *)
   2944         _env->GetPrimitiveArrayCritical(eqn_ref, (jboolean *)0);
   2945     eqn = eqn_base + offset;
   2946 
   2947     glGetClipPlanefOES(
   2948         (GLenum)pname,
   2949         (GLfloat *)eqn
   2950     );
   2951 
   2952 exit:
   2953     if (eqn_base) {
   2954         _env->ReleasePrimitiveArrayCritical(eqn_ref, eqn_base,
   2955             _exception ? JNI_ABORT: 0);
   2956     }
   2957     if (_exception) {
   2958         jniThrowException(_env, _exceptionType, _exceptionMessage);
   2959     }
   2960 }
   2961 
   2962 /* void glGetClipPlanefOES ( GLenum pname, GLfloat *eqn ) */
   2963 static void
   2964 android_glGetClipPlanefOES__ILjava_nio_FloatBuffer_2
   2965   (JNIEnv *_env, jobject _this, jint pname, jobject eqn_buf) {
   2966     jint _exception = 0;
   2967     const char * _exceptionType = NULL;
   2968     const char * _exceptionMessage = NULL;
   2969     jarray _array = (jarray) 0;
   2970     jint _bufferOffset = (jint) 0;
   2971     jint _remaining;
   2972     GLfloat *eqn = (GLfloat *) 0;
   2973 
   2974     eqn = (GLfloat *)getPointer(_env, eqn_buf, &_array, &_remaining, &_bufferOffset);
   2975     if (_remaining < 4) {
   2976         _exception = 1;
   2977         _exceptionType = "java/lang/IllegalArgumentException";
   2978         _exceptionMessage = "remaining() < 4 < needed";
   2979         goto exit;
   2980     }
   2981     if (eqn == NULL) {
   2982         char * _eqnBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   2983         eqn = (GLfloat *) (_eqnBase + _bufferOffset);
   2984     }
   2985     glGetClipPlanefOES(
   2986         (GLenum)pname,
   2987         (GLfloat *)eqn
   2988     );
   2989 
   2990 exit:
   2991     if (_array) {
   2992         releasePointer(_env, _array, eqn, _exception ? JNI_FALSE : JNI_TRUE);
   2993     }
   2994     if (_exception) {
   2995         jniThrowException(_env, _exceptionType, _exceptionMessage);
   2996     }
   2997 }
   2998 
   2999 /* void glClearDepthfOES ( GLclampf depth ) */
   3000 static void
   3001 android_glClearDepthfOES__F
   3002   (JNIEnv *_env, jobject _this, jfloat depth) {
   3003     glClearDepthfOES(
   3004         (GLclampf)depth
   3005     );
   3006 }
   3007 
   3008 /* void glTexGenfOES ( GLenum coord, GLenum pname, GLfloat param ) */
   3009 static void
   3010 android_glTexGenfOES__IIF
   3011   (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloat param) {
   3012     glTexGenfOES(
   3013         (GLenum)coord,
   3014         (GLenum)pname,
   3015         (GLfloat)param
   3016     );
   3017 }
   3018 
   3019 /* void glTexGenfvOES ( GLenum coord, GLenum pname, const GLfloat *params ) */
   3020 static void
   3021 android_glTexGenfvOES__II_3FI
   3022   (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) {
   3023     jint _exception = 0;
   3024     const char * _exceptionType = NULL;
   3025     const char * _exceptionMessage = NULL;
   3026     GLfloat *params_base = (GLfloat *) 0;
   3027     jint _remaining;
   3028     GLfloat *params = (GLfloat *) 0;
   3029 
   3030     if (!params_ref) {
   3031         _exception = 1;
   3032         _exceptionType = "java/lang/IllegalArgumentException";
   3033         _exceptionMessage = "params == null";
   3034         goto exit;
   3035     }
   3036     if (offset < 0) {
   3037         _exception = 1;
   3038         _exceptionType = "java/lang/IllegalArgumentException";
   3039         _exceptionMessage = "offset < 0";
   3040         goto exit;
   3041     }
   3042     _remaining = _env->GetArrayLength(params_ref) - offset;
   3043     params_base = (GLfloat *)
   3044         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   3045     params = params_base + offset;
   3046 
   3047     glTexGenfvOES(
   3048         (GLenum)coord,
   3049         (GLenum)pname,
   3050         (GLfloat *)params
   3051     );
   3052 
   3053 exit:
   3054     if (params_base) {
   3055         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   3056             JNI_ABORT);
   3057     }
   3058     if (_exception) {
   3059         jniThrowException(_env, _exceptionType, _exceptionMessage);
   3060     }
   3061 }
   3062 
   3063 /* void glTexGenfvOES ( GLenum coord, GLenum pname, const GLfloat *params ) */
   3064 static void
   3065 android_glTexGenfvOES__IILjava_nio_FloatBuffer_2
   3066   (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
   3067     jarray _array = (jarray) 0;
   3068     jint _bufferOffset = (jint) 0;
   3069     jint _remaining;
   3070     GLfloat *params = (GLfloat *) 0;
   3071 
   3072     params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   3073     if (params == NULL) {
   3074         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   3075         params = (GLfloat *) (_paramsBase + _bufferOffset);
   3076     }
   3077     glTexGenfvOES(
   3078         (GLenum)coord,
   3079         (GLenum)pname,
   3080         (GLfloat *)params
   3081     );
   3082     if (_array) {
   3083         releasePointer(_env, _array, params, JNI_FALSE);
   3084     }
   3085 }
   3086 
   3087 /* void glTexGeniOES ( GLenum coord, GLenum pname, GLint param ) */
   3088 static void
   3089 android_glTexGeniOES__III
   3090   (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) {
   3091     glTexGeniOES(
   3092         (GLenum)coord,
   3093         (GLenum)pname,
   3094         (GLint)param
   3095     );
   3096 }
   3097 
   3098 /* void glTexGenivOES ( GLenum coord, GLenum pname, const GLint *params ) */
   3099 static void
   3100 android_glTexGenivOES__II_3II
   3101   (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
   3102     jint _exception = 0;
   3103     const char * _exceptionType = NULL;
   3104     const char * _exceptionMessage = NULL;
   3105     GLint *params_base = (GLint *) 0;
   3106     jint _remaining;
   3107     GLint *params = (GLint *) 0;
   3108 
   3109     if (!params_ref) {
   3110         _exception = 1;
   3111         _exceptionType = "java/lang/IllegalArgumentException";
   3112         _exceptionMessage = "params == null";
   3113         goto exit;
   3114     }
   3115     if (offset < 0) {
   3116         _exception = 1;
   3117         _exceptionType = "java/lang/IllegalArgumentException";
   3118         _exceptionMessage = "offset < 0";
   3119         goto exit;
   3120     }
   3121     _remaining = _env->GetArrayLength(params_ref) - offset;
   3122     params_base = (GLint *)
   3123         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   3124     params = params_base + offset;
   3125 
   3126     glTexGenivOES(
   3127         (GLenum)coord,
   3128         (GLenum)pname,
   3129         (GLint *)params
   3130     );
   3131 
   3132 exit:
   3133     if (params_base) {
   3134         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   3135             JNI_ABORT);
   3136     }
   3137     if (_exception) {
   3138         jniThrowException(_env, _exceptionType, _exceptionMessage);
   3139     }
   3140 }
   3141 
   3142 /* void glTexGenivOES ( GLenum coord, GLenum pname, const GLint *params ) */
   3143 static void
   3144 android_glTexGenivOES__IILjava_nio_IntBuffer_2
   3145   (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
   3146     jarray _array = (jarray) 0;
   3147     jint _bufferOffset = (jint) 0;
   3148     jint _remaining;
   3149     GLint *params = (GLint *) 0;
   3150 
   3151     params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   3152     if (params == NULL) {
   3153         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   3154         params = (GLint *) (_paramsBase + _bufferOffset);
   3155     }
   3156     glTexGenivOES(
   3157         (GLenum)coord,
   3158         (GLenum)pname,
   3159         (GLint *)params
   3160     );
   3161     if (_array) {
   3162         releasePointer(_env, _array, params, JNI_FALSE);
   3163     }
   3164 }
   3165 
   3166 /* void glTexGenxOES ( GLenum coord, GLenum pname, GLfixed param ) */
   3167 static void
   3168 android_glTexGenxOES__III
   3169   (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) {
   3170     glTexGenxOES(
   3171         (GLenum)coord,
   3172         (GLenum)pname,
   3173         (GLfixed)param
   3174     );
   3175 }
   3176 
   3177 /* void glTexGenxvOES ( GLenum coord, GLenum pname, const GLfixed *params ) */
   3178 static void
   3179 android_glTexGenxvOES__II_3II
   3180   (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
   3181     jint _exception = 0;
   3182     const char * _exceptionType = NULL;
   3183     const char * _exceptionMessage = NULL;
   3184     GLfixed *params_base = (GLfixed *) 0;
   3185     jint _remaining;
   3186     GLfixed *params = (GLfixed *) 0;
   3187 
   3188     if (!params_ref) {
   3189         _exception = 1;
   3190         _exceptionType = "java/lang/IllegalArgumentException";
   3191         _exceptionMessage = "params == null";
   3192         goto exit;
   3193     }
   3194     if (offset < 0) {
   3195         _exception = 1;
   3196         _exceptionType = "java/lang/IllegalArgumentException";
   3197         _exceptionMessage = "offset < 0";
   3198         goto exit;
   3199     }
   3200     _remaining = _env->GetArrayLength(params_ref) - offset;
   3201     params_base = (GLfixed *)
   3202         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   3203     params = params_base + offset;
   3204 
   3205     glTexGenxvOES(
   3206         (GLenum)coord,
   3207         (GLenum)pname,
   3208         (GLfixed *)params
   3209     );
   3210 
   3211 exit:
   3212     if (params_base) {
   3213         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   3214             JNI_ABORT);
   3215     }
   3216     if (_exception) {
   3217         jniThrowException(_env, _exceptionType, _exceptionMessage);
   3218     }
   3219 }
   3220 
   3221 /* void glTexGenxvOES ( GLenum coord, GLenum pname, const GLfixed *params ) */
   3222 static void
   3223 android_glTexGenxvOES__IILjava_nio_IntBuffer_2
   3224   (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
   3225     jarray _array = (jarray) 0;
   3226     jint _bufferOffset = (jint) 0;
   3227     jint _remaining;
   3228     GLfixed *params = (GLfixed *) 0;
   3229 
   3230     params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   3231     if (params == NULL) {
   3232         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   3233         params = (GLfixed *) (_paramsBase + _bufferOffset);
   3234     }
   3235     glTexGenxvOES(
   3236         (GLenum)coord,
   3237         (GLenum)pname,
   3238         (GLfixed *)params
   3239     );
   3240     if (_array) {
   3241         releasePointer(_env, _array, params, JNI_FALSE);
   3242     }
   3243 }
   3244 
   3245 /* void glGetTexGenfvOES ( GLenum coord, GLenum pname, GLfloat *params ) */
   3246 static void
   3247 android_glGetTexGenfvOES__II_3FI
   3248   (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) {
   3249     jint _exception = 0;
   3250     const char * _exceptionType = NULL;
   3251     const char * _exceptionMessage = NULL;
   3252     GLfloat *params_base = (GLfloat *) 0;
   3253     jint _remaining;
   3254     GLfloat *params = (GLfloat *) 0;
   3255 
   3256     if (!params_ref) {
   3257         _exception = 1;
   3258         _exceptionType = "java/lang/IllegalArgumentException";
   3259         _exceptionMessage = "params == null";
   3260         goto exit;
   3261     }
   3262     if (offset < 0) {
   3263         _exception = 1;
   3264         _exceptionType = "java/lang/IllegalArgumentException";
   3265         _exceptionMessage = "offset < 0";
   3266         goto exit;
   3267     }
   3268     _remaining = _env->GetArrayLength(params_ref) - offset;
   3269     params_base = (GLfloat *)
   3270         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   3271     params = params_base + offset;
   3272 
   3273     glGetTexGenfvOES(
   3274         (GLenum)coord,
   3275         (GLenum)pname,
   3276         (GLfloat *)params
   3277     );
   3278 
   3279 exit:
   3280     if (params_base) {
   3281         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   3282             _exception ? JNI_ABORT: 0);
   3283     }
   3284     if (_exception) {
   3285         jniThrowException(_env, _exceptionType, _exceptionMessage);
   3286     }
   3287 }
   3288 
   3289 /* void glGetTexGenfvOES ( GLenum coord, GLenum pname, GLfloat *params ) */
   3290 static void
   3291 android_glGetTexGenfvOES__IILjava_nio_FloatBuffer_2
   3292   (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
   3293     jarray _array = (jarray) 0;
   3294     jint _bufferOffset = (jint) 0;
   3295     jint _remaining;
   3296     GLfloat *params = (GLfloat *) 0;
   3297 
   3298     params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   3299     if (params == NULL) {
   3300         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   3301         params = (GLfloat *) (_paramsBase + _bufferOffset);
   3302     }
   3303     glGetTexGenfvOES(
   3304         (GLenum)coord,
   3305         (GLenum)pname,
   3306         (GLfloat *)params
   3307     );
   3308     if (_array) {
   3309         releasePointer(_env, _array, params, JNI_TRUE);
   3310     }
   3311 }
   3312 
   3313 /* void glGetTexGenivOES ( GLenum coord, GLenum pname, GLint *params ) */
   3314 static void
   3315 android_glGetTexGenivOES__II_3II
   3316   (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
   3317     jint _exception = 0;
   3318     const char * _exceptionType = NULL;
   3319     const char * _exceptionMessage = NULL;
   3320     GLint *params_base = (GLint *) 0;
   3321     jint _remaining;
   3322     GLint *params = (GLint *) 0;
   3323 
   3324     if (!params_ref) {
   3325         _exception = 1;
   3326         _exceptionType = "java/lang/IllegalArgumentException";
   3327         _exceptionMessage = "params == null";
   3328         goto exit;
   3329     }
   3330     if (offset < 0) {
   3331         _exception = 1;
   3332         _exceptionType = "java/lang/IllegalArgumentException";
   3333         _exceptionMessage = "offset < 0";
   3334         goto exit;
   3335     }
   3336     _remaining = _env->GetArrayLength(params_ref) - offset;
   3337     params_base = (GLint *)
   3338         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   3339     params = params_base + offset;
   3340 
   3341     glGetTexGenivOES(
   3342         (GLenum)coord,
   3343         (GLenum)pname,
   3344         (GLint *)params
   3345     );
   3346 
   3347 exit:
   3348     if (params_base) {
   3349         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   3350             _exception ? JNI_ABORT: 0);
   3351     }
   3352     if (_exception) {
   3353         jniThrowException(_env, _exceptionType, _exceptionMessage);
   3354     }
   3355 }
   3356 
   3357 /* void glGetTexGenivOES ( GLenum coord, GLenum pname, GLint *params ) */
   3358 static void
   3359 android_glGetTexGenivOES__IILjava_nio_IntBuffer_2
   3360   (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
   3361     jarray _array = (jarray) 0;
   3362     jint _bufferOffset = (jint) 0;
   3363     jint _remaining;
   3364     GLint *params = (GLint *) 0;
   3365 
   3366     params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   3367     if (params == NULL) {
   3368         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   3369         params = (GLint *) (_paramsBase + _bufferOffset);
   3370     }
   3371     glGetTexGenivOES(
   3372         (GLenum)coord,
   3373         (GLenum)pname,
   3374         (GLint *)params
   3375     );
   3376     if (_array) {
   3377         releasePointer(_env, _array, params, JNI_TRUE);
   3378     }
   3379 }
   3380 
   3381 /* void glGetTexGenxvOES ( GLenum coord, GLenum pname, GLfixed *params ) */
   3382 static void
   3383 android_glGetTexGenxvOES__II_3II
   3384   (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
   3385     jint _exception = 0;
   3386     const char * _exceptionType = NULL;
   3387     const char * _exceptionMessage = NULL;
   3388     GLfixed *params_base = (GLfixed *) 0;
   3389     jint _remaining;
   3390     GLfixed *params = (GLfixed *) 0;
   3391 
   3392     if (!params_ref) {
   3393         _exception = 1;
   3394         _exceptionType = "java/lang/IllegalArgumentException";
   3395         _exceptionMessage = "params == null";
   3396         goto exit;
   3397     }
   3398     if (offset < 0) {
   3399         _exception = 1;
   3400         _exceptionType = "java/lang/IllegalArgumentException";
   3401         _exceptionMessage = "offset < 0";
   3402         goto exit;
   3403     }
   3404     _remaining = _env->GetArrayLength(params_ref) - offset;
   3405     params_base = (GLfixed *)
   3406         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
   3407     params = params_base + offset;
   3408 
   3409     glGetTexGenxvOES(
   3410         (GLenum)coord,
   3411         (GLenum)pname,
   3412         (GLfixed *)params
   3413     );
   3414 
   3415 exit:
   3416     if (params_base) {
   3417         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
   3418             _exception ? JNI_ABORT: 0);
   3419     }
   3420     if (_exception) {
   3421         jniThrowException(_env, _exceptionType, _exceptionMessage);
   3422     }
   3423 }
   3424 
   3425 /* void glGetTexGenxvOES ( GLenum coord, GLenum pname, GLfixed *params ) */
   3426 static void
   3427 android_glGetTexGenxvOES__IILjava_nio_IntBuffer_2
   3428   (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
   3429     jarray _array = (jarray) 0;
   3430     jint _bufferOffset = (jint) 0;
   3431     jint _remaining;
   3432     GLfixed *params = (GLfixed *) 0;
   3433 
   3434     params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
   3435     if (params == NULL) {
   3436         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
   3437         params = (GLfixed *) (_paramsBase + _bufferOffset);
   3438     }
   3439     glGetTexGenxvOES(
   3440         (GLenum)coord,
   3441         (GLenum)pname,
   3442         (GLfixed *)params
   3443     );
   3444     if (_array) {
   3445         releasePointer(_env, _array, params, JNI_TRUE);
   3446     }
   3447 }
   3448 
   3449 static const char *classPathName = "android/opengl/GLES11Ext";
   3450 
   3451 static JNINativeMethod methods[] = {
   3452 {"_nativeClassInit", "()V", (void*)nativeClassInit },
   3453 {"glBlendEquationSeparateOES", "(II)V", (void *) android_glBlendEquationSeparateOES__II },
   3454 {"glBlendFuncSeparateOES", "(IIII)V", (void *) android_glBlendFuncSeparateOES__IIII },
   3455 {"glBlendEquationOES", "(I)V", (void *) android_glBlendEquationOES__I },
   3456 {"glDrawTexsOES", "(SSSSS)V", (void *) android_glDrawTexsOES__SSSSS },
   3457 {"glDrawTexiOES", "(IIIII)V", (void *) android_glDrawTexiOES__IIIII },
   3458 {"glDrawTexxOES", "(IIIII)V", (void *) android_glDrawTexxOES__IIIII },
   3459 {"glDrawTexsvOES", "([SI)V", (void *) android_glDrawTexsvOES___3SI },
   3460 {"glDrawTexsvOES", "(Ljava/nio/ShortBuffer;)V", (void *) android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2 },
   3461 {"glDrawTexivOES", "([II)V", (void *) android_glDrawTexivOES___3II },
   3462 {"glDrawTexivOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexivOES__Ljava_nio_IntBuffer_2 },
   3463 {"glDrawTexxvOES", "([II)V", (void *) android_glDrawTexxvOES___3II },
   3464 {"glDrawTexxvOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexxvOES__Ljava_nio_IntBuffer_2 },
   3465 {"glDrawTexfOES", "(FFFFF)V", (void *) android_glDrawTexfOES__FFFFF },
   3466 {"glDrawTexfvOES", "([FI)V", (void *) android_glDrawTexfvOES___3FI },
   3467 {"glDrawTexfvOES", "(Ljava/nio/FloatBuffer;)V", (void *) android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2 },
   3468 {"glEGLImageTargetTexture2DOES", "(ILjava/nio/Buffer;)V", (void *) android_glEGLImageTargetTexture2DOES__ILjava_nio_Buffer_2 },
   3469 {"glEGLImageTargetRenderbufferStorageOES", "(ILjava/nio/Buffer;)V", (void *) android_glEGLImageTargetRenderbufferStorageOES__ILjava_nio_Buffer_2 },
   3470 {"glAlphaFuncxOES", "(II)V", (void *) android_glAlphaFuncxOES__II },
   3471 {"glClearColorxOES", "(IIII)V", (void *) android_glClearColorxOES__IIII },
   3472 {"glClearDepthxOES", "(I)V", (void *) android_glClearDepthxOES__I },
   3473 {"glClipPlanexOES", "(I[II)V", (void *) android_glClipPlanexOES__I_3II },
   3474 {"glClipPlanexOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glClipPlanexOES__ILjava_nio_IntBuffer_2 },
   3475 {"glColor4xOES", "(IIII)V", (void *) android_glColor4xOES__IIII },
   3476 {"glDepthRangexOES", "(II)V", (void *) android_glDepthRangexOES__II },
   3477 {"glFogxOES", "(II)V", (void *) android_glFogxOES__II },
   3478 {"glFogxvOES", "(I[II)V", (void *) android_glFogxvOES__I_3II },
   3479 {"glFogxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glFogxvOES__ILjava_nio_IntBuffer_2 },
   3480 {"glFrustumxOES", "(IIIIII)V", (void *) android_glFrustumxOES__IIIIII },
   3481 {"glGetClipPlanexOES", "(I[II)V", (void *) android_glGetClipPlanexOES__I_3II },
   3482 {"glGetClipPlanexOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetClipPlanexOES__ILjava_nio_IntBuffer_2 },
   3483 {"glGetFixedvOES", "(I[II)V", (void *) android_glGetFixedvOES__I_3II },
   3484 {"glGetFixedvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetFixedvOES__ILjava_nio_IntBuffer_2 },
   3485 {"glGetLightxvOES", "(II[II)V", (void *) android_glGetLightxvOES__II_3II },
   3486 {"glGetLightxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetLightxvOES__IILjava_nio_IntBuffer_2 },
   3487 {"glGetMaterialxvOES", "(II[II)V", (void *) android_glGetMaterialxvOES__II_3II },
   3488 {"glGetMaterialxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetMaterialxvOES__IILjava_nio_IntBuffer_2 },
   3489 {"glGetTexEnvxvOES", "(II[II)V", (void *) android_glGetTexEnvxvOES__II_3II },
   3490 {"glGetTexEnvxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexEnvxvOES__IILjava_nio_IntBuffer_2 },
   3491 {"glGetTexParameterxvOES", "(II[II)V", (void *) android_glGetTexParameterxvOES__II_3II },
   3492 {"glGetTexParameterxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameterxvOES__IILjava_nio_IntBuffer_2 },
   3493 {"glLightModelxOES", "(II)V", (void *) android_glLightModelxOES__II },
   3494 {"glLightModelxvOES", "(I[II)V", (void *) android_glLightModelxvOES__I_3II },
   3495 {"glLightModelxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glLightModelxvOES__ILjava_nio_IntBuffer_2 },
   3496 {"glLightxOES", "(III)V", (void *) android_glLightxOES__III },
   3497 {"glLightxvOES", "(II[II)V", (void *) android_glLightxvOES__II_3II },
   3498 {"glLightxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glLightxvOES__IILjava_nio_IntBuffer_2 },
   3499 {"glLineWidthxOES", "(I)V", (void *) android_glLineWidthxOES__I },
   3500 {"glLoadMatrixxOES", "([II)V", (void *) android_glLoadMatrixxOES___3II },
   3501 {"glLoadMatrixxOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glLoadMatrixxOES__Ljava_nio_IntBuffer_2 },
   3502 {"glMaterialxOES", "(III)V", (void *) android_glMaterialxOES__III },
   3503 {"glMaterialxvOES", "(II[II)V", (void *) android_glMaterialxvOES__II_3II },
   3504 {"glMaterialxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glMaterialxvOES__IILjava_nio_IntBuffer_2 },
   3505 {"glMultMatrixxOES", "([II)V", (void *) android_glMultMatrixxOES___3II },
   3506 {"glMultMatrixxOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glMultMatrixxOES__Ljava_nio_IntBuffer_2 },
   3507 {"glMultiTexCoord4xOES", "(IIIII)V", (void *) android_glMultiTexCoord4xOES__IIIII },
   3508 {"glNormal3xOES", "(III)V", (void *) android_glNormal3xOES__III },
   3509 {"glOrthoxOES", "(IIIIII)V", (void *) android_glOrthoxOES__IIIIII },
   3510 {"glPointParameterxOES", "(II)V", (void *) android_glPointParameterxOES__II },
   3511 {"glPointParameterxvOES", "(I[II)V", (void *) android_glPointParameterxvOES__I_3II },
   3512 {"glPointParameterxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glPointParameterxvOES__ILjava_nio_IntBuffer_2 },
   3513 {"glPointSizexOES", "(I)V", (void *) android_glPointSizexOES__I },
   3514 {"glPolygonOffsetxOES", "(II)V", (void *) android_glPolygonOffsetxOES__II },
   3515 {"glRotatexOES", "(IIII)V", (void *) android_glRotatexOES__IIII },
   3516 {"glSampleCoveragexOES", "(IZ)V", (void *) android_glSampleCoveragexOES__IZ },
   3517 {"glScalexOES", "(III)V", (void *) android_glScalexOES__III },
   3518 {"glTexEnvxOES", "(III)V", (void *) android_glTexEnvxOES__III },
   3519 {"glTexEnvxvOES", "(II[II)V", (void *) android_glTexEnvxvOES__II_3II },
   3520 {"glTexEnvxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexEnvxvOES__IILjava_nio_IntBuffer_2 },
   3521 {"glTexParameterxOES", "(III)V", (void *) android_glTexParameterxOES__III },
   3522 {"glTexParameterxvOES", "(II[II)V", (void *) android_glTexParameterxvOES__II_3II },
   3523 {"glTexParameterxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameterxvOES__IILjava_nio_IntBuffer_2 },
   3524 {"glTranslatexOES", "(III)V", (void *) android_glTranslatexOES__III },
   3525 {"glIsRenderbufferOES", "(I)Z", (void *) android_glIsRenderbufferOES__I },
   3526 {"glBindRenderbufferOES", "(II)V", (void *) android_glBindRenderbufferOES__II },
   3527 {"glDeleteRenderbuffersOES", "(I[II)V", (void *) android_glDeleteRenderbuffersOES__I_3II },
   3528 {"glDeleteRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2 },
   3529 {"glGenRenderbuffersOES", "(I[II)V", (void *) android_glGenRenderbuffersOES__I_3II },
   3530 {"glGenRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2 },
   3531 {"glRenderbufferStorageOES", "(IIII)V", (void *) android_glRenderbufferStorageOES__IIII },
   3532 {"glGetRenderbufferParameterivOES", "(II[II)V", (void *) android_glGetRenderbufferParameterivOES__II_3II },
   3533 {"glGetRenderbufferParameterivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2 },
   3534 {"glIsFramebufferOES", "(I)Z", (void *) android_glIsFramebufferOES__I },
   3535 {"glBindFramebufferOES", "(II)V", (void *) android_glBindFramebufferOES__II },
   3536 {"glDeleteFramebuffersOES", "(I[II)V", (void *) android_glDeleteFramebuffersOES__I_3II },
   3537 {"glDeleteFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2 },
   3538 {"glGenFramebuffersOES", "(I[II)V", (void *) android_glGenFramebuffersOES__I_3II },
   3539 {"glGenFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2 },
   3540 {"glCheckFramebufferStatusOES", "(I)I", (void *) android_glCheckFramebufferStatusOES__I },
   3541 {"glFramebufferRenderbufferOES", "(IIII)V", (void *) android_glFramebufferRenderbufferOES__IIII },
   3542 {"glFramebufferTexture2DOES", "(IIIII)V", (void *) android_glFramebufferTexture2DOES__IIIII },
   3543 {"glGetFramebufferAttachmentParameterivOES", "(III[II)V", (void *) android_glGetFramebufferAttachmentParameterivOES__III_3II },
   3544 {"glGetFramebufferAttachmentParameterivOES", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2 },
   3545 {"glGenerateMipmapOES", "(I)V", (void *) android_glGenerateMipmapOES__I },
   3546 {"glCurrentPaletteMatrixOES", "(I)V", (void *) android_glCurrentPaletteMatrixOES__I },
   3547 {"glLoadPaletteFromModelViewMatrixOES", "()V", (void *) android_glLoadPaletteFromModelViewMatrixOES__ },
   3548 {"glMatrixIndexPointerOESBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I },
   3549 {"glWeightPointerOESBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I },
   3550 {"glDepthRangefOES", "(FF)V", (void *) android_glDepthRangefOES__FF },
   3551 {"glFrustumfOES", "(FFFFFF)V", (void *) android_glFrustumfOES__FFFFFF },
   3552 {"glOrthofOES", "(FFFFFF)V", (void *) android_glOrthofOES__FFFFFF },
   3553 {"glClipPlanefOES", "(I[FI)V", (void *) android_glClipPlanefOES__I_3FI },
   3554 {"glClipPlanefOES", "(ILjava/nio/FloatBuffer;)V", (void *) android_glClipPlanefOES__ILjava_nio_FloatBuffer_2 },
   3555 {"glGetClipPlanefOES", "(I[FI)V", (void *) android_glGetClipPlanefOES__I_3FI },
   3556 {"glGetClipPlanefOES", "(ILjava/nio/FloatBuffer;)V", (void *) android_glGetClipPlanefOES__ILjava_nio_FloatBuffer_2 },
   3557 {"glClearDepthfOES", "(F)V", (void *) android_glClearDepthfOES__F },
   3558 {"glTexGenfOES", "(IIF)V", (void *) android_glTexGenfOES__IIF },
   3559 {"glTexGenfvOES", "(II[FI)V", (void *) android_glTexGenfvOES__II_3FI },
   3560 {"glTexGenfvOES", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexGenfvOES__IILjava_nio_FloatBuffer_2 },
   3561 {"glTexGeniOES", "(III)V", (void *) android_glTexGeniOES__III },
   3562 {"glTexGenivOES", "(II[II)V", (void *) android_glTexGenivOES__II_3II },
   3563 {"glTexGenivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGenivOES__IILjava_nio_IntBuffer_2 },
   3564 {"glTexGenxOES", "(III)V", (void *) android_glTexGenxOES__III },
   3565 {"glTexGenxvOES", "(II[II)V", (void *) android_glTexGenxvOES__II_3II },
   3566 {"glTexGenxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGenxvOES__IILjava_nio_IntBuffer_2 },
   3567 {"glGetTexGenfvOES", "(II[FI)V", (void *) android_glGetTexGenfvOES__II_3FI },
   3568 {"glGetTexGenfvOES", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetTexGenfvOES__IILjava_nio_FloatBuffer_2 },
   3569 {"glGetTexGenivOES", "(II[II)V", (void *) android_glGetTexGenivOES__II_3II },
   3570 {"glGetTexGenivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGenivOES__IILjava_nio_IntBuffer_2 },
   3571 {"glGetTexGenxvOES", "(II[II)V", (void *) android_glGetTexGenxvOES__II_3II },
   3572 {"glGetTexGenxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGenxvOES__IILjava_nio_IntBuffer_2 },
   3573 };
   3574 
   3575 int register_android_opengl_jni_GLES11Ext(JNIEnv *_env)
   3576 {
   3577     int err;
   3578     err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));
   3579     return err;
   3580 }
   3581