android_opengl_GLES11Ext.cpp revision 73108675c944ab4ee89631dced23566b12341b66 
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    GLboolean _returnValue;
1625    _returnValue = glIsRenderbufferOES(
1626        (GLuint)renderbuffer
1627    );
1628    return _returnValue;
1629}
1630
1631/* void glBindRenderbufferOES ( GLenum target, GLuint renderbuffer ) */
1632static void
1633android_glBindRenderbufferOES__II
1634  (JNIEnv *_env, jobject _this, jint target, jint renderbuffer) {
1635    glBindRenderbufferOES(
1636        (GLenum)target,
1637        (GLuint)renderbuffer
1638    );
1639}
1640
1641/* void glDeleteRenderbuffersOES ( GLsizei n, const GLuint *renderbuffers ) */
1642static void
1643android_glDeleteRenderbuffersOES__I_3II
1644  (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) {
1645    GLuint *renderbuffers_base = (GLuint *) 0;
1646    jint _remaining;
1647    GLuint *renderbuffers = (GLuint *) 0;
1648
1649    if (!renderbuffers_ref) {
1650        _env->ThrowNew(IAEClass, "renderbuffers == null");
1651        goto exit;
1652    }
1653    if (offset < 0) {
1654        _env->ThrowNew(IAEClass, "offset < 0");
1655        goto exit;
1656    }
1657    _remaining = _env->GetArrayLength(renderbuffers_ref) - offset;
1658    if (_remaining < n) {
1659        _env->ThrowNew(IAEClass, "length - offset < n");
1660        goto exit;
1661    }
1662    renderbuffers_base = (GLuint *)
1663        _env->GetPrimitiveArrayCritical(renderbuffers_ref, (jboolean *)0);
1664    renderbuffers = renderbuffers_base + offset;
1665
1666    glDeleteRenderbuffersOES(
1667        (GLsizei)n,
1668        (GLuint *)renderbuffers
1669    );
1670
1671exit:
1672    if (renderbuffers_base) {
1673        _env->ReleasePrimitiveArrayCritical(renderbuffers_ref, renderbuffers_base,
1674            JNI_ABORT);
1675    }
1676}
1677
1678/* void glDeleteRenderbuffersOES ( GLsizei n, const GLuint *renderbuffers ) */
1679static void
1680android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2
1681  (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) {
1682    jarray _array = (jarray) 0;
1683    jint _remaining;
1684    GLuint *renderbuffers = (GLuint *) 0;
1685
1686    renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, &_array, &_remaining);
1687    if (_remaining < n) {
1688        _env->ThrowNew(IAEClass, "remaining() < n");
1689        goto exit;
1690    }
1691    glDeleteRenderbuffersOES(
1692        (GLsizei)n,
1693        (GLuint *)renderbuffers
1694    );
1695
1696exit:
1697    if (_array) {
1698        releasePointer(_env, _array, renderbuffers, JNI_FALSE);
1699    }
1700}
1701
1702/* void glGenRenderbuffersOES ( GLsizei n, GLuint *renderbuffers ) */
1703static void
1704android_glGenRenderbuffersOES__I_3II
1705  (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) {
1706    jint _exception = 0;
1707    GLuint *renderbuffers_base = (GLuint *) 0;
1708    jint _remaining;
1709    GLuint *renderbuffers = (GLuint *) 0;
1710
1711    if (!renderbuffers_ref) {
1712        _exception = 1;
1713        _env->ThrowNew(IAEClass, "renderbuffers == null");
1714        goto exit;
1715    }
1716    if (offset < 0) {
1717        _exception = 1;
1718        _env->ThrowNew(IAEClass, "offset < 0");
1719        goto exit;
1720    }
1721    _remaining = _env->GetArrayLength(renderbuffers_ref) - offset;
1722    if (_remaining < n) {
1723        _exception = 1;
1724        _env->ThrowNew(IAEClass, "length - offset < n");
1725        goto exit;
1726    }
1727    renderbuffers_base = (GLuint *)
1728        _env->GetPrimitiveArrayCritical(renderbuffers_ref, (jboolean *)0);
1729    renderbuffers = renderbuffers_base + offset;
1730
1731    glGenRenderbuffersOES(
1732        (GLsizei)n,
1733        (GLuint *)renderbuffers
1734    );
1735
1736exit:
1737    if (renderbuffers_base) {
1738        _env->ReleasePrimitiveArrayCritical(renderbuffers_ref, renderbuffers_base,
1739            _exception ? JNI_ABORT: 0);
1740    }
1741}
1742
1743/* void glGenRenderbuffersOES ( GLsizei n, GLuint *renderbuffers ) */
1744static void
1745android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2
1746  (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) {
1747    jint _exception = 0;
1748    jarray _array = (jarray) 0;
1749    jint _remaining;
1750    GLuint *renderbuffers = (GLuint *) 0;
1751
1752    renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, &_array, &_remaining);
1753    if (_remaining < n) {
1754        _exception = 1;
1755        _env->ThrowNew(IAEClass, "remaining() < n");
1756        goto exit;
1757    }
1758    glGenRenderbuffersOES(
1759        (GLsizei)n,
1760        (GLuint *)renderbuffers
1761    );
1762
1763exit:
1764    if (_array) {
1765        releasePointer(_env, _array, renderbuffers, _exception ? JNI_FALSE : JNI_TRUE);
1766    }
1767}
1768
1769/* void glRenderbufferStorageOES ( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) */
1770static void
1771android_glRenderbufferStorageOES__IIII
1772  (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint width, jint height) {
1773    glRenderbufferStorageOES(
1774        (GLenum)target,
1775        (GLenum)internalformat,
1776        (GLsizei)width,
1777        (GLsizei)height
1778    );
1779}
1780
1781/* void glGetRenderbufferParameterivOES ( GLenum target, GLenum pname, GLint *params ) */
1782static void
1783android_glGetRenderbufferParameterivOES__II_3II
1784  (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
1785    jint _exception = 0;
1786    GLint *params_base = (GLint *) 0;
1787    jint _remaining;
1788    GLint *params = (GLint *) 0;
1789
1790    if (!params_ref) {
1791        _exception = 1;
1792        _env->ThrowNew(IAEClass, "params == null");
1793        goto exit;
1794    }
1795    if (offset < 0) {
1796        _exception = 1;
1797        _env->ThrowNew(IAEClass, "offset < 0");
1798        goto exit;
1799    }
1800    _remaining = _env->GetArrayLength(params_ref) - offset;
1801    if (_remaining < 1) {
1802        _exception = 1;
1803        _env->ThrowNew(IAEClass, "length - offset < 1");
1804        goto exit;
1805    }
1806    params_base = (GLint *)
1807        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1808    params = params_base + offset;
1809
1810    glGetRenderbufferParameterivOES(
1811        (GLenum)target,
1812        (GLenum)pname,
1813        (GLint *)params
1814    );
1815
1816exit:
1817    if (params_base) {
1818        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1819            _exception ? JNI_ABORT: 0);
1820    }
1821}
1822
1823/* void glGetRenderbufferParameterivOES ( GLenum target, GLenum pname, GLint *params ) */
1824static void
1825android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2
1826  (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
1827    jint _exception = 0;
1828    jarray _array = (jarray) 0;
1829    jint _remaining;
1830    GLint *params = (GLint *) 0;
1831
1832    params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
1833    if (_remaining < 1) {
1834        _exception = 1;
1835        _env->ThrowNew(IAEClass, "remaining() < 1");
1836        goto exit;
1837    }
1838    glGetRenderbufferParameterivOES(
1839        (GLenum)target,
1840        (GLenum)pname,
1841        (GLint *)params
1842    );
1843
1844exit:
1845    if (_array) {
1846        releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
1847    }
1848}
1849
1850/* GLboolean glIsFramebufferOES ( GLuint framebuffer ) */
1851static jboolean
1852android_glIsFramebufferOES__I
1853  (JNIEnv *_env, jobject _this, jint framebuffer) {
1854    GLboolean _returnValue;
1855    _returnValue = glIsFramebufferOES(
1856        (GLuint)framebuffer
1857    );
1858    return _returnValue;
1859}
1860
1861/* void glBindFramebufferOES ( GLenum target, GLuint framebuffer ) */
1862static void
1863android_glBindFramebufferOES__II
1864  (JNIEnv *_env, jobject _this, jint target, jint framebuffer) {
1865    glBindFramebufferOES(
1866        (GLenum)target,
1867        (GLuint)framebuffer
1868    );
1869}
1870
1871/* void glDeleteFramebuffersOES ( GLsizei n, const GLuint *framebuffers ) */
1872static void
1873android_glDeleteFramebuffersOES__I_3II
1874  (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) {
1875    GLuint *framebuffers_base = (GLuint *) 0;
1876    jint _remaining;
1877    GLuint *framebuffers = (GLuint *) 0;
1878
1879    if (!framebuffers_ref) {
1880        _env->ThrowNew(IAEClass, "framebuffers == null");
1881        goto exit;
1882    }
1883    if (offset < 0) {
1884        _env->ThrowNew(IAEClass, "offset < 0");
1885        goto exit;
1886    }
1887    _remaining = _env->GetArrayLength(framebuffers_ref) - offset;
1888    if (_remaining < n) {
1889        _env->ThrowNew(IAEClass, "length - offset < n");
1890        goto exit;
1891    }
1892    framebuffers_base = (GLuint *)
1893        _env->GetPrimitiveArrayCritical(framebuffers_ref, (jboolean *)0);
1894    framebuffers = framebuffers_base + offset;
1895
1896    glDeleteFramebuffersOES(
1897        (GLsizei)n,
1898        (GLuint *)framebuffers
1899    );
1900
1901exit:
1902    if (framebuffers_base) {
1903        _env->ReleasePrimitiveArrayCritical(framebuffers_ref, framebuffers_base,
1904            JNI_ABORT);
1905    }
1906}
1907
1908/* void glDeleteFramebuffersOES ( GLsizei n, const GLuint *framebuffers ) */
1909static void
1910android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2
1911  (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) {
1912    jarray _array = (jarray) 0;
1913    jint _remaining;
1914    GLuint *framebuffers = (GLuint *) 0;
1915
1916    framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, &_array, &_remaining);
1917    if (_remaining < n) {
1918        _env->ThrowNew(IAEClass, "remaining() < n");
1919        goto exit;
1920    }
1921    glDeleteFramebuffersOES(
1922        (GLsizei)n,
1923        (GLuint *)framebuffers
1924    );
1925
1926exit:
1927    if (_array) {
1928        releasePointer(_env, _array, framebuffers, JNI_FALSE);
1929    }
1930}
1931
1932/* void glGenFramebuffersOES ( GLsizei n, GLuint *framebuffers ) */
1933static void
1934android_glGenFramebuffersOES__I_3II
1935  (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) {
1936    jint _exception = 0;
1937    GLuint *framebuffers_base = (GLuint *) 0;
1938    jint _remaining;
1939    GLuint *framebuffers = (GLuint *) 0;
1940
1941    if (!framebuffers_ref) {
1942        _exception = 1;
1943        _env->ThrowNew(IAEClass, "framebuffers == null");
1944        goto exit;
1945    }
1946    if (offset < 0) {
1947        _exception = 1;
1948        _env->ThrowNew(IAEClass, "offset < 0");
1949        goto exit;
1950    }
1951    _remaining = _env->GetArrayLength(framebuffers_ref) - offset;
1952    if (_remaining < n) {
1953        _exception = 1;
1954        _env->ThrowNew(IAEClass, "length - offset < n");
1955        goto exit;
1956    }
1957    framebuffers_base = (GLuint *)
1958        _env->GetPrimitiveArrayCritical(framebuffers_ref, (jboolean *)0);
1959    framebuffers = framebuffers_base + offset;
1960
1961    glGenFramebuffersOES(
1962        (GLsizei)n,
1963        (GLuint *)framebuffers
1964    );
1965
1966exit:
1967    if (framebuffers_base) {
1968        _env->ReleasePrimitiveArrayCritical(framebuffers_ref, framebuffers_base,
1969            _exception ? JNI_ABORT: 0);
1970    }
1971}
1972
1973/* void glGenFramebuffersOES ( GLsizei n, GLuint *framebuffers ) */
1974static void
1975android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2
1976  (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) {
1977    jint _exception = 0;
1978    jarray _array = (jarray) 0;
1979    jint _remaining;
1980    GLuint *framebuffers = (GLuint *) 0;
1981
1982    framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, &_array, &_remaining);
1983    if (_remaining < n) {
1984        _exception = 1;
1985        _env->ThrowNew(IAEClass, "remaining() < n");
1986        goto exit;
1987    }
1988    glGenFramebuffersOES(
1989        (GLsizei)n,
1990        (GLuint *)framebuffers
1991    );
1992
1993exit:
1994    if (_array) {
1995        releasePointer(_env, _array, framebuffers, _exception ? JNI_FALSE : JNI_TRUE);
1996    }
1997}
1998
1999/* GLenum glCheckFramebufferStatusOES ( GLenum target ) */
2000static jint
2001android_glCheckFramebufferStatusOES__I
2002  (JNIEnv *_env, jobject _this, jint target) {
2003    GLenum _returnValue;
2004    _returnValue = glCheckFramebufferStatusOES(
2005        (GLenum)target
2006    );
2007    return _returnValue;
2008}
2009
2010/* void glFramebufferRenderbufferOES ( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) */
2011static void
2012android_glFramebufferRenderbufferOES__IIII
2013  (JNIEnv *_env, jobject _this, jint target, jint attachment, jint renderbuffertarget, jint renderbuffer) {
2014    glFramebufferRenderbufferOES(
2015        (GLenum)target,
2016        (GLenum)attachment,
2017        (GLenum)renderbuffertarget,
2018        (GLuint)renderbuffer
2019    );
2020}
2021
2022/* void glFramebufferTexture2DOES ( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) */
2023static void
2024android_glFramebufferTexture2DOES__IIIII
2025  (JNIEnv *_env, jobject _this, jint target, jint attachment, jint textarget, jint texture, jint level) {
2026    glFramebufferTexture2DOES(
2027        (GLenum)target,
2028        (GLenum)attachment,
2029        (GLenum)textarget,
2030        (GLuint)texture,
2031        (GLint)level
2032    );
2033}
2034
2035/* void glGetFramebufferAttachmentParameterivOES ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */
2036static void
2037android_glGetFramebufferAttachmentParameterivOES__III_3II
2038  (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jintArray params_ref, jint offset) {
2039    jint _exception = 0;
2040    GLint *params_base = (GLint *) 0;
2041    jint _remaining;
2042    GLint *params = (GLint *) 0;
2043
2044    if (!params_ref) {
2045        _exception = 1;
2046        _env->ThrowNew(IAEClass, "params == null");
2047        goto exit;
2048    }
2049    if (offset < 0) {
2050        _exception = 1;
2051        _env->ThrowNew(IAEClass, "offset < 0");
2052        goto exit;
2053    }
2054    _remaining = _env->GetArrayLength(params_ref) - offset;
2055    if (_remaining < 1) {
2056        _exception = 1;
2057        _env->ThrowNew(IAEClass, "length - offset < 1");
2058        goto exit;
2059    }
2060    params_base = (GLint *)
2061        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2062    params = params_base + offset;
2063
2064    glGetFramebufferAttachmentParameterivOES(
2065        (GLenum)target,
2066        (GLenum)attachment,
2067        (GLenum)pname,
2068        (GLint *)params
2069    );
2070
2071exit:
2072    if (params_base) {
2073        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2074            _exception ? JNI_ABORT: 0);
2075    }
2076}
2077
2078/* void glGetFramebufferAttachmentParameterivOES ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */
2079static void
2080android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2
2081  (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jobject params_buf) {
2082    jint _exception = 0;
2083    jarray _array = (jarray) 0;
2084    jint _remaining;
2085    GLint *params = (GLint *) 0;
2086
2087    params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
2088    if (_remaining < 1) {
2089        _exception = 1;
2090        _env->ThrowNew(IAEClass, "remaining() < 1");
2091        goto exit;
2092    }
2093    glGetFramebufferAttachmentParameterivOES(
2094        (GLenum)target,
2095        (GLenum)attachment,
2096        (GLenum)pname,
2097        (GLint *)params
2098    );
2099
2100exit:
2101    if (_array) {
2102        releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
2103    }
2104}
2105
2106/* void glGenerateMipmapOES ( GLenum target ) */
2107static void
2108android_glGenerateMipmapOES__I
2109  (JNIEnv *_env, jobject _this, jint target) {
2110    glGenerateMipmapOES(
2111        (GLenum)target
2112    );
2113}
2114
2115/* void glCurrentPaletteMatrixOES ( GLuint matrixpaletteindex ) */
2116static void
2117android_glCurrentPaletteMatrixOES__I
2118  (JNIEnv *_env, jobject _this, jint matrixpaletteindex) {
2119    glCurrentPaletteMatrixOES(
2120        (GLuint)matrixpaletteindex
2121    );
2122}
2123
2124/* void glLoadPaletteFromModelViewMatrixOES ( void ) */
2125static void
2126android_glLoadPaletteFromModelViewMatrixOES__
2127  (JNIEnv *_env, jobject _this) {
2128    glLoadPaletteFromModelViewMatrixOES();
2129}
2130
2131/* void glMatrixIndexPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
2132static void
2133android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I
2134  (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
2135    jarray _array = (jarray) 0;
2136    jint _remaining;
2137    GLvoid *pointer = (GLvoid *) 0;
2138
2139    if (pointer_buf) {
2140        pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
2141        if ( ! pointer ) {
2142            return;
2143        }
2144    }
2145    glMatrixIndexPointerOESBounds(
2146        (GLint)size,
2147        (GLenum)type,
2148        (GLsizei)stride,
2149        (GLvoid *)pointer,
2150        (GLsizei)remaining
2151    );
2152}
2153
2154/* void glWeightPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
2155static void
2156android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I
2157  (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
2158    jarray _array = (jarray) 0;
2159    jint _remaining;
2160    GLvoid *pointer = (GLvoid *) 0;
2161
2162    if (pointer_buf) {
2163        pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
2164        if ( ! pointer ) {
2165            return;
2166        }
2167    }
2168    glWeightPointerOESBounds(
2169        (GLint)size,
2170        (GLenum)type,
2171        (GLsizei)stride,
2172        (GLvoid *)pointer,
2173        (GLsizei)remaining
2174    );
2175}
2176
2177/* void glDepthRangefOES ( GLclampf zNear, GLclampf zFar ) */
2178static void
2179android_glDepthRangefOES__FF
2180  (JNIEnv *_env, jobject _this, jfloat zNear, jfloat zFar) {
2181    glDepthRangefOES(
2182        (GLclampf)zNear,
2183        (GLclampf)zFar
2184    );
2185}
2186
2187/* void glFrustumfOES ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */
2188static void
2189android_glFrustumfOES__FFFFFF
2190  (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) {
2191    glFrustumfOES(
2192        (GLfloat)left,
2193        (GLfloat)right,
2194        (GLfloat)bottom,
2195        (GLfloat)top,
2196        (GLfloat)zNear,
2197        (GLfloat)zFar
2198    );
2199}
2200
2201/* void glOrthofOES ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */
2202static void
2203android_glOrthofOES__FFFFFF
2204  (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) {
2205    glOrthofOES(
2206        (GLfloat)left,
2207        (GLfloat)right,
2208        (GLfloat)bottom,
2209        (GLfloat)top,
2210        (GLfloat)zNear,
2211        (GLfloat)zFar
2212    );
2213}
2214
2215/* void glClipPlanefOES ( GLenum plane, const GLfloat *equation ) */
2216static void
2217android_glClipPlanefOES__I_3FI
2218  (JNIEnv *_env, jobject _this, jint plane, jfloatArray equation_ref, jint offset) {
2219    GLfloat *equation_base = (GLfloat *) 0;
2220    jint _remaining;
2221    GLfloat *equation = (GLfloat *) 0;
2222
2223    if (!equation_ref) {
2224        _env->ThrowNew(IAEClass, "equation == null");
2225        goto exit;
2226    }
2227    if (offset < 0) {
2228        _env->ThrowNew(IAEClass, "offset < 0");
2229        goto exit;
2230    }
2231    _remaining = _env->GetArrayLength(equation_ref) - offset;
2232    equation_base = (GLfloat *)
2233        _env->GetPrimitiveArrayCritical(equation_ref, (jboolean *)0);
2234    equation = equation_base + offset;
2235
2236    glClipPlanefOES(
2237        (GLenum)plane,
2238        (GLfloat *)equation
2239    );
2240
2241exit:
2242    if (equation_base) {
2243        _env->ReleasePrimitiveArrayCritical(equation_ref, equation_base,
2244            JNI_ABORT);
2245    }
2246}
2247
2248/* void glClipPlanefOES ( GLenum plane, const GLfloat *equation ) */
2249static void
2250android_glClipPlanefOES__ILjava_nio_FloatBuffer_2
2251  (JNIEnv *_env, jobject _this, jint plane, jobject equation_buf) {
2252    jarray _array = (jarray) 0;
2253    jint _remaining;
2254    GLfloat *equation = (GLfloat *) 0;
2255
2256    equation = (GLfloat *)getPointer(_env, equation_buf, &_array, &_remaining);
2257    glClipPlanefOES(
2258        (GLenum)plane,
2259        (GLfloat *)equation
2260    );
2261    if (_array) {
2262        releasePointer(_env, _array, equation, JNI_FALSE);
2263    }
2264}
2265
2266/* void glGetClipPlanefOES ( GLenum pname, GLfloat *eqn ) */
2267static void
2268android_glGetClipPlanefOES__I_3FI
2269  (JNIEnv *_env, jobject _this, jint pname, jfloatArray eqn_ref, jint offset) {
2270    jint _exception = 0;
2271    GLfloat *eqn_base = (GLfloat *) 0;
2272    jint _remaining;
2273    GLfloat *eqn = (GLfloat *) 0;
2274
2275    if (!eqn_ref) {
2276        _exception = 1;
2277        _env->ThrowNew(IAEClass, "eqn == null");
2278        goto exit;
2279    }
2280    if (offset < 0) {
2281        _exception = 1;
2282        _env->ThrowNew(IAEClass, "offset < 0");
2283        goto exit;
2284    }
2285    _remaining = _env->GetArrayLength(eqn_ref) - offset;
2286    if (_remaining < 4) {
2287        _exception = 1;
2288        _env->ThrowNew(IAEClass, "length - offset < 4");
2289        goto exit;
2290    }
2291    eqn_base = (GLfloat *)
2292        _env->GetPrimitiveArrayCritical(eqn_ref, (jboolean *)0);
2293    eqn = eqn_base + offset;
2294
2295    glGetClipPlanefOES(
2296        (GLenum)pname,
2297        (GLfloat *)eqn
2298    );
2299
2300exit:
2301    if (eqn_base) {
2302        _env->ReleasePrimitiveArrayCritical(eqn_ref, eqn_base,
2303            _exception ? JNI_ABORT: 0);
2304    }
2305}
2306
2307/* void glGetClipPlanefOES ( GLenum pname, GLfloat *eqn ) */
2308static void
2309android_glGetClipPlanefOES__ILjava_nio_FloatBuffer_2
2310  (JNIEnv *_env, jobject _this, jint pname, jobject eqn_buf) {
2311    jint _exception = 0;
2312    jarray _array = (jarray) 0;
2313    jint _remaining;
2314    GLfloat *eqn = (GLfloat *) 0;
2315
2316    eqn = (GLfloat *)getPointer(_env, eqn_buf, &_array, &_remaining);
2317    if (_remaining < 4) {
2318        _exception = 1;
2319        _env->ThrowNew(IAEClass, "remaining() < 4");
2320        goto exit;
2321    }
2322    glGetClipPlanefOES(
2323        (GLenum)pname,
2324        (GLfloat *)eqn
2325    );
2326
2327exit:
2328    if (_array) {
2329        releasePointer(_env, _array, eqn, _exception ? JNI_FALSE : JNI_TRUE);
2330    }
2331}
2332
2333/* void glClearDepthfOES ( GLclampf depth ) */
2334static void
2335android_glClearDepthfOES__F
2336  (JNIEnv *_env, jobject _this, jfloat depth) {
2337    glClearDepthfOES(
2338        (GLclampf)depth
2339    );
2340}
2341
2342/* void glTexGenfOES ( GLenum coord, GLenum pname, GLfloat param ) */
2343static void
2344android_glTexGenfOES__IIF
2345  (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloat param) {
2346    glTexGenfOES(
2347        (GLenum)coord,
2348        (GLenum)pname,
2349        (GLfloat)param
2350    );
2351}
2352
2353/* void glTexGenfvOES ( GLenum coord, GLenum pname, const GLfloat *params ) */
2354static void
2355android_glTexGenfvOES__II_3FI
2356  (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) {
2357    GLfloat *params_base = (GLfloat *) 0;
2358    jint _remaining;
2359    GLfloat *params = (GLfloat *) 0;
2360
2361    if (!params_ref) {
2362        _env->ThrowNew(IAEClass, "params == null");
2363        goto exit;
2364    }
2365    if (offset < 0) {
2366        _env->ThrowNew(IAEClass, "offset < 0");
2367        goto exit;
2368    }
2369    _remaining = _env->GetArrayLength(params_ref) - offset;
2370    params_base = (GLfloat *)
2371        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2372    params = params_base + offset;
2373
2374    glTexGenfvOES(
2375        (GLenum)coord,
2376        (GLenum)pname,
2377        (GLfloat *)params
2378    );
2379
2380exit:
2381    if (params_base) {
2382        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2383            JNI_ABORT);
2384    }
2385}
2386
2387/* void glTexGenfvOES ( GLenum coord, GLenum pname, const GLfloat *params ) */
2388static void
2389android_glTexGenfvOES__IILjava_nio_FloatBuffer_2
2390  (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2391    jarray _array = (jarray) 0;
2392    jint _remaining;
2393    GLfloat *params = (GLfloat *) 0;
2394
2395    params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining);
2396    glTexGenfvOES(
2397        (GLenum)coord,
2398        (GLenum)pname,
2399        (GLfloat *)params
2400    );
2401    if (_array) {
2402        releasePointer(_env, _array, params, JNI_FALSE);
2403    }
2404}
2405
2406/* void glTexGeniOES ( GLenum coord, GLenum pname, GLint param ) */
2407static void
2408android_glTexGeniOES__III
2409  (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) {
2410    glTexGeniOES(
2411        (GLenum)coord,
2412        (GLenum)pname,
2413        (GLint)param
2414    );
2415}
2416
2417/* void glTexGenivOES ( GLenum coord, GLenum pname, const GLint *params ) */
2418static void
2419android_glTexGenivOES__II_3II
2420  (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
2421    GLint *params_base = (GLint *) 0;
2422    jint _remaining;
2423    GLint *params = (GLint *) 0;
2424
2425    if (!params_ref) {
2426        _env->ThrowNew(IAEClass, "params == null");
2427        goto exit;
2428    }
2429    if (offset < 0) {
2430        _env->ThrowNew(IAEClass, "offset < 0");
2431        goto exit;
2432    }
2433    _remaining = _env->GetArrayLength(params_ref) - offset;
2434    params_base = (GLint *)
2435        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2436    params = params_base + offset;
2437
2438    glTexGenivOES(
2439        (GLenum)coord,
2440        (GLenum)pname,
2441        (GLint *)params
2442    );
2443
2444exit:
2445    if (params_base) {
2446        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2447            JNI_ABORT);
2448    }
2449}
2450
2451/* void glTexGenivOES ( GLenum coord, GLenum pname, const GLint *params ) */
2452static void
2453android_glTexGenivOES__IILjava_nio_IntBuffer_2
2454  (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2455    jarray _array = (jarray) 0;
2456    jint _remaining;
2457    GLint *params = (GLint *) 0;
2458
2459    params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
2460    glTexGenivOES(
2461        (GLenum)coord,
2462        (GLenum)pname,
2463        (GLint *)params
2464    );
2465    if (_array) {
2466        releasePointer(_env, _array, params, JNI_FALSE);
2467    }
2468}
2469
2470/* void glTexGenxOES ( GLenum coord, GLenum pname, GLfixed param ) */
2471static void
2472android_glTexGenxOES__III
2473  (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) {
2474    glTexGenxOES(
2475        (GLenum)coord,
2476        (GLenum)pname,
2477        (GLfixed)param
2478    );
2479}
2480
2481/* void glTexGenxvOES ( GLenum coord, GLenum pname, const GLfixed *params ) */
2482static void
2483android_glTexGenxvOES__II_3II
2484  (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
2485    GLfixed *params_base = (GLfixed *) 0;
2486    jint _remaining;
2487    GLfixed *params = (GLfixed *) 0;
2488
2489    if (!params_ref) {
2490        _env->ThrowNew(IAEClass, "params == null");
2491        goto exit;
2492    }
2493    if (offset < 0) {
2494        _env->ThrowNew(IAEClass, "offset < 0");
2495        goto exit;
2496    }
2497    _remaining = _env->GetArrayLength(params_ref) - offset;
2498    params_base = (GLfixed *)
2499        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2500    params = params_base + offset;
2501
2502    glTexGenxvOES(
2503        (GLenum)coord,
2504        (GLenum)pname,
2505        (GLfixed *)params
2506    );
2507
2508exit:
2509    if (params_base) {
2510        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2511            JNI_ABORT);
2512    }
2513}
2514
2515/* void glTexGenxvOES ( GLenum coord, GLenum pname, const GLfixed *params ) */
2516static void
2517android_glTexGenxvOES__IILjava_nio_IntBuffer_2
2518  (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2519    jarray _array = (jarray) 0;
2520    jint _remaining;
2521    GLfixed *params = (GLfixed *) 0;
2522
2523    params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
2524    glTexGenxvOES(
2525        (GLenum)coord,
2526        (GLenum)pname,
2527        (GLfixed *)params
2528    );
2529    if (_array) {
2530        releasePointer(_env, _array, params, JNI_FALSE);
2531    }
2532}
2533
2534/* void glGetTexGenfvOES ( GLenum coord, GLenum pname, GLfloat *params ) */
2535static void
2536android_glGetTexGenfvOES__II_3FI
2537  (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) {
2538    jint _exception = 0;
2539    GLfloat *params_base = (GLfloat *) 0;
2540    jint _remaining;
2541    GLfloat *params = (GLfloat *) 0;
2542
2543    if (!params_ref) {
2544        _exception = 1;
2545        _env->ThrowNew(IAEClass, "params == null");
2546        goto exit;
2547    }
2548    if (offset < 0) {
2549        _exception = 1;
2550        _env->ThrowNew(IAEClass, "offset < 0");
2551        goto exit;
2552    }
2553    _remaining = _env->GetArrayLength(params_ref) - offset;
2554    params_base = (GLfloat *)
2555        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2556    params = params_base + offset;
2557
2558    glGetTexGenfvOES(
2559        (GLenum)coord,
2560        (GLenum)pname,
2561        (GLfloat *)params
2562    );
2563
2564exit:
2565    if (params_base) {
2566        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2567            _exception ? JNI_ABORT: 0);
2568    }
2569}
2570
2571/* void glGetTexGenfvOES ( GLenum coord, GLenum pname, GLfloat *params ) */
2572static void
2573android_glGetTexGenfvOES__IILjava_nio_FloatBuffer_2
2574  (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2575    jint _exception = 0;
2576    jarray _array = (jarray) 0;
2577    jint _remaining;
2578    GLfloat *params = (GLfloat *) 0;
2579
2580    params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining);
2581    glGetTexGenfvOES(
2582        (GLenum)coord,
2583        (GLenum)pname,
2584        (GLfloat *)params
2585    );
2586    if (_array) {
2587        releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
2588    }
2589}
2590
2591/* void glGetTexGenivOES ( GLenum coord, GLenum pname, GLint *params ) */
2592static void
2593android_glGetTexGenivOES__II_3II
2594  (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
2595    jint _exception = 0;
2596    GLint *params_base = (GLint *) 0;
2597    jint _remaining;
2598    GLint *params = (GLint *) 0;
2599
2600    if (!params_ref) {
2601        _exception = 1;
2602        _env->ThrowNew(IAEClass, "params == null");
2603        goto exit;
2604    }
2605    if (offset < 0) {
2606        _exception = 1;
2607        _env->ThrowNew(IAEClass, "offset < 0");
2608        goto exit;
2609    }
2610    _remaining = _env->GetArrayLength(params_ref) - offset;
2611    params_base = (GLint *)
2612        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2613    params = params_base + offset;
2614
2615    glGetTexGenivOES(
2616        (GLenum)coord,
2617        (GLenum)pname,
2618        (GLint *)params
2619    );
2620
2621exit:
2622    if (params_base) {
2623        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2624            _exception ? JNI_ABORT: 0);
2625    }
2626}
2627
2628/* void glGetTexGenivOES ( GLenum coord, GLenum pname, GLint *params ) */
2629static void
2630android_glGetTexGenivOES__IILjava_nio_IntBuffer_2
2631  (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2632    jint _exception = 0;
2633    jarray _array = (jarray) 0;
2634    jint _remaining;
2635    GLint *params = (GLint *) 0;
2636
2637    params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
2638    glGetTexGenivOES(
2639        (GLenum)coord,
2640        (GLenum)pname,
2641        (GLint *)params
2642    );
2643    if (_array) {
2644        releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
2645    }
2646}
2647
2648/* void glGetTexGenxvOES ( GLenum coord, GLenum pname, GLfixed *params ) */
2649static void
2650android_glGetTexGenxvOES__II_3II
2651  (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
2652    jint _exception = 0;
2653    GLfixed *params_base = (GLfixed *) 0;
2654    jint _remaining;
2655    GLfixed *params = (GLfixed *) 0;
2656
2657    if (!params_ref) {
2658        _exception = 1;
2659        _env->ThrowNew(IAEClass, "params == null");
2660        goto exit;
2661    }
2662    if (offset < 0) {
2663        _exception = 1;
2664        _env->ThrowNew(IAEClass, "offset < 0");
2665        goto exit;
2666    }
2667    _remaining = _env->GetArrayLength(params_ref) - offset;
2668    params_base = (GLfixed *)
2669        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2670    params = params_base + offset;
2671
2672    glGetTexGenxvOES(
2673        (GLenum)coord,
2674        (GLenum)pname,
2675        (GLfixed *)params
2676    );
2677
2678exit:
2679    if (params_base) {
2680        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2681            _exception ? JNI_ABORT: 0);
2682    }
2683}
2684
2685/* void glGetTexGenxvOES ( GLenum coord, GLenum pname, GLfixed *params ) */
2686static void
2687android_glGetTexGenxvOES__IILjava_nio_IntBuffer_2
2688  (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2689    jint _exception = 0;
2690    jarray _array = (jarray) 0;
2691    jint _remaining;
2692    GLfixed *params = (GLfixed *) 0;
2693
2694    params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
2695    glGetTexGenxvOES(
2696        (GLenum)coord,
2697        (GLenum)pname,
2698        (GLfixed *)params
2699    );
2700    if (_array) {
2701        releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
2702    }
2703}
2704
2705static const char *classPathName = "android/opengl/GLES11Ext";
2706
2707static JNINativeMethod methods[] = {
2708{"_nativeClassInit", "()V", (void*)nativeClassInit },
2709{"glBlendEquationSeparateOES", "(II)V", (void *) android_glBlendEquationSeparateOES__II },
2710{"glBlendFuncSeparateOES", "(IIII)V", (void *) android_glBlendFuncSeparateOES__IIII },
2711{"glBlendEquationOES", "(I)V", (void *) android_glBlendEquationOES__I },
2712{"glDrawTexsOES", "(SSSSS)V", (void *) android_glDrawTexsOES__SSSSS },
2713{"glDrawTexiOES", "(IIIII)V", (void *) android_glDrawTexiOES__IIIII },
2714{"glDrawTexxOES", "(IIIII)V", (void *) android_glDrawTexxOES__IIIII },
2715{"glDrawTexsvOES", "([SI)V", (void *) android_glDrawTexsvOES___3SI },
2716{"glDrawTexsvOES", "(Ljava/nio/ShortBuffer;)V", (void *) android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2 },
2717{"glDrawTexivOES", "([II)V", (void *) android_glDrawTexivOES___3II },
2718{"glDrawTexivOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexivOES__Ljava_nio_IntBuffer_2 },
2719{"glDrawTexxvOES", "([II)V", (void *) android_glDrawTexxvOES___3II },
2720{"glDrawTexxvOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexxvOES__Ljava_nio_IntBuffer_2 },
2721{"glDrawTexfOES", "(FFFFF)V", (void *) android_glDrawTexfOES__FFFFF },
2722{"glDrawTexfvOES", "([FI)V", (void *) android_glDrawTexfvOES___3FI },
2723{"glDrawTexfvOES", "(Ljava/nio/FloatBuffer;)V", (void *) android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2 },
2724{"glEGLImageTargetTexture2DOES", "(ILjava/nio/Buffer;)V", (void *) android_glEGLImageTargetTexture2DOES__ILjava_nio_Buffer_2 },
2725{"glEGLImageTargetRenderbufferStorageOES", "(ILjava/nio/Buffer;)V", (void *) android_glEGLImageTargetRenderbufferStorageOES__ILjava_nio_Buffer_2 },
2726{"glAlphaFuncxOES", "(II)V", (void *) android_glAlphaFuncxOES__II },
2727{"glClearColorxOES", "(IIII)V", (void *) android_glClearColorxOES__IIII },
2728{"glClearDepthxOES", "(I)V", (void *) android_glClearDepthxOES__I },
2729{"glClipPlanexOES", "(I[II)V", (void *) android_glClipPlanexOES__I_3II },
2730{"glClipPlanexOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glClipPlanexOES__ILjava_nio_IntBuffer_2 },
2731{"glColor4xOES", "(IIII)V", (void *) android_glColor4xOES__IIII },
2732{"glDepthRangexOES", "(II)V", (void *) android_glDepthRangexOES__II },
2733{"glFogxOES", "(II)V", (void *) android_glFogxOES__II },
2734{"glFogxvOES", "(I[II)V", (void *) android_glFogxvOES__I_3II },
2735{"glFogxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glFogxvOES__ILjava_nio_IntBuffer_2 },
2736{"glFrustumxOES", "(IIIIII)V", (void *) android_glFrustumxOES__IIIIII },
2737{"glGetClipPlanexOES", "(I[II)V", (void *) android_glGetClipPlanexOES__I_3II },
2738{"glGetClipPlanexOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetClipPlanexOES__ILjava_nio_IntBuffer_2 },
2739{"glGetFixedvOES", "(I[II)V", (void *) android_glGetFixedvOES__I_3II },
2740{"glGetFixedvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetFixedvOES__ILjava_nio_IntBuffer_2 },
2741{"glGetLightxvOES", "(II[II)V", (void *) android_glGetLightxvOES__II_3II },
2742{"glGetLightxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetLightxvOES__IILjava_nio_IntBuffer_2 },
2743{"glGetMaterialxvOES", "(II[II)V", (void *) android_glGetMaterialxvOES__II_3II },
2744{"glGetMaterialxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetMaterialxvOES__IILjava_nio_IntBuffer_2 },
2745{"glGetTexEnvxvOES", "(II[II)V", (void *) android_glGetTexEnvxvOES__II_3II },
2746{"glGetTexEnvxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexEnvxvOES__IILjava_nio_IntBuffer_2 },
2747{"glGetTexParameterxvOES", "(II[II)V", (void *) android_glGetTexParameterxvOES__II_3II },
2748{"glGetTexParameterxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameterxvOES__IILjava_nio_IntBuffer_2 },
2749{"glLightModelxOES", "(II)V", (void *) android_glLightModelxOES__II },
2750{"glLightModelxvOES", "(I[II)V", (void *) android_glLightModelxvOES__I_3II },
2751{"glLightModelxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glLightModelxvOES__ILjava_nio_IntBuffer_2 },
2752{"glLightxOES", "(III)V", (void *) android_glLightxOES__III },
2753{"glLightxvOES", "(II[II)V", (void *) android_glLightxvOES__II_3II },
2754{"glLightxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glLightxvOES__IILjava_nio_IntBuffer_2 },
2755{"glLineWidthxOES", "(I)V", (void *) android_glLineWidthxOES__I },
2756{"glLoadMatrixxOES", "([II)V", (void *) android_glLoadMatrixxOES___3II },
2757{"glLoadMatrixxOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glLoadMatrixxOES__Ljava_nio_IntBuffer_2 },
2758{"glMaterialxOES", "(III)V", (void *) android_glMaterialxOES__III },
2759{"glMaterialxvOES", "(II[II)V", (void *) android_glMaterialxvOES__II_3II },
2760{"glMaterialxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glMaterialxvOES__IILjava_nio_IntBuffer_2 },
2761{"glMultMatrixxOES", "([II)V", (void *) android_glMultMatrixxOES___3II },
2762{"glMultMatrixxOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glMultMatrixxOES__Ljava_nio_IntBuffer_2 },
2763{"glMultiTexCoord4xOES", "(IIIII)V", (void *) android_glMultiTexCoord4xOES__IIIII },
2764{"glNormal3xOES", "(III)V", (void *) android_glNormal3xOES__III },
2765{"glOrthoxOES", "(IIIIII)V", (void *) android_glOrthoxOES__IIIIII },
2766{"glPointParameterxOES", "(II)V", (void *) android_glPointParameterxOES__II },
2767{"glPointParameterxvOES", "(I[II)V", (void *) android_glPointParameterxvOES__I_3II },
2768{"glPointParameterxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glPointParameterxvOES__ILjava_nio_IntBuffer_2 },
2769{"glPointSizexOES", "(I)V", (void *) android_glPointSizexOES__I },
2770{"glPolygonOffsetxOES", "(II)V", (void *) android_glPolygonOffsetxOES__II },
2771{"glRotatexOES", "(IIII)V", (void *) android_glRotatexOES__IIII },
2772{"glSampleCoveragexOES", "(IZ)V", (void *) android_glSampleCoveragexOES__IZ },
2773{"glScalexOES", "(III)V", (void *) android_glScalexOES__III },
2774{"glTexEnvxOES", "(III)V", (void *) android_glTexEnvxOES__III },
2775{"glTexEnvxvOES", "(II[II)V", (void *) android_glTexEnvxvOES__II_3II },
2776{"glTexEnvxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexEnvxvOES__IILjava_nio_IntBuffer_2 },
2777{"glTexParameterxOES", "(III)V", (void *) android_glTexParameterxOES__III },
2778{"glTexParameterxvOES", "(II[II)V", (void *) android_glTexParameterxvOES__II_3II },
2779{"glTexParameterxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameterxvOES__IILjava_nio_IntBuffer_2 },
2780{"glTranslatexOES", "(III)V", (void *) android_glTranslatexOES__III },
2781{"glIsRenderbufferOES", "(I)Z", (void *) android_glIsRenderbufferOES__I },
2782{"glBindRenderbufferOES", "(II)V", (void *) android_glBindRenderbufferOES__II },
2783{"glDeleteRenderbuffersOES", "(I[II)V", (void *) android_glDeleteRenderbuffersOES__I_3II },
2784{"glDeleteRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2 },
2785{"glGenRenderbuffersOES", "(I[II)V", (void *) android_glGenRenderbuffersOES__I_3II },
2786{"glGenRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2 },
2787{"glRenderbufferStorageOES", "(IIII)V", (void *) android_glRenderbufferStorageOES__IIII },
2788{"glGetRenderbufferParameterivOES", "(II[II)V", (void *) android_glGetRenderbufferParameterivOES__II_3II },
2789{"glGetRenderbufferParameterivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2 },
2790{"glIsFramebufferOES", "(I)Z", (void *) android_glIsFramebufferOES__I },
2791{"glBindFramebufferOES", "(II)V", (void *) android_glBindFramebufferOES__II },
2792{"glDeleteFramebuffersOES", "(I[II)V", (void *) android_glDeleteFramebuffersOES__I_3II },
2793{"glDeleteFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2 },
2794{"glGenFramebuffersOES", "(I[II)V", (void *) android_glGenFramebuffersOES__I_3II },
2795{"glGenFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2 },
2796{"glCheckFramebufferStatusOES", "(I)I", (void *) android_glCheckFramebufferStatusOES__I },
2797{"glFramebufferRenderbufferOES", "(IIII)V", (void *) android_glFramebufferRenderbufferOES__IIII },
2798{"glFramebufferTexture2DOES", "(IIIII)V", (void *) android_glFramebufferTexture2DOES__IIIII },
2799{"glGetFramebufferAttachmentParameterivOES", "(III[II)V", (void *) android_glGetFramebufferAttachmentParameterivOES__III_3II },
2800{"glGetFramebufferAttachmentParameterivOES", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2 },
2801{"glGenerateMipmapOES", "(I)V", (void *) android_glGenerateMipmapOES__I },
2802{"glCurrentPaletteMatrixOES", "(I)V", (void *) android_glCurrentPaletteMatrixOES__I },
2803{"glLoadPaletteFromModelViewMatrixOES", "()V", (void *) android_glLoadPaletteFromModelViewMatrixOES__ },
2804{"glMatrixIndexPointerOESBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I },
2805{"glWeightPointerOESBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I },
2806{"glDepthRangefOES", "(FF)V", (void *) android_glDepthRangefOES__FF },
2807{"glFrustumfOES", "(FFFFFF)V", (void *) android_glFrustumfOES__FFFFFF },
2808{"glOrthofOES", "(FFFFFF)V", (void *) android_glOrthofOES__FFFFFF },
2809{"glClipPlanefOES", "(I[FI)V", (void *) android_glClipPlanefOES__I_3FI },
2810{"glClipPlanefOES", "(ILjava/nio/FloatBuffer;)V", (void *) android_glClipPlanefOES__ILjava_nio_FloatBuffer_2 },
2811{"glGetClipPlanefOES", "(I[FI)V", (void *) android_glGetClipPlanefOES__I_3FI },
2812{"glGetClipPlanefOES", "(ILjava/nio/FloatBuffer;)V", (void *) android_glGetClipPlanefOES__ILjava_nio_FloatBuffer_2 },
2813{"glClearDepthfOES", "(F)V", (void *) android_glClearDepthfOES__F },
2814{"glTexGenfOES", "(IIF)V", (void *) android_glTexGenfOES__IIF },
2815{"glTexGenfvOES", "(II[FI)V", (void *) android_glTexGenfvOES__II_3FI },
2816{"glTexGenfvOES", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexGenfvOES__IILjava_nio_FloatBuffer_2 },
2817{"glTexGeniOES", "(III)V", (void *) android_glTexGeniOES__III },
2818{"glTexGenivOES", "(II[II)V", (void *) android_glTexGenivOES__II_3II },
2819{"glTexGenivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGenivOES__IILjava_nio_IntBuffer_2 },
2820{"glTexGenxOES", "(III)V", (void *) android_glTexGenxOES__III },
2821{"glTexGenxvOES", "(II[II)V", (void *) android_glTexGenxvOES__II_3II },
2822{"glTexGenxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGenxvOES__IILjava_nio_IntBuffer_2 },
2823{"glGetTexGenfvOES", "(II[FI)V", (void *) android_glGetTexGenfvOES__II_3FI },
2824{"glGetTexGenfvOES", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetTexGenfvOES__IILjava_nio_FloatBuffer_2 },
2825{"glGetTexGenivOES", "(II[II)V", (void *) android_glGetTexGenivOES__II_3II },
2826{"glGetTexGenivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGenivOES__IILjava_nio_IntBuffer_2 },
2827{"glGetTexGenxvOES", "(II[II)V", (void *) android_glGetTexGenxvOES__II_3II },
2828{"glGetTexGenxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGenxvOES__IILjava_nio_IntBuffer_2 },
2829};
2830
2831int register_android_opengl_jni_GLES11Ext(JNIEnv *_env)
2832{
2833    int err;
2834    err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));
2835    return err;
2836}
2837