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