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