1/*
2**
3** Copyright 2009, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18// This source file is automatically generated
19
20#include <android_runtime/AndroidRuntime.h>
21#include <utils/misc.h>
22
23#include <assert.h>
24#include <GLES/gl.h>
25#include <GLES/glext.h>
26
27/* special calls implemented in Android's GLES wrapper used to more
28 * efficiently bound-check passed arrays */
29extern "C" {
30GL_API void GL_APIENTRY glMatrixIndexPointerOESBounds(GLint size, GLenum type, GLsizei stride,
31        const GLvoid *ptr, GLsizei count);
32GL_API void GL_APIENTRY glWeightPointerOESBounds(GLint size, GLenum type, GLsizei stride,
33        const GLvoid *ptr, GLsizei count);
34}
35
36static int initialized = 0;
37
38static jclass nioAccessClass;
39static jclass bufferClass;
40static jclass OOMEClass;
41static jclass UOEClass;
42static jclass IAEClass;
43static jclass AIOOBEClass;
44static jmethodID getBasePointerID;
45static jmethodID getBaseArrayID;
46static jmethodID getBaseArrayOffsetID;
47static jfieldID positionID;
48static jfieldID limitID;
49static jfieldID elementSizeShiftID;
50
51/* Cache method IDs each time the class is loaded. */
52
53static void
54nativeClassInitBuffer(JNIEnv *_env)
55{
56    jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess");
57    nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal);
58
59    jclass bufferClassLocal = _env->FindClass("java/nio/Buffer");
60    bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal);
61
62    getBasePointerID = _env->GetStaticMethodID(nioAccessClass,
63            "getBasePointer", "(Ljava/nio/Buffer;)J");
64    getBaseArrayID = _env->GetStaticMethodID(nioAccessClass,
65            "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;");
66    getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass,
67            "getBaseArrayOffset", "(Ljava/nio/Buffer;)I");
68
69    positionID = _env->GetFieldID(bufferClass, "position", "I");
70    limitID = _env->GetFieldID(bufferClass, "limit", "I");
71    elementSizeShiftID =
72        _env->GetFieldID(bufferClass, "_elementSizeShift", "I");
73}
74
75
76static void
77nativeClassInit(JNIEnv *_env, jclass glImplClass)
78{
79    nativeClassInitBuffer(_env);
80
81    jclass IAEClassLocal =
82        _env->FindClass("java/lang/IllegalArgumentException");
83    jclass OOMEClassLocal =
84         _env->FindClass("java/lang/OutOfMemoryError");
85    jclass UOEClassLocal =
86         _env->FindClass("java/lang/UnsupportedOperationException");
87    jclass AIOOBEClassLocal =
88         _env->FindClass("java/lang/ArrayIndexOutOfBoundsException");
89
90    IAEClass = (jclass) _env->NewGlobalRef(IAEClassLocal);
91    OOMEClass = (jclass) _env->NewGlobalRef(OOMEClassLocal);
92    UOEClass = (jclass) _env->NewGlobalRef(UOEClassLocal);
93    AIOOBEClass = (jclass) _env->NewGlobalRef(AIOOBEClassLocal);
94}
95
96static void *
97getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining)
98{
99    jint position;
100    jint limit;
101    jint elementSizeShift;
102    jlong pointer;
103    jint offset;
104    void *data;
105
106    position = _env->GetIntField(buffer, positionID);
107    limit = _env->GetIntField(buffer, limitID);
108    elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
109    *remaining = (limit - position) << elementSizeShift;
110    pointer = _env->CallStaticLongMethod(nioAccessClass,
111            getBasePointerID, buffer);
112    if (pointer != 0L) {
113        *array = NULL;
114        return (void *) (jint) pointer;
115    }
116
117    *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass,
118            getBaseArrayID, buffer);
119    offset = _env->CallStaticIntMethod(nioAccessClass,
120            getBaseArrayOffsetID, buffer);
121    data = _env->GetPrimitiveArrayCritical(*array, (jboolean *) 0);
122
123    return (void *) ((char *) data + offset);
124}
125
126
127static void
128releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit)
129{
130    _env->ReleasePrimitiveArrayCritical(array, data,
131					   commit ? 0 : JNI_ABORT);
132}
133
134static void *
135getDirectBufferPointer(JNIEnv *_env, jobject buffer) {
136    char* buf = (char*) _env->GetDirectBufferAddress(buffer);
137    if (buf) {
138        jint position = _env->GetIntField(buffer, positionID);
139        jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
140        buf += position << elementSizeShift;
141    } else {
142        _env->ThrowNew(IAEClass, "Must use a native order direct Buffer");
143    }
144    return (void*) buf;
145}
146// --------------------------------------------------------------------------
147
148/* void glBlendEquationSeparateOES ( GLenum modeRGB, GLenum modeAlpha ) */
149static void
150android_glBlendEquationSeparateOES__II
151  (JNIEnv *_env, jobject _this, jint modeRGB, jint modeAlpha) {
152    glBlendEquationSeparateOES(
153        (GLenum)modeRGB,
154        (GLenum)modeAlpha
155    );
156}
157
158/* void glBlendFuncSeparateOES ( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) */
159static void
160android_glBlendFuncSeparateOES__IIII
161  (JNIEnv *_env, jobject _this, jint srcRGB, jint dstRGB, jint srcAlpha, jint dstAlpha) {
162    glBlendFuncSeparateOES(
163        (GLenum)srcRGB,
164        (GLenum)dstRGB,
165        (GLenum)srcAlpha,
166        (GLenum)dstAlpha
167    );
168}
169
170/* void glBlendEquationOES ( GLenum mode ) */
171static void
172android_glBlendEquationOES__I
173  (JNIEnv *_env, jobject _this, jint mode) {
174    glBlendEquationOES(
175        (GLenum)mode
176    );
177}
178
179/* void glDrawTexsOES ( GLshort x, GLshort y, GLshort z, GLshort width, GLshort height ) */
180static void
181android_glDrawTexsOES__SSSSS
182  (JNIEnv *_env, jobject _this, jshort x, jshort y, jshort z, jshort width, jshort height) {
183    glDrawTexsOES(
184        (GLshort)x,
185        (GLshort)y,
186        (GLshort)z,
187        (GLshort)width,
188        (GLshort)height
189    );
190}
191
192/* void glDrawTexiOES ( GLint x, GLint y, GLint z, GLint width, GLint height ) */
193static void
194android_glDrawTexiOES__IIIII
195  (JNIEnv *_env, jobject _this, jint x, jint y, jint z, jint width, jint height) {
196    glDrawTexiOES(
197        (GLint)x,
198        (GLint)y,
199        (GLint)z,
200        (GLint)width,
201        (GLint)height
202    );
203}
204
205/* void glDrawTexxOES ( GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height ) */
206static void
207android_glDrawTexxOES__IIIII
208  (JNIEnv *_env, jobject _this, jint x, jint y, jint z, jint width, jint height) {
209    glDrawTexxOES(
210        (GLfixed)x,
211        (GLfixed)y,
212        (GLfixed)z,
213        (GLfixed)width,
214        (GLfixed)height
215    );
216}
217
218/* void glDrawTexsvOES ( const GLshort *coords ) */
219static void
220android_glDrawTexsvOES___3SI
221  (JNIEnv *_env, jobject _this, jshortArray coords_ref, jint offset) {
222    GLshort *coords_base = (GLshort *) 0;
223    jint _remaining;
224    GLshort *coords = (GLshort *) 0;
225
226    if (!coords_ref) {
227        _env->ThrowNew(IAEClass, "coords == null");
228        goto exit;
229    }
230    if (offset < 0) {
231        _env->ThrowNew(IAEClass, "offset < 0");
232        goto exit;
233    }
234    _remaining = _env->GetArrayLength(coords_ref) - offset;
235    if (_remaining < 5) {
236        _env->ThrowNew(IAEClass, "length - offset < 5");
237        goto exit;
238    }
239    coords_base = (GLshort *)
240        _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0);
241    coords = coords_base + offset;
242
243    glDrawTexsvOES(
244        (GLshort *)coords
245    );
246
247exit:
248    if (coords_base) {
249        _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base,
250            JNI_ABORT);
251    }
252}
253
254/* void glDrawTexsvOES ( const GLshort *coords ) */
255static void
256android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2
257  (JNIEnv *_env, jobject _this, jobject coords_buf) {
258    jarray _array = (jarray) 0;
259    jint _remaining;
260    GLshort *coords = (GLshort *) 0;
261
262    coords = (GLshort *)getPointer(_env, coords_buf, &_array, &_remaining);
263    if (_remaining < 5) {
264        _env->ThrowNew(IAEClass, "remaining() < 5");
265        goto exit;
266    }
267    glDrawTexsvOES(
268        (GLshort *)coords
269    );
270
271exit:
272    if (_array) {
273        releasePointer(_env, _array, coords, JNI_FALSE);
274    }
275}
276
277/* void glDrawTexivOES ( const GLint *coords ) */
278static void
279android_glDrawTexivOES___3II
280  (JNIEnv *_env, jobject _this, jintArray coords_ref, jint offset) {
281    GLint *coords_base = (GLint *) 0;
282    jint _remaining;
283    GLint *coords = (GLint *) 0;
284
285    if (!coords_ref) {
286        _env->ThrowNew(IAEClass, "coords == null");
287        goto exit;
288    }
289    if (offset < 0) {
290        _env->ThrowNew(IAEClass, "offset < 0");
291        goto exit;
292    }
293    _remaining = _env->GetArrayLength(coords_ref) - offset;
294    if (_remaining < 5) {
295        _env->ThrowNew(IAEClass, "length - offset < 5");
296        goto exit;
297    }
298    coords_base = (GLint *)
299        _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0);
300    coords = coords_base + offset;
301
302    glDrawTexivOES(
303        (GLint *)coords
304    );
305
306exit:
307    if (coords_base) {
308        _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base,
309            JNI_ABORT);
310    }
311}
312
313/* void glDrawTexivOES ( const GLint *coords ) */
314static void
315android_glDrawTexivOES__Ljava_nio_IntBuffer_2
316  (JNIEnv *_env, jobject _this, jobject coords_buf) {
317    jarray _array = (jarray) 0;
318    jint _remaining;
319    GLint *coords = (GLint *) 0;
320
321    coords = (GLint *)getPointer(_env, coords_buf, &_array, &_remaining);
322    if (_remaining < 5) {
323        _env->ThrowNew(IAEClass, "remaining() < 5");
324        goto exit;
325    }
326    glDrawTexivOES(
327        (GLint *)coords
328    );
329
330exit:
331    if (_array) {
332        releasePointer(_env, _array, coords, JNI_FALSE);
333    }
334}
335
336/* void glDrawTexxvOES ( const GLfixed *coords ) */
337static void
338android_glDrawTexxvOES___3II
339  (JNIEnv *_env, jobject _this, jintArray coords_ref, jint offset) {
340    GLfixed *coords_base = (GLfixed *) 0;
341    jint _remaining;
342    GLfixed *coords = (GLfixed *) 0;
343
344    if (!coords_ref) {
345        _env->ThrowNew(IAEClass, "coords == null");
346        goto exit;
347    }
348    if (offset < 0) {
349        _env->ThrowNew(IAEClass, "offset < 0");
350        goto exit;
351    }
352    _remaining = _env->GetArrayLength(coords_ref) - offset;
353    if (_remaining < 5) {
354        _env->ThrowNew(IAEClass, "length - offset < 5");
355        goto exit;
356    }
357    coords_base = (GLfixed *)
358        _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0);
359    coords = coords_base + offset;
360
361    glDrawTexxvOES(
362        (GLfixed *)coords
363    );
364
365exit:
366    if (coords_base) {
367        _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base,
368            JNI_ABORT);
369    }
370}
371
372/* void glDrawTexxvOES ( const GLfixed *coords ) */
373static void
374android_glDrawTexxvOES__Ljava_nio_IntBuffer_2
375  (JNIEnv *_env, jobject _this, jobject coords_buf) {
376    jarray _array = (jarray) 0;
377    jint _remaining;
378    GLfixed *coords = (GLfixed *) 0;
379
380    coords = (GLfixed *)getPointer(_env, coords_buf, &_array, &_remaining);
381    if (_remaining < 5) {
382        _env->ThrowNew(IAEClass, "remaining() < 5");
383        goto exit;
384    }
385    glDrawTexxvOES(
386        (GLfixed *)coords
387    );
388
389exit:
390    if (_array) {
391        releasePointer(_env, _array, coords, JNI_FALSE);
392    }
393}
394
395/* void glDrawTexfOES ( GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height ) */
396static void
397android_glDrawTexfOES__FFFFF
398  (JNIEnv *_env, jobject _this, jfloat x, jfloat y, jfloat z, jfloat width, jfloat height) {
399    glDrawTexfOES(
400        (GLfloat)x,
401        (GLfloat)y,
402        (GLfloat)z,
403        (GLfloat)width,
404        (GLfloat)height
405    );
406}
407
408/* void glDrawTexfvOES ( const GLfloat *coords ) */
409static void
410android_glDrawTexfvOES___3FI
411  (JNIEnv *_env, jobject _this, jfloatArray coords_ref, jint offset) {
412    GLfloat *coords_base = (GLfloat *) 0;
413    jint _remaining;
414    GLfloat *coords = (GLfloat *) 0;
415
416    if (!coords_ref) {
417        _env->ThrowNew(IAEClass, "coords == null");
418        goto exit;
419    }
420    if (offset < 0) {
421        _env->ThrowNew(IAEClass, "offset < 0");
422        goto exit;
423    }
424    _remaining = _env->GetArrayLength(coords_ref) - offset;
425    if (_remaining < 5) {
426        _env->ThrowNew(IAEClass, "length - offset < 5");
427        goto exit;
428    }
429    coords_base = (GLfloat *)
430        _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0);
431    coords = coords_base + offset;
432
433    glDrawTexfvOES(
434        (GLfloat *)coords
435    );
436
437exit:
438    if (coords_base) {
439        _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base,
440            JNI_ABORT);
441    }
442}
443
444/* void glDrawTexfvOES ( const GLfloat *coords ) */
445static void
446android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2
447  (JNIEnv *_env, jobject _this, jobject coords_buf) {
448    jarray _array = (jarray) 0;
449    jint _remaining;
450    GLfloat *coords = (GLfloat *) 0;
451
452    coords = (GLfloat *)getPointer(_env, coords_buf, &_array, &_remaining);
453    if (_remaining < 5) {
454        _env->ThrowNew(IAEClass, "remaining() < 5");
455        goto exit;
456    }
457    glDrawTexfvOES(
458        (GLfloat *)coords
459    );
460
461exit:
462    if (_array) {
463        releasePointer(_env, _array, coords, JNI_FALSE);
464    }
465}
466
467/* void glEGLImageTargetTexture2DOES ( GLenum target, GLeglImageOES image ) */
468static void
469android_glEGLImageTargetTexture2DOES__ILjava_nio_Buffer_2
470  (JNIEnv *_env, jobject _this, jint target, jobject image_buf) {
471    jint _exception = 0;
472    jarray _array = (jarray) 0;
473    jint _remaining;
474    GLeglImageOES image = (GLeglImageOES) 0;
475
476    image = (GLeglImageOES)getPointer(_env, image_buf, &_array, &_remaining);
477    glEGLImageTargetTexture2DOES(
478        (GLenum)target,
479        (GLeglImageOES)image
480    );
481    if (_array) {
482        releasePointer(_env, _array, image, _exception ? JNI_FALSE : JNI_TRUE);
483    }
484}
485
486/* void glEGLImageTargetRenderbufferStorageOES ( GLenum target, GLeglImageOES image ) */
487static void
488android_glEGLImageTargetRenderbufferStorageOES__ILjava_nio_Buffer_2
489  (JNIEnv *_env, jobject _this, jint target, jobject image_buf) {
490    jint _exception = 0;
491    jarray _array = (jarray) 0;
492    jint _remaining;
493    GLeglImageOES image = (GLeglImageOES) 0;
494
495    image = (GLeglImageOES)getPointer(_env, image_buf, &_array, &_remaining);
496    glEGLImageTargetRenderbufferStorageOES(
497        (GLenum)target,
498        (GLeglImageOES)image
499    );
500    if (_array) {
501        releasePointer(_env, _array, image, _exception ? JNI_FALSE : JNI_TRUE);
502    }
503}
504
505/* void glAlphaFuncxOES ( GLenum func, GLclampx ref ) */
506static void
507android_glAlphaFuncxOES__II
508  (JNIEnv *_env, jobject _this, jint func, jint ref) {
509    glAlphaFuncxOES(
510        (GLenum)func,
511        (GLclampx)ref
512    );
513}
514
515/* void glClearColorxOES ( GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha ) */
516static void
517android_glClearColorxOES__IIII
518  (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) {
519    glClearColorxOES(
520        (GLclampx)red,
521        (GLclampx)green,
522        (GLclampx)blue,
523        (GLclampx)alpha
524    );
525}
526
527/* void glClearDepthxOES ( GLclampx depth ) */
528static void
529android_glClearDepthxOES__I
530  (JNIEnv *_env, jobject _this, jint depth) {
531    glClearDepthxOES(
532        (GLclampx)depth
533    );
534}
535
536/* void glClipPlanexOES ( GLenum plane, const GLfixed *equation ) */
537static void
538android_glClipPlanexOES__I_3II
539  (JNIEnv *_env, jobject _this, jint plane, jintArray equation_ref, jint offset) {
540    GLfixed *equation_base = (GLfixed *) 0;
541    jint _remaining;
542    GLfixed *equation = (GLfixed *) 0;
543
544    if (!equation_ref) {
545        _env->ThrowNew(IAEClass, "equation == null");
546        goto exit;
547    }
548    if (offset < 0) {
549        _env->ThrowNew(IAEClass, "offset < 0");
550        goto exit;
551    }
552    _remaining = _env->GetArrayLength(equation_ref) - offset;
553    equation_base = (GLfixed *)
554        _env->GetPrimitiveArrayCritical(equation_ref, (jboolean *)0);
555    equation = equation_base + offset;
556
557    glClipPlanexOES(
558        (GLenum)plane,
559        (GLfixed *)equation
560    );
561
562exit:
563    if (equation_base) {
564        _env->ReleasePrimitiveArrayCritical(equation_ref, equation_base,
565            JNI_ABORT);
566    }
567}
568
569/* void glClipPlanexOES ( GLenum plane, const GLfixed *equation ) */
570static void
571android_glClipPlanexOES__ILjava_nio_IntBuffer_2
572  (JNIEnv *_env, jobject _this, jint plane, jobject equation_buf) {
573    jarray _array = (jarray) 0;
574    jint _remaining;
575    GLfixed *equation = (GLfixed *) 0;
576
577    equation = (GLfixed *)getPointer(_env, equation_buf, &_array, &_remaining);
578    glClipPlanexOES(
579        (GLenum)plane,
580        (GLfixed *)equation
581    );
582    if (_array) {
583        releasePointer(_env, _array, equation, JNI_FALSE);
584    }
585}
586
587/* void glColor4xOES ( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) */
588static void
589android_glColor4xOES__IIII
590  (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) {
591    glColor4xOES(
592        (GLfixed)red,
593        (GLfixed)green,
594        (GLfixed)blue,
595        (GLfixed)alpha
596    );
597}
598
599/* void glDepthRangexOES ( GLclampx zNear, GLclampx zFar ) */
600static void
601android_glDepthRangexOES__II
602  (JNIEnv *_env, jobject _this, jint zNear, jint zFar) {
603    glDepthRangexOES(
604        (GLclampx)zNear,
605        (GLclampx)zFar
606    );
607}
608
609/* void glFogxOES ( GLenum pname, GLfixed param ) */
610static void
611android_glFogxOES__II
612  (JNIEnv *_env, jobject _this, jint pname, jint param) {
613    glFogxOES(
614        (GLenum)pname,
615        (GLfixed)param
616    );
617}
618
619/* void glFogxvOES ( GLenum pname, const GLfixed *params ) */
620static void
621android_glFogxvOES__I_3II
622  (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
623    GLfixed *params_base = (GLfixed *) 0;
624    jint _remaining;
625    GLfixed *params = (GLfixed *) 0;
626
627    if (!params_ref) {
628        _env->ThrowNew(IAEClass, "params == null");
629        goto exit;
630    }
631    if (offset < 0) {
632        _env->ThrowNew(IAEClass, "offset < 0");
633        goto exit;
634    }
635    _remaining = _env->GetArrayLength(params_ref) - offset;
636    params_base = (GLfixed *)
637        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
638    params = params_base + offset;
639
640    glFogxvOES(
641        (GLenum)pname,
642        (GLfixed *)params
643    );
644
645exit:
646    if (params_base) {
647        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
648            JNI_ABORT);
649    }
650}
651
652/* void glFogxvOES ( GLenum pname, const GLfixed *params ) */
653static void
654android_glFogxvOES__ILjava_nio_IntBuffer_2
655  (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
656    jarray _array = (jarray) 0;
657    jint _remaining;
658    GLfixed *params = (GLfixed *) 0;
659
660    params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
661    glFogxvOES(
662        (GLenum)pname,
663        (GLfixed *)params
664    );
665    if (_array) {
666        releasePointer(_env, _array, params, JNI_FALSE);
667    }
668}
669
670/* void glFrustumxOES ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */
671static void
672android_glFrustumxOES__IIIIII
673  (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) {
674    glFrustumxOES(
675        (GLfixed)left,
676        (GLfixed)right,
677        (GLfixed)bottom,
678        (GLfixed)top,
679        (GLfixed)zNear,
680        (GLfixed)zFar
681    );
682}
683
684/* void glGetClipPlanexOES ( GLenum pname, GLfixed *eqn ) */
685static void
686android_glGetClipPlanexOES__I_3II
687  (JNIEnv *_env, jobject _this, jint pname, jintArray eqn_ref, jint offset) {
688    jint _exception = 0;
689    GLfixed *eqn_base = (GLfixed *) 0;
690    jint _remaining;
691    GLfixed *eqn = (GLfixed *) 0;
692
693    if (!eqn_ref) {
694        _exception = 1;
695        _env->ThrowNew(IAEClass, "eqn == null");
696        goto exit;
697    }
698    if (offset < 0) {
699        _exception = 1;
700        _env->ThrowNew(IAEClass, "offset < 0");
701        goto exit;
702    }
703    _remaining = _env->GetArrayLength(eqn_ref) - offset;
704    if (_remaining < 4) {
705        _exception = 1;
706        _env->ThrowNew(IAEClass, "length - offset < 4");
707        goto exit;
708    }
709    eqn_base = (GLfixed *)
710        _env->GetPrimitiveArrayCritical(eqn_ref, (jboolean *)0);
711    eqn = eqn_base + offset;
712
713    glGetClipPlanexOES(
714        (GLenum)pname,
715        (GLfixed *)eqn
716    );
717
718exit:
719    if (eqn_base) {
720        _env->ReleasePrimitiveArrayCritical(eqn_ref, eqn_base,
721            _exception ? JNI_ABORT: 0);
722    }
723}
724
725/* void glGetClipPlanexOES ( GLenum pname, GLfixed *eqn ) */
726static void
727android_glGetClipPlanexOES__ILjava_nio_IntBuffer_2
728  (JNIEnv *_env, jobject _this, jint pname, jobject eqn_buf) {
729    jint _exception = 0;
730    jarray _array = (jarray) 0;
731    jint _remaining;
732    GLfixed *eqn = (GLfixed *) 0;
733
734    eqn = (GLfixed *)getPointer(_env, eqn_buf, &_array, &_remaining);
735    if (_remaining < 4) {
736        _exception = 1;
737        _env->ThrowNew(IAEClass, "remaining() < 4");
738        goto exit;
739    }
740    glGetClipPlanexOES(
741        (GLenum)pname,
742        (GLfixed *)eqn
743    );
744
745exit:
746    if (_array) {
747        releasePointer(_env, _array, eqn, _exception ? JNI_FALSE : JNI_TRUE);
748    }
749}
750
751/* void glGetFixedvOES ( GLenum pname, GLfixed *params ) */
752static void
753android_glGetFixedvOES__I_3II
754  (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
755    jint _exception = 0;
756    GLfixed *params_base = (GLfixed *) 0;
757    jint _remaining;
758    GLfixed *params = (GLfixed *) 0;
759
760    if (!params_ref) {
761        _exception = 1;
762        _env->ThrowNew(IAEClass, "params == null");
763        goto exit;
764    }
765    if (offset < 0) {
766        _exception = 1;
767        _env->ThrowNew(IAEClass, "offset < 0");
768        goto exit;
769    }
770    _remaining = _env->GetArrayLength(params_ref) - offset;
771    params_base = (GLfixed *)
772        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
773    params = params_base + offset;
774
775    glGetFixedvOES(
776        (GLenum)pname,
777        (GLfixed *)params
778    );
779
780exit:
781    if (params_base) {
782        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
783            _exception ? JNI_ABORT: 0);
784    }
785}
786
787/* void glGetFixedvOES ( GLenum pname, GLfixed *params ) */
788static void
789android_glGetFixedvOES__ILjava_nio_IntBuffer_2
790  (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
791    jint _exception = 0;
792    jarray _array = (jarray) 0;
793    jint _remaining;
794    GLfixed *params = (GLfixed *) 0;
795
796    params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
797    glGetFixedvOES(
798        (GLenum)pname,
799        (GLfixed *)params
800    );
801    if (_array) {
802        releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
803    }
804}
805
806/* void glGetLightxvOES ( GLenum light, GLenum pname, GLfixed *params ) */
807static void
808android_glGetLightxvOES__II_3II
809  (JNIEnv *_env, jobject _this, jint light, jint pname, jintArray params_ref, jint offset) {
810    jint _exception = 0;
811    GLfixed *params_base = (GLfixed *) 0;
812    jint _remaining;
813    GLfixed *params = (GLfixed *) 0;
814
815    if (!params_ref) {
816        _exception = 1;
817        _env->ThrowNew(IAEClass, "params == null");
818        goto exit;
819    }
820    if (offset < 0) {
821        _exception = 1;
822        _env->ThrowNew(IAEClass, "offset < 0");
823        goto exit;
824    }
825    _remaining = _env->GetArrayLength(params_ref) - offset;
826    params_base = (GLfixed *)
827        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
828    params = params_base + offset;
829
830    glGetLightxvOES(
831        (GLenum)light,
832        (GLenum)pname,
833        (GLfixed *)params
834    );
835
836exit:
837    if (params_base) {
838        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
839            _exception ? JNI_ABORT: 0);
840    }
841}
842
843/* void glGetLightxvOES ( GLenum light, GLenum pname, GLfixed *params ) */
844static void
845android_glGetLightxvOES__IILjava_nio_IntBuffer_2
846  (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) {
847    jint _exception = 0;
848    jarray _array = (jarray) 0;
849    jint _remaining;
850    GLfixed *params = (GLfixed *) 0;
851
852    params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
853    glGetLightxvOES(
854        (GLenum)light,
855        (GLenum)pname,
856        (GLfixed *)params
857    );
858    if (_array) {
859        releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
860    }
861}
862
863/* void glGetMaterialxvOES ( GLenum face, GLenum pname, GLfixed *params ) */
864static void
865android_glGetMaterialxvOES__II_3II
866  (JNIEnv *_env, jobject _this, jint face, jint pname, jintArray params_ref, jint offset) {
867    jint _exception = 0;
868    GLfixed *params_base = (GLfixed *) 0;
869    jint _remaining;
870    GLfixed *params = (GLfixed *) 0;
871
872    if (!params_ref) {
873        _exception = 1;
874        _env->ThrowNew(IAEClass, "params == null");
875        goto exit;
876    }
877    if (offset < 0) {
878        _exception = 1;
879        _env->ThrowNew(IAEClass, "offset < 0");
880        goto exit;
881    }
882    _remaining = _env->GetArrayLength(params_ref) - offset;
883    params_base = (GLfixed *)
884        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
885    params = params_base + offset;
886
887    glGetMaterialxvOES(
888        (GLenum)face,
889        (GLenum)pname,
890        (GLfixed *)params
891    );
892
893exit:
894    if (params_base) {
895        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
896            _exception ? JNI_ABORT: 0);
897    }
898}
899
900/* void glGetMaterialxvOES ( GLenum face, GLenum pname, GLfixed *params ) */
901static void
902android_glGetMaterialxvOES__IILjava_nio_IntBuffer_2
903  (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) {
904    jint _exception = 0;
905    jarray _array = (jarray) 0;
906    jint _remaining;
907    GLfixed *params = (GLfixed *) 0;
908
909    params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
910    glGetMaterialxvOES(
911        (GLenum)face,
912        (GLenum)pname,
913        (GLfixed *)params
914    );
915    if (_array) {
916        releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
917    }
918}
919
920/* void glGetTexEnvxvOES ( GLenum env, GLenum pname, GLfixed *params ) */
921static void
922android_glGetTexEnvxvOES__II_3II
923  (JNIEnv *_env, jobject _this, jint env, jint pname, jintArray params_ref, jint offset) {
924    jint _exception = 0;
925    GLfixed *params_base = (GLfixed *) 0;
926    jint _remaining;
927    GLfixed *params = (GLfixed *) 0;
928
929    if (!params_ref) {
930        _exception = 1;
931        _env->ThrowNew(IAEClass, "params == null");
932        goto exit;
933    }
934    if (offset < 0) {
935        _exception = 1;
936        _env->ThrowNew(IAEClass, "offset < 0");
937        goto exit;
938    }
939    _remaining = _env->GetArrayLength(params_ref) - offset;
940    params_base = (GLfixed *)
941        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
942    params = params_base + offset;
943
944    glGetTexEnvxvOES(
945        (GLenum)env,
946        (GLenum)pname,
947        (GLfixed *)params
948    );
949
950exit:
951    if (params_base) {
952        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
953            _exception ? JNI_ABORT: 0);
954    }
955}
956
957/* void glGetTexEnvxvOES ( GLenum env, GLenum pname, GLfixed *params ) */
958static void
959android_glGetTexEnvxvOES__IILjava_nio_IntBuffer_2
960  (JNIEnv *_env, jobject _this, jint env, jint pname, jobject params_buf) {
961    jint _exception = 0;
962    jarray _array = (jarray) 0;
963    jint _remaining;
964    GLfixed *params = (GLfixed *) 0;
965
966    params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
967    glGetTexEnvxvOES(
968        (GLenum)env,
969        (GLenum)pname,
970        (GLfixed *)params
971    );
972    if (_array) {
973        releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
974    }
975}
976
977/* void glGetTexParameterxvOES ( GLenum target, GLenum pname, GLfixed *params ) */
978static void
979android_glGetTexParameterxvOES__II_3II
980  (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
981    jint _exception = 0;
982    GLfixed *params_base = (GLfixed *) 0;
983    jint _remaining;
984    GLfixed *params = (GLfixed *) 0;
985
986    if (!params_ref) {
987        _exception = 1;
988        _env->ThrowNew(IAEClass, "params == null");
989        goto exit;
990    }
991    if (offset < 0) {
992        _exception = 1;
993        _env->ThrowNew(IAEClass, "offset < 0");
994        goto exit;
995    }
996    _remaining = _env->GetArrayLength(params_ref) - offset;
997    params_base = (GLfixed *)
998        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
999    params = params_base + offset;
1000
1001    glGetTexParameterxvOES(
1002        (GLenum)target,
1003        (GLenum)pname,
1004        (GLfixed *)params
1005    );
1006
1007exit:
1008    if (params_base) {
1009        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1010            _exception ? JNI_ABORT: 0);
1011    }
1012}
1013
1014/* void glGetTexParameterxvOES ( GLenum target, GLenum pname, GLfixed *params ) */
1015static void
1016android_glGetTexParameterxvOES__IILjava_nio_IntBuffer_2
1017  (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
1018    jint _exception = 0;
1019    jarray _array = (jarray) 0;
1020    jint _remaining;
1021    GLfixed *params = (GLfixed *) 0;
1022
1023    params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
1024    glGetTexParameterxvOES(
1025        (GLenum)target,
1026        (GLenum)pname,
1027        (GLfixed *)params
1028    );
1029    if (_array) {
1030        releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
1031    }
1032}
1033
1034/* void glLightModelxOES ( GLenum pname, GLfixed param ) */
1035static void
1036android_glLightModelxOES__II
1037  (JNIEnv *_env, jobject _this, jint pname, jint param) {
1038    glLightModelxOES(
1039        (GLenum)pname,
1040        (GLfixed)param
1041    );
1042}
1043
1044/* void glLightModelxvOES ( GLenum pname, const GLfixed *params ) */
1045static void
1046android_glLightModelxvOES__I_3II
1047  (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
1048    GLfixed *params_base = (GLfixed *) 0;
1049    jint _remaining;
1050    GLfixed *params = (GLfixed *) 0;
1051
1052    if (!params_ref) {
1053        _env->ThrowNew(IAEClass, "params == null");
1054        goto exit;
1055    }
1056    if (offset < 0) {
1057        _env->ThrowNew(IAEClass, "offset < 0");
1058        goto exit;
1059    }
1060    _remaining = _env->GetArrayLength(params_ref) - offset;
1061    params_base = (GLfixed *)
1062        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1063    params = params_base + offset;
1064
1065    glLightModelxvOES(
1066        (GLenum)pname,
1067        (GLfixed *)params
1068    );
1069
1070exit:
1071    if (params_base) {
1072        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1073            JNI_ABORT);
1074    }
1075}
1076
1077/* void glLightModelxvOES ( GLenum pname, const GLfixed *params ) */
1078static void
1079android_glLightModelxvOES__ILjava_nio_IntBuffer_2
1080  (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
1081    jarray _array = (jarray) 0;
1082    jint _remaining;
1083    GLfixed *params = (GLfixed *) 0;
1084
1085    params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
1086    glLightModelxvOES(
1087        (GLenum)pname,
1088        (GLfixed *)params
1089    );
1090    if (_array) {
1091        releasePointer(_env, _array, params, JNI_FALSE);
1092    }
1093}
1094
1095/* void glLightxOES ( GLenum light, GLenum pname, GLfixed param ) */
1096static void
1097android_glLightxOES__III
1098  (JNIEnv *_env, jobject _this, jint light, jint pname, jint param) {
1099    glLightxOES(
1100        (GLenum)light,
1101        (GLenum)pname,
1102        (GLfixed)param
1103    );
1104}
1105
1106/* void glLightxvOES ( GLenum light, GLenum pname, const GLfixed *params ) */
1107static void
1108android_glLightxvOES__II_3II
1109  (JNIEnv *_env, jobject _this, jint light, jint pname, jintArray params_ref, jint offset) {
1110    GLfixed *params_base = (GLfixed *) 0;
1111    jint _remaining;
1112    GLfixed *params = (GLfixed *) 0;
1113
1114    if (!params_ref) {
1115        _env->ThrowNew(IAEClass, "params == null");
1116        goto exit;
1117    }
1118    if (offset < 0) {
1119        _env->ThrowNew(IAEClass, "offset < 0");
1120        goto exit;
1121    }
1122    _remaining = _env->GetArrayLength(params_ref) - offset;
1123    params_base = (GLfixed *)
1124        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1125    params = params_base + offset;
1126
1127    glLightxvOES(
1128        (GLenum)light,
1129        (GLenum)pname,
1130        (GLfixed *)params
1131    );
1132
1133exit:
1134    if (params_base) {
1135        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1136            JNI_ABORT);
1137    }
1138}
1139
1140/* void glLightxvOES ( GLenum light, GLenum pname, const GLfixed *params ) */
1141static void
1142android_glLightxvOES__IILjava_nio_IntBuffer_2
1143  (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) {
1144    jarray _array = (jarray) 0;
1145    jint _remaining;
1146    GLfixed *params = (GLfixed *) 0;
1147
1148    params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
1149    glLightxvOES(
1150        (GLenum)light,
1151        (GLenum)pname,
1152        (GLfixed *)params
1153    );
1154    if (_array) {
1155        releasePointer(_env, _array, params, JNI_FALSE);
1156    }
1157}
1158
1159/* void glLineWidthxOES ( GLfixed width ) */
1160static void
1161android_glLineWidthxOES__I
1162  (JNIEnv *_env, jobject _this, jint width) {
1163    glLineWidthxOES(
1164        (GLfixed)width
1165    );
1166}
1167
1168/* void glLoadMatrixxOES ( const GLfixed *m ) */
1169static void
1170android_glLoadMatrixxOES___3II
1171  (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) {
1172    GLfixed *m_base = (GLfixed *) 0;
1173    jint _remaining;
1174    GLfixed *m = (GLfixed *) 0;
1175
1176    if (!m_ref) {
1177        _env->ThrowNew(IAEClass, "m == null");
1178        goto exit;
1179    }
1180    if (offset < 0) {
1181        _env->ThrowNew(IAEClass, "offset < 0");
1182        goto exit;
1183    }
1184    _remaining = _env->GetArrayLength(m_ref) - offset;
1185    m_base = (GLfixed *)
1186        _env->GetPrimitiveArrayCritical(m_ref, (jboolean *)0);
1187    m = m_base + offset;
1188
1189    glLoadMatrixxOES(
1190        (GLfixed *)m
1191    );
1192
1193exit:
1194    if (m_base) {
1195        _env->ReleasePrimitiveArrayCritical(m_ref, m_base,
1196            JNI_ABORT);
1197    }
1198}
1199
1200/* void glLoadMatrixxOES ( const GLfixed *m ) */
1201static void
1202android_glLoadMatrixxOES__Ljava_nio_IntBuffer_2
1203  (JNIEnv *_env, jobject _this, jobject m_buf) {
1204    jarray _array = (jarray) 0;
1205    jint _remaining;
1206    GLfixed *m = (GLfixed *) 0;
1207
1208    m = (GLfixed *)getPointer(_env, m_buf, &_array, &_remaining);
1209    glLoadMatrixxOES(
1210        (GLfixed *)m
1211    );
1212    if (_array) {
1213        releasePointer(_env, _array, m, JNI_FALSE);
1214    }
1215}
1216
1217/* void glMaterialxOES ( GLenum face, GLenum pname, GLfixed param ) */
1218static void
1219android_glMaterialxOES__III
1220  (JNIEnv *_env, jobject _this, jint face, jint pname, jint param) {
1221    glMaterialxOES(
1222        (GLenum)face,
1223        (GLenum)pname,
1224        (GLfixed)param
1225    );
1226}
1227
1228/* void glMaterialxvOES ( GLenum face, GLenum pname, const GLfixed *params ) */
1229static void
1230android_glMaterialxvOES__II_3II
1231  (JNIEnv *_env, jobject _this, jint face, jint pname, jintArray params_ref, jint offset) {
1232    GLfixed *params_base = (GLfixed *) 0;
1233    jint _remaining;
1234    GLfixed *params = (GLfixed *) 0;
1235
1236    if (!params_ref) {
1237        _env->ThrowNew(IAEClass, "params == null");
1238        goto exit;
1239    }
1240    if (offset < 0) {
1241        _env->ThrowNew(IAEClass, "offset < 0");
1242        goto exit;
1243    }
1244    _remaining = _env->GetArrayLength(params_ref) - offset;
1245    params_base = (GLfixed *)
1246        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1247    params = params_base + offset;
1248
1249    glMaterialxvOES(
1250        (GLenum)face,
1251        (GLenum)pname,
1252        (GLfixed *)params
1253    );
1254
1255exit:
1256    if (params_base) {
1257        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1258            JNI_ABORT);
1259    }
1260}
1261
1262/* void glMaterialxvOES ( GLenum face, GLenum pname, const GLfixed *params ) */
1263static void
1264android_glMaterialxvOES__IILjava_nio_IntBuffer_2
1265  (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) {
1266    jarray _array = (jarray) 0;
1267    jint _remaining;
1268    GLfixed *params = (GLfixed *) 0;
1269
1270    params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
1271    glMaterialxvOES(
1272        (GLenum)face,
1273        (GLenum)pname,
1274        (GLfixed *)params
1275    );
1276    if (_array) {
1277        releasePointer(_env, _array, params, JNI_FALSE);
1278    }
1279}
1280
1281/* void glMultMatrixxOES ( const GLfixed *m ) */
1282static void
1283android_glMultMatrixxOES___3II
1284  (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) {
1285    GLfixed *m_base = (GLfixed *) 0;
1286    jint _remaining;
1287    GLfixed *m = (GLfixed *) 0;
1288
1289    if (!m_ref) {
1290        _env->ThrowNew(IAEClass, "m == null");
1291        goto exit;
1292    }
1293    if (offset < 0) {
1294        _env->ThrowNew(IAEClass, "offset < 0");
1295        goto exit;
1296    }
1297    _remaining = _env->GetArrayLength(m_ref) - offset;
1298    m_base = (GLfixed *)
1299        _env->GetPrimitiveArrayCritical(m_ref, (jboolean *)0);
1300    m = m_base + offset;
1301
1302    glMultMatrixxOES(
1303        (GLfixed *)m
1304    );
1305
1306exit:
1307    if (m_base) {
1308        _env->ReleasePrimitiveArrayCritical(m_ref, m_base,
1309            JNI_ABORT);
1310    }
1311}
1312
1313/* void glMultMatrixxOES ( const GLfixed *m ) */
1314static void
1315android_glMultMatrixxOES__Ljava_nio_IntBuffer_2
1316  (JNIEnv *_env, jobject _this, jobject m_buf) {
1317    jarray _array = (jarray) 0;
1318    jint _remaining;
1319    GLfixed *m = (GLfixed *) 0;
1320
1321    m = (GLfixed *)getPointer(_env, m_buf, &_array, &_remaining);
1322    glMultMatrixxOES(
1323        (GLfixed *)m
1324    );
1325    if (_array) {
1326        releasePointer(_env, _array, m, JNI_FALSE);
1327    }
1328}
1329
1330/* void glMultiTexCoord4xOES ( GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q ) */
1331static void
1332android_glMultiTexCoord4xOES__IIIII
1333  (JNIEnv *_env, jobject _this, jint target, jint s, jint t, jint r, jint q) {
1334    glMultiTexCoord4xOES(
1335        (GLenum)target,
1336        (GLfixed)s,
1337        (GLfixed)t,
1338        (GLfixed)r,
1339        (GLfixed)q
1340    );
1341}
1342
1343/* void glNormal3xOES ( GLfixed nx, GLfixed ny, GLfixed nz ) */
1344static void
1345android_glNormal3xOES__III
1346  (JNIEnv *_env, jobject _this, jint nx, jint ny, jint nz) {
1347    glNormal3xOES(
1348        (GLfixed)nx,
1349        (GLfixed)ny,
1350        (GLfixed)nz
1351    );
1352}
1353
1354/* void glOrthoxOES ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */
1355static void
1356android_glOrthoxOES__IIIIII
1357  (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) {
1358    glOrthoxOES(
1359        (GLfixed)left,
1360        (GLfixed)right,
1361        (GLfixed)bottom,
1362        (GLfixed)top,
1363        (GLfixed)zNear,
1364        (GLfixed)zFar
1365    );
1366}
1367
1368/* void glPointParameterxOES ( GLenum pname, GLfixed param ) */
1369static void
1370android_glPointParameterxOES__II
1371  (JNIEnv *_env, jobject _this, jint pname, jint param) {
1372    glPointParameterxOES(
1373        (GLenum)pname,
1374        (GLfixed)param
1375    );
1376}
1377
1378/* void glPointParameterxvOES ( GLenum pname, const GLfixed *params ) */
1379static void
1380android_glPointParameterxvOES__I_3II
1381  (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
1382    GLfixed *params_base = (GLfixed *) 0;
1383    jint _remaining;
1384    GLfixed *params = (GLfixed *) 0;
1385
1386    if (!params_ref) {
1387        _env->ThrowNew(IAEClass, "params == null");
1388        goto exit;
1389    }
1390    if (offset < 0) {
1391        _env->ThrowNew(IAEClass, "offset < 0");
1392        goto exit;
1393    }
1394    _remaining = _env->GetArrayLength(params_ref) - offset;
1395    params_base = (GLfixed *)
1396        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1397    params = params_base + offset;
1398
1399    glPointParameterxvOES(
1400        (GLenum)pname,
1401        (GLfixed *)params
1402    );
1403
1404exit:
1405    if (params_base) {
1406        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1407            JNI_ABORT);
1408    }
1409}
1410
1411/* void glPointParameterxvOES ( GLenum pname, const GLfixed *params ) */
1412static void
1413android_glPointParameterxvOES__ILjava_nio_IntBuffer_2
1414  (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
1415    jarray _array = (jarray) 0;
1416    jint _remaining;
1417    GLfixed *params = (GLfixed *) 0;
1418
1419    params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
1420    glPointParameterxvOES(
1421        (GLenum)pname,
1422        (GLfixed *)params
1423    );
1424    if (_array) {
1425        releasePointer(_env, _array, params, JNI_FALSE);
1426    }
1427}
1428
1429/* void glPointSizexOES ( GLfixed size ) */
1430static void
1431android_glPointSizexOES__I
1432  (JNIEnv *_env, jobject _this, jint size) {
1433    glPointSizexOES(
1434        (GLfixed)size
1435    );
1436}
1437
1438/* void glPolygonOffsetxOES ( GLfixed factor, GLfixed units ) */
1439static void
1440android_glPolygonOffsetxOES__II
1441  (JNIEnv *_env, jobject _this, jint factor, jint units) {
1442    glPolygonOffsetxOES(
1443        (GLfixed)factor,
1444        (GLfixed)units
1445    );
1446}
1447
1448/* void glRotatexOES ( GLfixed angle, GLfixed x, GLfixed y, GLfixed z ) */
1449static void
1450android_glRotatexOES__IIII
1451  (JNIEnv *_env, jobject _this, jint angle, jint x, jint y, jint z) {
1452    glRotatexOES(
1453        (GLfixed)angle,
1454        (GLfixed)x,
1455        (GLfixed)y,
1456        (GLfixed)z
1457    );
1458}
1459
1460/* void glSampleCoveragexOES ( GLclampx value, GLboolean invert ) */
1461static void
1462android_glSampleCoveragexOES__IZ
1463  (JNIEnv *_env, jobject _this, jint value, jboolean invert) {
1464    glSampleCoveragexOES(
1465        (GLclampx)value,
1466        (GLboolean)invert
1467    );
1468}
1469
1470/* void glScalexOES ( GLfixed x, GLfixed y, GLfixed z ) */
1471static void
1472android_glScalexOES__III
1473  (JNIEnv *_env, jobject _this, jint x, jint y, jint z) {
1474    glScalexOES(
1475        (GLfixed)x,
1476        (GLfixed)y,
1477        (GLfixed)z
1478    );
1479}
1480
1481/* void glTexEnvxOES ( GLenum target, GLenum pname, GLfixed param ) */
1482static void
1483android_glTexEnvxOES__III
1484  (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) {
1485    glTexEnvxOES(
1486        (GLenum)target,
1487        (GLenum)pname,
1488        (GLfixed)param
1489    );
1490}
1491
1492/* void glTexEnvxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */
1493static void
1494android_glTexEnvxvOES__II_3II
1495  (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
1496    GLfixed *params_base = (GLfixed *) 0;
1497    jint _remaining;
1498    GLfixed *params = (GLfixed *) 0;
1499
1500    if (!params_ref) {
1501        _env->ThrowNew(IAEClass, "params == null");
1502        goto exit;
1503    }
1504    if (offset < 0) {
1505        _env->ThrowNew(IAEClass, "offset < 0");
1506        goto exit;
1507    }
1508    _remaining = _env->GetArrayLength(params_ref) - offset;
1509    params_base = (GLfixed *)
1510        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1511    params = params_base + offset;
1512
1513    glTexEnvxvOES(
1514        (GLenum)target,
1515        (GLenum)pname,
1516        (GLfixed *)params
1517    );
1518
1519exit:
1520    if (params_base) {
1521        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1522            JNI_ABORT);
1523    }
1524}
1525
1526/* void glTexEnvxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */
1527static void
1528android_glTexEnvxvOES__IILjava_nio_IntBuffer_2
1529  (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
1530    jarray _array = (jarray) 0;
1531    jint _remaining;
1532    GLfixed *params = (GLfixed *) 0;
1533
1534    params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
1535    glTexEnvxvOES(
1536        (GLenum)target,
1537        (GLenum)pname,
1538        (GLfixed *)params
1539    );
1540    if (_array) {
1541        releasePointer(_env, _array, params, JNI_FALSE);
1542    }
1543}
1544
1545/* void glTexParameterxOES ( GLenum target, GLenum pname, GLfixed param ) */
1546static void
1547android_glTexParameterxOES__III
1548  (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) {
1549    glTexParameterxOES(
1550        (GLenum)target,
1551        (GLenum)pname,
1552        (GLfixed)param
1553    );
1554}
1555
1556/* void glTexParameterxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */
1557static void
1558android_glTexParameterxvOES__II_3II
1559  (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
1560    GLfixed *params_base = (GLfixed *) 0;
1561    jint _remaining;
1562    GLfixed *params = (GLfixed *) 0;
1563
1564    if (!params_ref) {
1565        _env->ThrowNew(IAEClass, "params == null");
1566        goto exit;
1567    }
1568    if (offset < 0) {
1569        _env->ThrowNew(IAEClass, "offset < 0");
1570        goto exit;
1571    }
1572    _remaining = _env->GetArrayLength(params_ref) - offset;
1573    params_base = (GLfixed *)
1574        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1575    params = params_base + offset;
1576
1577    glTexParameterxvOES(
1578        (GLenum)target,
1579        (GLenum)pname,
1580        (GLfixed *)params
1581    );
1582
1583exit:
1584    if (params_base) {
1585        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1586            JNI_ABORT);
1587    }
1588}
1589
1590/* void glTexParameterxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */
1591static void
1592android_glTexParameterxvOES__IILjava_nio_IntBuffer_2
1593  (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
1594    jarray _array = (jarray) 0;
1595    jint _remaining;
1596    GLfixed *params = (GLfixed *) 0;
1597
1598    params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
1599    glTexParameterxvOES(
1600        (GLenum)target,
1601        (GLenum)pname,
1602        (GLfixed *)params
1603    );
1604    if (_array) {
1605        releasePointer(_env, _array, params, JNI_FALSE);
1606    }
1607}
1608
1609/* void glTranslatexOES ( GLfixed x, GLfixed y, GLfixed z ) */
1610static void
1611android_glTranslatexOES__III
1612  (JNIEnv *_env, jobject _this, jint x, jint y, jint z) {
1613    glTranslatexOES(
1614        (GLfixed)x,
1615        (GLfixed)y,
1616        (GLfixed)z
1617    );
1618}
1619
1620/* GLboolean glIsRenderbufferOES ( GLuint renderbuffer ) */
1621static jboolean
1622android_glIsRenderbufferOES__I
1623  (JNIEnv *_env, jobject _this, jint renderbuffer) {
1624    _env->ThrowNew(UOEClass,
1625        "glIsRenderbufferOES");
1626    return JNI_FALSE;
1627}
1628
1629/* void glBindRenderbufferOES ( GLenum target, GLuint renderbuffer ) */
1630static void
1631android_glBindRenderbufferOES__II
1632  (JNIEnv *_env, jobject _this, jint target, jint renderbuffer) {
1633    _env->ThrowNew(UOEClass,
1634        "glBindRenderbufferOES");
1635}
1636
1637/* void glDeleteRenderbuffersOES ( GLsizei n, const GLuint *renderbuffers ) */
1638static void
1639android_glDeleteRenderbuffersOES__I_3II
1640  (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) {
1641    _env->ThrowNew(UOEClass,
1642        "glDeleteRenderbuffersOES");
1643}
1644
1645/* void glDeleteRenderbuffersOES ( GLsizei n, const GLuint *renderbuffers ) */
1646static void
1647android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2
1648  (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) {
1649    _env->ThrowNew(UOEClass,
1650        "glDeleteRenderbuffersOES");
1651}
1652
1653/* void glGenRenderbuffersOES ( GLsizei n, GLuint *renderbuffers ) */
1654static void
1655android_glGenRenderbuffersOES__I_3II
1656  (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) {
1657    _env->ThrowNew(UOEClass,
1658        "glGenRenderbuffersOES");
1659}
1660
1661/* void glGenRenderbuffersOES ( GLsizei n, GLuint *renderbuffers ) */
1662static void
1663android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2
1664  (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) {
1665    _env->ThrowNew(UOEClass,
1666        "glGenRenderbuffersOES");
1667}
1668
1669/* void glRenderbufferStorageOES ( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) */
1670static void
1671android_glRenderbufferStorageOES__IIII
1672  (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint width, jint height) {
1673    _env->ThrowNew(UOEClass,
1674        "glRenderbufferStorageOES");
1675}
1676
1677/* void glGetRenderbufferParameterivOES ( GLenum target, GLenum pname, GLint *params ) */
1678static void
1679android_glGetRenderbufferParameterivOES__II_3II
1680  (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
1681    _env->ThrowNew(UOEClass,
1682        "glGetRenderbufferParameterivOES");
1683}
1684
1685/* void glGetRenderbufferParameterivOES ( GLenum target, GLenum pname, GLint *params ) */
1686static void
1687android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2
1688  (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
1689    _env->ThrowNew(UOEClass,
1690        "glGetRenderbufferParameterivOES");
1691}
1692
1693/* GLboolean glIsFramebufferOES ( GLuint framebuffer ) */
1694static jboolean
1695android_glIsFramebufferOES__I
1696  (JNIEnv *_env, jobject _this, jint framebuffer) {
1697    _env->ThrowNew(UOEClass,
1698        "glIsFramebufferOES");
1699    return JNI_FALSE;
1700}
1701
1702/* void glBindFramebufferOES ( GLenum target, GLuint framebuffer ) */
1703static void
1704android_glBindFramebufferOES__II
1705  (JNIEnv *_env, jobject _this, jint target, jint framebuffer) {
1706    _env->ThrowNew(UOEClass,
1707        "glBindFramebufferOES");
1708}
1709
1710/* void glDeleteFramebuffersOES ( GLsizei n, const GLuint *framebuffers ) */
1711static void
1712android_glDeleteFramebuffersOES__I_3II
1713  (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) {
1714    _env->ThrowNew(UOEClass,
1715        "glDeleteFramebuffersOES");
1716}
1717
1718/* void glDeleteFramebuffersOES ( GLsizei n, const GLuint *framebuffers ) */
1719static void
1720android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2
1721  (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) {
1722    _env->ThrowNew(UOEClass,
1723        "glDeleteFramebuffersOES");
1724}
1725
1726/* void glGenFramebuffersOES ( GLsizei n, GLuint *framebuffers ) */
1727static void
1728android_glGenFramebuffersOES__I_3II
1729  (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) {
1730    _env->ThrowNew(UOEClass,
1731        "glGenFramebuffersOES");
1732}
1733
1734/* void glGenFramebuffersOES ( GLsizei n, GLuint *framebuffers ) */
1735static void
1736android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2
1737  (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) {
1738    _env->ThrowNew(UOEClass,
1739        "glGenFramebuffersOES");
1740}
1741
1742/* GLenum glCheckFramebufferStatusOES ( GLenum target ) */
1743static jint
1744android_glCheckFramebufferStatusOES__I
1745  (JNIEnv *_env, jobject _this, jint target) {
1746    _env->ThrowNew(UOEClass,
1747        "glCheckFramebufferStatusOES");
1748    return 0;
1749}
1750
1751/* void glFramebufferRenderbufferOES ( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) */
1752static void
1753android_glFramebufferRenderbufferOES__IIII
1754  (JNIEnv *_env, jobject _this, jint target, jint attachment, jint renderbuffertarget, jint renderbuffer) {
1755    _env->ThrowNew(UOEClass,
1756        "glFramebufferRenderbufferOES");
1757}
1758
1759/* void glFramebufferTexture2DOES ( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) */
1760static void
1761android_glFramebufferTexture2DOES__IIIII
1762  (JNIEnv *_env, jobject _this, jint target, jint attachment, jint textarget, jint texture, jint level) {
1763    _env->ThrowNew(UOEClass,
1764        "glFramebufferTexture2DOES");
1765}
1766
1767/* void glGetFramebufferAttachmentParameterivOES ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */
1768static void
1769android_glGetFramebufferAttachmentParameterivOES__III_3II
1770  (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jintArray params_ref, jint offset) {
1771    _env->ThrowNew(UOEClass,
1772        "glGetFramebufferAttachmentParameterivOES");
1773}
1774
1775/* void glGetFramebufferAttachmentParameterivOES ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */
1776static void
1777android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2
1778  (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jobject params_buf) {
1779    _env->ThrowNew(UOEClass,
1780        "glGetFramebufferAttachmentParameterivOES");
1781}
1782
1783/* void glGenerateMipmapOES ( GLenum target ) */
1784static void
1785android_glGenerateMipmapOES__I
1786  (JNIEnv *_env, jobject _this, jint target) {
1787    _env->ThrowNew(UOEClass,
1788        "glGenerateMipmapOES");
1789}
1790
1791/* void glCurrentPaletteMatrixOES ( GLuint matrixpaletteindex ) */
1792static void
1793android_glCurrentPaletteMatrixOES__I
1794  (JNIEnv *_env, jobject _this, jint matrixpaletteindex) {
1795    glCurrentPaletteMatrixOES(
1796        (GLuint)matrixpaletteindex
1797    );
1798}
1799
1800/* void glLoadPaletteFromModelViewMatrixOES ( void ) */
1801static void
1802android_glLoadPaletteFromModelViewMatrixOES__
1803  (JNIEnv *_env, jobject _this) {
1804    glLoadPaletteFromModelViewMatrixOES();
1805}
1806
1807/* void glMatrixIndexPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
1808static void
1809android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I
1810  (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
1811    jarray _array = (jarray) 0;
1812    jint _remaining;
1813    GLvoid *pointer = (GLvoid *) 0;
1814
1815    if (pointer_buf) {
1816        pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
1817        if ( ! pointer ) {
1818            return;
1819        }
1820    }
1821    glMatrixIndexPointerOESBounds(
1822        (GLint)size,
1823        (GLenum)type,
1824        (GLsizei)stride,
1825        (GLvoid *)pointer,
1826        (GLsizei)remaining
1827    );
1828}
1829
1830/* void glWeightPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
1831static void
1832android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I
1833  (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
1834    jarray _array = (jarray) 0;
1835    jint _remaining;
1836    GLvoid *pointer = (GLvoid *) 0;
1837
1838    if (pointer_buf) {
1839        pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
1840        if ( ! pointer ) {
1841            return;
1842        }
1843    }
1844    glWeightPointerOESBounds(
1845        (GLint)size,
1846        (GLenum)type,
1847        (GLsizei)stride,
1848        (GLvoid *)pointer,
1849        (GLsizei)remaining
1850    );
1851}
1852
1853/* void glDepthRangefOES ( GLclampf zNear, GLclampf zFar ) */
1854static void
1855android_glDepthRangefOES__FF
1856  (JNIEnv *_env, jobject _this, jfloat zNear, jfloat zFar) {
1857    glDepthRangefOES(
1858        (GLclampf)zNear,
1859        (GLclampf)zFar
1860    );
1861}
1862
1863/* void glFrustumfOES ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */
1864static void
1865android_glFrustumfOES__FFFFFF
1866  (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) {
1867    glFrustumfOES(
1868        (GLfloat)left,
1869        (GLfloat)right,
1870        (GLfloat)bottom,
1871        (GLfloat)top,
1872        (GLfloat)zNear,
1873        (GLfloat)zFar
1874    );
1875}
1876
1877/* void glOrthofOES ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */
1878static void
1879android_glOrthofOES__FFFFFF
1880  (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) {
1881    glOrthofOES(
1882        (GLfloat)left,
1883        (GLfloat)right,
1884        (GLfloat)bottom,
1885        (GLfloat)top,
1886        (GLfloat)zNear,
1887        (GLfloat)zFar
1888    );
1889}
1890
1891/* void glClipPlanefOES ( GLenum plane, const GLfloat *equation ) */
1892static void
1893android_glClipPlanefOES__I_3FI
1894  (JNIEnv *_env, jobject _this, jint plane, jfloatArray equation_ref, jint offset) {
1895    GLfloat *equation_base = (GLfloat *) 0;
1896    jint _remaining;
1897    GLfloat *equation = (GLfloat *) 0;
1898
1899    if (!equation_ref) {
1900        _env->ThrowNew(IAEClass, "equation == null");
1901        goto exit;
1902    }
1903    if (offset < 0) {
1904        _env->ThrowNew(IAEClass, "offset < 0");
1905        goto exit;
1906    }
1907    _remaining = _env->GetArrayLength(equation_ref) - offset;
1908    equation_base = (GLfloat *)
1909        _env->GetPrimitiveArrayCritical(equation_ref, (jboolean *)0);
1910    equation = equation_base + offset;
1911
1912    glClipPlanefOES(
1913        (GLenum)plane,
1914        (GLfloat *)equation
1915    );
1916
1917exit:
1918    if (equation_base) {
1919        _env->ReleasePrimitiveArrayCritical(equation_ref, equation_base,
1920            JNI_ABORT);
1921    }
1922}
1923
1924/* void glClipPlanefOES ( GLenum plane, const GLfloat *equation ) */
1925static void
1926android_glClipPlanefOES__ILjava_nio_FloatBuffer_2
1927  (JNIEnv *_env, jobject _this, jint plane, jobject equation_buf) {
1928    jarray _array = (jarray) 0;
1929    jint _remaining;
1930    GLfloat *equation = (GLfloat *) 0;
1931
1932    equation = (GLfloat *)getPointer(_env, equation_buf, &_array, &_remaining);
1933    glClipPlanefOES(
1934        (GLenum)plane,
1935        (GLfloat *)equation
1936    );
1937    if (_array) {
1938        releasePointer(_env, _array, equation, JNI_FALSE);
1939    }
1940}
1941
1942/* void glGetClipPlanefOES ( GLenum pname, GLfloat *eqn ) */
1943static void
1944android_glGetClipPlanefOES__I_3FI
1945  (JNIEnv *_env, jobject _this, jint pname, jfloatArray eqn_ref, jint offset) {
1946    jint _exception = 0;
1947    GLfloat *eqn_base = (GLfloat *) 0;
1948    jint _remaining;
1949    GLfloat *eqn = (GLfloat *) 0;
1950
1951    if (!eqn_ref) {
1952        _exception = 1;
1953        _env->ThrowNew(IAEClass, "eqn == null");
1954        goto exit;
1955    }
1956    if (offset < 0) {
1957        _exception = 1;
1958        _env->ThrowNew(IAEClass, "offset < 0");
1959        goto exit;
1960    }
1961    _remaining = _env->GetArrayLength(eqn_ref) - offset;
1962    if (_remaining < 4) {
1963        _exception = 1;
1964        _env->ThrowNew(IAEClass, "length - offset < 4");
1965        goto exit;
1966    }
1967    eqn_base = (GLfloat *)
1968        _env->GetPrimitiveArrayCritical(eqn_ref, (jboolean *)0);
1969    eqn = eqn_base + offset;
1970
1971    glGetClipPlanefOES(
1972        (GLenum)pname,
1973        (GLfloat *)eqn
1974    );
1975
1976exit:
1977    if (eqn_base) {
1978        _env->ReleasePrimitiveArrayCritical(eqn_ref, eqn_base,
1979            _exception ? JNI_ABORT: 0);
1980    }
1981}
1982
1983/* void glGetClipPlanefOES ( GLenum pname, GLfloat *eqn ) */
1984static void
1985android_glGetClipPlanefOES__ILjava_nio_FloatBuffer_2
1986  (JNIEnv *_env, jobject _this, jint pname, jobject eqn_buf) {
1987    jint _exception = 0;
1988    jarray _array = (jarray) 0;
1989    jint _remaining;
1990    GLfloat *eqn = (GLfloat *) 0;
1991
1992    eqn = (GLfloat *)getPointer(_env, eqn_buf, &_array, &_remaining);
1993    if (_remaining < 4) {
1994        _exception = 1;
1995        _env->ThrowNew(IAEClass, "remaining() < 4");
1996        goto exit;
1997    }
1998    glGetClipPlanefOES(
1999        (GLenum)pname,
2000        (GLfloat *)eqn
2001    );
2002
2003exit:
2004    if (_array) {
2005        releasePointer(_env, _array, eqn, _exception ? JNI_FALSE : JNI_TRUE);
2006    }
2007}
2008
2009/* void glClearDepthfOES ( GLclampf depth ) */
2010static void
2011android_glClearDepthfOES__F
2012  (JNIEnv *_env, jobject _this, jfloat depth) {
2013    glClearDepthfOES(
2014        (GLclampf)depth
2015    );
2016}
2017
2018/* void glTexGenfOES ( GLenum coord, GLenum pname, GLfloat param ) */
2019static void
2020android_glTexGenfOES__IIF
2021  (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloat param) {
2022    glTexGenfOES(
2023        (GLenum)coord,
2024        (GLenum)pname,
2025        (GLfloat)param
2026    );
2027}
2028
2029/* void glTexGenfvOES ( GLenum coord, GLenum pname, const GLfloat *params ) */
2030static void
2031android_glTexGenfvOES__II_3FI
2032  (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) {
2033    GLfloat *params_base = (GLfloat *) 0;
2034    jint _remaining;
2035    GLfloat *params = (GLfloat *) 0;
2036
2037    if (!params_ref) {
2038        _env->ThrowNew(IAEClass, "params == null");
2039        goto exit;
2040    }
2041    if (offset < 0) {
2042        _env->ThrowNew(IAEClass, "offset < 0");
2043        goto exit;
2044    }
2045    _remaining = _env->GetArrayLength(params_ref) - offset;
2046    params_base = (GLfloat *)
2047        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2048    params = params_base + offset;
2049
2050    glTexGenfvOES(
2051        (GLenum)coord,
2052        (GLenum)pname,
2053        (GLfloat *)params
2054    );
2055
2056exit:
2057    if (params_base) {
2058        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2059            JNI_ABORT);
2060    }
2061}
2062
2063/* void glTexGenfvOES ( GLenum coord, GLenum pname, const GLfloat *params ) */
2064static void
2065android_glTexGenfvOES__IILjava_nio_FloatBuffer_2
2066  (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2067    jarray _array = (jarray) 0;
2068    jint _remaining;
2069    GLfloat *params = (GLfloat *) 0;
2070
2071    params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining);
2072    glTexGenfvOES(
2073        (GLenum)coord,
2074        (GLenum)pname,
2075        (GLfloat *)params
2076    );
2077    if (_array) {
2078        releasePointer(_env, _array, params, JNI_FALSE);
2079    }
2080}
2081
2082/* void glTexGeniOES ( GLenum coord, GLenum pname, GLint param ) */
2083static void
2084android_glTexGeniOES__III
2085  (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) {
2086    glTexGeniOES(
2087        (GLenum)coord,
2088        (GLenum)pname,
2089        (GLint)param
2090    );
2091}
2092
2093/* void glTexGenivOES ( GLenum coord, GLenum pname, const GLint *params ) */
2094static void
2095android_glTexGenivOES__II_3II
2096  (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
2097    GLint *params_base = (GLint *) 0;
2098    jint _remaining;
2099    GLint *params = (GLint *) 0;
2100
2101    if (!params_ref) {
2102        _env->ThrowNew(IAEClass, "params == null");
2103        goto exit;
2104    }
2105    if (offset < 0) {
2106        _env->ThrowNew(IAEClass, "offset < 0");
2107        goto exit;
2108    }
2109    _remaining = _env->GetArrayLength(params_ref) - offset;
2110    params_base = (GLint *)
2111        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2112    params = params_base + offset;
2113
2114    glTexGenivOES(
2115        (GLenum)coord,
2116        (GLenum)pname,
2117        (GLint *)params
2118    );
2119
2120exit:
2121    if (params_base) {
2122        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2123            JNI_ABORT);
2124    }
2125}
2126
2127/* void glTexGenivOES ( GLenum coord, GLenum pname, const GLint *params ) */
2128static void
2129android_glTexGenivOES__IILjava_nio_IntBuffer_2
2130  (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2131    jarray _array = (jarray) 0;
2132    jint _remaining;
2133    GLint *params = (GLint *) 0;
2134
2135    params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
2136    glTexGenivOES(
2137        (GLenum)coord,
2138        (GLenum)pname,
2139        (GLint *)params
2140    );
2141    if (_array) {
2142        releasePointer(_env, _array, params, JNI_FALSE);
2143    }
2144}
2145
2146/* void glTexGenxOES ( GLenum coord, GLenum pname, GLfixed param ) */
2147static void
2148android_glTexGenxOES__III
2149  (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) {
2150    glTexGenxOES(
2151        (GLenum)coord,
2152        (GLenum)pname,
2153        (GLfixed)param
2154    );
2155}
2156
2157/* void glTexGenxvOES ( GLenum coord, GLenum pname, const GLfixed *params ) */
2158static void
2159android_glTexGenxvOES__II_3II
2160  (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
2161    GLfixed *params_base = (GLfixed *) 0;
2162    jint _remaining;
2163    GLfixed *params = (GLfixed *) 0;
2164
2165    if (!params_ref) {
2166        _env->ThrowNew(IAEClass, "params == null");
2167        goto exit;
2168    }
2169    if (offset < 0) {
2170        _env->ThrowNew(IAEClass, "offset < 0");
2171        goto exit;
2172    }
2173    _remaining = _env->GetArrayLength(params_ref) - offset;
2174    params_base = (GLfixed *)
2175        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2176    params = params_base + offset;
2177
2178    glTexGenxvOES(
2179        (GLenum)coord,
2180        (GLenum)pname,
2181        (GLfixed *)params
2182    );
2183
2184exit:
2185    if (params_base) {
2186        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2187            JNI_ABORT);
2188    }
2189}
2190
2191/* void glTexGenxvOES ( GLenum coord, GLenum pname, const GLfixed *params ) */
2192static void
2193android_glTexGenxvOES__IILjava_nio_IntBuffer_2
2194  (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2195    jarray _array = (jarray) 0;
2196    jint _remaining;
2197    GLfixed *params = (GLfixed *) 0;
2198
2199    params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
2200    glTexGenxvOES(
2201        (GLenum)coord,
2202        (GLenum)pname,
2203        (GLfixed *)params
2204    );
2205    if (_array) {
2206        releasePointer(_env, _array, params, JNI_FALSE);
2207    }
2208}
2209
2210/* void glGetTexGenfvOES ( GLenum coord, GLenum pname, GLfloat *params ) */
2211static void
2212android_glGetTexGenfvOES__II_3FI
2213  (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) {
2214    jint _exception = 0;
2215    GLfloat *params_base = (GLfloat *) 0;
2216    jint _remaining;
2217    GLfloat *params = (GLfloat *) 0;
2218
2219    if (!params_ref) {
2220        _exception = 1;
2221        _env->ThrowNew(IAEClass, "params == null");
2222        goto exit;
2223    }
2224    if (offset < 0) {
2225        _exception = 1;
2226        _env->ThrowNew(IAEClass, "offset < 0");
2227        goto exit;
2228    }
2229    _remaining = _env->GetArrayLength(params_ref) - offset;
2230    params_base = (GLfloat *)
2231        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2232    params = params_base + offset;
2233
2234    glGetTexGenfvOES(
2235        (GLenum)coord,
2236        (GLenum)pname,
2237        (GLfloat *)params
2238    );
2239
2240exit:
2241    if (params_base) {
2242        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2243            _exception ? JNI_ABORT: 0);
2244    }
2245}
2246
2247/* void glGetTexGenfvOES ( GLenum coord, GLenum pname, GLfloat *params ) */
2248static void
2249android_glGetTexGenfvOES__IILjava_nio_FloatBuffer_2
2250  (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2251    jint _exception = 0;
2252    jarray _array = (jarray) 0;
2253    jint _remaining;
2254    GLfloat *params = (GLfloat *) 0;
2255
2256    params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining);
2257    glGetTexGenfvOES(
2258        (GLenum)coord,
2259        (GLenum)pname,
2260        (GLfloat *)params
2261    );
2262    if (_array) {
2263        releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
2264    }
2265}
2266
2267/* void glGetTexGenivOES ( GLenum coord, GLenum pname, GLint *params ) */
2268static void
2269android_glGetTexGenivOES__II_3II
2270  (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
2271    jint _exception = 0;
2272    GLint *params_base = (GLint *) 0;
2273    jint _remaining;
2274    GLint *params = (GLint *) 0;
2275
2276    if (!params_ref) {
2277        _exception = 1;
2278        _env->ThrowNew(IAEClass, "params == null");
2279        goto exit;
2280    }
2281    if (offset < 0) {
2282        _exception = 1;
2283        _env->ThrowNew(IAEClass, "offset < 0");
2284        goto exit;
2285    }
2286    _remaining = _env->GetArrayLength(params_ref) - offset;
2287    params_base = (GLint *)
2288        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2289    params = params_base + offset;
2290
2291    glGetTexGenivOES(
2292        (GLenum)coord,
2293        (GLenum)pname,
2294        (GLint *)params
2295    );
2296
2297exit:
2298    if (params_base) {
2299        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2300            _exception ? JNI_ABORT: 0);
2301    }
2302}
2303
2304/* void glGetTexGenivOES ( GLenum coord, GLenum pname, GLint *params ) */
2305static void
2306android_glGetTexGenivOES__IILjava_nio_IntBuffer_2
2307  (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2308    jint _exception = 0;
2309    jarray _array = (jarray) 0;
2310    jint _remaining;
2311    GLint *params = (GLint *) 0;
2312
2313    params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
2314    glGetTexGenivOES(
2315        (GLenum)coord,
2316        (GLenum)pname,
2317        (GLint *)params
2318    );
2319    if (_array) {
2320        releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
2321    }
2322}
2323
2324/* void glGetTexGenxvOES ( GLenum coord, GLenum pname, GLfixed *params ) */
2325static void
2326android_glGetTexGenxvOES__II_3II
2327  (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
2328    jint _exception = 0;
2329    GLfixed *params_base = (GLfixed *) 0;
2330    jint _remaining;
2331    GLfixed *params = (GLfixed *) 0;
2332
2333    if (!params_ref) {
2334        _exception = 1;
2335        _env->ThrowNew(IAEClass, "params == null");
2336        goto exit;
2337    }
2338    if (offset < 0) {
2339        _exception = 1;
2340        _env->ThrowNew(IAEClass, "offset < 0");
2341        goto exit;
2342    }
2343    _remaining = _env->GetArrayLength(params_ref) - offset;
2344    params_base = (GLfixed *)
2345        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2346    params = params_base + offset;
2347
2348    glGetTexGenxvOES(
2349        (GLenum)coord,
2350        (GLenum)pname,
2351        (GLfixed *)params
2352    );
2353
2354exit:
2355    if (params_base) {
2356        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2357            _exception ? JNI_ABORT: 0);
2358    }
2359}
2360
2361/* void glGetTexGenxvOES ( GLenum coord, GLenum pname, GLfixed *params ) */
2362static void
2363android_glGetTexGenxvOES__IILjava_nio_IntBuffer_2
2364  (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2365    jint _exception = 0;
2366    jarray _array = (jarray) 0;
2367    jint _remaining;
2368    GLfixed *params = (GLfixed *) 0;
2369
2370    params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
2371    glGetTexGenxvOES(
2372        (GLenum)coord,
2373        (GLenum)pname,
2374        (GLfixed *)params
2375    );
2376    if (_array) {
2377        releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
2378    }
2379}
2380
2381static const char *classPathName = "android/opengl/GLES11Ext";
2382
2383static JNINativeMethod methods[] = {
2384{"_nativeClassInit", "()V", (void*)nativeClassInit },
2385{"glBlendEquationSeparateOES", "(II)V", (void *) android_glBlendEquationSeparateOES__II },
2386{"glBlendFuncSeparateOES", "(IIII)V", (void *) android_glBlendFuncSeparateOES__IIII },
2387{"glBlendEquationOES", "(I)V", (void *) android_glBlendEquationOES__I },
2388{"glDrawTexsOES", "(SSSSS)V", (void *) android_glDrawTexsOES__SSSSS },
2389{"glDrawTexiOES", "(IIIII)V", (void *) android_glDrawTexiOES__IIIII },
2390{"glDrawTexxOES", "(IIIII)V", (void *) android_glDrawTexxOES__IIIII },
2391{"glDrawTexsvOES", "([SI)V", (void *) android_glDrawTexsvOES___3SI },
2392{"glDrawTexsvOES", "(Ljava/nio/ShortBuffer;)V", (void *) android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2 },
2393{"glDrawTexivOES", "([II)V", (void *) android_glDrawTexivOES___3II },
2394{"glDrawTexivOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexivOES__Ljava_nio_IntBuffer_2 },
2395{"glDrawTexxvOES", "([II)V", (void *) android_glDrawTexxvOES___3II },
2396{"glDrawTexxvOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexxvOES__Ljava_nio_IntBuffer_2 },
2397{"glDrawTexfOES", "(FFFFF)V", (void *) android_glDrawTexfOES__FFFFF },
2398{"glDrawTexfvOES", "([FI)V", (void *) android_glDrawTexfvOES___3FI },
2399{"glDrawTexfvOES", "(Ljava/nio/FloatBuffer;)V", (void *) android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2 },
2400{"glEGLImageTargetTexture2DOES", "(ILjava/nio/Buffer;)V", (void *) android_glEGLImageTargetTexture2DOES__ILjava_nio_Buffer_2 },
2401{"glEGLImageTargetRenderbufferStorageOES", "(ILjava/nio/Buffer;)V", (void *) android_glEGLImageTargetRenderbufferStorageOES__ILjava_nio_Buffer_2 },
2402{"glAlphaFuncxOES", "(II)V", (void *) android_glAlphaFuncxOES__II },
2403{"glClearColorxOES", "(IIII)V", (void *) android_glClearColorxOES__IIII },
2404{"glClearDepthxOES", "(I)V", (void *) android_glClearDepthxOES__I },
2405{"glClipPlanexOES", "(I[II)V", (void *) android_glClipPlanexOES__I_3II },
2406{"glClipPlanexOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glClipPlanexOES__ILjava_nio_IntBuffer_2 },
2407{"glColor4xOES", "(IIII)V", (void *) android_glColor4xOES__IIII },
2408{"glDepthRangexOES", "(II)V", (void *) android_glDepthRangexOES__II },
2409{"glFogxOES", "(II)V", (void *) android_glFogxOES__II },
2410{"glFogxvOES", "(I[II)V", (void *) android_glFogxvOES__I_3II },
2411{"glFogxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glFogxvOES__ILjava_nio_IntBuffer_2 },
2412{"glFrustumxOES", "(IIIIII)V", (void *) android_glFrustumxOES__IIIIII },
2413{"glGetClipPlanexOES", "(I[II)V", (void *) android_glGetClipPlanexOES__I_3II },
2414{"glGetClipPlanexOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetClipPlanexOES__ILjava_nio_IntBuffer_2 },
2415{"glGetFixedvOES", "(I[II)V", (void *) android_glGetFixedvOES__I_3II },
2416{"glGetFixedvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetFixedvOES__ILjava_nio_IntBuffer_2 },
2417{"glGetLightxvOES", "(II[II)V", (void *) android_glGetLightxvOES__II_3II },
2418{"glGetLightxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetLightxvOES__IILjava_nio_IntBuffer_2 },
2419{"glGetMaterialxvOES", "(II[II)V", (void *) android_glGetMaterialxvOES__II_3II },
2420{"glGetMaterialxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetMaterialxvOES__IILjava_nio_IntBuffer_2 },
2421{"glGetTexEnvxvOES", "(II[II)V", (void *) android_glGetTexEnvxvOES__II_3II },
2422{"glGetTexEnvxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexEnvxvOES__IILjava_nio_IntBuffer_2 },
2423{"glGetTexParameterxvOES", "(II[II)V", (void *) android_glGetTexParameterxvOES__II_3II },
2424{"glGetTexParameterxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameterxvOES__IILjava_nio_IntBuffer_2 },
2425{"glLightModelxOES", "(II)V", (void *) android_glLightModelxOES__II },
2426{"glLightModelxvOES", "(I[II)V", (void *) android_glLightModelxvOES__I_3II },
2427{"glLightModelxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glLightModelxvOES__ILjava_nio_IntBuffer_2 },
2428{"glLightxOES", "(III)V", (void *) android_glLightxOES__III },
2429{"glLightxvOES", "(II[II)V", (void *) android_glLightxvOES__II_3II },
2430{"glLightxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glLightxvOES__IILjava_nio_IntBuffer_2 },
2431{"glLineWidthxOES", "(I)V", (void *) android_glLineWidthxOES__I },
2432{"glLoadMatrixxOES", "([II)V", (void *) android_glLoadMatrixxOES___3II },
2433{"glLoadMatrixxOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glLoadMatrixxOES__Ljava_nio_IntBuffer_2 },
2434{"glMaterialxOES", "(III)V", (void *) android_glMaterialxOES__III },
2435{"glMaterialxvOES", "(II[II)V", (void *) android_glMaterialxvOES__II_3II },
2436{"glMaterialxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glMaterialxvOES__IILjava_nio_IntBuffer_2 },
2437{"glMultMatrixxOES", "([II)V", (void *) android_glMultMatrixxOES___3II },
2438{"glMultMatrixxOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glMultMatrixxOES__Ljava_nio_IntBuffer_2 },
2439{"glMultiTexCoord4xOES", "(IIIII)V", (void *) android_glMultiTexCoord4xOES__IIIII },
2440{"glNormal3xOES", "(III)V", (void *) android_glNormal3xOES__III },
2441{"glOrthoxOES", "(IIIIII)V", (void *) android_glOrthoxOES__IIIIII },
2442{"glPointParameterxOES", "(II)V", (void *) android_glPointParameterxOES__II },
2443{"glPointParameterxvOES", "(I[II)V", (void *) android_glPointParameterxvOES__I_3II },
2444{"glPointParameterxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glPointParameterxvOES__ILjava_nio_IntBuffer_2 },
2445{"glPointSizexOES", "(I)V", (void *) android_glPointSizexOES__I },
2446{"glPolygonOffsetxOES", "(II)V", (void *) android_glPolygonOffsetxOES__II },
2447{"glRotatexOES", "(IIII)V", (void *) android_glRotatexOES__IIII },
2448{"glSampleCoveragexOES", "(IZ)V", (void *) android_glSampleCoveragexOES__IZ },
2449{"glScalexOES", "(III)V", (void *) android_glScalexOES__III },
2450{"glTexEnvxOES", "(III)V", (void *) android_glTexEnvxOES__III },
2451{"glTexEnvxvOES", "(II[II)V", (void *) android_glTexEnvxvOES__II_3II },
2452{"glTexEnvxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexEnvxvOES__IILjava_nio_IntBuffer_2 },
2453{"glTexParameterxOES", "(III)V", (void *) android_glTexParameterxOES__III },
2454{"glTexParameterxvOES", "(II[II)V", (void *) android_glTexParameterxvOES__II_3II },
2455{"glTexParameterxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameterxvOES__IILjava_nio_IntBuffer_2 },
2456{"glTranslatexOES", "(III)V", (void *) android_glTranslatexOES__III },
2457{"glIsRenderbufferOES", "(I)Z", (void *) android_glIsRenderbufferOES__I },
2458{"glBindRenderbufferOES", "(II)V", (void *) android_glBindRenderbufferOES__II },
2459{"glDeleteRenderbuffersOES", "(I[II)V", (void *) android_glDeleteRenderbuffersOES__I_3II },
2460{"glDeleteRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2 },
2461{"glGenRenderbuffersOES", "(I[II)V", (void *) android_glGenRenderbuffersOES__I_3II },
2462{"glGenRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2 },
2463{"glRenderbufferStorageOES", "(IIII)V", (void *) android_glRenderbufferStorageOES__IIII },
2464{"glGetRenderbufferParameterivOES", "(II[II)V", (void *) android_glGetRenderbufferParameterivOES__II_3II },
2465{"glGetRenderbufferParameterivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2 },
2466{"glIsFramebufferOES", "(I)Z", (void *) android_glIsFramebufferOES__I },
2467{"glBindFramebufferOES", "(II)V", (void *) android_glBindFramebufferOES__II },
2468{"glDeleteFramebuffersOES", "(I[II)V", (void *) android_glDeleteFramebuffersOES__I_3II },
2469{"glDeleteFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2 },
2470{"glGenFramebuffersOES", "(I[II)V", (void *) android_glGenFramebuffersOES__I_3II },
2471{"glGenFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2 },
2472{"glCheckFramebufferStatusOES", "(I)I", (void *) android_glCheckFramebufferStatusOES__I },
2473{"glFramebufferRenderbufferOES", "(IIII)V", (void *) android_glFramebufferRenderbufferOES__IIII },
2474{"glFramebufferTexture2DOES", "(IIIII)V", (void *) android_glFramebufferTexture2DOES__IIIII },
2475{"glGetFramebufferAttachmentParameterivOES", "(III[II)V", (void *) android_glGetFramebufferAttachmentParameterivOES__III_3II },
2476{"glGetFramebufferAttachmentParameterivOES", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2 },
2477{"glGenerateMipmapOES", "(I)V", (void *) android_glGenerateMipmapOES__I },
2478{"glCurrentPaletteMatrixOES", "(I)V", (void *) android_glCurrentPaletteMatrixOES__I },
2479{"glLoadPaletteFromModelViewMatrixOES", "()V", (void *) android_glLoadPaletteFromModelViewMatrixOES__ },
2480{"glMatrixIndexPointerOESBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I },
2481{"glWeightPointerOESBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I },
2482{"glDepthRangefOES", "(FF)V", (void *) android_glDepthRangefOES__FF },
2483{"glFrustumfOES", "(FFFFFF)V", (void *) android_glFrustumfOES__FFFFFF },
2484{"glOrthofOES", "(FFFFFF)V", (void *) android_glOrthofOES__FFFFFF },
2485{"glClipPlanefOES", "(I[FI)V", (void *) android_glClipPlanefOES__I_3FI },
2486{"glClipPlanefOES", "(ILjava/nio/FloatBuffer;)V", (void *) android_glClipPlanefOES__ILjava_nio_FloatBuffer_2 },
2487{"glGetClipPlanefOES", "(I[FI)V", (void *) android_glGetClipPlanefOES__I_3FI },
2488{"glGetClipPlanefOES", "(ILjava/nio/FloatBuffer;)V", (void *) android_glGetClipPlanefOES__ILjava_nio_FloatBuffer_2 },
2489{"glClearDepthfOES", "(F)V", (void *) android_glClearDepthfOES__F },
2490{"glTexGenfOES", "(IIF)V", (void *) android_glTexGenfOES__IIF },
2491{"glTexGenfvOES", "(II[FI)V", (void *) android_glTexGenfvOES__II_3FI },
2492{"glTexGenfvOES", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexGenfvOES__IILjava_nio_FloatBuffer_2 },
2493{"glTexGeniOES", "(III)V", (void *) android_glTexGeniOES__III },
2494{"glTexGenivOES", "(II[II)V", (void *) android_glTexGenivOES__II_3II },
2495{"glTexGenivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGenivOES__IILjava_nio_IntBuffer_2 },
2496{"glTexGenxOES", "(III)V", (void *) android_glTexGenxOES__III },
2497{"glTexGenxvOES", "(II[II)V", (void *) android_glTexGenxvOES__II_3II },
2498{"glTexGenxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGenxvOES__IILjava_nio_IntBuffer_2 },
2499{"glGetTexGenfvOES", "(II[FI)V", (void *) android_glGetTexGenfvOES__II_3FI },
2500{"glGetTexGenfvOES", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetTexGenfvOES__IILjava_nio_FloatBuffer_2 },
2501{"glGetTexGenivOES", "(II[II)V", (void *) android_glGetTexGenivOES__II_3II },
2502{"glGetTexGenivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGenivOES__IILjava_nio_IntBuffer_2 },
2503{"glGetTexGenxvOES", "(II[II)V", (void *) android_glGetTexGenxvOES__II_3II },
2504{"glGetTexGenxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGenxvOES__IILjava_nio_IntBuffer_2 },
2505};
2506
2507int register_android_opengl_jni_GLES11Ext(JNIEnv *_env)
2508{
2509    int err;
2510    err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));
2511    return err;
2512}
2513