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