android_opengl_GLES20.cpp revision 37c9b49ab5eb5a676370fd7081db0967c38e97a6 
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 "jni.h"
21#include "JNIHelp.h"
22#include <android_runtime/AndroidRuntime.h>
23#include <utils/misc.h>
24
25#include <assert.h>
26#include <GLES2/gl2.h>
27#include <GLES2/gl2ext.h>
28
29static int initialized = 0;
30
31static jclass nioAccessClass;
32static jclass bufferClass;
33static jmethodID getBasePointerID;
34static jmethodID getBaseArrayID;
35static jmethodID getBaseArrayOffsetID;
36static jfieldID positionID;
37static jfieldID limitID;
38static jfieldID elementSizeShiftID;
39
40/* Cache method IDs each time the class is loaded. */
41
42static void
43nativeClassInit(JNIEnv *_env, jclass glImplClass)
44{
45    jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess");
46    nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal);
47
48    jclass bufferClassLocal = _env->FindClass("java/nio/Buffer");
49    bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal);
50
51    getBasePointerID = _env->GetStaticMethodID(nioAccessClass,
52            "getBasePointer", "(Ljava/nio/Buffer;)J");
53    getBaseArrayID = _env->GetStaticMethodID(nioAccessClass,
54            "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;");
55    getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass,
56            "getBaseArrayOffset", "(Ljava/nio/Buffer;)I");
57
58    positionID = _env->GetFieldID(bufferClass, "position", "I");
59    limitID = _env->GetFieldID(bufferClass, "limit", "I");
60    elementSizeShiftID =
61        _env->GetFieldID(bufferClass, "_elementSizeShift", "I");
62}
63
64
65static void *
66getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining, jint *offset)
67{
68    jint position;
69    jint limit;
70    jint elementSizeShift;
71    jlong pointer;
72
73    position = _env->GetIntField(buffer, positionID);
74    limit = _env->GetIntField(buffer, limitID);
75    elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
76    *remaining = (limit - position) << elementSizeShift;
77    pointer = _env->CallStaticLongMethod(nioAccessClass,
78            getBasePointerID, buffer);
79    if (pointer != 0L) {
80        *array = NULL;
81        return (void *) (jint) pointer;
82    }
83
84    *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass,
85            getBaseArrayID, buffer);
86    *offset = _env->CallStaticIntMethod(nioAccessClass,
87            getBaseArrayOffsetID, buffer);
88
89    return NULL;
90}
91
92
93static void
94releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit)
95{
96    _env->ReleasePrimitiveArrayCritical(array, data,
97					   commit ? 0 : JNI_ABORT);
98}
99
100static void *
101getDirectBufferPointer(JNIEnv *_env, jobject buffer) {
102    char* buf = (char*) _env->GetDirectBufferAddress(buffer);
103    if (buf) {
104        jint position = _env->GetIntField(buffer, positionID);
105        jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
106        buf += position << elementSizeShift;
107    } else {
108        jniThrowException(_env, "java/lang/IllegalArgumentException",
109                          "Must use a native order direct Buffer");
110    }
111    return (void*) buf;
112}
113
114static int
115getNumCompressedTextureFormats() {
116    int numCompressedTextureFormats = 0;
117    glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numCompressedTextureFormats);
118    return numCompressedTextureFormats;
119}
120
121static void glVertexAttribPointerBounds(GLuint indx, GLint size, GLenum type,
122        GLboolean normalized, GLsizei stride, const GLvoid *pointer, GLsizei count) {
123    glVertexAttribPointer(indx, size, type, normalized, stride, pointer);
124}
125
126// --------------------------------------------------------------------------
127/* void glActiveTexture ( GLenum texture ) */
128static void
129android_glActiveTexture__I
130  (JNIEnv *_env, jobject _this, jint texture) {
131    glActiveTexture(
132        (GLenum)texture
133    );
134}
135
136/* void glAttachShader ( GLuint program, GLuint shader ) */
137static void
138android_glAttachShader__II
139  (JNIEnv *_env, jobject _this, jint program, jint shader) {
140    glAttachShader(
141        (GLuint)program,
142        (GLuint)shader
143    );
144}
145
146/* void glBindAttribLocation ( GLuint program, GLuint index, const char *name ) */
147static void
148android_glBindAttribLocation__IILjava_lang_String_2
149  (JNIEnv *_env, jobject _this, jint program, jint index, jstring name) {
150    jint _exception = 0;
151    const char * _exceptionType;
152    const char * _exceptionMessage;
153    const char* _nativename = 0;
154
155    if (!name) {
156        _exceptionType = "java/lang/IllegalArgumentException";
157        _exceptionMessage = "name == null";
158        goto exit;
159    }
160    _nativename = _env->GetStringUTFChars(name, 0);
161
162    glBindAttribLocation(
163        (GLuint)program,
164        (GLuint)index,
165        (char *)_nativename
166    );
167
168exit:
169    if (_nativename) {
170        _env->ReleaseStringUTFChars(name, _nativename);
171    }
172
173    if (_exception) {
174        jniThrowException(_env, _exceptionType, _exceptionMessage);
175    }
176}
177
178/* void glBindBuffer ( GLenum target, GLuint buffer ) */
179static void
180android_glBindBuffer__II
181  (JNIEnv *_env, jobject _this, jint target, jint buffer) {
182    glBindBuffer(
183        (GLenum)target,
184        (GLuint)buffer
185    );
186}
187
188/* void glBindFramebuffer ( GLenum target, GLuint framebuffer ) */
189static void
190android_glBindFramebuffer__II
191  (JNIEnv *_env, jobject _this, jint target, jint framebuffer) {
192    glBindFramebuffer(
193        (GLenum)target,
194        (GLuint)framebuffer
195    );
196}
197
198/* void glBindRenderbuffer ( GLenum target, GLuint renderbuffer ) */
199static void
200android_glBindRenderbuffer__II
201  (JNIEnv *_env, jobject _this, jint target, jint renderbuffer) {
202    glBindRenderbuffer(
203        (GLenum)target,
204        (GLuint)renderbuffer
205    );
206}
207
208/* void glBindTexture ( GLenum target, GLuint texture ) */
209static void
210android_glBindTexture__II
211  (JNIEnv *_env, jobject _this, jint target, jint texture) {
212    glBindTexture(
213        (GLenum)target,
214        (GLuint)texture
215    );
216}
217
218/* void glBlendColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) */
219static void
220android_glBlendColor__FFFF
221  (JNIEnv *_env, jobject _this, jfloat red, jfloat green, jfloat blue, jfloat alpha) {
222    glBlendColor(
223        (GLclampf)red,
224        (GLclampf)green,
225        (GLclampf)blue,
226        (GLclampf)alpha
227    );
228}
229
230/* void glBlendEquation ( GLenum mode ) */
231static void
232android_glBlendEquation__I
233  (JNIEnv *_env, jobject _this, jint mode) {
234    glBlendEquation(
235        (GLenum)mode
236    );
237}
238
239/* void glBlendEquationSeparate ( GLenum modeRGB, GLenum modeAlpha ) */
240static void
241android_glBlendEquationSeparate__II
242  (JNIEnv *_env, jobject _this, jint modeRGB, jint modeAlpha) {
243    glBlendEquationSeparate(
244        (GLenum)modeRGB,
245        (GLenum)modeAlpha
246    );
247}
248
249/* void glBlendFunc ( GLenum sfactor, GLenum dfactor ) */
250static void
251android_glBlendFunc__II
252  (JNIEnv *_env, jobject _this, jint sfactor, jint dfactor) {
253    glBlendFunc(
254        (GLenum)sfactor,
255        (GLenum)dfactor
256    );
257}
258
259/* void glBlendFuncSeparate ( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) */
260static void
261android_glBlendFuncSeparate__IIII
262  (JNIEnv *_env, jobject _this, jint srcRGB, jint dstRGB, jint srcAlpha, jint dstAlpha) {
263    glBlendFuncSeparate(
264        (GLenum)srcRGB,
265        (GLenum)dstRGB,
266        (GLenum)srcAlpha,
267        (GLenum)dstAlpha
268    );
269}
270
271/* void glBufferData ( GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage ) */
272static void
273android_glBufferData__IILjava_nio_Buffer_2I
274  (JNIEnv *_env, jobject _this, jint target, jint size, jobject data_buf, jint usage) {
275    jint _exception = 0;
276    const char * _exceptionType;
277    const char * _exceptionMessage;
278    jarray _array = (jarray) 0;
279    jint _bufferOffset = (jint) 0;
280    jint _remaining;
281    GLvoid *data = (GLvoid *) 0;
282
283    if (data_buf) {
284        data = (GLvoid *)getPointer(_env, data_buf, &_array, &_remaining, &_bufferOffset);
285        if (_remaining < size) {
286            _exception = 1;
287            _exceptionType = "java/lang/IllegalArgumentException";
288            _exceptionMessage = "remaining() < size < needed";
289            goto exit;
290        }
291    }
292    if (data_buf && data == NULL) {
293        char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
294        data = (GLvoid *) (_dataBase + _bufferOffset);
295    }
296    glBufferData(
297        (GLenum)target,
298        (GLsizeiptr)size,
299        (GLvoid *)data,
300        (GLenum)usage
301    );
302
303exit:
304    if (_array) {
305        releasePointer(_env, _array, data, JNI_FALSE);
306    }
307    if (_exception) {
308        jniThrowException(_env, _exceptionType, _exceptionMessage);
309    }
310}
311
312/* void glBufferSubData ( GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data ) */
313static void
314android_glBufferSubData__IIILjava_nio_Buffer_2
315  (JNIEnv *_env, jobject _this, jint target, jint offset, jint size, jobject data_buf) {
316    jint _exception = 0;
317    const char * _exceptionType;
318    const char * _exceptionMessage;
319    jarray _array = (jarray) 0;
320    jint _bufferOffset = (jint) 0;
321    jint _remaining;
322    GLvoid *data = (GLvoid *) 0;
323
324    data = (GLvoid *)getPointer(_env, data_buf, &_array, &_remaining, &_bufferOffset);
325    if (_remaining < size) {
326        _exception = 1;
327        _exceptionType = "java/lang/IllegalArgumentException";
328        _exceptionMessage = "remaining() < size < needed";
329        goto exit;
330    }
331    if (data == NULL) {
332        char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
333        data = (GLvoid *) (_dataBase + _bufferOffset);
334    }
335    glBufferSubData(
336        (GLenum)target,
337        (GLintptr)offset,
338        (GLsizeiptr)size,
339        (GLvoid *)data
340    );
341
342exit:
343    if (_array) {
344        releasePointer(_env, _array, data, JNI_FALSE);
345    }
346    if (_exception) {
347        jniThrowException(_env, _exceptionType, _exceptionMessage);
348    }
349}
350
351/* GLenum glCheckFramebufferStatus ( GLenum target ) */
352static jint
353android_glCheckFramebufferStatus__I
354  (JNIEnv *_env, jobject _this, jint target) {
355    GLenum _returnValue;
356    _returnValue = glCheckFramebufferStatus(
357        (GLenum)target
358    );
359    return _returnValue;
360}
361
362/* void glClear ( GLbitfield mask ) */
363static void
364android_glClear__I
365  (JNIEnv *_env, jobject _this, jint mask) {
366    glClear(
367        (GLbitfield)mask
368    );
369}
370
371/* void glClearColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) */
372static void
373android_glClearColor__FFFF
374  (JNIEnv *_env, jobject _this, jfloat red, jfloat green, jfloat blue, jfloat alpha) {
375    glClearColor(
376        (GLclampf)red,
377        (GLclampf)green,
378        (GLclampf)blue,
379        (GLclampf)alpha
380    );
381}
382
383/* void glClearDepthf ( GLclampf depth ) */
384static void
385android_glClearDepthf__F
386  (JNIEnv *_env, jobject _this, jfloat depth) {
387    glClearDepthf(
388        (GLclampf)depth
389    );
390}
391
392/* void glClearStencil ( GLint s ) */
393static void
394android_glClearStencil__I
395  (JNIEnv *_env, jobject _this, jint s) {
396    glClearStencil(
397        (GLint)s
398    );
399}
400
401/* void glColorMask ( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) */
402static void
403android_glColorMask__ZZZZ
404  (JNIEnv *_env, jobject _this, jboolean red, jboolean green, jboolean blue, jboolean alpha) {
405    glColorMask(
406        (GLboolean)red,
407        (GLboolean)green,
408        (GLboolean)blue,
409        (GLboolean)alpha
410    );
411}
412
413/* void glCompileShader ( GLuint shader ) */
414static void
415android_glCompileShader__I
416  (JNIEnv *_env, jobject _this, jint shader) {
417    glCompileShader(
418        (GLuint)shader
419    );
420}
421
422/* void glCompressedTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data ) */
423static void
424android_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2
425  (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint imageSize, jobject data_buf) {
426    jarray _array = (jarray) 0;
427    jint _bufferOffset = (jint) 0;
428    jint _remaining;
429    GLvoid *data = (GLvoid *) 0;
430
431    data = (GLvoid *)getPointer(_env, data_buf, &_array, &_remaining, &_bufferOffset);
432    if (data == NULL) {
433        char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
434        data = (GLvoid *) (_dataBase + _bufferOffset);
435    }
436    glCompressedTexImage2D(
437        (GLenum)target,
438        (GLint)level,
439        (GLenum)internalformat,
440        (GLsizei)width,
441        (GLsizei)height,
442        (GLint)border,
443        (GLsizei)imageSize,
444        (GLvoid *)data
445    );
446    if (_array) {
447        releasePointer(_env, _array, data, JNI_FALSE);
448    }
449}
450
451/* void glCompressedTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data ) */
452static void
453android_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2
454  (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint imageSize, jobject data_buf) {
455    jarray _array = (jarray) 0;
456    jint _bufferOffset = (jint) 0;
457    jint _remaining;
458    GLvoid *data = (GLvoid *) 0;
459
460    data = (GLvoid *)getPointer(_env, data_buf, &_array, &_remaining, &_bufferOffset);
461    if (data == NULL) {
462        char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
463        data = (GLvoid *) (_dataBase + _bufferOffset);
464    }
465    glCompressedTexSubImage2D(
466        (GLenum)target,
467        (GLint)level,
468        (GLint)xoffset,
469        (GLint)yoffset,
470        (GLsizei)width,
471        (GLsizei)height,
472        (GLenum)format,
473        (GLsizei)imageSize,
474        (GLvoid *)data
475    );
476    if (_array) {
477        releasePointer(_env, _array, data, JNI_FALSE);
478    }
479}
480
481/* void glCopyTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) */
482static void
483android_glCopyTexImage2D__IIIIIIII
484  (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint x, jint y, jint width, jint height, jint border) {
485    glCopyTexImage2D(
486        (GLenum)target,
487        (GLint)level,
488        (GLenum)internalformat,
489        (GLint)x,
490        (GLint)y,
491        (GLsizei)width,
492        (GLsizei)height,
493        (GLint)border
494    );
495}
496
497/* void glCopyTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) */
498static void
499android_glCopyTexSubImage2D__IIIIIIII
500  (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint x, jint y, jint width, jint height) {
501    glCopyTexSubImage2D(
502        (GLenum)target,
503        (GLint)level,
504        (GLint)xoffset,
505        (GLint)yoffset,
506        (GLint)x,
507        (GLint)y,
508        (GLsizei)width,
509        (GLsizei)height
510    );
511}
512
513/* GLuint glCreateProgram ( void ) */
514static jint
515android_glCreateProgram__
516  (JNIEnv *_env, jobject _this) {
517    GLuint _returnValue;
518    _returnValue = glCreateProgram();
519    return _returnValue;
520}
521
522/* GLuint glCreateShader ( GLenum type ) */
523static jint
524android_glCreateShader__I
525  (JNIEnv *_env, jobject _this, jint type) {
526    GLuint _returnValue;
527    _returnValue = glCreateShader(
528        (GLenum)type
529    );
530    return _returnValue;
531}
532
533/* void glCullFace ( GLenum mode ) */
534static void
535android_glCullFace__I
536  (JNIEnv *_env, jobject _this, jint mode) {
537    glCullFace(
538        (GLenum)mode
539    );
540}
541
542/* void glDeleteBuffers ( GLsizei n, const GLuint *buffers ) */
543static void
544android_glDeleteBuffers__I_3II
545  (JNIEnv *_env, jobject _this, jint n, jintArray buffers_ref, jint offset) {
546    jint _exception = 0;
547    const char * _exceptionType;
548    const char * _exceptionMessage;
549    GLuint *buffers_base = (GLuint *) 0;
550    jint _remaining;
551    GLuint *buffers = (GLuint *) 0;
552
553    if (!buffers_ref) {
554        _exception = 1;
555        _exceptionType = "java/lang/IllegalArgumentException";
556        _exceptionMessage = "buffers == null";
557        goto exit;
558    }
559    if (offset < 0) {
560        _exception = 1;
561        _exceptionType = "java/lang/IllegalArgumentException";
562        _exceptionMessage = "offset < 0";
563        goto exit;
564    }
565    _remaining = _env->GetArrayLength(buffers_ref) - offset;
566    if (_remaining < n) {
567        _exception = 1;
568        _exceptionType = "java/lang/IllegalArgumentException";
569        _exceptionMessage = "length - offset < n < needed";
570        goto exit;
571    }
572    buffers_base = (GLuint *)
573        _env->GetPrimitiveArrayCritical(buffers_ref, (jboolean *)0);
574    buffers = buffers_base + offset;
575
576    glDeleteBuffers(
577        (GLsizei)n,
578        (GLuint *)buffers
579    );
580
581exit:
582    if (buffers_base) {
583        _env->ReleasePrimitiveArrayCritical(buffers_ref, buffers_base,
584            JNI_ABORT);
585    }
586    if (_exception) {
587        jniThrowException(_env, _exceptionType, _exceptionMessage);
588    }
589}
590
591/* void glDeleteBuffers ( GLsizei n, const GLuint *buffers ) */
592static void
593android_glDeleteBuffers__ILjava_nio_IntBuffer_2
594  (JNIEnv *_env, jobject _this, jint n, jobject buffers_buf) {
595    jint _exception = 0;
596    const char * _exceptionType;
597    const char * _exceptionMessage;
598    jarray _array = (jarray) 0;
599    jint _bufferOffset = (jint) 0;
600    jint _remaining;
601    GLuint *buffers = (GLuint *) 0;
602
603    buffers = (GLuint *)getPointer(_env, buffers_buf, &_array, &_remaining, &_bufferOffset);
604    if (_remaining < n) {
605        _exception = 1;
606        _exceptionType = "java/lang/IllegalArgumentException";
607        _exceptionMessage = "remaining() < n < needed";
608        goto exit;
609    }
610    if (buffers == NULL) {
611        char * _buffersBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
612        buffers = (GLuint *) (_buffersBase + _bufferOffset);
613    }
614    glDeleteBuffers(
615        (GLsizei)n,
616        (GLuint *)buffers
617    );
618
619exit:
620    if (_array) {
621        releasePointer(_env, _array, buffers, JNI_FALSE);
622    }
623    if (_exception) {
624        jniThrowException(_env, _exceptionType, _exceptionMessage);
625    }
626}
627
628/* void glDeleteFramebuffers ( GLsizei n, const GLuint *framebuffers ) */
629static void
630android_glDeleteFramebuffers__I_3II
631  (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) {
632    jint _exception = 0;
633    const char * _exceptionType;
634    const char * _exceptionMessage;
635    GLuint *framebuffers_base = (GLuint *) 0;
636    jint _remaining;
637    GLuint *framebuffers = (GLuint *) 0;
638
639    if (!framebuffers_ref) {
640        _exception = 1;
641        _exceptionType = "java/lang/IllegalArgumentException";
642        _exceptionMessage = "framebuffers == null";
643        goto exit;
644    }
645    if (offset < 0) {
646        _exception = 1;
647        _exceptionType = "java/lang/IllegalArgumentException";
648        _exceptionMessage = "offset < 0";
649        goto exit;
650    }
651    _remaining = _env->GetArrayLength(framebuffers_ref) - offset;
652    framebuffers_base = (GLuint *)
653        _env->GetPrimitiveArrayCritical(framebuffers_ref, (jboolean *)0);
654    framebuffers = framebuffers_base + offset;
655
656    glDeleteFramebuffers(
657        (GLsizei)n,
658        (GLuint *)framebuffers
659    );
660
661exit:
662    if (framebuffers_base) {
663        _env->ReleasePrimitiveArrayCritical(framebuffers_ref, framebuffers_base,
664            JNI_ABORT);
665    }
666    if (_exception) {
667        jniThrowException(_env, _exceptionType, _exceptionMessage);
668    }
669}
670
671/* void glDeleteFramebuffers ( GLsizei n, const GLuint *framebuffers ) */
672static void
673android_glDeleteFramebuffers__ILjava_nio_IntBuffer_2
674  (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) {
675    jarray _array = (jarray) 0;
676    jint _bufferOffset = (jint) 0;
677    jint _remaining;
678    GLuint *framebuffers = (GLuint *) 0;
679
680    framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, &_array, &_remaining, &_bufferOffset);
681    if (framebuffers == NULL) {
682        char * _framebuffersBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
683        framebuffers = (GLuint *) (_framebuffersBase + _bufferOffset);
684    }
685    glDeleteFramebuffers(
686        (GLsizei)n,
687        (GLuint *)framebuffers
688    );
689    if (_array) {
690        releasePointer(_env, _array, framebuffers, JNI_FALSE);
691    }
692}
693
694/* void glDeleteProgram ( GLuint program ) */
695static void
696android_glDeleteProgram__I
697  (JNIEnv *_env, jobject _this, jint program) {
698    glDeleteProgram(
699        (GLuint)program
700    );
701}
702
703/* void glDeleteRenderbuffers ( GLsizei n, const GLuint *renderbuffers ) */
704static void
705android_glDeleteRenderbuffers__I_3II
706  (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) {
707    jint _exception = 0;
708    const char * _exceptionType;
709    const char * _exceptionMessage;
710    GLuint *renderbuffers_base = (GLuint *) 0;
711    jint _remaining;
712    GLuint *renderbuffers = (GLuint *) 0;
713
714    if (!renderbuffers_ref) {
715        _exception = 1;
716        _exceptionType = "java/lang/IllegalArgumentException";
717        _exceptionMessage = "renderbuffers == null";
718        goto exit;
719    }
720    if (offset < 0) {
721        _exception = 1;
722        _exceptionType = "java/lang/IllegalArgumentException";
723        _exceptionMessage = "offset < 0";
724        goto exit;
725    }
726    _remaining = _env->GetArrayLength(renderbuffers_ref) - offset;
727    renderbuffers_base = (GLuint *)
728        _env->GetPrimitiveArrayCritical(renderbuffers_ref, (jboolean *)0);
729    renderbuffers = renderbuffers_base + offset;
730
731    glDeleteRenderbuffers(
732        (GLsizei)n,
733        (GLuint *)renderbuffers
734    );
735
736exit:
737    if (renderbuffers_base) {
738        _env->ReleasePrimitiveArrayCritical(renderbuffers_ref, renderbuffers_base,
739            JNI_ABORT);
740    }
741    if (_exception) {
742        jniThrowException(_env, _exceptionType, _exceptionMessage);
743    }
744}
745
746/* void glDeleteRenderbuffers ( GLsizei n, const GLuint *renderbuffers ) */
747static void
748android_glDeleteRenderbuffers__ILjava_nio_IntBuffer_2
749  (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) {
750    jarray _array = (jarray) 0;
751    jint _bufferOffset = (jint) 0;
752    jint _remaining;
753    GLuint *renderbuffers = (GLuint *) 0;
754
755    renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, &_array, &_remaining, &_bufferOffset);
756    if (renderbuffers == NULL) {
757        char * _renderbuffersBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
758        renderbuffers = (GLuint *) (_renderbuffersBase + _bufferOffset);
759    }
760    glDeleteRenderbuffers(
761        (GLsizei)n,
762        (GLuint *)renderbuffers
763    );
764    if (_array) {
765        releasePointer(_env, _array, renderbuffers, JNI_FALSE);
766    }
767}
768
769/* void glDeleteShader ( GLuint shader ) */
770static void
771android_glDeleteShader__I
772  (JNIEnv *_env, jobject _this, jint shader) {
773    glDeleteShader(
774        (GLuint)shader
775    );
776}
777
778/* void glDeleteTextures ( GLsizei n, const GLuint *textures ) */
779static void
780android_glDeleteTextures__I_3II
781  (JNIEnv *_env, jobject _this, jint n, jintArray textures_ref, jint offset) {
782    jint _exception = 0;
783    const char * _exceptionType;
784    const char * _exceptionMessage;
785    GLuint *textures_base = (GLuint *) 0;
786    jint _remaining;
787    GLuint *textures = (GLuint *) 0;
788
789    if (!textures_ref) {
790        _exception = 1;
791        _exceptionType = "java/lang/IllegalArgumentException";
792        _exceptionMessage = "textures == null";
793        goto exit;
794    }
795    if (offset < 0) {
796        _exception = 1;
797        _exceptionType = "java/lang/IllegalArgumentException";
798        _exceptionMessage = "offset < 0";
799        goto exit;
800    }
801    _remaining = _env->GetArrayLength(textures_ref) - offset;
802    if (_remaining < n) {
803        _exception = 1;
804        _exceptionType = "java/lang/IllegalArgumentException";
805        _exceptionMessage = "length - offset < n < needed";
806        goto exit;
807    }
808    textures_base = (GLuint *)
809        _env->GetPrimitiveArrayCritical(textures_ref, (jboolean *)0);
810    textures = textures_base + offset;
811
812    glDeleteTextures(
813        (GLsizei)n,
814        (GLuint *)textures
815    );
816
817exit:
818    if (textures_base) {
819        _env->ReleasePrimitiveArrayCritical(textures_ref, textures_base,
820            JNI_ABORT);
821    }
822    if (_exception) {
823        jniThrowException(_env, _exceptionType, _exceptionMessage);
824    }
825}
826
827/* void glDeleteTextures ( GLsizei n, const GLuint *textures ) */
828static void
829android_glDeleteTextures__ILjava_nio_IntBuffer_2
830  (JNIEnv *_env, jobject _this, jint n, jobject textures_buf) {
831    jint _exception = 0;
832    const char * _exceptionType;
833    const char * _exceptionMessage;
834    jarray _array = (jarray) 0;
835    jint _bufferOffset = (jint) 0;
836    jint _remaining;
837    GLuint *textures = (GLuint *) 0;
838
839    textures = (GLuint *)getPointer(_env, textures_buf, &_array, &_remaining, &_bufferOffset);
840    if (_remaining < n) {
841        _exception = 1;
842        _exceptionType = "java/lang/IllegalArgumentException";
843        _exceptionMessage = "remaining() < n < needed";
844        goto exit;
845    }
846    if (textures == NULL) {
847        char * _texturesBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
848        textures = (GLuint *) (_texturesBase + _bufferOffset);
849    }
850    glDeleteTextures(
851        (GLsizei)n,
852        (GLuint *)textures
853    );
854
855exit:
856    if (_array) {
857        releasePointer(_env, _array, textures, JNI_FALSE);
858    }
859    if (_exception) {
860        jniThrowException(_env, _exceptionType, _exceptionMessage);
861    }
862}
863
864/* void glDepthFunc ( GLenum func ) */
865static void
866android_glDepthFunc__I
867  (JNIEnv *_env, jobject _this, jint func) {
868    glDepthFunc(
869        (GLenum)func
870    );
871}
872
873/* void glDepthMask ( GLboolean flag ) */
874static void
875android_glDepthMask__Z
876  (JNIEnv *_env, jobject _this, jboolean flag) {
877    glDepthMask(
878        (GLboolean)flag
879    );
880}
881
882/* void glDepthRangef ( GLclampf zNear, GLclampf zFar ) */
883static void
884android_glDepthRangef__FF
885  (JNIEnv *_env, jobject _this, jfloat zNear, jfloat zFar) {
886    glDepthRangef(
887        (GLclampf)zNear,
888        (GLclampf)zFar
889    );
890}
891
892/* void glDetachShader ( GLuint program, GLuint shader ) */
893static void
894android_glDetachShader__II
895  (JNIEnv *_env, jobject _this, jint program, jint shader) {
896    glDetachShader(
897        (GLuint)program,
898        (GLuint)shader
899    );
900}
901
902/* void glDisable ( GLenum cap ) */
903static void
904android_glDisable__I
905  (JNIEnv *_env, jobject _this, jint cap) {
906    glDisable(
907        (GLenum)cap
908    );
909}
910
911/* void glDisableVertexAttribArray ( GLuint index ) */
912static void
913android_glDisableVertexAttribArray__I
914  (JNIEnv *_env, jobject _this, jint index) {
915    glDisableVertexAttribArray(
916        (GLuint)index
917    );
918}
919
920/* void glDrawArrays ( GLenum mode, GLint first, GLsizei count ) */
921static void
922android_glDrawArrays__III
923  (JNIEnv *_env, jobject _this, jint mode, jint first, jint count) {
924    glDrawArrays(
925        (GLenum)mode,
926        (GLint)first,
927        (GLsizei)count
928    );
929}
930
931/* void glDrawElements ( GLenum mode, GLsizei count, GLenum type, GLint offset ) */
932static void
933android_glDrawElements__IIII
934  (JNIEnv *_env, jobject _this, jint mode, jint count, jint type, jint offset) {
935    jint _exception = 0;
936    const char * _exceptionType;
937    const char * _exceptionMessage;
938    glDrawElements(
939        (GLenum)mode,
940        (GLsizei)count,
941        (GLenum)type,
942        (const GLvoid *)offset
943    );
944    if (_exception) {
945        jniThrowException(_env, _exceptionType, _exceptionMessage);
946    }
947}
948
949/* void glDrawElements ( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices ) */
950static void
951android_glDrawElements__IIILjava_nio_Buffer_2
952  (JNIEnv *_env, jobject _this, jint mode, jint count, jint type, jobject indices_buf) {
953    jint _exception = 0;
954    const char * _exceptionType;
955    const char * _exceptionMessage;
956    jarray _array = (jarray) 0;
957    jint _bufferOffset = (jint) 0;
958    jint _remaining;
959    GLvoid *indices = (GLvoid *) 0;
960
961    indices = (GLvoid *)getPointer(_env, indices_buf, &_array, &_remaining, &_bufferOffset);
962    if (_remaining < count) {
963        _exception = 1;
964        _exceptionType = "java/lang/ArrayIndexOutOfBoundsException";
965        _exceptionMessage = "remaining() < count < needed";
966        goto exit;
967    }
968    if (indices == NULL) {
969        char * _indicesBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
970        indices = (GLvoid *) (_indicesBase + _bufferOffset);
971    }
972    glDrawElements(
973        (GLenum)mode,
974        (GLsizei)count,
975        (GLenum)type,
976        (GLvoid *)indices
977    );
978
979exit:
980    if (_array) {
981        releasePointer(_env, _array, indices, JNI_FALSE);
982    }
983    if (_exception) {
984        jniThrowException(_env, _exceptionType, _exceptionMessage);
985    }
986}
987
988/* void glEnable ( GLenum cap ) */
989static void
990android_glEnable__I
991  (JNIEnv *_env, jobject _this, jint cap) {
992    glEnable(
993        (GLenum)cap
994    );
995}
996
997/* void glEnableVertexAttribArray ( GLuint index ) */
998static void
999android_glEnableVertexAttribArray__I
1000  (JNIEnv *_env, jobject _this, jint index) {
1001    glEnableVertexAttribArray(
1002        (GLuint)index
1003    );
1004}
1005
1006/* void glFinish ( void ) */
1007static void
1008android_glFinish__
1009  (JNIEnv *_env, jobject _this) {
1010    glFinish();
1011}
1012
1013/* void glFlush ( void ) */
1014static void
1015android_glFlush__
1016  (JNIEnv *_env, jobject _this) {
1017    glFlush();
1018}
1019
1020/* void glFramebufferRenderbuffer ( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) */
1021static void
1022android_glFramebufferRenderbuffer__IIII
1023  (JNIEnv *_env, jobject _this, jint target, jint attachment, jint renderbuffertarget, jint renderbuffer) {
1024    glFramebufferRenderbuffer(
1025        (GLenum)target,
1026        (GLenum)attachment,
1027        (GLenum)renderbuffertarget,
1028        (GLuint)renderbuffer
1029    );
1030}
1031
1032/* void glFramebufferTexture2D ( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) */
1033static void
1034android_glFramebufferTexture2D__IIIII
1035  (JNIEnv *_env, jobject _this, jint target, jint attachment, jint textarget, jint texture, jint level) {
1036    glFramebufferTexture2D(
1037        (GLenum)target,
1038        (GLenum)attachment,
1039        (GLenum)textarget,
1040        (GLuint)texture,
1041        (GLint)level
1042    );
1043}
1044
1045/* void glFrontFace ( GLenum mode ) */
1046static void
1047android_glFrontFace__I
1048  (JNIEnv *_env, jobject _this, jint mode) {
1049    glFrontFace(
1050        (GLenum)mode
1051    );
1052}
1053
1054/* void glGenBuffers ( GLsizei n, GLuint *buffers ) */
1055static void
1056android_glGenBuffers__I_3II
1057  (JNIEnv *_env, jobject _this, jint n, jintArray buffers_ref, jint offset) {
1058    jint _exception = 0;
1059    const char * _exceptionType;
1060    const char * _exceptionMessage;
1061    GLuint *buffers_base = (GLuint *) 0;
1062    jint _remaining;
1063    GLuint *buffers = (GLuint *) 0;
1064
1065    if (!buffers_ref) {
1066        _exception = 1;
1067        _exceptionType = "java/lang/IllegalArgumentException";
1068        _exceptionMessage = "buffers == null";
1069        goto exit;
1070    }
1071    if (offset < 0) {
1072        _exception = 1;
1073        _exceptionType = "java/lang/IllegalArgumentException";
1074        _exceptionMessage = "offset < 0";
1075        goto exit;
1076    }
1077    _remaining = _env->GetArrayLength(buffers_ref) - offset;
1078    if (_remaining < n) {
1079        _exception = 1;
1080        _exceptionType = "java/lang/IllegalArgumentException";
1081        _exceptionMessage = "length - offset < n < needed";
1082        goto exit;
1083    }
1084    buffers_base = (GLuint *)
1085        _env->GetPrimitiveArrayCritical(buffers_ref, (jboolean *)0);
1086    buffers = buffers_base + offset;
1087
1088    glGenBuffers(
1089        (GLsizei)n,
1090        (GLuint *)buffers
1091    );
1092
1093exit:
1094    if (buffers_base) {
1095        _env->ReleasePrimitiveArrayCritical(buffers_ref, buffers_base,
1096            _exception ? JNI_ABORT: 0);
1097    }
1098    if (_exception) {
1099        jniThrowException(_env, _exceptionType, _exceptionMessage);
1100    }
1101}
1102
1103/* void glGenBuffers ( GLsizei n, GLuint *buffers ) */
1104static void
1105android_glGenBuffers__ILjava_nio_IntBuffer_2
1106  (JNIEnv *_env, jobject _this, jint n, jobject buffers_buf) {
1107    jint _exception = 0;
1108    const char * _exceptionType;
1109    const char * _exceptionMessage;
1110    jarray _array = (jarray) 0;
1111    jint _bufferOffset = (jint) 0;
1112    jint _remaining;
1113    GLuint *buffers = (GLuint *) 0;
1114
1115    buffers = (GLuint *)getPointer(_env, buffers_buf, &_array, &_remaining, &_bufferOffset);
1116    if (_remaining < n) {
1117        _exception = 1;
1118        _exceptionType = "java/lang/IllegalArgumentException";
1119        _exceptionMessage = "remaining() < n < needed";
1120        goto exit;
1121    }
1122    if (buffers == NULL) {
1123        char * _buffersBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1124        buffers = (GLuint *) (_buffersBase + _bufferOffset);
1125    }
1126    glGenBuffers(
1127        (GLsizei)n,
1128        (GLuint *)buffers
1129    );
1130
1131exit:
1132    if (_array) {
1133        releasePointer(_env, _array, buffers, _exception ? JNI_FALSE : JNI_TRUE);
1134    }
1135    if (_exception) {
1136        jniThrowException(_env, _exceptionType, _exceptionMessage);
1137    }
1138}
1139
1140/* void glGenerateMipmap ( GLenum target ) */
1141static void
1142android_glGenerateMipmap__I
1143  (JNIEnv *_env, jobject _this, jint target) {
1144    glGenerateMipmap(
1145        (GLenum)target
1146    );
1147}
1148
1149/* void glGenFramebuffers ( GLsizei n, GLuint *framebuffers ) */
1150static void
1151android_glGenFramebuffers__I_3II
1152  (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) {
1153    jint _exception = 0;
1154    const char * _exceptionType;
1155    const char * _exceptionMessage;
1156    GLuint *framebuffers_base = (GLuint *) 0;
1157    jint _remaining;
1158    GLuint *framebuffers = (GLuint *) 0;
1159
1160    if (!framebuffers_ref) {
1161        _exception = 1;
1162        _exceptionType = "java/lang/IllegalArgumentException";
1163        _exceptionMessage = "framebuffers == null";
1164        goto exit;
1165    }
1166    if (offset < 0) {
1167        _exception = 1;
1168        _exceptionType = "java/lang/IllegalArgumentException";
1169        _exceptionMessage = "offset < 0";
1170        goto exit;
1171    }
1172    _remaining = _env->GetArrayLength(framebuffers_ref) - offset;
1173    framebuffers_base = (GLuint *)
1174        _env->GetPrimitiveArrayCritical(framebuffers_ref, (jboolean *)0);
1175    framebuffers = framebuffers_base + offset;
1176
1177    glGenFramebuffers(
1178        (GLsizei)n,
1179        (GLuint *)framebuffers
1180    );
1181
1182exit:
1183    if (framebuffers_base) {
1184        _env->ReleasePrimitiveArrayCritical(framebuffers_ref, framebuffers_base,
1185            _exception ? JNI_ABORT: 0);
1186    }
1187    if (_exception) {
1188        jniThrowException(_env, _exceptionType, _exceptionMessage);
1189    }
1190}
1191
1192/* void glGenFramebuffers ( GLsizei n, GLuint *framebuffers ) */
1193static void
1194android_glGenFramebuffers__ILjava_nio_IntBuffer_2
1195  (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) {
1196    jarray _array = (jarray) 0;
1197    jint _bufferOffset = (jint) 0;
1198    jint _remaining;
1199    GLuint *framebuffers = (GLuint *) 0;
1200
1201    framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, &_array, &_remaining, &_bufferOffset);
1202    if (framebuffers == NULL) {
1203        char * _framebuffersBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1204        framebuffers = (GLuint *) (_framebuffersBase + _bufferOffset);
1205    }
1206    glGenFramebuffers(
1207        (GLsizei)n,
1208        (GLuint *)framebuffers
1209    );
1210    if (_array) {
1211        releasePointer(_env, _array, framebuffers, JNI_TRUE);
1212    }
1213}
1214
1215/* void glGenRenderbuffers ( GLsizei n, GLuint *renderbuffers ) */
1216static void
1217android_glGenRenderbuffers__I_3II
1218  (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) {
1219    jint _exception = 0;
1220    const char * _exceptionType;
1221    const char * _exceptionMessage;
1222    GLuint *renderbuffers_base = (GLuint *) 0;
1223    jint _remaining;
1224    GLuint *renderbuffers = (GLuint *) 0;
1225
1226    if (!renderbuffers_ref) {
1227        _exception = 1;
1228        _exceptionType = "java/lang/IllegalArgumentException";
1229        _exceptionMessage = "renderbuffers == null";
1230        goto exit;
1231    }
1232    if (offset < 0) {
1233        _exception = 1;
1234        _exceptionType = "java/lang/IllegalArgumentException";
1235        _exceptionMessage = "offset < 0";
1236        goto exit;
1237    }
1238    _remaining = _env->GetArrayLength(renderbuffers_ref) - offset;
1239    renderbuffers_base = (GLuint *)
1240        _env->GetPrimitiveArrayCritical(renderbuffers_ref, (jboolean *)0);
1241    renderbuffers = renderbuffers_base + offset;
1242
1243    glGenRenderbuffers(
1244        (GLsizei)n,
1245        (GLuint *)renderbuffers
1246    );
1247
1248exit:
1249    if (renderbuffers_base) {
1250        _env->ReleasePrimitiveArrayCritical(renderbuffers_ref, renderbuffers_base,
1251            _exception ? JNI_ABORT: 0);
1252    }
1253    if (_exception) {
1254        jniThrowException(_env, _exceptionType, _exceptionMessage);
1255    }
1256}
1257
1258/* void glGenRenderbuffers ( GLsizei n, GLuint *renderbuffers ) */
1259static void
1260android_glGenRenderbuffers__ILjava_nio_IntBuffer_2
1261  (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) {
1262    jarray _array = (jarray) 0;
1263    jint _bufferOffset = (jint) 0;
1264    jint _remaining;
1265    GLuint *renderbuffers = (GLuint *) 0;
1266
1267    renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, &_array, &_remaining, &_bufferOffset);
1268    if (renderbuffers == NULL) {
1269        char * _renderbuffersBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1270        renderbuffers = (GLuint *) (_renderbuffersBase + _bufferOffset);
1271    }
1272    glGenRenderbuffers(
1273        (GLsizei)n,
1274        (GLuint *)renderbuffers
1275    );
1276    if (_array) {
1277        releasePointer(_env, _array, renderbuffers, JNI_TRUE);
1278    }
1279}
1280
1281/* void glGenTextures ( GLsizei n, GLuint *textures ) */
1282static void
1283android_glGenTextures__I_3II
1284  (JNIEnv *_env, jobject _this, jint n, jintArray textures_ref, jint offset) {
1285    jint _exception = 0;
1286    const char * _exceptionType;
1287    const char * _exceptionMessage;
1288    GLuint *textures_base = (GLuint *) 0;
1289    jint _remaining;
1290    GLuint *textures = (GLuint *) 0;
1291
1292    if (!textures_ref) {
1293        _exception = 1;
1294        _exceptionType = "java/lang/IllegalArgumentException";
1295        _exceptionMessage = "textures == null";
1296        goto exit;
1297    }
1298    if (offset < 0) {
1299        _exception = 1;
1300        _exceptionType = "java/lang/IllegalArgumentException";
1301        _exceptionMessage = "offset < 0";
1302        goto exit;
1303    }
1304    _remaining = _env->GetArrayLength(textures_ref) - offset;
1305    if (_remaining < n) {
1306        _exception = 1;
1307        _exceptionType = "java/lang/IllegalArgumentException";
1308        _exceptionMessage = "length - offset < n < needed";
1309        goto exit;
1310    }
1311    textures_base = (GLuint *)
1312        _env->GetPrimitiveArrayCritical(textures_ref, (jboolean *)0);
1313    textures = textures_base + offset;
1314
1315    glGenTextures(
1316        (GLsizei)n,
1317        (GLuint *)textures
1318    );
1319
1320exit:
1321    if (textures_base) {
1322        _env->ReleasePrimitiveArrayCritical(textures_ref, textures_base,
1323            _exception ? JNI_ABORT: 0);
1324    }
1325    if (_exception) {
1326        jniThrowException(_env, _exceptionType, _exceptionMessage);
1327    }
1328}
1329
1330/* void glGenTextures ( GLsizei n, GLuint *textures ) */
1331static void
1332android_glGenTextures__ILjava_nio_IntBuffer_2
1333  (JNIEnv *_env, jobject _this, jint n, jobject textures_buf) {
1334    jint _exception = 0;
1335    const char * _exceptionType;
1336    const char * _exceptionMessage;
1337    jarray _array = (jarray) 0;
1338    jint _bufferOffset = (jint) 0;
1339    jint _remaining;
1340    GLuint *textures = (GLuint *) 0;
1341
1342    textures = (GLuint *)getPointer(_env, textures_buf, &_array, &_remaining, &_bufferOffset);
1343    if (_remaining < n) {
1344        _exception = 1;
1345        _exceptionType = "java/lang/IllegalArgumentException";
1346        _exceptionMessage = "remaining() < n < needed";
1347        goto exit;
1348    }
1349    if (textures == NULL) {
1350        char * _texturesBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1351        textures = (GLuint *) (_texturesBase + _bufferOffset);
1352    }
1353    glGenTextures(
1354        (GLsizei)n,
1355        (GLuint *)textures
1356    );
1357
1358exit:
1359    if (_array) {
1360        releasePointer(_env, _array, textures, _exception ? JNI_FALSE : JNI_TRUE);
1361    }
1362    if (_exception) {
1363        jniThrowException(_env, _exceptionType, _exceptionMessage);
1364    }
1365}
1366
1367/* void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */
1368static void
1369android_glGetActiveAttrib__III_3II_3II_3II_3BI
1370  (JNIEnv *_env, jobject _this, jint program, jint index, jint bufsize, jintArray length_ref, jint lengthOffset, jintArray size_ref, jint sizeOffset, jintArray type_ref, jint typeOffset, jbyteArray name_ref, jint nameOffset) {
1371    jint _exception = 0;
1372    const char * _exceptionType;
1373    const char * _exceptionMessage;
1374    GLsizei *length_base = (GLsizei *) 0;
1375    jint _lengthRemaining;
1376    GLsizei *length = (GLsizei *) 0;
1377    GLint *size_base = (GLint *) 0;
1378    jint _sizeRemaining;
1379    GLint *size = (GLint *) 0;
1380    GLenum *type_base = (GLenum *) 0;
1381    jint _typeRemaining;
1382    GLenum *type = (GLenum *) 0;
1383    char *name_base = (char *) 0;
1384    jint _nameRemaining;
1385    char *name = (char *) 0;
1386
1387    if (!length_ref) {
1388        _exception = 1;
1389        _exceptionType = "java/lang/IllegalArgumentException";
1390        _exceptionMessage = "length == null";
1391        goto exit;
1392    }
1393    if (lengthOffset < 0) {
1394        _exception = 1;
1395        _exceptionType = "java/lang/IllegalArgumentException";
1396        _exceptionMessage = "lengthOffset < 0";
1397        goto exit;
1398    }
1399    _lengthRemaining = _env->GetArrayLength(length_ref) - lengthOffset;
1400    length_base = (GLsizei *)
1401        _env->GetPrimitiveArrayCritical(length_ref, (jboolean *)0);
1402    length = length_base + lengthOffset;
1403
1404    if (!size_ref) {
1405        _exception = 1;
1406        _exceptionType = "java/lang/IllegalArgumentException";
1407        _exceptionMessage = "size == null";
1408        goto exit;
1409    }
1410    if (sizeOffset < 0) {
1411        _exception = 1;
1412        _exceptionType = "java/lang/IllegalArgumentException";
1413        _exceptionMessage = "sizeOffset < 0";
1414        goto exit;
1415    }
1416    _sizeRemaining = _env->GetArrayLength(size_ref) - sizeOffset;
1417    size_base = (GLint *)
1418        _env->GetPrimitiveArrayCritical(size_ref, (jboolean *)0);
1419    size = size_base + sizeOffset;
1420
1421    if (!type_ref) {
1422        _exception = 1;
1423        _exceptionType = "java/lang/IllegalArgumentException";
1424        _exceptionMessage = "type == null";
1425        goto exit;
1426    }
1427    if (typeOffset < 0) {
1428        _exception = 1;
1429        _exceptionType = "java/lang/IllegalArgumentException";
1430        _exceptionMessage = "typeOffset < 0";
1431        goto exit;
1432    }
1433    _typeRemaining = _env->GetArrayLength(type_ref) - typeOffset;
1434    type_base = (GLenum *)
1435        _env->GetPrimitiveArrayCritical(type_ref, (jboolean *)0);
1436    type = type_base + typeOffset;
1437
1438    if (!name_ref) {
1439        _exception = 1;
1440        _exceptionType = "java/lang/IllegalArgumentException";
1441        _exceptionMessage = "name == null";
1442        goto exit;
1443    }
1444    if (nameOffset < 0) {
1445        _exception = 1;
1446        _exceptionType = "java/lang/IllegalArgumentException";
1447        _exceptionMessage = "nameOffset < 0";
1448        goto exit;
1449    }
1450    _nameRemaining = _env->GetArrayLength(name_ref) - nameOffset;
1451    name_base = (char *)
1452        _env->GetPrimitiveArrayCritical(name_ref, (jboolean *)0);
1453    name = name_base + nameOffset;
1454
1455    glGetActiveAttrib(
1456        (GLuint)program,
1457        (GLuint)index,
1458        (GLsizei)bufsize,
1459        (GLsizei *)length,
1460        (GLint *)size,
1461        (GLenum *)type,
1462        (char *)name
1463    );
1464
1465exit:
1466    if (name_base) {
1467        _env->ReleasePrimitiveArrayCritical(name_ref, name_base,
1468            _exception ? JNI_ABORT: 0);
1469    }
1470    if (type_base) {
1471        _env->ReleasePrimitiveArrayCritical(type_ref, type_base,
1472            _exception ? JNI_ABORT: 0);
1473    }
1474    if (size_base) {
1475        _env->ReleasePrimitiveArrayCritical(size_ref, size_base,
1476            _exception ? JNI_ABORT: 0);
1477    }
1478    if (length_base) {
1479        _env->ReleasePrimitiveArrayCritical(length_ref, length_base,
1480            _exception ? JNI_ABORT: 0);
1481    }
1482    if (_exception) {
1483        jniThrowException(_env, _exceptionType, _exceptionMessage);
1484    }
1485}
1486
1487/* void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */
1488static void
1489android_glGetActiveAttrib__IIILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2B
1490  (JNIEnv *_env, jobject _this, jint program, jint index, jint bufsize, jobject length_buf, jobject size_buf, jobject type_buf, jbyte name) {
1491    jarray _lengthArray = (jarray) 0;
1492    jint _lengthBufferOffset = (jint) 0;
1493    jarray _sizeArray = (jarray) 0;
1494    jint _sizeBufferOffset = (jint) 0;
1495    jarray _typeArray = (jarray) 0;
1496    jint _typeBufferOffset = (jint) 0;
1497    jint _lengthRemaining;
1498    GLsizei *length = (GLsizei *) 0;
1499    jint _sizeRemaining;
1500    GLint *size = (GLint *) 0;
1501    jint _typeRemaining;
1502    GLenum *type = (GLenum *) 0;
1503
1504    length = (GLsizei *)getPointer(_env, length_buf, &_lengthArray, &_lengthRemaining, &_lengthBufferOffset);
1505    size = (GLint *)getPointer(_env, size_buf, &_sizeArray, &_sizeRemaining, &_sizeBufferOffset);
1506    type = (GLenum *)getPointer(_env, type_buf, &_typeArray, &_typeRemaining, &_typeBufferOffset);
1507    if (length == NULL) {
1508        char * _lengthBase = (char *)_env->GetPrimitiveArrayCritical(_lengthArray, (jboolean *) 0);
1509        length = (GLsizei *) (_lengthBase + _lengthBufferOffset);
1510    }
1511    if (size == NULL) {
1512        char * _sizeBase = (char *)_env->GetPrimitiveArrayCritical(_sizeArray, (jboolean *) 0);
1513        size = (GLint *) (_sizeBase + _sizeBufferOffset);
1514    }
1515    if (type == NULL) {
1516        char * _typeBase = (char *)_env->GetPrimitiveArrayCritical(_typeArray, (jboolean *) 0);
1517        type = (GLenum *) (_typeBase + _typeBufferOffset);
1518    }
1519    glGetActiveAttrib(
1520        (GLuint)program,
1521        (GLuint)index,
1522        (GLsizei)bufsize,
1523        (GLsizei *)length,
1524        (GLint *)size,
1525        (GLenum *)type,
1526        (char *)name
1527    );
1528    if (_typeArray) {
1529        releasePointer(_env, _typeArray, type, JNI_TRUE);
1530    }
1531    if (_sizeArray) {
1532        releasePointer(_env, _sizeArray, size, JNI_TRUE);
1533    }
1534    if (_lengthArray) {
1535        releasePointer(_env, _lengthArray, length, JNI_TRUE);
1536    }
1537}
1538
1539/* void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */
1540static jstring
1541android_glGetActiveAttrib1
1542  (JNIEnv *_env, jobject _this, jint program, jint index, jintArray size_ref, jint sizeOffset, jintArray type_ref, jint typeOffset) {
1543    jint _exception = 0;
1544    const char * _exceptionType;
1545    const char * _exceptionMessage;
1546    GLint *size_base = (GLint *) 0;
1547    jint _sizeRemaining;
1548    GLint *size = (GLint *) 0;
1549    GLenum *type_base = (GLenum *) 0;
1550    jint _typeRemaining;
1551    GLenum *type = (GLenum *) 0;
1552
1553    jstring result = 0;
1554
1555    GLint len = 0;
1556    glGetProgramiv((GLuint)program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &len);
1557    if (!len) {
1558        return _env->NewStringUTF("");
1559    }
1560    char* buf = (char*) malloc(len);
1561
1562    if (buf == NULL) {
1563        jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory");
1564        return NULL;
1565    }
1566    if (!size_ref) {
1567        _exception = 1;
1568        _exceptionType = "java/lang/IllegalArgumentException";
1569        _exceptionMessage = "size == null";
1570        goto exit;
1571    }
1572    if (sizeOffset < 0) {
1573        _exception = 1;
1574        _exceptionType = "java/lang/IllegalArgumentException";
1575        _exceptionMessage = "sizeOffset < 0";
1576        goto exit;
1577    }
1578    _sizeRemaining = _env->GetArrayLength(size_ref) - sizeOffset;
1579    size_base = (GLint *)
1580        _env->GetPrimitiveArrayCritical(size_ref, (jboolean *)0);
1581    size = size_base + sizeOffset;
1582
1583    if (!type_ref) {
1584        _exception = 1;
1585        _exceptionType = "java/lang/IllegalArgumentException";
1586        _exceptionMessage = "type == null";
1587        goto exit;
1588    }
1589    if (typeOffset < 0) {
1590        _exception = 1;
1591        _exceptionType = "java/lang/IllegalArgumentException";
1592        _exceptionMessage = "typeOffset < 0";
1593        goto exit;
1594    }
1595    _typeRemaining = _env->GetArrayLength(type_ref) - typeOffset;
1596    type_base = (GLenum *)
1597        _env->GetPrimitiveArrayCritical(type_ref, (jboolean *)0);
1598    type = type_base + typeOffset;
1599
1600    glGetActiveAttrib(
1601        (GLuint)program,
1602        (GLuint)index,
1603        (GLsizei)len,
1604        NULL,
1605        (GLint *)size,
1606        (GLenum *)type,
1607        (char *)buf
1608    );
1609exit:
1610    if (type_base) {
1611        _env->ReleasePrimitiveArrayCritical(type_ref, type_base,
1612            _exception ? JNI_ABORT: 0);
1613    }
1614    if (size_base) {
1615        _env->ReleasePrimitiveArrayCritical(size_ref, size_base,
1616            _exception ? JNI_ABORT: 0);
1617    }
1618    if (_exception != 1) {
1619        result = _env->NewStringUTF(buf);
1620    }
1621    if (buf) {
1622        free(buf);
1623    }
1624    if (_exception) {
1625        jniThrowException(_env, _exceptionType, _exceptionMessage);
1626    }
1627    if (result == 0) {
1628        result = _env->NewStringUTF("");
1629    }
1630
1631    return result;
1632}
1633
1634/* void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */
1635static jstring
1636android_glGetActiveAttrib2
1637  (JNIEnv *_env, jobject _this, jint program, jint index, jobject size_buf, jobject type_buf) {
1638    jarray _sizeArray = (jarray) 0;
1639    jint _sizeBufferOffset = (jint) 0;
1640    jarray _typeArray = (jarray) 0;
1641    jint _typeBufferOffset = (jint) 0;
1642    jint _lengthRemaining;
1643    GLsizei *length = (GLsizei *) 0;
1644    jint _sizeRemaining;
1645    GLint *size = (GLint *) 0;
1646    jint _typeRemaining;
1647    GLenum *type = (GLenum *) 0;
1648
1649    jstring result = 0;
1650
1651    GLint len = 0;
1652    glGetProgramiv((GLuint)program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &len);
1653    if (!len) {
1654        return _env->NewStringUTF("");
1655    }
1656    char* buf = (char*) malloc(len);
1657
1658    if (buf == NULL) {
1659        jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory");
1660        return NULL;
1661    }
1662
1663    size = (GLint *)getPointer(_env, size_buf, &_sizeArray, &_sizeRemaining, &_sizeBufferOffset);
1664    type = (GLenum *)getPointer(_env, type_buf, &_typeArray, &_typeRemaining, &_typeBufferOffset);
1665    if (size == NULL) {
1666        char * _sizeBase = (char *)_env->GetPrimitiveArrayCritical(_sizeArray, (jboolean *) 0);
1667        size = (GLint *) (_sizeBase + _sizeBufferOffset);
1668    }
1669    if (type == NULL) {
1670        char * _typeBase = (char *)_env->GetPrimitiveArrayCritical(_typeArray, (jboolean *) 0);
1671        type = (GLenum *) (_typeBase + _typeBufferOffset);
1672    }
1673    glGetActiveAttrib(
1674        (GLuint)program,
1675        (GLuint)index,
1676        (GLsizei)len,
1677        NULL,
1678        (GLint *)size,
1679        (GLenum *)type,
1680        (char *)buf
1681    );
1682
1683    if (_typeArray) {
1684        releasePointer(_env, _typeArray, type, JNI_TRUE);
1685    }
1686    if (_sizeArray) {
1687        releasePointer(_env, _sizeArray, size, JNI_TRUE);
1688    }
1689    result = _env->NewStringUTF(buf);
1690    if (buf) {
1691        free(buf);
1692    }
1693    return result;
1694}
1695/* void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */
1696static void
1697android_glGetActiveUniform__III_3II_3II_3II_3BI
1698  (JNIEnv *_env, jobject _this, jint program, jint index, jint bufsize, jintArray length_ref, jint lengthOffset, jintArray size_ref, jint sizeOffset, jintArray type_ref, jint typeOffset, jbyteArray name_ref, jint nameOffset) {
1699    jint _exception = 0;
1700    const char * _exceptionType;
1701    const char * _exceptionMessage;
1702    GLsizei *length_base = (GLsizei *) 0;
1703    jint _lengthRemaining;
1704    GLsizei *length = (GLsizei *) 0;
1705    GLint *size_base = (GLint *) 0;
1706    jint _sizeRemaining;
1707    GLint *size = (GLint *) 0;
1708    GLenum *type_base = (GLenum *) 0;
1709    jint _typeRemaining;
1710    GLenum *type = (GLenum *) 0;
1711    char *name_base = (char *) 0;
1712    jint _nameRemaining;
1713    char *name = (char *) 0;
1714
1715    if (!length_ref) {
1716        _exception = 1;
1717        _exceptionType = "java/lang/IllegalArgumentException";
1718        _exceptionMessage = "length == null";
1719        goto exit;
1720    }
1721    if (lengthOffset < 0) {
1722        _exception = 1;
1723        _exceptionType = "java/lang/IllegalArgumentException";
1724        _exceptionMessage = "lengthOffset < 0";
1725        goto exit;
1726    }
1727    _lengthRemaining = _env->GetArrayLength(length_ref) - lengthOffset;
1728    length_base = (GLsizei *)
1729        _env->GetPrimitiveArrayCritical(length_ref, (jboolean *)0);
1730    length = length_base + lengthOffset;
1731
1732    if (!size_ref) {
1733        _exception = 1;
1734        _exceptionType = "java/lang/IllegalArgumentException";
1735        _exceptionMessage = "size == null";
1736        goto exit;
1737    }
1738    if (sizeOffset < 0) {
1739        _exception = 1;
1740        _exceptionType = "java/lang/IllegalArgumentException";
1741        _exceptionMessage = "sizeOffset < 0";
1742        goto exit;
1743    }
1744    _sizeRemaining = _env->GetArrayLength(size_ref) - sizeOffset;
1745    size_base = (GLint *)
1746        _env->GetPrimitiveArrayCritical(size_ref, (jboolean *)0);
1747    size = size_base + sizeOffset;
1748
1749    if (!type_ref) {
1750        _exception = 1;
1751        _exceptionType = "java/lang/IllegalArgumentException";
1752        _exceptionMessage = "type == null";
1753        goto exit;
1754    }
1755    if (typeOffset < 0) {
1756        _exception = 1;
1757        _exceptionType = "java/lang/IllegalArgumentException";
1758        _exceptionMessage = "typeOffset < 0";
1759        goto exit;
1760    }
1761    _typeRemaining = _env->GetArrayLength(type_ref) - typeOffset;
1762    type_base = (GLenum *)
1763        _env->GetPrimitiveArrayCritical(type_ref, (jboolean *)0);
1764    type = type_base + typeOffset;
1765
1766    if (!name_ref) {
1767        _exception = 1;
1768        _exceptionType = "java/lang/IllegalArgumentException";
1769        _exceptionMessage = "name == null";
1770        goto exit;
1771    }
1772    if (nameOffset < 0) {
1773        _exception = 1;
1774        _exceptionType = "java/lang/IllegalArgumentException";
1775        _exceptionMessage = "nameOffset < 0";
1776        goto exit;
1777    }
1778    _nameRemaining = _env->GetArrayLength(name_ref) - nameOffset;
1779    name_base = (char *)
1780        _env->GetPrimitiveArrayCritical(name_ref, (jboolean *)0);
1781    name = name_base + nameOffset;
1782
1783    glGetActiveUniform(
1784        (GLuint)program,
1785        (GLuint)index,
1786        (GLsizei)bufsize,
1787        (GLsizei *)length,
1788        (GLint *)size,
1789        (GLenum *)type,
1790        (char *)name
1791    );
1792
1793exit:
1794    if (name_base) {
1795        _env->ReleasePrimitiveArrayCritical(name_ref, name_base,
1796            _exception ? JNI_ABORT: 0);
1797    }
1798    if (type_base) {
1799        _env->ReleasePrimitiveArrayCritical(type_ref, type_base,
1800            _exception ? JNI_ABORT: 0);
1801    }
1802    if (size_base) {
1803        _env->ReleasePrimitiveArrayCritical(size_ref, size_base,
1804            _exception ? JNI_ABORT: 0);
1805    }
1806    if (length_base) {
1807        _env->ReleasePrimitiveArrayCritical(length_ref, length_base,
1808            _exception ? JNI_ABORT: 0);
1809    }
1810    if (_exception) {
1811        jniThrowException(_env, _exceptionType, _exceptionMessage);
1812    }
1813}
1814
1815/* void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */
1816static void
1817android_glGetActiveUniform__IIILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2B
1818  (JNIEnv *_env, jobject _this, jint program, jint index, jint bufsize, jobject length_buf, jobject size_buf, jobject type_buf, jbyte name) {
1819    jarray _lengthArray = (jarray) 0;
1820    jint _lengthBufferOffset = (jint) 0;
1821    jarray _sizeArray = (jarray) 0;
1822    jint _sizeBufferOffset = (jint) 0;
1823    jarray _typeArray = (jarray) 0;
1824    jint _typeBufferOffset = (jint) 0;
1825    jint _lengthRemaining;
1826    GLsizei *length = (GLsizei *) 0;
1827    jint _sizeRemaining;
1828    GLint *size = (GLint *) 0;
1829    jint _typeRemaining;
1830    GLenum *type = (GLenum *) 0;
1831
1832    length = (GLsizei *)getPointer(_env, length_buf, &_lengthArray, &_lengthRemaining, &_lengthBufferOffset);
1833    size = (GLint *)getPointer(_env, size_buf, &_sizeArray, &_sizeRemaining, &_sizeBufferOffset);
1834    type = (GLenum *)getPointer(_env, type_buf, &_typeArray, &_typeRemaining, &_typeBufferOffset);
1835    if (length == NULL) {
1836        char * _lengthBase = (char *)_env->GetPrimitiveArrayCritical(_lengthArray, (jboolean *) 0);
1837        length = (GLsizei *) (_lengthBase + _lengthBufferOffset);
1838    }
1839    if (size == NULL) {
1840        char * _sizeBase = (char *)_env->GetPrimitiveArrayCritical(_sizeArray, (jboolean *) 0);
1841        size = (GLint *) (_sizeBase + _sizeBufferOffset);
1842    }
1843    if (type == NULL) {
1844        char * _typeBase = (char *)_env->GetPrimitiveArrayCritical(_typeArray, (jboolean *) 0);
1845        type = (GLenum *) (_typeBase + _typeBufferOffset);
1846    }
1847    glGetActiveUniform(
1848        (GLuint)program,
1849        (GLuint)index,
1850        (GLsizei)bufsize,
1851        (GLsizei *)length,
1852        (GLint *)size,
1853        (GLenum *)type,
1854        (char *)name
1855    );
1856    if (_typeArray) {
1857        releasePointer(_env, _typeArray, type, JNI_TRUE);
1858    }
1859    if (_sizeArray) {
1860        releasePointer(_env, _sizeArray, size, JNI_TRUE);
1861    }
1862    if (_lengthArray) {
1863        releasePointer(_env, _lengthArray, length, JNI_TRUE);
1864    }
1865}
1866
1867/* void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */
1868static jstring
1869android_glGetActiveUniform1
1870  (JNIEnv *_env, jobject _this, jint program, jint index, jintArray size_ref, jint sizeOffset, jintArray type_ref, jint typeOffset) {
1871    jint _exception = 0;
1872    const char * _exceptionType;
1873    const char * _exceptionMessage;
1874
1875    GLint *size_base = (GLint *) 0;
1876    jint _sizeRemaining;
1877    GLint *size = (GLint *) 0;
1878
1879    GLenum *type_base = (GLenum *) 0;
1880    jint _typeRemaining;
1881    GLenum *type = (GLenum *) 0;
1882
1883    jstring result = 0;
1884
1885    GLint len = 0;
1886    glGetProgramiv((GLuint)program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &len);
1887    if (!len) {
1888        return _env->NewStringUTF("");
1889    }
1890    char* buf = (char*) malloc(len);
1891
1892    if (buf == NULL) {
1893        jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory");
1894        return NULL;
1895    }
1896
1897    if (!size_ref) {
1898        _exception = 1;
1899        _exceptionType = "java/lang/IllegalArgumentException";
1900        _exceptionMessage = "size == null";
1901        goto exit;
1902    }
1903    if (sizeOffset < 0) {
1904        _exception = 1;
1905        _exceptionType = "java/lang/IllegalArgumentException";
1906        _exceptionMessage = "sizeOffset < 0";
1907        goto exit;
1908    }
1909    _sizeRemaining = _env->GetArrayLength(size_ref) - sizeOffset;
1910    size_base = (GLint *)
1911        _env->GetPrimitiveArrayCritical(size_ref, (jboolean *)0);
1912    size = size_base + sizeOffset;
1913
1914    if (!type_ref) {
1915        _exception = 1;
1916        _exceptionType = "java/lang/IllegalArgumentException";
1917        _exceptionMessage = "type == null";
1918        goto exit;
1919    }
1920    if (typeOffset < 0) {
1921        _exception = 1;
1922        _exceptionType = "java/lang/IllegalArgumentException";
1923        _exceptionMessage = "typeOffset < 0";
1924        goto exit;
1925    }
1926    _typeRemaining = _env->GetArrayLength(type_ref) - typeOffset;
1927    type_base = (GLenum *)
1928        _env->GetPrimitiveArrayCritical(type_ref, (jboolean *)0);
1929    type = type_base + typeOffset;
1930
1931    glGetActiveUniform(
1932        (GLuint)program,
1933        (GLuint)index,
1934        (GLsizei)len,
1935        NULL,
1936        (GLint *)size,
1937        (GLenum *)type,
1938        (char *)buf
1939    );
1940
1941exit:
1942    if (type_base) {
1943        _env->ReleasePrimitiveArrayCritical(type_ref, type_base,
1944            _exception ? JNI_ABORT: 0);
1945    }
1946    if (size_base) {
1947        _env->ReleasePrimitiveArrayCritical(size_ref, size_base,
1948            _exception ? JNI_ABORT: 0);
1949    }
1950    if (_exception != 1) {
1951        result = _env->NewStringUTF(buf);
1952    }
1953    if (buf) {
1954        free(buf);
1955    }
1956    if (_exception) {
1957        jniThrowException(_env, _exceptionType, _exceptionMessage);
1958    }
1959    if (result == 0) {
1960        result = _env->NewStringUTF("");
1961    }
1962    return result;
1963}
1964
1965/* void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */
1966static jstring
1967android_glGetActiveUniform2
1968  (JNIEnv *_env, jobject _this, jint program, jint index, jobject size_buf, jobject type_buf) {
1969    jarray _sizeArray = (jarray) 0;
1970    jint _sizeBufferOffset = (jint) 0;
1971    jarray _typeArray = (jarray) 0;
1972    jint _typeBufferOffset = (jint) 0;
1973    jint _sizeRemaining;
1974    GLint *size = (GLint *) 0;
1975    jint _typeRemaining;
1976    GLenum *type = (GLenum *) 0;
1977
1978    jstring result = 0;
1979    GLint len = 0;
1980    glGetProgramiv((GLuint)program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &len);
1981    if (!len) {
1982        return _env->NewStringUTF("");
1983    }
1984    char* buf = (char*) malloc(len);
1985
1986    if (buf == NULL) {
1987        jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory");
1988        return NULL;
1989    }
1990
1991    size = (GLint *)getPointer(_env, size_buf, &_sizeArray, &_sizeRemaining, &_sizeBufferOffset);
1992    type = (GLenum *)getPointer(_env, type_buf, &_typeArray, &_typeRemaining, &_typeBufferOffset);
1993
1994    if (size == NULL) {
1995        char * _sizeBase = (char *)_env->GetPrimitiveArrayCritical(_sizeArray, (jboolean *) 0);
1996        size = (GLint *) (_sizeBase + _sizeBufferOffset);
1997    }
1998    if (type == NULL) {
1999        char * _typeBase = (char *)_env->GetPrimitiveArrayCritical(_typeArray, (jboolean *) 0);
2000        type = (GLenum *) (_typeBase + _typeBufferOffset);
2001    }
2002    glGetActiveUniform(
2003        (GLuint)program,
2004        (GLuint)index,
2005        len,
2006        NULL,
2007        (GLint *)size,
2008        (GLenum *)type,
2009        (char *)buf
2010    );
2011
2012    if (_typeArray) {
2013        releasePointer(_env, _typeArray, type, JNI_TRUE);
2014    }
2015    if (_sizeArray) {
2016        releasePointer(_env, _sizeArray, size, JNI_TRUE);
2017    }
2018    result = _env->NewStringUTF(buf);
2019    if (buf) {
2020        free(buf);
2021    }
2022    return result;
2023}
2024/* void glGetAttachedShaders ( GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders ) */
2025static void
2026android_glGetAttachedShaders__II_3II_3II
2027  (JNIEnv *_env, jobject _this, jint program, jint maxcount, jintArray count_ref, jint countOffset, jintArray shaders_ref, jint shadersOffset) {
2028    jint _exception = 0;
2029    const char * _exceptionType;
2030    const char * _exceptionMessage;
2031    GLsizei *count_base = (GLsizei *) 0;
2032    jint _countRemaining;
2033    GLsizei *count = (GLsizei *) 0;
2034    GLuint *shaders_base = (GLuint *) 0;
2035    jint _shadersRemaining;
2036    GLuint *shaders = (GLuint *) 0;
2037
2038    if (!count_ref) {
2039        _exception = 1;
2040        _exceptionType = "java/lang/IllegalArgumentException";
2041        _exceptionMessage = "count == null";
2042        goto exit;
2043    }
2044    if (countOffset < 0) {
2045        _exception = 1;
2046        _exceptionType = "java/lang/IllegalArgumentException";
2047        _exceptionMessage = "countOffset < 0";
2048        goto exit;
2049    }
2050    _countRemaining = _env->GetArrayLength(count_ref) - countOffset;
2051    count_base = (GLsizei *)
2052        _env->GetPrimitiveArrayCritical(count_ref, (jboolean *)0);
2053    count = count_base + countOffset;
2054
2055    if (!shaders_ref) {
2056        _exception = 1;
2057        _exceptionType = "java/lang/IllegalArgumentException";
2058        _exceptionMessage = "shaders == null";
2059        goto exit;
2060    }
2061    if (shadersOffset < 0) {
2062        _exception = 1;
2063        _exceptionType = "java/lang/IllegalArgumentException";
2064        _exceptionMessage = "shadersOffset < 0";
2065        goto exit;
2066    }
2067    _shadersRemaining = _env->GetArrayLength(shaders_ref) - shadersOffset;
2068    shaders_base = (GLuint *)
2069        _env->GetPrimitiveArrayCritical(shaders_ref, (jboolean *)0);
2070    shaders = shaders_base + shadersOffset;
2071
2072    glGetAttachedShaders(
2073        (GLuint)program,
2074        (GLsizei)maxcount,
2075        (GLsizei *)count,
2076        (GLuint *)shaders
2077    );
2078
2079exit:
2080    if (shaders_base) {
2081        _env->ReleasePrimitiveArrayCritical(shaders_ref, shaders_base,
2082            _exception ? JNI_ABORT: 0);
2083    }
2084    if (count_base) {
2085        _env->ReleasePrimitiveArrayCritical(count_ref, count_base,
2086            _exception ? JNI_ABORT: 0);
2087    }
2088    if (_exception) {
2089        jniThrowException(_env, _exceptionType, _exceptionMessage);
2090    }
2091}
2092
2093/* void glGetAttachedShaders ( GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders ) */
2094static void
2095android_glGetAttachedShaders__IILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2
2096  (JNIEnv *_env, jobject _this, jint program, jint maxcount, jobject count_buf, jobject shaders_buf) {
2097    jarray _countArray = (jarray) 0;
2098    jint _countBufferOffset = (jint) 0;
2099    jarray _shadersArray = (jarray) 0;
2100    jint _shadersBufferOffset = (jint) 0;
2101    jint _countRemaining;
2102    GLsizei *count = (GLsizei *) 0;
2103    jint _shadersRemaining;
2104    GLuint *shaders = (GLuint *) 0;
2105
2106    count = (GLsizei *)getPointer(_env, count_buf, &_countArray, &_countRemaining, &_countBufferOffset);
2107    shaders = (GLuint *)getPointer(_env, shaders_buf, &_shadersArray, &_shadersRemaining, &_shadersBufferOffset);
2108    if (count == NULL) {
2109        char * _countBase = (char *)_env->GetPrimitiveArrayCritical(_countArray, (jboolean *) 0);
2110        count = (GLsizei *) (_countBase + _countBufferOffset);
2111    }
2112    if (shaders == NULL) {
2113        char * _shadersBase = (char *)_env->GetPrimitiveArrayCritical(_shadersArray, (jboolean *) 0);
2114        shaders = (GLuint *) (_shadersBase + _shadersBufferOffset);
2115    }
2116    glGetAttachedShaders(
2117        (GLuint)program,
2118        (GLsizei)maxcount,
2119        (GLsizei *)count,
2120        (GLuint *)shaders
2121    );
2122    if (_shadersArray) {
2123        releasePointer(_env, _shadersArray, shaders, JNI_TRUE);
2124    }
2125    if (_countArray) {
2126        releasePointer(_env, _countArray, count, JNI_TRUE);
2127    }
2128}
2129
2130/* int glGetAttribLocation ( GLuint program, const char *name ) */
2131static jint
2132android_glGetAttribLocation__ILjava_lang_String_2
2133  (JNIEnv *_env, jobject _this, jint program, jstring name) {
2134    jint _exception = 0;
2135    const char * _exceptionType;
2136    const char * _exceptionMessage;
2137    int _returnValue = 0;
2138    const char* _nativename = 0;
2139
2140    if (!name) {
2141        _exceptionType = "java/lang/IllegalArgumentException";
2142        _exceptionMessage = "name == null";
2143        goto exit;
2144    }
2145    _nativename = _env->GetStringUTFChars(name, 0);
2146
2147    _returnValue = glGetAttribLocation(
2148        (GLuint)program,
2149        (char *)_nativename
2150    );
2151
2152exit:
2153    if (_nativename) {
2154        _env->ReleaseStringUTFChars(name, _nativename);
2155    }
2156
2157    if (_exception) {
2158        jniThrowException(_env, _exceptionType, _exceptionMessage);
2159    }
2160    return _returnValue;
2161}
2162
2163/* void glGetBooleanv ( GLenum pname, GLboolean *params ) */
2164static void
2165android_glGetBooleanv__I_3ZI
2166  (JNIEnv *_env, jobject _this, jint pname, jbooleanArray params_ref, jint offset) {
2167    jint _exception = 0;
2168    const char * _exceptionType;
2169    const char * _exceptionMessage;
2170    GLboolean *params_base = (GLboolean *) 0;
2171    jint _remaining;
2172    GLboolean *params = (GLboolean *) 0;
2173
2174    if (!params_ref) {
2175        _exception = 1;
2176        _exceptionType = "java/lang/IllegalArgumentException";
2177        _exceptionMessage = "params == null";
2178        goto exit;
2179    }
2180    if (offset < 0) {
2181        _exception = 1;
2182        _exceptionType = "java/lang/IllegalArgumentException";
2183        _exceptionMessage = "offset < 0";
2184        goto exit;
2185    }
2186    _remaining = _env->GetArrayLength(params_ref) - offset;
2187    params_base = (GLboolean *)
2188        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2189    params = params_base + offset;
2190
2191    glGetBooleanv(
2192        (GLenum)pname,
2193        (GLboolean *)params
2194    );
2195
2196exit:
2197    if (params_base) {
2198        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2199            _exception ? JNI_ABORT: 0);
2200    }
2201    if (_exception) {
2202        jniThrowException(_env, _exceptionType, _exceptionMessage);
2203    }
2204}
2205
2206/* void glGetBooleanv ( GLenum pname, GLboolean *params ) */
2207static void
2208android_glGetBooleanv__ILjava_nio_IntBuffer_2
2209  (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
2210    jarray _array = (jarray) 0;
2211    jint _bufferOffset = (jint) 0;
2212    jint _remaining;
2213    GLboolean *params = (GLboolean *) 0;
2214
2215    params = (GLboolean *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
2216    if (params == NULL) {
2217        char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
2218        params = (GLboolean *) (_paramsBase + _bufferOffset);
2219    }
2220    glGetBooleanv(
2221        (GLenum)pname,
2222        (GLboolean *)params
2223    );
2224    if (_array) {
2225        releasePointer(_env, _array, params, JNI_TRUE);
2226    }
2227}
2228
2229/* void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */
2230static void
2231android_glGetBufferParameteriv__II_3II
2232  (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
2233    jint _exception = 0;
2234    const char * _exceptionType;
2235    const char * _exceptionMessage;
2236    GLint *params_base = (GLint *) 0;
2237    jint _remaining;
2238    GLint *params = (GLint *) 0;
2239
2240    if (!params_ref) {
2241        _exception = 1;
2242        _exceptionType = "java/lang/IllegalArgumentException";
2243        _exceptionMessage = "params == null";
2244        goto exit;
2245    }
2246    if (offset < 0) {
2247        _exception = 1;
2248        _exceptionType = "java/lang/IllegalArgumentException";
2249        _exceptionMessage = "offset < 0";
2250        goto exit;
2251    }
2252    _remaining = _env->GetArrayLength(params_ref) - offset;
2253    if (_remaining < 1) {
2254        _exception = 1;
2255        _exceptionType = "java/lang/IllegalArgumentException";
2256        _exceptionMessage = "length - offset < 1 < needed";
2257        goto exit;
2258    }
2259    params_base = (GLint *)
2260        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2261    params = params_base + offset;
2262
2263    glGetBufferParameteriv(
2264        (GLenum)target,
2265        (GLenum)pname,
2266        (GLint *)params
2267    );
2268
2269exit:
2270    if (params_base) {
2271        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2272            _exception ? JNI_ABORT: 0);
2273    }
2274    if (_exception) {
2275        jniThrowException(_env, _exceptionType, _exceptionMessage);
2276    }
2277}
2278
2279/* void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */
2280static void
2281android_glGetBufferParameteriv__IILjava_nio_IntBuffer_2
2282  (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
2283    jint _exception = 0;
2284    const char * _exceptionType;
2285    const char * _exceptionMessage;
2286    jarray _array = (jarray) 0;
2287    jint _bufferOffset = (jint) 0;
2288    jint _remaining;
2289    GLint *params = (GLint *) 0;
2290
2291    params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
2292    if (_remaining < 1) {
2293        _exception = 1;
2294        _exceptionType = "java/lang/IllegalArgumentException";
2295        _exceptionMessage = "remaining() < 1 < needed";
2296        goto exit;
2297    }
2298    if (params == NULL) {
2299        char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
2300        params = (GLint *) (_paramsBase + _bufferOffset);
2301    }
2302    glGetBufferParameteriv(
2303        (GLenum)target,
2304        (GLenum)pname,
2305        (GLint *)params
2306    );
2307
2308exit:
2309    if (_array) {
2310        releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
2311    }
2312    if (_exception) {
2313        jniThrowException(_env, _exceptionType, _exceptionMessage);
2314    }
2315}
2316
2317/* GLenum glGetError ( void ) */
2318static jint
2319android_glGetError__
2320  (JNIEnv *_env, jobject _this) {
2321    GLenum _returnValue;
2322    _returnValue = glGetError();
2323    return _returnValue;
2324}
2325
2326/* void glGetFloatv ( GLenum pname, GLfloat *params ) */
2327static void
2328android_glGetFloatv__I_3FI
2329  (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) {
2330    jint _exception = 0;
2331    const char * _exceptionType;
2332    const char * _exceptionMessage;
2333    GLfloat *params_base = (GLfloat *) 0;
2334    jint _remaining;
2335    GLfloat *params = (GLfloat *) 0;
2336
2337    if (!params_ref) {
2338        _exception = 1;
2339        _exceptionType = "java/lang/IllegalArgumentException";
2340        _exceptionMessage = "params == null";
2341        goto exit;
2342    }
2343    if (offset < 0) {
2344        _exception = 1;
2345        _exceptionType = "java/lang/IllegalArgumentException";
2346        _exceptionMessage = "offset < 0";
2347        goto exit;
2348    }
2349    _remaining = _env->GetArrayLength(params_ref) - offset;
2350    params_base = (GLfloat *)
2351        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2352    params = params_base + offset;
2353
2354    glGetFloatv(
2355        (GLenum)pname,
2356        (GLfloat *)params
2357    );
2358
2359exit:
2360    if (params_base) {
2361        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2362            _exception ? JNI_ABORT: 0);
2363    }
2364    if (_exception) {
2365        jniThrowException(_env, _exceptionType, _exceptionMessage);
2366    }
2367}
2368
2369/* void glGetFloatv ( GLenum pname, GLfloat *params ) */
2370static void
2371android_glGetFloatv__ILjava_nio_FloatBuffer_2
2372  (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
2373    jarray _array = (jarray) 0;
2374    jint _bufferOffset = (jint) 0;
2375    jint _remaining;
2376    GLfloat *params = (GLfloat *) 0;
2377
2378    params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
2379    if (params == NULL) {
2380        char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
2381        params = (GLfloat *) (_paramsBase + _bufferOffset);
2382    }
2383    glGetFloatv(
2384        (GLenum)pname,
2385        (GLfloat *)params
2386    );
2387    if (_array) {
2388        releasePointer(_env, _array, params, JNI_TRUE);
2389    }
2390}
2391
2392/* void glGetFramebufferAttachmentParameteriv ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */
2393static void
2394android_glGetFramebufferAttachmentParameteriv__III_3II
2395  (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jintArray params_ref, jint offset) {
2396    jint _exception = 0;
2397    const char * _exceptionType;
2398    const char * _exceptionMessage;
2399    GLint *params_base = (GLint *) 0;
2400    jint _remaining;
2401    GLint *params = (GLint *) 0;
2402
2403    if (!params_ref) {
2404        _exception = 1;
2405        _exceptionType = "java/lang/IllegalArgumentException";
2406        _exceptionMessage = "params == null";
2407        goto exit;
2408    }
2409    if (offset < 0) {
2410        _exception = 1;
2411        _exceptionType = "java/lang/IllegalArgumentException";
2412        _exceptionMessage = "offset < 0";
2413        goto exit;
2414    }
2415    _remaining = _env->GetArrayLength(params_ref) - offset;
2416    params_base = (GLint *)
2417        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2418    params = params_base + offset;
2419
2420    glGetFramebufferAttachmentParameteriv(
2421        (GLenum)target,
2422        (GLenum)attachment,
2423        (GLenum)pname,
2424        (GLint *)params
2425    );
2426
2427exit:
2428    if (params_base) {
2429        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2430            _exception ? JNI_ABORT: 0);
2431    }
2432    if (_exception) {
2433        jniThrowException(_env, _exceptionType, _exceptionMessage);
2434    }
2435}
2436
2437/* void glGetFramebufferAttachmentParameteriv ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */
2438static void
2439android_glGetFramebufferAttachmentParameteriv__IIILjava_nio_IntBuffer_2
2440  (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jobject params_buf) {
2441    jarray _array = (jarray) 0;
2442    jint _bufferOffset = (jint) 0;
2443    jint _remaining;
2444    GLint *params = (GLint *) 0;
2445
2446    params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
2447    if (params == NULL) {
2448        char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
2449        params = (GLint *) (_paramsBase + _bufferOffset);
2450    }
2451    glGetFramebufferAttachmentParameteriv(
2452        (GLenum)target,
2453        (GLenum)attachment,
2454        (GLenum)pname,
2455        (GLint *)params
2456    );
2457    if (_array) {
2458        releasePointer(_env, _array, params, JNI_TRUE);
2459    }
2460}
2461
2462/* void glGetIntegerv ( GLenum pname, GLint *params ) */
2463static void
2464android_glGetIntegerv__I_3II
2465  (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
2466    jint _exception = 0;
2467    const char * _exceptionType;
2468    const char * _exceptionMessage;
2469    GLint *params_base = (GLint *) 0;
2470    jint _remaining;
2471    GLint *params = (GLint *) 0;
2472
2473    if (!params_ref) {
2474        _exception = 1;
2475        _exceptionType = "java/lang/IllegalArgumentException";
2476        _exceptionMessage = "params == null";
2477        goto exit;
2478    }
2479    if (offset < 0) {
2480        _exception = 1;
2481        _exceptionType = "java/lang/IllegalArgumentException";
2482        _exceptionMessage = "offset < 0";
2483        goto exit;
2484    }
2485    _remaining = _env->GetArrayLength(params_ref) - offset;
2486    int _needed;
2487    switch (pname) {
2488#if defined(GL_ALPHA_BITS)
2489        case GL_ALPHA_BITS:
2490#endif // defined(GL_ALPHA_BITS)
2491#if defined(GL_ALPHA_TEST_FUNC)
2492        case GL_ALPHA_TEST_FUNC:
2493#endif // defined(GL_ALPHA_TEST_FUNC)
2494#if defined(GL_ALPHA_TEST_REF)
2495        case GL_ALPHA_TEST_REF:
2496#endif // defined(GL_ALPHA_TEST_REF)
2497#if defined(GL_BLEND_DST)
2498        case GL_BLEND_DST:
2499#endif // defined(GL_BLEND_DST)
2500#if defined(GL_BLUE_BITS)
2501        case GL_BLUE_BITS:
2502#endif // defined(GL_BLUE_BITS)
2503#if defined(GL_COLOR_ARRAY_BUFFER_BINDING)
2504        case GL_COLOR_ARRAY_BUFFER_BINDING:
2505#endif // defined(GL_COLOR_ARRAY_BUFFER_BINDING)
2506#if defined(GL_COLOR_ARRAY_SIZE)
2507        case GL_COLOR_ARRAY_SIZE:
2508#endif // defined(GL_COLOR_ARRAY_SIZE)
2509#if defined(GL_COLOR_ARRAY_STRIDE)
2510        case GL_COLOR_ARRAY_STRIDE:
2511#endif // defined(GL_COLOR_ARRAY_STRIDE)
2512#if defined(GL_COLOR_ARRAY_TYPE)
2513        case GL_COLOR_ARRAY_TYPE:
2514#endif // defined(GL_COLOR_ARRAY_TYPE)
2515#if defined(GL_CULL_FACE)
2516        case GL_CULL_FACE:
2517#endif // defined(GL_CULL_FACE)
2518#if defined(GL_DEPTH_BITS)
2519        case GL_DEPTH_BITS:
2520#endif // defined(GL_DEPTH_BITS)
2521#if defined(GL_DEPTH_CLEAR_VALUE)
2522        case GL_DEPTH_CLEAR_VALUE:
2523#endif // defined(GL_DEPTH_CLEAR_VALUE)
2524#if defined(GL_DEPTH_FUNC)
2525        case GL_DEPTH_FUNC:
2526#endif // defined(GL_DEPTH_FUNC)
2527#if defined(GL_DEPTH_WRITEMASK)
2528        case GL_DEPTH_WRITEMASK:
2529#endif // defined(GL_DEPTH_WRITEMASK)
2530#if defined(GL_FOG_DENSITY)
2531        case GL_FOG_DENSITY:
2532#endif // defined(GL_FOG_DENSITY)
2533#if defined(GL_FOG_END)
2534        case GL_FOG_END:
2535#endif // defined(GL_FOG_END)
2536#if defined(GL_FOG_MODE)
2537        case GL_FOG_MODE:
2538#endif // defined(GL_FOG_MODE)
2539#if defined(GL_FOG_START)
2540        case GL_FOG_START:
2541#endif // defined(GL_FOG_START)
2542#if defined(GL_FRONT_FACE)
2543        case GL_FRONT_FACE:
2544#endif // defined(GL_FRONT_FACE)
2545#if defined(GL_GREEN_BITS)
2546        case GL_GREEN_BITS:
2547#endif // defined(GL_GREEN_BITS)
2548#if defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES)
2549        case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
2550#endif // defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES)
2551#if defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES)
2552        case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
2553#endif // defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES)
2554#if defined(GL_LIGHT_MODEL_COLOR_CONTROL)
2555        case GL_LIGHT_MODEL_COLOR_CONTROL:
2556#endif // defined(GL_LIGHT_MODEL_COLOR_CONTROL)
2557#if defined(GL_LIGHT_MODEL_LOCAL_VIEWER)
2558        case GL_LIGHT_MODEL_LOCAL_VIEWER:
2559#endif // defined(GL_LIGHT_MODEL_LOCAL_VIEWER)
2560#if defined(GL_LIGHT_MODEL_TWO_SIDE)
2561        case GL_LIGHT_MODEL_TWO_SIDE:
2562#endif // defined(GL_LIGHT_MODEL_TWO_SIDE)
2563#if defined(GL_LINE_SMOOTH_HINT)
2564        case GL_LINE_SMOOTH_HINT:
2565#endif // defined(GL_LINE_SMOOTH_HINT)
2566#if defined(GL_LINE_WIDTH)
2567        case GL_LINE_WIDTH:
2568#endif // defined(GL_LINE_WIDTH)
2569#if defined(GL_LOGIC_OP_MODE)
2570        case GL_LOGIC_OP_MODE:
2571#endif // defined(GL_LOGIC_OP_MODE)
2572#if defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES)
2573        case GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES:
2574#endif // defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES)
2575#if defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES)
2576        case GL_MATRIX_INDEX_ARRAY_SIZE_OES:
2577#endif // defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES)
2578#if defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES)
2579        case GL_MATRIX_INDEX_ARRAY_STRIDE_OES:
2580#endif // defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES)
2581#if defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES)
2582        case GL_MATRIX_INDEX_ARRAY_TYPE_OES:
2583#endif // defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES)
2584#if defined(GL_MATRIX_MODE)
2585        case GL_MATRIX_MODE:
2586#endif // defined(GL_MATRIX_MODE)
2587#if defined(GL_MAX_CLIP_PLANES)
2588        case GL_MAX_CLIP_PLANES:
2589#endif // defined(GL_MAX_CLIP_PLANES)
2590#if defined(GL_MAX_ELEMENTS_INDICES)
2591        case GL_MAX_ELEMENTS_INDICES:
2592#endif // defined(GL_MAX_ELEMENTS_INDICES)
2593#if defined(GL_MAX_ELEMENTS_VERTICES)
2594        case GL_MAX_ELEMENTS_VERTICES:
2595#endif // defined(GL_MAX_ELEMENTS_VERTICES)
2596#if defined(GL_MAX_LIGHTS)
2597        case GL_MAX_LIGHTS:
2598#endif // defined(GL_MAX_LIGHTS)
2599#if defined(GL_MAX_MODELVIEW_STACK_DEPTH)
2600        case GL_MAX_MODELVIEW_STACK_DEPTH:
2601#endif // defined(GL_MAX_MODELVIEW_STACK_DEPTH)
2602#if defined(GL_MAX_PALETTE_MATRICES_OES)
2603        case GL_MAX_PALETTE_MATRICES_OES:
2604#endif // defined(GL_MAX_PALETTE_MATRICES_OES)
2605#if defined(GL_MAX_PROJECTION_STACK_DEPTH)
2606        case GL_MAX_PROJECTION_STACK_DEPTH:
2607#endif // defined(GL_MAX_PROJECTION_STACK_DEPTH)
2608#if defined(GL_MAX_TEXTURE_SIZE)
2609        case GL_MAX_TEXTURE_SIZE:
2610#endif // defined(GL_MAX_TEXTURE_SIZE)
2611#if defined(GL_MAX_TEXTURE_STACK_DEPTH)
2612        case GL_MAX_TEXTURE_STACK_DEPTH:
2613#endif // defined(GL_MAX_TEXTURE_STACK_DEPTH)
2614#if defined(GL_MAX_TEXTURE_UNITS)
2615        case GL_MAX_TEXTURE_UNITS:
2616#endif // defined(GL_MAX_TEXTURE_UNITS)
2617#if defined(GL_MAX_VERTEX_UNITS_OES)
2618        case GL_MAX_VERTEX_UNITS_OES:
2619#endif // defined(GL_MAX_VERTEX_UNITS_OES)
2620#if defined(GL_MODELVIEW_STACK_DEPTH)
2621        case GL_MODELVIEW_STACK_DEPTH:
2622#endif // defined(GL_MODELVIEW_STACK_DEPTH)
2623#if defined(GL_NORMAL_ARRAY_BUFFER_BINDING)
2624        case GL_NORMAL_ARRAY_BUFFER_BINDING:
2625#endif // defined(GL_NORMAL_ARRAY_BUFFER_BINDING)
2626#if defined(GL_NORMAL_ARRAY_STRIDE)
2627        case GL_NORMAL_ARRAY_STRIDE:
2628#endif // defined(GL_NORMAL_ARRAY_STRIDE)
2629#if defined(GL_NORMAL_ARRAY_TYPE)
2630        case GL_NORMAL_ARRAY_TYPE:
2631#endif // defined(GL_NORMAL_ARRAY_TYPE)
2632#if defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS)
2633        case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
2634#endif // defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS)
2635#if defined(GL_PACK_ALIGNMENT)
2636        case GL_PACK_ALIGNMENT:
2637#endif // defined(GL_PACK_ALIGNMENT)
2638#if defined(GL_PERSPECTIVE_CORRECTION_HINT)
2639        case GL_PERSPECTIVE_CORRECTION_HINT:
2640#endif // defined(GL_PERSPECTIVE_CORRECTION_HINT)
2641#if defined(GL_POINT_SIZE)
2642        case GL_POINT_SIZE:
2643#endif // defined(GL_POINT_SIZE)
2644#if defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES)
2645        case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
2646#endif // defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES)
2647#if defined(GL_POINT_SIZE_ARRAY_STRIDE_OES)
2648        case GL_POINT_SIZE_ARRAY_STRIDE_OES:
2649#endif // defined(GL_POINT_SIZE_ARRAY_STRIDE_OES)
2650#if defined(GL_POINT_SIZE_ARRAY_TYPE_OES)
2651        case GL_POINT_SIZE_ARRAY_TYPE_OES:
2652#endif // defined(GL_POINT_SIZE_ARRAY_TYPE_OES)
2653#if defined(GL_POINT_SMOOTH_HINT)
2654        case GL_POINT_SMOOTH_HINT:
2655#endif // defined(GL_POINT_SMOOTH_HINT)
2656#if defined(GL_POLYGON_OFFSET_FACTOR)
2657        case GL_POLYGON_OFFSET_FACTOR:
2658#endif // defined(GL_POLYGON_OFFSET_FACTOR)
2659#if defined(GL_POLYGON_OFFSET_UNITS)
2660        case GL_POLYGON_OFFSET_UNITS:
2661#endif // defined(GL_POLYGON_OFFSET_UNITS)
2662#if defined(GL_PROJECTION_STACK_DEPTH)
2663        case GL_PROJECTION_STACK_DEPTH:
2664#endif // defined(GL_PROJECTION_STACK_DEPTH)
2665#if defined(GL_RED_BITS)
2666        case GL_RED_BITS:
2667#endif // defined(GL_RED_BITS)
2668#if defined(GL_SHADE_MODEL)
2669        case GL_SHADE_MODEL:
2670#endif // defined(GL_SHADE_MODEL)
2671#if defined(GL_STENCIL_BITS)
2672        case GL_STENCIL_BITS:
2673#endif // defined(GL_STENCIL_BITS)
2674#if defined(GL_STENCIL_CLEAR_VALUE)
2675        case GL_STENCIL_CLEAR_VALUE:
2676#endif // defined(GL_STENCIL_CLEAR_VALUE)
2677#if defined(GL_STENCIL_FAIL)
2678        case GL_STENCIL_FAIL:
2679#endif // defined(GL_STENCIL_FAIL)
2680#if defined(GL_STENCIL_FUNC)
2681        case GL_STENCIL_FUNC:
2682#endif // defined(GL_STENCIL_FUNC)
2683#if defined(GL_STENCIL_PASS_DEPTH_FAIL)
2684        case GL_STENCIL_PASS_DEPTH_FAIL:
2685#endif // defined(GL_STENCIL_PASS_DEPTH_FAIL)
2686#if defined(GL_STENCIL_PASS_DEPTH_PASS)
2687        case GL_STENCIL_PASS_DEPTH_PASS:
2688#endif // defined(GL_STENCIL_PASS_DEPTH_PASS)
2689#if defined(GL_STENCIL_REF)
2690        case GL_STENCIL_REF:
2691#endif // defined(GL_STENCIL_REF)
2692#if defined(GL_STENCIL_VALUE_MASK)
2693        case GL_STENCIL_VALUE_MASK:
2694#endif // defined(GL_STENCIL_VALUE_MASK)
2695#if defined(GL_STENCIL_WRITEMASK)
2696        case GL_STENCIL_WRITEMASK:
2697#endif // defined(GL_STENCIL_WRITEMASK)
2698#if defined(GL_SUBPIXEL_BITS)
2699        case GL_SUBPIXEL_BITS:
2700#endif // defined(GL_SUBPIXEL_BITS)
2701#if defined(GL_TEXTURE_BINDING_2D)
2702        case GL_TEXTURE_BINDING_2D:
2703#endif // defined(GL_TEXTURE_BINDING_2D)
2704#if defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING)
2705        case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:
2706#endif // defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING)
2707#if defined(GL_TEXTURE_COORD_ARRAY_SIZE)
2708        case GL_TEXTURE_COORD_ARRAY_SIZE:
2709#endif // defined(GL_TEXTURE_COORD_ARRAY_SIZE)
2710#if defined(GL_TEXTURE_COORD_ARRAY_STRIDE)
2711        case GL_TEXTURE_COORD_ARRAY_STRIDE:
2712#endif // defined(GL_TEXTURE_COORD_ARRAY_STRIDE)
2713#if defined(GL_TEXTURE_COORD_ARRAY_TYPE)
2714        case GL_TEXTURE_COORD_ARRAY_TYPE:
2715#endif // defined(GL_TEXTURE_COORD_ARRAY_TYPE)
2716#if defined(GL_TEXTURE_STACK_DEPTH)
2717        case GL_TEXTURE_STACK_DEPTH:
2718#endif // defined(GL_TEXTURE_STACK_DEPTH)
2719#if defined(GL_UNPACK_ALIGNMENT)
2720        case GL_UNPACK_ALIGNMENT:
2721#endif // defined(GL_UNPACK_ALIGNMENT)
2722#if defined(GL_VERTEX_ARRAY_BUFFER_BINDING)
2723        case GL_VERTEX_ARRAY_BUFFER_BINDING:
2724#endif // defined(GL_VERTEX_ARRAY_BUFFER_BINDING)
2725#if defined(GL_VERTEX_ARRAY_SIZE)
2726        case GL_VERTEX_ARRAY_SIZE:
2727#endif // defined(GL_VERTEX_ARRAY_SIZE)
2728#if defined(GL_VERTEX_ARRAY_STRIDE)
2729        case GL_VERTEX_ARRAY_STRIDE:
2730#endif // defined(GL_VERTEX_ARRAY_STRIDE)
2731#if defined(GL_VERTEX_ARRAY_TYPE)
2732        case GL_VERTEX_ARRAY_TYPE:
2733#endif // defined(GL_VERTEX_ARRAY_TYPE)
2734#if defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES)
2735        case GL_WEIGHT_ARRAY_BUFFER_BINDING_OES:
2736#endif // defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES)
2737#if defined(GL_WEIGHT_ARRAY_SIZE_OES)
2738        case GL_WEIGHT_ARRAY_SIZE_OES:
2739#endif // defined(GL_WEIGHT_ARRAY_SIZE_OES)
2740#if defined(GL_WEIGHT_ARRAY_STRIDE_OES)
2741        case GL_WEIGHT_ARRAY_STRIDE_OES:
2742#endif // defined(GL_WEIGHT_ARRAY_STRIDE_OES)
2743#if defined(GL_WEIGHT_ARRAY_TYPE_OES)
2744        case GL_WEIGHT_ARRAY_TYPE_OES:
2745#endif // defined(GL_WEIGHT_ARRAY_TYPE_OES)
2746            _needed = 1;
2747            break;
2748#if defined(GL_ALIASED_POINT_SIZE_RANGE)
2749        case GL_ALIASED_POINT_SIZE_RANGE:
2750#endif // defined(GL_ALIASED_POINT_SIZE_RANGE)
2751#if defined(GL_ALIASED_LINE_WIDTH_RANGE)
2752        case GL_ALIASED_LINE_WIDTH_RANGE:
2753#endif // defined(GL_ALIASED_LINE_WIDTH_RANGE)
2754#if defined(GL_DEPTH_RANGE)
2755        case GL_DEPTH_RANGE:
2756#endif // defined(GL_DEPTH_RANGE)
2757#if defined(GL_MAX_VIEWPORT_DIMS)
2758        case GL_MAX_VIEWPORT_DIMS:
2759#endif // defined(GL_MAX_VIEWPORT_DIMS)
2760#if defined(GL_SMOOTH_LINE_WIDTH_RANGE)
2761        case GL_SMOOTH_LINE_WIDTH_RANGE:
2762#endif // defined(GL_SMOOTH_LINE_WIDTH_RANGE)
2763#if defined(GL_SMOOTH_POINT_SIZE_RANGE)
2764        case GL_SMOOTH_POINT_SIZE_RANGE:
2765#endif // defined(GL_SMOOTH_POINT_SIZE_RANGE)
2766            _needed = 2;
2767            break;
2768#if defined(GL_COLOR_CLEAR_VALUE)
2769        case GL_COLOR_CLEAR_VALUE:
2770#endif // defined(GL_COLOR_CLEAR_VALUE)
2771#if defined(GL_COLOR_WRITEMASK)
2772        case GL_COLOR_WRITEMASK:
2773#endif // defined(GL_COLOR_WRITEMASK)
2774#if defined(GL_FOG_COLOR)
2775        case GL_FOG_COLOR:
2776#endif // defined(GL_FOG_COLOR)
2777#if defined(GL_LIGHT_MODEL_AMBIENT)
2778        case GL_LIGHT_MODEL_AMBIENT:
2779#endif // defined(GL_LIGHT_MODEL_AMBIENT)
2780#if defined(GL_SCISSOR_BOX)
2781        case GL_SCISSOR_BOX:
2782#endif // defined(GL_SCISSOR_BOX)
2783#if defined(GL_VIEWPORT)
2784        case GL_VIEWPORT:
2785#endif // defined(GL_VIEWPORT)
2786            _needed = 4;
2787            break;
2788#if defined(GL_MODELVIEW_MATRIX)
2789        case GL_MODELVIEW_MATRIX:
2790#endif // defined(GL_MODELVIEW_MATRIX)
2791#if defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES)
2792        case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES:
2793#endif // defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES)
2794#if defined(GL_PROJECTION_MATRIX)
2795        case GL_PROJECTION_MATRIX:
2796#endif // defined(GL_PROJECTION_MATRIX)
2797#if defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES)
2798        case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES:
2799#endif // defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES)
2800#if defined(GL_TEXTURE_MATRIX)
2801        case GL_TEXTURE_MATRIX:
2802#endif // defined(GL_TEXTURE_MATRIX)
2803#if defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES)
2804        case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES:
2805#endif // defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES)
2806            _needed = 16;
2807            break;
2808#if defined(GL_COMPRESSED_TEXTURE_FORMATS)
2809        case GL_COMPRESSED_TEXTURE_FORMATS:
2810#endif // defined(GL_COMPRESSED_TEXTURE_FORMATS)
2811            _needed = getNumCompressedTextureFormats();
2812            break;
2813        default:
2814            _needed = 0;
2815            break;
2816    }
2817    if (_remaining < _needed) {
2818        _exception = 1;
2819        _exceptionType = "java/lang/IllegalArgumentException";
2820        _exceptionMessage = "length - offset < needed";
2821        goto exit;
2822    }
2823    params_base = (GLint *)
2824        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2825    params = params_base + offset;
2826
2827    glGetIntegerv(
2828        (GLenum)pname,
2829        (GLint *)params
2830    );
2831
2832exit:
2833    if (params_base) {
2834        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2835            _exception ? JNI_ABORT: 0);
2836    }
2837    if (_exception) {
2838        jniThrowException(_env, _exceptionType, _exceptionMessage);
2839    }
2840}
2841
2842/* void glGetIntegerv ( GLenum pname, GLint *params ) */
2843static void
2844android_glGetIntegerv__ILjava_nio_IntBuffer_2
2845  (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
2846    jint _exception = 0;
2847    const char * _exceptionType;
2848    const char * _exceptionMessage;
2849    jarray _array = (jarray) 0;
2850    jint _bufferOffset = (jint) 0;
2851    jint _remaining;
2852    GLint *params = (GLint *) 0;
2853
2854    params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
2855    int _needed;
2856    switch (pname) {
2857#if defined(GL_ALPHA_BITS)
2858        case GL_ALPHA_BITS:
2859#endif // defined(GL_ALPHA_BITS)
2860#if defined(GL_ALPHA_TEST_FUNC)
2861        case GL_ALPHA_TEST_FUNC:
2862#endif // defined(GL_ALPHA_TEST_FUNC)
2863#if defined(GL_ALPHA_TEST_REF)
2864        case GL_ALPHA_TEST_REF:
2865#endif // defined(GL_ALPHA_TEST_REF)
2866#if defined(GL_BLEND_DST)
2867        case GL_BLEND_DST:
2868#endif // defined(GL_BLEND_DST)
2869#if defined(GL_BLUE_BITS)
2870        case GL_BLUE_BITS:
2871#endif // defined(GL_BLUE_BITS)
2872#if defined(GL_COLOR_ARRAY_BUFFER_BINDING)
2873        case GL_COLOR_ARRAY_BUFFER_BINDING:
2874#endif // defined(GL_COLOR_ARRAY_BUFFER_BINDING)
2875#if defined(GL_COLOR_ARRAY_SIZE)
2876        case GL_COLOR_ARRAY_SIZE:
2877#endif // defined(GL_COLOR_ARRAY_SIZE)
2878#if defined(GL_COLOR_ARRAY_STRIDE)
2879        case GL_COLOR_ARRAY_STRIDE:
2880#endif // defined(GL_COLOR_ARRAY_STRIDE)
2881#if defined(GL_COLOR_ARRAY_TYPE)
2882        case GL_COLOR_ARRAY_TYPE:
2883#endif // defined(GL_COLOR_ARRAY_TYPE)
2884#if defined(GL_CULL_FACE)
2885        case GL_CULL_FACE:
2886#endif // defined(GL_CULL_FACE)
2887#if defined(GL_DEPTH_BITS)
2888        case GL_DEPTH_BITS:
2889#endif // defined(GL_DEPTH_BITS)
2890#if defined(GL_DEPTH_CLEAR_VALUE)
2891        case GL_DEPTH_CLEAR_VALUE:
2892#endif // defined(GL_DEPTH_CLEAR_VALUE)
2893#if defined(GL_DEPTH_FUNC)
2894        case GL_DEPTH_FUNC:
2895#endif // defined(GL_DEPTH_FUNC)
2896#if defined(GL_DEPTH_WRITEMASK)
2897        case GL_DEPTH_WRITEMASK:
2898#endif // defined(GL_DEPTH_WRITEMASK)
2899#if defined(GL_FOG_DENSITY)
2900        case GL_FOG_DENSITY:
2901#endif // defined(GL_FOG_DENSITY)
2902#if defined(GL_FOG_END)
2903        case GL_FOG_END:
2904#endif // defined(GL_FOG_END)
2905#if defined(GL_FOG_MODE)
2906        case GL_FOG_MODE:
2907#endif // defined(GL_FOG_MODE)
2908#if defined(GL_FOG_START)
2909        case GL_FOG_START:
2910#endif // defined(GL_FOG_START)
2911#if defined(GL_FRONT_FACE)
2912        case GL_FRONT_FACE:
2913#endif // defined(GL_FRONT_FACE)
2914#if defined(GL_GREEN_BITS)
2915        case GL_GREEN_BITS:
2916#endif // defined(GL_GREEN_BITS)
2917#if defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES)
2918        case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
2919#endif // defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES)
2920#if defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES)
2921        case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
2922#endif // defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES)
2923#if defined(GL_LIGHT_MODEL_COLOR_CONTROL)
2924        case GL_LIGHT_MODEL_COLOR_CONTROL:
2925#endif // defined(GL_LIGHT_MODEL_COLOR_CONTROL)
2926#if defined(GL_LIGHT_MODEL_LOCAL_VIEWER)
2927        case GL_LIGHT_MODEL_LOCAL_VIEWER:
2928#endif // defined(GL_LIGHT_MODEL_LOCAL_VIEWER)
2929#if defined(GL_LIGHT_MODEL_TWO_SIDE)
2930        case GL_LIGHT_MODEL_TWO_SIDE:
2931#endif // defined(GL_LIGHT_MODEL_TWO_SIDE)
2932#if defined(GL_LINE_SMOOTH_HINT)
2933        case GL_LINE_SMOOTH_HINT:
2934#endif // defined(GL_LINE_SMOOTH_HINT)
2935#if defined(GL_LINE_WIDTH)
2936        case GL_LINE_WIDTH:
2937#endif // defined(GL_LINE_WIDTH)
2938#if defined(GL_LOGIC_OP_MODE)
2939        case GL_LOGIC_OP_MODE:
2940#endif // defined(GL_LOGIC_OP_MODE)
2941#if defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES)
2942        case GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES:
2943#endif // defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES)
2944#if defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES)
2945        case GL_MATRIX_INDEX_ARRAY_SIZE_OES:
2946#endif // defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES)
2947#if defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES)
2948        case GL_MATRIX_INDEX_ARRAY_STRIDE_OES:
2949#endif // defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES)
2950#if defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES)
2951        case GL_MATRIX_INDEX_ARRAY_TYPE_OES:
2952#endif // defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES)
2953#if defined(GL_MATRIX_MODE)
2954        case GL_MATRIX_MODE:
2955#endif // defined(GL_MATRIX_MODE)
2956#if defined(GL_MAX_CLIP_PLANES)
2957        case GL_MAX_CLIP_PLANES:
2958#endif // defined(GL_MAX_CLIP_PLANES)
2959#if defined(GL_MAX_ELEMENTS_INDICES)
2960        case GL_MAX_ELEMENTS_INDICES:
2961#endif // defined(GL_MAX_ELEMENTS_INDICES)
2962#if defined(GL_MAX_ELEMENTS_VERTICES)
2963        case GL_MAX_ELEMENTS_VERTICES:
2964#endif // defined(GL_MAX_ELEMENTS_VERTICES)
2965#if defined(GL_MAX_LIGHTS)
2966        case GL_MAX_LIGHTS:
2967#endif // defined(GL_MAX_LIGHTS)
2968#if defined(GL_MAX_MODELVIEW_STACK_DEPTH)
2969        case GL_MAX_MODELVIEW_STACK_DEPTH:
2970#endif // defined(GL_MAX_MODELVIEW_STACK_DEPTH)
2971#if defined(GL_MAX_PALETTE_MATRICES_OES)
2972        case GL_MAX_PALETTE_MATRICES_OES:
2973#endif // defined(GL_MAX_PALETTE_MATRICES_OES)
2974#if defined(GL_MAX_PROJECTION_STACK_DEPTH)
2975        case GL_MAX_PROJECTION_STACK_DEPTH:
2976#endif // defined(GL_MAX_PROJECTION_STACK_DEPTH)
2977#if defined(GL_MAX_TEXTURE_SIZE)
2978        case GL_MAX_TEXTURE_SIZE:
2979#endif // defined(GL_MAX_TEXTURE_SIZE)
2980#if defined(GL_MAX_TEXTURE_STACK_DEPTH)
2981        case GL_MAX_TEXTURE_STACK_DEPTH:
2982#endif // defined(GL_MAX_TEXTURE_STACK_DEPTH)
2983#if defined(GL_MAX_TEXTURE_UNITS)
2984        case GL_MAX_TEXTURE_UNITS:
2985#endif // defined(GL_MAX_TEXTURE_UNITS)
2986#if defined(GL_MAX_VERTEX_UNITS_OES)
2987        case GL_MAX_VERTEX_UNITS_OES:
2988#endif // defined(GL_MAX_VERTEX_UNITS_OES)
2989#if defined(GL_MODELVIEW_STACK_DEPTH)
2990        case GL_MODELVIEW_STACK_DEPTH:
2991#endif // defined(GL_MODELVIEW_STACK_DEPTH)
2992#if defined(GL_NORMAL_ARRAY_BUFFER_BINDING)
2993        case GL_NORMAL_ARRAY_BUFFER_BINDING:
2994#endif // defined(GL_NORMAL_ARRAY_BUFFER_BINDING)
2995#if defined(GL_NORMAL_ARRAY_STRIDE)
2996        case GL_NORMAL_ARRAY_STRIDE:
2997#endif // defined(GL_NORMAL_ARRAY_STRIDE)
2998#if defined(GL_NORMAL_ARRAY_TYPE)
2999        case GL_NORMAL_ARRAY_TYPE:
3000#endif // defined(GL_NORMAL_ARRAY_TYPE)
3001#if defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS)
3002        case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
3003#endif // defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS)
3004#if defined(GL_PACK_ALIGNMENT)
3005        case GL_PACK_ALIGNMENT:
3006#endif // defined(GL_PACK_ALIGNMENT)
3007#if defined(GL_PERSPECTIVE_CORRECTION_HINT)
3008        case GL_PERSPECTIVE_CORRECTION_HINT:
3009#endif // defined(GL_PERSPECTIVE_CORRECTION_HINT)
3010#if defined(GL_POINT_SIZE)
3011        case GL_POINT_SIZE:
3012#endif // defined(GL_POINT_SIZE)
3013#if defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES)
3014        case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
3015#endif // defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES)
3016#if defined(GL_POINT_SIZE_ARRAY_STRIDE_OES)
3017        case GL_POINT_SIZE_ARRAY_STRIDE_OES:
3018#endif // defined(GL_POINT_SIZE_ARRAY_STRIDE_OES)
3019#if defined(GL_POINT_SIZE_ARRAY_TYPE_OES)
3020        case GL_POINT_SIZE_ARRAY_TYPE_OES:
3021#endif // defined(GL_POINT_SIZE_ARRAY_TYPE_OES)
3022#if defined(GL_POINT_SMOOTH_HINT)
3023        case GL_POINT_SMOOTH_HINT:
3024#endif // defined(GL_POINT_SMOOTH_HINT)
3025#if defined(GL_POLYGON_OFFSET_FACTOR)
3026        case GL_POLYGON_OFFSET_FACTOR:
3027#endif // defined(GL_POLYGON_OFFSET_FACTOR)
3028#if defined(GL_POLYGON_OFFSET_UNITS)
3029        case GL_POLYGON_OFFSET_UNITS:
3030#endif // defined(GL_POLYGON_OFFSET_UNITS)
3031#if defined(GL_PROJECTION_STACK_DEPTH)
3032        case GL_PROJECTION_STACK_DEPTH:
3033#endif // defined(GL_PROJECTION_STACK_DEPTH)
3034#if defined(GL_RED_BITS)
3035        case GL_RED_BITS:
3036#endif // defined(GL_RED_BITS)
3037#if defined(GL_SHADE_MODEL)
3038        case GL_SHADE_MODEL:
3039#endif // defined(GL_SHADE_MODEL)
3040#if defined(GL_STENCIL_BITS)
3041        case GL_STENCIL_BITS:
3042#endif // defined(GL_STENCIL_BITS)
3043#if defined(GL_STENCIL_CLEAR_VALUE)
3044        case GL_STENCIL_CLEAR_VALUE:
3045#endif // defined(GL_STENCIL_CLEAR_VALUE)
3046#if defined(GL_STENCIL_FAIL)
3047        case GL_STENCIL_FAIL:
3048#endif // defined(GL_STENCIL_FAIL)
3049#if defined(GL_STENCIL_FUNC)
3050        case GL_STENCIL_FUNC:
3051#endif // defined(GL_STENCIL_FUNC)
3052#if defined(GL_STENCIL_PASS_DEPTH_FAIL)
3053        case GL_STENCIL_PASS_DEPTH_FAIL:
3054#endif // defined(GL_STENCIL_PASS_DEPTH_FAIL)
3055#if defined(GL_STENCIL_PASS_DEPTH_PASS)
3056        case GL_STENCIL_PASS_DEPTH_PASS:
3057#endif // defined(GL_STENCIL_PASS_DEPTH_PASS)
3058#if defined(GL_STENCIL_REF)
3059        case GL_STENCIL_REF:
3060#endif // defined(GL_STENCIL_REF)
3061#if defined(GL_STENCIL_VALUE_MASK)
3062        case GL_STENCIL_VALUE_MASK:
3063#endif // defined(GL_STENCIL_VALUE_MASK)
3064#if defined(GL_STENCIL_WRITEMASK)
3065        case GL_STENCIL_WRITEMASK:
3066#endif // defined(GL_STENCIL_WRITEMASK)
3067#if defined(GL_SUBPIXEL_BITS)
3068        case GL_SUBPIXEL_BITS:
3069#endif // defined(GL_SUBPIXEL_BITS)
3070#if defined(GL_TEXTURE_BINDING_2D)
3071        case GL_TEXTURE_BINDING_2D:
3072#endif // defined(GL_TEXTURE_BINDING_2D)
3073#if defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING)
3074        case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:
3075#endif // defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING)
3076#if defined(GL_TEXTURE_COORD_ARRAY_SIZE)
3077        case GL_TEXTURE_COORD_ARRAY_SIZE:
3078#endif // defined(GL_TEXTURE_COORD_ARRAY_SIZE)
3079#if defined(GL_TEXTURE_COORD_ARRAY_STRIDE)
3080        case GL_TEXTURE_COORD_ARRAY_STRIDE:
3081#endif // defined(GL_TEXTURE_COORD_ARRAY_STRIDE)
3082#if defined(GL_TEXTURE_COORD_ARRAY_TYPE)
3083        case GL_TEXTURE_COORD_ARRAY_TYPE:
3084#endif // defined(GL_TEXTURE_COORD_ARRAY_TYPE)
3085#if defined(GL_TEXTURE_STACK_DEPTH)
3086        case GL_TEXTURE_STACK_DEPTH:
3087#endif // defined(GL_TEXTURE_STACK_DEPTH)
3088#if defined(GL_UNPACK_ALIGNMENT)
3089        case GL_UNPACK_ALIGNMENT:
3090#endif // defined(GL_UNPACK_ALIGNMENT)
3091#if defined(GL_VERTEX_ARRAY_BUFFER_BINDING)
3092        case GL_VERTEX_ARRAY_BUFFER_BINDING:
3093#endif // defined(GL_VERTEX_ARRAY_BUFFER_BINDING)
3094#if defined(GL_VERTEX_ARRAY_SIZE)
3095        case GL_VERTEX_ARRAY_SIZE:
3096#endif // defined(GL_VERTEX_ARRAY_SIZE)
3097#if defined(GL_VERTEX_ARRAY_STRIDE)
3098        case GL_VERTEX_ARRAY_STRIDE:
3099#endif // defined(GL_VERTEX_ARRAY_STRIDE)
3100#if defined(GL_VERTEX_ARRAY_TYPE)
3101        case GL_VERTEX_ARRAY_TYPE:
3102#endif // defined(GL_VERTEX_ARRAY_TYPE)
3103#if defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES)
3104        case GL_WEIGHT_ARRAY_BUFFER_BINDING_OES:
3105#endif // defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES)
3106#if defined(GL_WEIGHT_ARRAY_SIZE_OES)
3107        case GL_WEIGHT_ARRAY_SIZE_OES:
3108#endif // defined(GL_WEIGHT_ARRAY_SIZE_OES)
3109#if defined(GL_WEIGHT_ARRAY_STRIDE_OES)
3110        case GL_WEIGHT_ARRAY_STRIDE_OES:
3111#endif // defined(GL_WEIGHT_ARRAY_STRIDE_OES)
3112#if defined(GL_WEIGHT_ARRAY_TYPE_OES)
3113        case GL_WEIGHT_ARRAY_TYPE_OES:
3114#endif // defined(GL_WEIGHT_ARRAY_TYPE_OES)
3115            _needed = 1;
3116            break;
3117#if defined(GL_ALIASED_POINT_SIZE_RANGE)
3118        case GL_ALIASED_POINT_SIZE_RANGE:
3119#endif // defined(GL_ALIASED_POINT_SIZE_RANGE)
3120#if defined(GL_ALIASED_LINE_WIDTH_RANGE)
3121        case GL_ALIASED_LINE_WIDTH_RANGE:
3122#endif // defined(GL_ALIASED_LINE_WIDTH_RANGE)
3123#if defined(GL_DEPTH_RANGE)
3124        case GL_DEPTH_RANGE:
3125#endif // defined(GL_DEPTH_RANGE)
3126#if defined(GL_MAX_VIEWPORT_DIMS)
3127        case GL_MAX_VIEWPORT_DIMS:
3128#endif // defined(GL_MAX_VIEWPORT_DIMS)
3129#if defined(GL_SMOOTH_LINE_WIDTH_RANGE)
3130        case GL_SMOOTH_LINE_WIDTH_RANGE:
3131#endif // defined(GL_SMOOTH_LINE_WIDTH_RANGE)
3132#if defined(GL_SMOOTH_POINT_SIZE_RANGE)
3133        case GL_SMOOTH_POINT_SIZE_RANGE:
3134#endif // defined(GL_SMOOTH_POINT_SIZE_RANGE)
3135            _needed = 2;
3136            break;
3137#if defined(GL_COLOR_CLEAR_VALUE)
3138        case GL_COLOR_CLEAR_VALUE:
3139#endif // defined(GL_COLOR_CLEAR_VALUE)
3140#if defined(GL_COLOR_WRITEMASK)
3141        case GL_COLOR_WRITEMASK:
3142#endif // defined(GL_COLOR_WRITEMASK)
3143#if defined(GL_FOG_COLOR)
3144        case GL_FOG_COLOR:
3145#endif // defined(GL_FOG_COLOR)
3146#if defined(GL_LIGHT_MODEL_AMBIENT)
3147        case GL_LIGHT_MODEL_AMBIENT:
3148#endif // defined(GL_LIGHT_MODEL_AMBIENT)
3149#if defined(GL_SCISSOR_BOX)
3150        case GL_SCISSOR_BOX:
3151#endif // defined(GL_SCISSOR_BOX)
3152#if defined(GL_VIEWPORT)
3153        case GL_VIEWPORT:
3154#endif // defined(GL_VIEWPORT)
3155            _needed = 4;
3156            break;
3157#if defined(GL_MODELVIEW_MATRIX)
3158        case GL_MODELVIEW_MATRIX:
3159#endif // defined(GL_MODELVIEW_MATRIX)
3160#if defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES)
3161        case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES:
3162#endif // defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES)
3163#if defined(GL_PROJECTION_MATRIX)
3164        case GL_PROJECTION_MATRIX:
3165#endif // defined(GL_PROJECTION_MATRIX)
3166#if defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES)
3167        case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES:
3168#endif // defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES)
3169#if defined(GL_TEXTURE_MATRIX)
3170        case GL_TEXTURE_MATRIX:
3171#endif // defined(GL_TEXTURE_MATRIX)
3172#if defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES)
3173        case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES:
3174#endif // defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES)
3175            _needed = 16;
3176            break;
3177#if defined(GL_COMPRESSED_TEXTURE_FORMATS)
3178        case GL_COMPRESSED_TEXTURE_FORMATS:
3179#endif // defined(GL_COMPRESSED_TEXTURE_FORMATS)
3180            _needed = getNumCompressedTextureFormats();
3181            break;
3182        default:
3183            _needed = 0;
3184            break;
3185    }
3186    if (_remaining < _needed) {
3187        _exception = 1;
3188        _exceptionType = "java/lang/IllegalArgumentException";
3189        _exceptionMessage = "remaining() < needed";
3190        goto exit;
3191    }
3192    if (params == NULL) {
3193        char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3194        params = (GLint *) (_paramsBase + _bufferOffset);
3195    }
3196    glGetIntegerv(
3197        (GLenum)pname,
3198        (GLint *)params
3199    );
3200
3201exit:
3202    if (_array) {
3203        releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
3204    }
3205    if (_exception) {
3206        jniThrowException(_env, _exceptionType, _exceptionMessage);
3207    }
3208}
3209
3210/* void glGetProgramiv ( GLuint program, GLenum pname, GLint *params ) */
3211static void
3212android_glGetProgramiv__II_3II
3213  (JNIEnv *_env, jobject _this, jint program, jint pname, jintArray params_ref, jint offset) {
3214    jint _exception = 0;
3215    const char * _exceptionType;
3216    const char * _exceptionMessage;
3217    GLint *params_base = (GLint *) 0;
3218    jint _remaining;
3219    GLint *params = (GLint *) 0;
3220
3221    if (!params_ref) {
3222        _exception = 1;
3223        _exceptionType = "java/lang/IllegalArgumentException";
3224        _exceptionMessage = "params == null";
3225        goto exit;
3226    }
3227    if (offset < 0) {
3228        _exception = 1;
3229        _exceptionType = "java/lang/IllegalArgumentException";
3230        _exceptionMessage = "offset < 0";
3231        goto exit;
3232    }
3233    _remaining = _env->GetArrayLength(params_ref) - offset;
3234    params_base = (GLint *)
3235        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
3236    params = params_base + offset;
3237
3238    glGetProgramiv(
3239        (GLuint)program,
3240        (GLenum)pname,
3241        (GLint *)params
3242    );
3243
3244exit:
3245    if (params_base) {
3246        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
3247            _exception ? JNI_ABORT: 0);
3248    }
3249    if (_exception) {
3250        jniThrowException(_env, _exceptionType, _exceptionMessage);
3251    }
3252}
3253
3254/* void glGetProgramiv ( GLuint program, GLenum pname, GLint *params ) */
3255static void
3256android_glGetProgramiv__IILjava_nio_IntBuffer_2
3257  (JNIEnv *_env, jobject _this, jint program, jint pname, jobject params_buf) {
3258    jarray _array = (jarray) 0;
3259    jint _bufferOffset = (jint) 0;
3260    jint _remaining;
3261    GLint *params = (GLint *) 0;
3262
3263    params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
3264    if (params == NULL) {
3265        char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3266        params = (GLint *) (_paramsBase + _bufferOffset);
3267    }
3268    glGetProgramiv(
3269        (GLuint)program,
3270        (GLenum)pname,
3271        (GLint *)params
3272    );
3273    if (_array) {
3274        releasePointer(_env, _array, params, JNI_TRUE);
3275    }
3276}
3277
3278#include <stdlib.h>
3279
3280/* void glGetProgramInfoLog ( GLuint shader, GLsizei maxLength, GLsizei* length, GLchar* infoLog ) */
3281static jstring android_glGetProgramInfoLog(JNIEnv *_env, jobject, jint shader) {
3282    GLint infoLen = 0;
3283    glGetProgramiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
3284    if (!infoLen) {
3285        return _env->NewStringUTF("");
3286    }
3287    char* buf = (char*) malloc(infoLen);
3288    if (buf == NULL) {
3289        jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory");
3290        return NULL;
3291    }
3292    glGetProgramInfoLog(shader, infoLen, NULL, buf);
3293    jstring result = _env->NewStringUTF(buf);
3294    free(buf);
3295    return result;
3296}
3297/* void glGetRenderbufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */
3298static void
3299android_glGetRenderbufferParameteriv__II_3II
3300  (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
3301    jint _exception = 0;
3302    const char * _exceptionType;
3303    const char * _exceptionMessage;
3304    GLint *params_base = (GLint *) 0;
3305    jint _remaining;
3306    GLint *params = (GLint *) 0;
3307
3308    if (!params_ref) {
3309        _exception = 1;
3310        _exceptionType = "java/lang/IllegalArgumentException";
3311        _exceptionMessage = "params == null";
3312        goto exit;
3313    }
3314    if (offset < 0) {
3315        _exception = 1;
3316        _exceptionType = "java/lang/IllegalArgumentException";
3317        _exceptionMessage = "offset < 0";
3318        goto exit;
3319    }
3320    _remaining = _env->GetArrayLength(params_ref) - offset;
3321    params_base = (GLint *)
3322        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
3323    params = params_base + offset;
3324
3325    glGetRenderbufferParameteriv(
3326        (GLenum)target,
3327        (GLenum)pname,
3328        (GLint *)params
3329    );
3330
3331exit:
3332    if (params_base) {
3333        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
3334            _exception ? JNI_ABORT: 0);
3335    }
3336    if (_exception) {
3337        jniThrowException(_env, _exceptionType, _exceptionMessage);
3338    }
3339}
3340
3341/* void glGetRenderbufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */
3342static void
3343android_glGetRenderbufferParameteriv__IILjava_nio_IntBuffer_2
3344  (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
3345    jarray _array = (jarray) 0;
3346    jint _bufferOffset = (jint) 0;
3347    jint _remaining;
3348    GLint *params = (GLint *) 0;
3349
3350    params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
3351    if (params == NULL) {
3352        char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3353        params = (GLint *) (_paramsBase + _bufferOffset);
3354    }
3355    glGetRenderbufferParameteriv(
3356        (GLenum)target,
3357        (GLenum)pname,
3358        (GLint *)params
3359    );
3360    if (_array) {
3361        releasePointer(_env, _array, params, JNI_TRUE);
3362    }
3363}
3364
3365/* void glGetShaderiv ( GLuint shader, GLenum pname, GLint *params ) */
3366static void
3367android_glGetShaderiv__II_3II
3368  (JNIEnv *_env, jobject _this, jint shader, jint pname, jintArray params_ref, jint offset) {
3369    jint _exception = 0;
3370    const char * _exceptionType;
3371    const char * _exceptionMessage;
3372    GLint *params_base = (GLint *) 0;
3373    jint _remaining;
3374    GLint *params = (GLint *) 0;
3375
3376    if (!params_ref) {
3377        _exception = 1;
3378        _exceptionType = "java/lang/IllegalArgumentException";
3379        _exceptionMessage = "params == null";
3380        goto exit;
3381    }
3382    if (offset < 0) {
3383        _exception = 1;
3384        _exceptionType = "java/lang/IllegalArgumentException";
3385        _exceptionMessage = "offset < 0";
3386        goto exit;
3387    }
3388    _remaining = _env->GetArrayLength(params_ref) - offset;
3389    params_base = (GLint *)
3390        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
3391    params = params_base + offset;
3392
3393    glGetShaderiv(
3394        (GLuint)shader,
3395        (GLenum)pname,
3396        (GLint *)params
3397    );
3398
3399exit:
3400    if (params_base) {
3401        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
3402            _exception ? JNI_ABORT: 0);
3403    }
3404    if (_exception) {
3405        jniThrowException(_env, _exceptionType, _exceptionMessage);
3406    }
3407}
3408
3409/* void glGetShaderiv ( GLuint shader, GLenum pname, GLint *params ) */
3410static void
3411android_glGetShaderiv__IILjava_nio_IntBuffer_2
3412  (JNIEnv *_env, jobject _this, jint shader, jint pname, jobject params_buf) {
3413    jarray _array = (jarray) 0;
3414    jint _bufferOffset = (jint) 0;
3415    jint _remaining;
3416    GLint *params = (GLint *) 0;
3417
3418    params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
3419    if (params == NULL) {
3420        char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3421        params = (GLint *) (_paramsBase + _bufferOffset);
3422    }
3423    glGetShaderiv(
3424        (GLuint)shader,
3425        (GLenum)pname,
3426        (GLint *)params
3427    );
3428    if (_array) {
3429        releasePointer(_env, _array, params, JNI_TRUE);
3430    }
3431}
3432
3433#include <stdlib.h>
3434
3435/* void glGetShaderInfoLog ( GLuint shader, GLsizei maxLength, GLsizei* length, GLchar* infoLog ) */
3436static jstring android_glGetShaderInfoLog(JNIEnv *_env, jobject, jint shader) {
3437    GLint infoLen = 0;
3438    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
3439    if (!infoLen) {
3440        return _env->NewStringUTF("");
3441    }
3442    char* buf = (char*) malloc(infoLen);
3443    if (buf == NULL) {
3444        jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory");
3445        return NULL;
3446    }
3447    glGetShaderInfoLog(shader, infoLen, NULL, buf);
3448    jstring result = _env->NewStringUTF(buf);
3449    free(buf);
3450    return result;
3451}
3452/* void glGetShaderPrecisionFormat ( GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision ) */
3453static void
3454android_glGetShaderPrecisionFormat__II_3II_3II
3455  (JNIEnv *_env, jobject _this, jint shadertype, jint precisiontype, jintArray range_ref, jint rangeOffset, jintArray precision_ref, jint precisionOffset) {
3456    jint _exception = 0;
3457    const char * _exceptionType;
3458    const char * _exceptionMessage;
3459    GLint *range_base = (GLint *) 0;
3460    jint _rangeRemaining;
3461    GLint *range = (GLint *) 0;
3462    GLint *precision_base = (GLint *) 0;
3463    jint _precisionRemaining;
3464    GLint *precision = (GLint *) 0;
3465
3466    if (!range_ref) {
3467        _exception = 1;
3468        _exceptionType = "java/lang/IllegalArgumentException";
3469        _exceptionMessage = "range == null";
3470        goto exit;
3471    }
3472    if (rangeOffset < 0) {
3473        _exception = 1;
3474        _exceptionType = "java/lang/IllegalArgumentException";
3475        _exceptionMessage = "rangeOffset < 0";
3476        goto exit;
3477    }
3478    _rangeRemaining = _env->GetArrayLength(range_ref) - rangeOffset;
3479    range_base = (GLint *)
3480        _env->GetPrimitiveArrayCritical(range_ref, (jboolean *)0);
3481    range = range_base + rangeOffset;
3482
3483    if (!precision_ref) {
3484        _exception = 1;
3485        _exceptionType = "java/lang/IllegalArgumentException";
3486        _exceptionMessage = "precision == null";
3487        goto exit;
3488    }
3489    if (precisionOffset < 0) {
3490        _exception = 1;
3491        _exceptionType = "java/lang/IllegalArgumentException";
3492        _exceptionMessage = "precisionOffset < 0";
3493        goto exit;
3494    }
3495    _precisionRemaining = _env->GetArrayLength(precision_ref) - precisionOffset;
3496    precision_base = (GLint *)
3497        _env->GetPrimitiveArrayCritical(precision_ref, (jboolean *)0);
3498    precision = precision_base + precisionOffset;
3499
3500    glGetShaderPrecisionFormat(
3501        (GLenum)shadertype,
3502        (GLenum)precisiontype,
3503        (GLint *)range,
3504        (GLint *)precision
3505    );
3506
3507exit:
3508    if (precision_base) {
3509        _env->ReleasePrimitiveArrayCritical(precision_ref, precision_base,
3510            _exception ? JNI_ABORT: 0);
3511    }
3512    if (range_base) {
3513        _env->ReleasePrimitiveArrayCritical(range_ref, range_base,
3514            _exception ? JNI_ABORT: 0);
3515    }
3516    if (_exception) {
3517        jniThrowException(_env, _exceptionType, _exceptionMessage);
3518    }
3519}
3520
3521/* void glGetShaderPrecisionFormat ( GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision ) */
3522static void
3523android_glGetShaderPrecisionFormat__IILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2
3524  (JNIEnv *_env, jobject _this, jint shadertype, jint precisiontype, jobject range_buf, jobject precision_buf) {
3525    jarray _rangeArray = (jarray) 0;
3526    jint _rangeBufferOffset = (jint) 0;
3527    jarray _precisionArray = (jarray) 0;
3528    jint _precisionBufferOffset = (jint) 0;
3529    jint _rangeRemaining;
3530    GLint *range = (GLint *) 0;
3531    jint _precisionRemaining;
3532    GLint *precision = (GLint *) 0;
3533
3534    range = (GLint *)getPointer(_env, range_buf, &_rangeArray, &_rangeRemaining, &_rangeBufferOffset);
3535    precision = (GLint *)getPointer(_env, precision_buf, &_precisionArray, &_precisionRemaining, &_precisionBufferOffset);
3536    if (range == NULL) {
3537        char * _rangeBase = (char *)_env->GetPrimitiveArrayCritical(_rangeArray, (jboolean *) 0);
3538        range = (GLint *) (_rangeBase + _rangeBufferOffset);
3539    }
3540    if (precision == NULL) {
3541        char * _precisionBase = (char *)_env->GetPrimitiveArrayCritical(_precisionArray, (jboolean *) 0);
3542        precision = (GLint *) (_precisionBase + _precisionBufferOffset);
3543    }
3544    glGetShaderPrecisionFormat(
3545        (GLenum)shadertype,
3546        (GLenum)precisiontype,
3547        (GLint *)range,
3548        (GLint *)precision
3549    );
3550    if (_precisionArray) {
3551        releasePointer(_env, _precisionArray, precision, JNI_TRUE);
3552    }
3553    if (_rangeArray) {
3554        releasePointer(_env, _rangeArray, range, JNI_TRUE);
3555    }
3556}
3557
3558/* void glGetShaderSource ( GLuint shader, GLsizei bufsize, GLsizei *length, char *source ) */
3559static void
3560android_glGetShaderSource__II_3II_3BI
3561  (JNIEnv *_env, jobject _this, jint shader, jint bufsize, jintArray length_ref, jint lengthOffset, jbyteArray source_ref, jint sourceOffset) {
3562    jint _exception = 0;
3563    const char * _exceptionType;
3564    const char * _exceptionMessage;
3565    GLsizei *length_base = (GLsizei *) 0;
3566    jint _lengthRemaining;
3567    GLsizei *length = (GLsizei *) 0;
3568    char *source_base = (char *) 0;
3569    jint _sourceRemaining;
3570    char *source = (char *) 0;
3571
3572    if (!length_ref) {
3573        _exception = 1;
3574        _exceptionType = "java/lang/IllegalArgumentException";
3575        _exceptionMessage = "length == null";
3576        goto exit;
3577    }
3578    if (lengthOffset < 0) {
3579        _exception = 1;
3580        _exceptionType = "java/lang/IllegalArgumentException";
3581        _exceptionMessage = "lengthOffset < 0";
3582        goto exit;
3583    }
3584    _lengthRemaining = _env->GetArrayLength(length_ref) - lengthOffset;
3585    length_base = (GLsizei *)
3586        _env->GetPrimitiveArrayCritical(length_ref, (jboolean *)0);
3587    length = length_base + lengthOffset;
3588
3589    if (!source_ref) {
3590        _exception = 1;
3591        _exceptionType = "java/lang/IllegalArgumentException";
3592        _exceptionMessage = "source == null";
3593        goto exit;
3594    }
3595    if (sourceOffset < 0) {
3596        _exception = 1;
3597        _exceptionType = "java/lang/IllegalArgumentException";
3598        _exceptionMessage = "sourceOffset < 0";
3599        goto exit;
3600    }
3601    _sourceRemaining = _env->GetArrayLength(source_ref) - sourceOffset;
3602    source_base = (char *)
3603        _env->GetPrimitiveArrayCritical(source_ref, (jboolean *)0);
3604    source = source_base + sourceOffset;
3605
3606    glGetShaderSource(
3607        (GLuint)shader,
3608        (GLsizei)bufsize,
3609        (GLsizei *)length,
3610        (char *)source
3611    );
3612
3613exit:
3614    if (source_base) {
3615        _env->ReleasePrimitiveArrayCritical(source_ref, source_base,
3616            _exception ? JNI_ABORT: 0);
3617    }
3618    if (length_base) {
3619        _env->ReleasePrimitiveArrayCritical(length_ref, length_base,
3620            _exception ? JNI_ABORT: 0);
3621    }
3622    if (_exception) {
3623        jniThrowException(_env, _exceptionType, _exceptionMessage);
3624    }
3625}
3626
3627/* void glGetShaderSource ( GLuint shader, GLsizei bufsize, GLsizei *length, char *source ) */
3628static void
3629android_glGetShaderSource__IILjava_nio_IntBuffer_2B
3630  (JNIEnv *_env, jobject _this, jint shader, jint bufsize, jobject length_buf, jbyte source) {
3631    jarray _array = (jarray) 0;
3632    jint _bufferOffset = (jint) 0;
3633    jint _remaining;
3634    GLsizei *length = (GLsizei *) 0;
3635
3636    length = (GLsizei *)getPointer(_env, length_buf, &_array, &_remaining, &_bufferOffset);
3637    if (length == NULL) {
3638        char * _lengthBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3639        length = (GLsizei *) (_lengthBase + _bufferOffset);
3640    }
3641    glGetShaderSource(
3642        (GLuint)shader,
3643        (GLsizei)bufsize,
3644        (GLsizei *)length,
3645        (char *)source
3646    );
3647    if (_array) {
3648        releasePointer(_env, _array, length, JNI_TRUE);
3649    }
3650}
3651
3652/* void glGetShaderSource ( GLuint shader, GLsizei bufsize, GLsizei *length, char *source ) */
3653static jstring android_glGetShaderSource(JNIEnv *_env, jobject, jint shader) {
3654    GLint shaderLen = 0;
3655    glGetShaderiv((GLuint)shader, GL_SHADER_SOURCE_LENGTH, &shaderLen);
3656    if (!shaderLen) {
3657        return _env->NewStringUTF("");
3658    }
3659    char* buf = (char*) malloc(shaderLen);
3660    if (buf == NULL) {
3661        jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory");
3662        return NULL;
3663    }
3664    glGetShaderSource(shader, shaderLen, NULL, buf);
3665    jstring result = _env->NewStringUTF(buf);
3666    free(buf);
3667    return result;
3668}
3669/* const GLubyte * glGetString ( GLenum name ) */
3670static jstring android_glGetString(JNIEnv* _env, jobject, jint name) {
3671    const char* chars = (const char*) glGetString((GLenum) name);
3672    return _env->NewStringUTF(chars);
3673}
3674/* void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) */
3675static void
3676android_glGetTexParameterfv__II_3FI
3677  (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) {
3678    jint _exception = 0;
3679    const char * _exceptionType;
3680    const char * _exceptionMessage;
3681    GLfloat *params_base = (GLfloat *) 0;
3682    jint _remaining;
3683    GLfloat *params = (GLfloat *) 0;
3684
3685    if (!params_ref) {
3686        _exception = 1;
3687        _exceptionType = "java/lang/IllegalArgumentException";
3688        _exceptionMessage = "params == null";
3689        goto exit;
3690    }
3691    if (offset < 0) {
3692        _exception = 1;
3693        _exceptionType = "java/lang/IllegalArgumentException";
3694        _exceptionMessage = "offset < 0";
3695        goto exit;
3696    }
3697    _remaining = _env->GetArrayLength(params_ref) - offset;
3698    if (_remaining < 1) {
3699        _exception = 1;
3700        _exceptionType = "java/lang/IllegalArgumentException";
3701        _exceptionMessage = "length - offset < 1 < needed";
3702        goto exit;
3703    }
3704    params_base = (GLfloat *)
3705        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
3706    params = params_base + offset;
3707
3708    glGetTexParameterfv(
3709        (GLenum)target,
3710        (GLenum)pname,
3711        (GLfloat *)params
3712    );
3713
3714exit:
3715    if (params_base) {
3716        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
3717            _exception ? JNI_ABORT: 0);
3718    }
3719    if (_exception) {
3720        jniThrowException(_env, _exceptionType, _exceptionMessage);
3721    }
3722}
3723
3724/* void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) */
3725static void
3726android_glGetTexParameterfv__IILjava_nio_FloatBuffer_2
3727  (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
3728    jint _exception = 0;
3729    const char * _exceptionType;
3730    const char * _exceptionMessage;
3731    jarray _array = (jarray) 0;
3732    jint _bufferOffset = (jint) 0;
3733    jint _remaining;
3734    GLfloat *params = (GLfloat *) 0;
3735
3736    params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
3737    if (_remaining < 1) {
3738        _exception = 1;
3739        _exceptionType = "java/lang/IllegalArgumentException";
3740        _exceptionMessage = "remaining() < 1 < needed";
3741        goto exit;
3742    }
3743    if (params == NULL) {
3744        char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3745        params = (GLfloat *) (_paramsBase + _bufferOffset);
3746    }
3747    glGetTexParameterfv(
3748        (GLenum)target,
3749        (GLenum)pname,
3750        (GLfloat *)params
3751    );
3752
3753exit:
3754    if (_array) {
3755        releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
3756    }
3757    if (_exception) {
3758        jniThrowException(_env, _exceptionType, _exceptionMessage);
3759    }
3760}
3761
3762/* void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) */
3763static void
3764android_glGetTexParameteriv__II_3II
3765  (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
3766    jint _exception = 0;
3767    const char * _exceptionType;
3768    const char * _exceptionMessage;
3769    GLint *params_base = (GLint *) 0;
3770    jint _remaining;
3771    GLint *params = (GLint *) 0;
3772
3773    if (!params_ref) {
3774        _exception = 1;
3775        _exceptionType = "java/lang/IllegalArgumentException";
3776        _exceptionMessage = "params == null";
3777        goto exit;
3778    }
3779    if (offset < 0) {
3780        _exception = 1;
3781        _exceptionType = "java/lang/IllegalArgumentException";
3782        _exceptionMessage = "offset < 0";
3783        goto exit;
3784    }
3785    _remaining = _env->GetArrayLength(params_ref) - offset;
3786    if (_remaining < 1) {
3787        _exception = 1;
3788        _exceptionType = "java/lang/IllegalArgumentException";
3789        _exceptionMessage = "length - offset < 1 < needed";
3790        goto exit;
3791    }
3792    params_base = (GLint *)
3793        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
3794    params = params_base + offset;
3795
3796    glGetTexParameteriv(
3797        (GLenum)target,
3798        (GLenum)pname,
3799        (GLint *)params
3800    );
3801
3802exit:
3803    if (params_base) {
3804        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
3805            _exception ? JNI_ABORT: 0);
3806    }
3807    if (_exception) {
3808        jniThrowException(_env, _exceptionType, _exceptionMessage);
3809    }
3810}
3811
3812/* void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) */
3813static void
3814android_glGetTexParameteriv__IILjava_nio_IntBuffer_2
3815  (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
3816    jint _exception = 0;
3817    const char * _exceptionType;
3818    const char * _exceptionMessage;
3819    jarray _array = (jarray) 0;
3820    jint _bufferOffset = (jint) 0;
3821    jint _remaining;
3822    GLint *params = (GLint *) 0;
3823
3824    params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
3825    if (_remaining < 1) {
3826        _exception = 1;
3827        _exceptionType = "java/lang/IllegalArgumentException";
3828        _exceptionMessage = "remaining() < 1 < needed";
3829        goto exit;
3830    }
3831    if (params == NULL) {
3832        char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3833        params = (GLint *) (_paramsBase + _bufferOffset);
3834    }
3835    glGetTexParameteriv(
3836        (GLenum)target,
3837        (GLenum)pname,
3838        (GLint *)params
3839    );
3840
3841exit:
3842    if (_array) {
3843        releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
3844    }
3845    if (_exception) {
3846        jniThrowException(_env, _exceptionType, _exceptionMessage);
3847    }
3848}
3849
3850/* void glGetUniformfv ( GLuint program, GLint location, GLfloat *params ) */
3851static void
3852android_glGetUniformfv__II_3FI
3853  (JNIEnv *_env, jobject _this, jint program, jint location, jfloatArray params_ref, jint offset) {
3854    jint _exception = 0;
3855    const char * _exceptionType;
3856    const char * _exceptionMessage;
3857    GLfloat *params_base = (GLfloat *) 0;
3858    jint _remaining;
3859    GLfloat *params = (GLfloat *) 0;
3860
3861    if (!params_ref) {
3862        _exception = 1;
3863        _exceptionType = "java/lang/IllegalArgumentException";
3864        _exceptionMessage = "params == null";
3865        goto exit;
3866    }
3867    if (offset < 0) {
3868        _exception = 1;
3869        _exceptionType = "java/lang/IllegalArgumentException";
3870        _exceptionMessage = "offset < 0";
3871        goto exit;
3872    }
3873    _remaining = _env->GetArrayLength(params_ref) - offset;
3874    params_base = (GLfloat *)
3875        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
3876    params = params_base + offset;
3877
3878    glGetUniformfv(
3879        (GLuint)program,
3880        (GLint)location,
3881        (GLfloat *)params
3882    );
3883
3884exit:
3885    if (params_base) {
3886        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
3887            _exception ? JNI_ABORT: 0);
3888    }
3889    if (_exception) {
3890        jniThrowException(_env, _exceptionType, _exceptionMessage);
3891    }
3892}
3893
3894/* void glGetUniformfv ( GLuint program, GLint location, GLfloat *params ) */
3895static void
3896android_glGetUniformfv__IILjava_nio_FloatBuffer_2
3897  (JNIEnv *_env, jobject _this, jint program, jint location, jobject params_buf) {
3898    jarray _array = (jarray) 0;
3899    jint _bufferOffset = (jint) 0;
3900    jint _remaining;
3901    GLfloat *params = (GLfloat *) 0;
3902
3903    params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
3904    if (params == NULL) {
3905        char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3906        params = (GLfloat *) (_paramsBase + _bufferOffset);
3907    }
3908    glGetUniformfv(
3909        (GLuint)program,
3910        (GLint)location,
3911        (GLfloat *)params
3912    );
3913    if (_array) {
3914        releasePointer(_env, _array, params, JNI_TRUE);
3915    }
3916}
3917
3918/* void glGetUniformiv ( GLuint program, GLint location, GLint *params ) */
3919static void
3920android_glGetUniformiv__II_3II
3921  (JNIEnv *_env, jobject _this, jint program, jint location, jintArray params_ref, jint offset) {
3922    jint _exception = 0;
3923    const char * _exceptionType;
3924    const char * _exceptionMessage;
3925    GLint *params_base = (GLint *) 0;
3926    jint _remaining;
3927    GLint *params = (GLint *) 0;
3928
3929    if (!params_ref) {
3930        _exception = 1;
3931        _exceptionType = "java/lang/IllegalArgumentException";
3932        _exceptionMessage = "params == null";
3933        goto exit;
3934    }
3935    if (offset < 0) {
3936        _exception = 1;
3937        _exceptionType = "java/lang/IllegalArgumentException";
3938        _exceptionMessage = "offset < 0";
3939        goto exit;
3940    }
3941    _remaining = _env->GetArrayLength(params_ref) - offset;
3942    params_base = (GLint *)
3943        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
3944    params = params_base + offset;
3945
3946    glGetUniformiv(
3947        (GLuint)program,
3948        (GLint)location,
3949        (GLint *)params
3950    );
3951
3952exit:
3953    if (params_base) {
3954        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
3955            _exception ? JNI_ABORT: 0);
3956    }
3957    if (_exception) {
3958        jniThrowException(_env, _exceptionType, _exceptionMessage);
3959    }
3960}
3961
3962/* void glGetUniformiv ( GLuint program, GLint location, GLint *params ) */
3963static void
3964android_glGetUniformiv__IILjava_nio_IntBuffer_2
3965  (JNIEnv *_env, jobject _this, jint program, jint location, jobject params_buf) {
3966    jarray _array = (jarray) 0;
3967    jint _bufferOffset = (jint) 0;
3968    jint _remaining;
3969    GLint *params = (GLint *) 0;
3970
3971    params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
3972    if (params == NULL) {
3973        char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3974        params = (GLint *) (_paramsBase + _bufferOffset);
3975    }
3976    glGetUniformiv(
3977        (GLuint)program,
3978        (GLint)location,
3979        (GLint *)params
3980    );
3981    if (_array) {
3982        releasePointer(_env, _array, params, JNI_TRUE);
3983    }
3984}
3985
3986/* int glGetUniformLocation ( GLuint program, const char *name ) */
3987static jint
3988android_glGetUniformLocation__ILjava_lang_String_2
3989  (JNIEnv *_env, jobject _this, jint program, jstring name) {
3990    jint _exception = 0;
3991    const char * _exceptionType;
3992    const char * _exceptionMessage;
3993    int _returnValue = 0;
3994    const char* _nativename = 0;
3995
3996    if (!name) {
3997        _exceptionType = "java/lang/IllegalArgumentException";
3998        _exceptionMessage = "name == null";
3999        goto exit;
4000    }
4001    _nativename = _env->GetStringUTFChars(name, 0);
4002
4003    _returnValue = glGetUniformLocation(
4004        (GLuint)program,
4005        (char *)_nativename
4006    );
4007
4008exit:
4009    if (_nativename) {
4010        _env->ReleaseStringUTFChars(name, _nativename);
4011    }
4012
4013    if (_exception) {
4014        jniThrowException(_env, _exceptionType, _exceptionMessage);
4015    }
4016    return _returnValue;
4017}
4018
4019/* void glGetVertexAttribfv ( GLuint index, GLenum pname, GLfloat *params ) */
4020static void
4021android_glGetVertexAttribfv__II_3FI
4022  (JNIEnv *_env, jobject _this, jint index, jint pname, jfloatArray params_ref, jint offset) {
4023    jint _exception = 0;
4024    const char * _exceptionType;
4025    const char * _exceptionMessage;
4026    GLfloat *params_base = (GLfloat *) 0;
4027    jint _remaining;
4028    GLfloat *params = (GLfloat *) 0;
4029
4030    if (!params_ref) {
4031        _exception = 1;
4032        _exceptionType = "java/lang/IllegalArgumentException";
4033        _exceptionMessage = "params == null";
4034        goto exit;
4035    }
4036    if (offset < 0) {
4037        _exception = 1;
4038        _exceptionType = "java/lang/IllegalArgumentException";
4039        _exceptionMessage = "offset < 0";
4040        goto exit;
4041    }
4042    _remaining = _env->GetArrayLength(params_ref) - offset;
4043    params_base = (GLfloat *)
4044        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
4045    params = params_base + offset;
4046
4047    glGetVertexAttribfv(
4048        (GLuint)index,
4049        (GLenum)pname,
4050        (GLfloat *)params
4051    );
4052
4053exit:
4054    if (params_base) {
4055        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
4056            _exception ? JNI_ABORT: 0);
4057    }
4058    if (_exception) {
4059        jniThrowException(_env, _exceptionType, _exceptionMessage);
4060    }
4061}
4062
4063/* void glGetVertexAttribfv ( GLuint index, GLenum pname, GLfloat *params ) */
4064static void
4065android_glGetVertexAttribfv__IILjava_nio_FloatBuffer_2
4066  (JNIEnv *_env, jobject _this, jint index, jint pname, jobject params_buf) {
4067    jarray _array = (jarray) 0;
4068    jint _bufferOffset = (jint) 0;
4069    jint _remaining;
4070    GLfloat *params = (GLfloat *) 0;
4071
4072    params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
4073    if (params == NULL) {
4074        char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
4075        params = (GLfloat *) (_paramsBase + _bufferOffset);
4076    }
4077    glGetVertexAttribfv(
4078        (GLuint)index,
4079        (GLenum)pname,
4080        (GLfloat *)params
4081    );
4082    if (_array) {
4083        releasePointer(_env, _array, params, JNI_TRUE);
4084    }
4085}
4086
4087/* void glGetVertexAttribiv ( GLuint index, GLenum pname, GLint *params ) */
4088static void
4089android_glGetVertexAttribiv__II_3II
4090  (JNIEnv *_env, jobject _this, jint index, jint pname, jintArray params_ref, jint offset) {
4091    jint _exception = 0;
4092    const char * _exceptionType;
4093    const char * _exceptionMessage;
4094    GLint *params_base = (GLint *) 0;
4095    jint _remaining;
4096    GLint *params = (GLint *) 0;
4097
4098    if (!params_ref) {
4099        _exception = 1;
4100        _exceptionType = "java/lang/IllegalArgumentException";
4101        _exceptionMessage = "params == null";
4102        goto exit;
4103    }
4104    if (offset < 0) {
4105        _exception = 1;
4106        _exceptionType = "java/lang/IllegalArgumentException";
4107        _exceptionMessage = "offset < 0";
4108        goto exit;
4109    }
4110    _remaining = _env->GetArrayLength(params_ref) - offset;
4111    params_base = (GLint *)
4112        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
4113    params = params_base + offset;
4114
4115    glGetVertexAttribiv(
4116        (GLuint)index,
4117        (GLenum)pname,
4118        (GLint *)params
4119    );
4120
4121exit:
4122    if (params_base) {
4123        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
4124            _exception ? JNI_ABORT: 0);
4125    }
4126    if (_exception) {
4127        jniThrowException(_env, _exceptionType, _exceptionMessage);
4128    }
4129}
4130
4131/* void glGetVertexAttribiv ( GLuint index, GLenum pname, GLint *params ) */
4132static void
4133android_glGetVertexAttribiv__IILjava_nio_IntBuffer_2
4134  (JNIEnv *_env, jobject _this, jint index, jint pname, jobject params_buf) {
4135    jarray _array = (jarray) 0;
4136    jint _bufferOffset = (jint) 0;
4137    jint _remaining;
4138    GLint *params = (GLint *) 0;
4139
4140    params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
4141    if (params == NULL) {
4142        char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
4143        params = (GLint *) (_paramsBase + _bufferOffset);
4144    }
4145    glGetVertexAttribiv(
4146        (GLuint)index,
4147        (GLenum)pname,
4148        (GLint *)params
4149    );
4150    if (_array) {
4151        releasePointer(_env, _array, params, JNI_TRUE);
4152    }
4153}
4154
4155/* void glHint ( GLenum target, GLenum mode ) */
4156static void
4157android_glHint__II
4158  (JNIEnv *_env, jobject _this, jint target, jint mode) {
4159    glHint(
4160        (GLenum)target,
4161        (GLenum)mode
4162    );
4163}
4164
4165/* GLboolean glIsBuffer ( GLuint buffer ) */
4166static jboolean
4167android_glIsBuffer__I
4168  (JNIEnv *_env, jobject _this, jint buffer) {
4169    GLboolean _returnValue;
4170    _returnValue = glIsBuffer(
4171        (GLuint)buffer
4172    );
4173    return _returnValue;
4174}
4175
4176/* GLboolean glIsEnabled ( GLenum cap ) */
4177static jboolean
4178android_glIsEnabled__I
4179  (JNIEnv *_env, jobject _this, jint cap) {
4180    GLboolean _returnValue;
4181    _returnValue = glIsEnabled(
4182        (GLenum)cap
4183    );
4184    return _returnValue;
4185}
4186
4187/* GLboolean glIsFramebuffer ( GLuint framebuffer ) */
4188static jboolean
4189android_glIsFramebuffer__I
4190  (JNIEnv *_env, jobject _this, jint framebuffer) {
4191    GLboolean _returnValue;
4192    _returnValue = glIsFramebuffer(
4193        (GLuint)framebuffer
4194    );
4195    return _returnValue;
4196}
4197
4198/* GLboolean glIsProgram ( GLuint program ) */
4199static jboolean
4200android_glIsProgram__I
4201  (JNIEnv *_env, jobject _this, jint program) {
4202    GLboolean _returnValue;
4203    _returnValue = glIsProgram(
4204        (GLuint)program
4205    );
4206    return _returnValue;
4207}
4208
4209/* GLboolean glIsRenderbuffer ( GLuint renderbuffer ) */
4210static jboolean
4211android_glIsRenderbuffer__I
4212  (JNIEnv *_env, jobject _this, jint renderbuffer) {
4213    GLboolean _returnValue;
4214    _returnValue = glIsRenderbuffer(
4215        (GLuint)renderbuffer
4216    );
4217    return _returnValue;
4218}
4219
4220/* GLboolean glIsShader ( GLuint shader ) */
4221static jboolean
4222android_glIsShader__I
4223  (JNIEnv *_env, jobject _this, jint shader) {
4224    GLboolean _returnValue;
4225    _returnValue = glIsShader(
4226        (GLuint)shader
4227    );
4228    return _returnValue;
4229}
4230
4231/* GLboolean glIsTexture ( GLuint texture ) */
4232static jboolean
4233android_glIsTexture__I
4234  (JNIEnv *_env, jobject _this, jint texture) {
4235    GLboolean _returnValue;
4236    _returnValue = glIsTexture(
4237        (GLuint)texture
4238    );
4239    return _returnValue;
4240}
4241
4242/* void glLineWidth ( GLfloat width ) */
4243static void
4244android_glLineWidth__F
4245  (JNIEnv *_env, jobject _this, jfloat width) {
4246    glLineWidth(
4247        (GLfloat)width
4248    );
4249}
4250
4251/* void glLinkProgram ( GLuint program ) */
4252static void
4253android_glLinkProgram__I
4254  (JNIEnv *_env, jobject _this, jint program) {
4255    glLinkProgram(
4256        (GLuint)program
4257    );
4258}
4259
4260/* void glPixelStorei ( GLenum pname, GLint param ) */
4261static void
4262android_glPixelStorei__II
4263  (JNIEnv *_env, jobject _this, jint pname, jint param) {
4264    glPixelStorei(
4265        (GLenum)pname,
4266        (GLint)param
4267    );
4268}
4269
4270/* void glPolygonOffset ( GLfloat factor, GLfloat units ) */
4271static void
4272android_glPolygonOffset__FF
4273  (JNIEnv *_env, jobject _this, jfloat factor, jfloat units) {
4274    glPolygonOffset(
4275        (GLfloat)factor,
4276        (GLfloat)units
4277    );
4278}
4279
4280/* void glReadPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) */
4281static void
4282android_glReadPixels__IIIIIILjava_nio_Buffer_2
4283  (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height, jint format, jint type, jobject pixels_buf) {
4284    jarray _array = (jarray) 0;
4285    jint _bufferOffset = (jint) 0;
4286    jint _remaining;
4287    GLvoid *pixels = (GLvoid *) 0;
4288
4289    pixels = (GLvoid *)getPointer(_env, pixels_buf, &_array, &_remaining, &_bufferOffset);
4290    if (pixels == NULL) {
4291        char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
4292        pixels = (GLvoid *) (_pixelsBase + _bufferOffset);
4293    }
4294    glReadPixels(
4295        (GLint)x,
4296        (GLint)y,
4297        (GLsizei)width,
4298        (GLsizei)height,
4299        (GLenum)format,
4300        (GLenum)type,
4301        (GLvoid *)pixels
4302    );
4303    if (_array) {
4304        releasePointer(_env, _array, pixels, JNI_TRUE);
4305    }
4306}
4307
4308/* void glReleaseShaderCompiler ( void ) */
4309static void
4310android_glReleaseShaderCompiler__
4311  (JNIEnv *_env, jobject _this) {
4312    glReleaseShaderCompiler();
4313}
4314
4315/* void glRenderbufferStorage ( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) */
4316static void
4317android_glRenderbufferStorage__IIII
4318  (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint width, jint height) {
4319    glRenderbufferStorage(
4320        (GLenum)target,
4321        (GLenum)internalformat,
4322        (GLsizei)width,
4323        (GLsizei)height
4324    );
4325}
4326
4327/* void glSampleCoverage ( GLclampf value, GLboolean invert ) */
4328static void
4329android_glSampleCoverage__FZ
4330  (JNIEnv *_env, jobject _this, jfloat value, jboolean invert) {
4331    glSampleCoverage(
4332        (GLclampf)value,
4333        (GLboolean)invert
4334    );
4335}
4336
4337/* void glScissor ( GLint x, GLint y, GLsizei width, GLsizei height ) */
4338static void
4339android_glScissor__IIII
4340  (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height) {
4341    glScissor(
4342        (GLint)x,
4343        (GLint)y,
4344        (GLsizei)width,
4345        (GLsizei)height
4346    );
4347}
4348
4349/* void glShaderBinary ( GLsizei n, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length ) */
4350static void
4351android_glShaderBinary__I_3IIILjava_nio_Buffer_2I
4352  (JNIEnv *_env, jobject _this, jint n, jintArray shaders_ref, jint offset, jint binaryformat, jobject binary_buf, jint length) {
4353    jint _exception = 0;
4354    const char * _exceptionType;
4355    const char * _exceptionMessage;
4356    jarray _array = (jarray) 0;
4357    jint _bufferOffset = (jint) 0;
4358    GLuint *shaders_base = (GLuint *) 0;
4359    jint _shadersRemaining;
4360    GLuint *shaders = (GLuint *) 0;
4361    jint _binaryRemaining;
4362    GLvoid *binary = (GLvoid *) 0;
4363
4364    if (!shaders_ref) {
4365        _exception = 1;
4366        _exceptionType = "java/lang/IllegalArgumentException";
4367        _exceptionMessage = "shaders == null";
4368        goto exit;
4369    }
4370    if (offset < 0) {
4371        _exception = 1;
4372        _exceptionType = "java/lang/IllegalArgumentException";
4373        _exceptionMessage = "offset < 0";
4374        goto exit;
4375    }
4376    _shadersRemaining = _env->GetArrayLength(shaders_ref) - offset;
4377    shaders_base = (GLuint *)
4378        _env->GetPrimitiveArrayCritical(shaders_ref, (jboolean *)0);
4379    shaders = shaders_base + offset;
4380
4381    binary = (GLvoid *)getPointer(_env, binary_buf, &_array, &_binaryRemaining, &_bufferOffset);
4382    if (binary == NULL) {
4383        char * _binaryBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
4384        binary = (GLvoid *) (_binaryBase + _bufferOffset);
4385    }
4386    glShaderBinary(
4387        (GLsizei)n,
4388        (GLuint *)shaders,
4389        (GLenum)binaryformat,
4390        (GLvoid *)binary,
4391        (GLsizei)length
4392    );
4393
4394exit:
4395    if (_array) {
4396        releasePointer(_env, _array, binary, JNI_FALSE);
4397    }
4398    if (shaders_base) {
4399        _env->ReleasePrimitiveArrayCritical(shaders_ref, shaders_base,
4400            JNI_ABORT);
4401    }
4402    if (_exception) {
4403        jniThrowException(_env, _exceptionType, _exceptionMessage);
4404    }
4405}
4406
4407/* void glShaderBinary ( GLsizei n, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length ) */
4408static void
4409android_glShaderBinary__ILjava_nio_IntBuffer_2ILjava_nio_Buffer_2I
4410  (JNIEnv *_env, jobject _this, jint n, jobject shaders_buf, jint binaryformat, jobject binary_buf, jint length) {
4411    jarray _shadersArray = (jarray) 0;
4412    jint _shadersBufferOffset = (jint) 0;
4413    jarray _binaryArray = (jarray) 0;
4414    jint _binaryBufferOffset = (jint) 0;
4415    jint _shadersRemaining;
4416    GLuint *shaders = (GLuint *) 0;
4417    jint _binaryRemaining;
4418    GLvoid *binary = (GLvoid *) 0;
4419
4420    shaders = (GLuint *)getPointer(_env, shaders_buf, &_shadersArray, &_shadersRemaining, &_shadersBufferOffset);
4421    binary = (GLvoid *)getPointer(_env, binary_buf, &_binaryArray, &_binaryRemaining, &_binaryBufferOffset);
4422    if (shaders == NULL) {
4423        char * _shadersBase = (char *)_env->GetPrimitiveArrayCritical(_shadersArray, (jboolean *) 0);
4424        shaders = (GLuint *) (_shadersBase + _shadersBufferOffset);
4425    }
4426    if (binary == NULL) {
4427        char * _binaryBase = (char *)_env->GetPrimitiveArrayCritical(_binaryArray, (jboolean *) 0);
4428        binary = (GLvoid *) (_binaryBase + _binaryBufferOffset);
4429    }
4430    glShaderBinary(
4431        (GLsizei)n,
4432        (GLuint *)shaders,
4433        (GLenum)binaryformat,
4434        (GLvoid *)binary,
4435        (GLsizei)length
4436    );
4437    if (_binaryArray) {
4438        releasePointer(_env, _binaryArray, binary, JNI_FALSE);
4439    }
4440    if (_shadersArray) {
4441        releasePointer(_env, _shadersArray, shaders, JNI_FALSE);
4442    }
4443}
4444
4445
4446/* void glShaderSource ( GLuint shader, GLsizei count, const GLchar ** string, const GLint * length ) */
4447static
4448void
4449android_glShaderSource
4450    (JNIEnv *_env, jobject _this, jint shader, jstring string) {
4451
4452    if (!string) {
4453        jniThrowException(_env, "java/lang/IllegalArgumentException", "string == null");
4454        return;
4455    }
4456
4457    const char* nativeString = _env->GetStringUTFChars(string, 0);
4458    const char* strings[] = {nativeString};
4459    glShaderSource(shader, 1, strings, 0);
4460    _env->ReleaseStringUTFChars(string, nativeString);
4461}
4462/* void glStencilFunc ( GLenum func, GLint ref, GLuint mask ) */
4463static void
4464android_glStencilFunc__III
4465  (JNIEnv *_env, jobject _this, jint func, jint ref, jint mask) {
4466    glStencilFunc(
4467        (GLenum)func,
4468        (GLint)ref,
4469        (GLuint)mask
4470    );
4471}
4472
4473/* void glStencilFuncSeparate ( GLenum face, GLenum func, GLint ref, GLuint mask ) */
4474static void
4475android_glStencilFuncSeparate__IIII
4476  (JNIEnv *_env, jobject _this, jint face, jint func, jint ref, jint mask) {
4477    glStencilFuncSeparate(
4478        (GLenum)face,
4479        (GLenum)func,
4480        (GLint)ref,
4481        (GLuint)mask
4482    );
4483}
4484
4485/* void glStencilMask ( GLuint mask ) */
4486static void
4487android_glStencilMask__I
4488  (JNIEnv *_env, jobject _this, jint mask) {
4489    glStencilMask(
4490        (GLuint)mask
4491    );
4492}
4493
4494/* void glStencilMaskSeparate ( GLenum face, GLuint mask ) */
4495static void
4496android_glStencilMaskSeparate__II
4497  (JNIEnv *_env, jobject _this, jint face, jint mask) {
4498    glStencilMaskSeparate(
4499        (GLenum)face,
4500        (GLuint)mask
4501    );
4502}
4503
4504/* void glStencilOp ( GLenum fail, GLenum zfail, GLenum zpass ) */
4505static void
4506android_glStencilOp__III
4507  (JNIEnv *_env, jobject _this, jint fail, jint zfail, jint zpass) {
4508    glStencilOp(
4509        (GLenum)fail,
4510        (GLenum)zfail,
4511        (GLenum)zpass
4512    );
4513}
4514
4515/* void glStencilOpSeparate ( GLenum face, GLenum fail, GLenum zfail, GLenum zpass ) */
4516static void
4517android_glStencilOpSeparate__IIII
4518  (JNIEnv *_env, jobject _this, jint face, jint fail, jint zfail, jint zpass) {
4519    glStencilOpSeparate(
4520        (GLenum)face,
4521        (GLenum)fail,
4522        (GLenum)zfail,
4523        (GLenum)zpass
4524    );
4525}
4526
4527/* void glTexImage2D ( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) */
4528static void
4529android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2
4530  (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint format, jint type, jobject pixels_buf) {
4531    jarray _array = (jarray) 0;
4532    jint _bufferOffset = (jint) 0;
4533    jint _remaining;
4534    GLvoid *pixels = (GLvoid *) 0;
4535
4536    if (pixels_buf) {
4537        pixels = (GLvoid *)getPointer(_env, pixels_buf, &_array, &_remaining, &_bufferOffset);
4538    }
4539    if (pixels_buf && pixels == NULL) {
4540        char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
4541        pixels = (GLvoid *) (_pixelsBase + _bufferOffset);
4542    }
4543    glTexImage2D(
4544        (GLenum)target,
4545        (GLint)level,
4546        (GLint)internalformat,
4547        (GLsizei)width,
4548        (GLsizei)height,
4549        (GLint)border,
4550        (GLenum)format,
4551        (GLenum)type,
4552        (GLvoid *)pixels
4553    );
4554    if (_array) {
4555        releasePointer(_env, _array, pixels, JNI_FALSE);
4556    }
4557}
4558
4559/* void glTexParameterf ( GLenum target, GLenum pname, GLfloat param ) */
4560static void
4561android_glTexParameterf__IIF
4562  (JNIEnv *_env, jobject _this, jint target, jint pname, jfloat param) {
4563    glTexParameterf(
4564        (GLenum)target,
4565        (GLenum)pname,
4566        (GLfloat)param
4567    );
4568}
4569
4570/* void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params ) */
4571static void
4572android_glTexParameterfv__II_3FI
4573  (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) {
4574    jint _exception = 0;
4575    const char * _exceptionType;
4576    const char * _exceptionMessage;
4577    GLfloat *params_base = (GLfloat *) 0;
4578    jint _remaining;
4579    GLfloat *params = (GLfloat *) 0;
4580
4581    if (!params_ref) {
4582        _exception = 1;
4583        _exceptionType = "java/lang/IllegalArgumentException";
4584        _exceptionMessage = "params == null";
4585        goto exit;
4586    }
4587    if (offset < 0) {
4588        _exception = 1;
4589        _exceptionType = "java/lang/IllegalArgumentException";
4590        _exceptionMessage = "offset < 0";
4591        goto exit;
4592    }
4593    _remaining = _env->GetArrayLength(params_ref) - offset;
4594    if (_remaining < 1) {
4595        _exception = 1;
4596        _exceptionType = "java/lang/IllegalArgumentException";
4597        _exceptionMessage = "length - offset < 1 < needed";
4598        goto exit;
4599    }
4600    params_base = (GLfloat *)
4601        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
4602    params = params_base + offset;
4603
4604    glTexParameterfv(
4605        (GLenum)target,
4606        (GLenum)pname,
4607        (GLfloat *)params
4608    );
4609
4610exit:
4611    if (params_base) {
4612        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
4613            JNI_ABORT);
4614    }
4615    if (_exception) {
4616        jniThrowException(_env, _exceptionType, _exceptionMessage);
4617    }
4618}
4619
4620/* void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params ) */
4621static void
4622android_glTexParameterfv__IILjava_nio_FloatBuffer_2
4623  (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
4624    jint _exception = 0;
4625    const char * _exceptionType;
4626    const char * _exceptionMessage;
4627    jarray _array = (jarray) 0;
4628    jint _bufferOffset = (jint) 0;
4629    jint _remaining;
4630    GLfloat *params = (GLfloat *) 0;
4631
4632    params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
4633    if (_remaining < 1) {
4634        _exception = 1;
4635        _exceptionType = "java/lang/IllegalArgumentException";
4636        _exceptionMessage = "remaining() < 1 < needed";
4637        goto exit;
4638    }
4639    if (params == NULL) {
4640        char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
4641        params = (GLfloat *) (_paramsBase + _bufferOffset);
4642    }
4643    glTexParameterfv(
4644        (GLenum)target,
4645        (GLenum)pname,
4646        (GLfloat *)params
4647    );
4648
4649exit:
4650    if (_array) {
4651        releasePointer(_env, _array, params, JNI_FALSE);
4652    }
4653    if (_exception) {
4654        jniThrowException(_env, _exceptionType, _exceptionMessage);
4655    }
4656}
4657
4658/* void glTexParameteri ( GLenum target, GLenum pname, GLint param ) */
4659static void
4660android_glTexParameteri__III
4661  (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) {
4662    glTexParameteri(
4663        (GLenum)target,
4664        (GLenum)pname,
4665        (GLint)param
4666    );
4667}
4668
4669/* void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params ) */
4670static void
4671android_glTexParameteriv__II_3II
4672  (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
4673    jint _exception = 0;
4674    const char * _exceptionType;
4675    const char * _exceptionMessage;
4676    GLint *params_base = (GLint *) 0;
4677    jint _remaining;
4678    GLint *params = (GLint *) 0;
4679
4680    if (!params_ref) {
4681        _exception = 1;
4682        _exceptionType = "java/lang/IllegalArgumentException";
4683        _exceptionMessage = "params == null";
4684        goto exit;
4685    }
4686    if (offset < 0) {
4687        _exception = 1;
4688        _exceptionType = "java/lang/IllegalArgumentException";
4689        _exceptionMessage = "offset < 0";
4690        goto exit;
4691    }
4692    _remaining = _env->GetArrayLength(params_ref) - offset;
4693    if (_remaining < 1) {
4694        _exception = 1;
4695        _exceptionType = "java/lang/IllegalArgumentException";
4696        _exceptionMessage = "length - offset < 1 < needed";
4697        goto exit;
4698    }
4699    params_base = (GLint *)
4700        _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
4701    params = params_base + offset;
4702
4703    glTexParameteriv(
4704        (GLenum)target,
4705        (GLenum)pname,
4706        (GLint *)params
4707    );
4708
4709exit:
4710    if (params_base) {
4711        _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
4712            JNI_ABORT);
4713    }
4714    if (_exception) {
4715        jniThrowException(_env, _exceptionType, _exceptionMessage);
4716    }
4717}
4718
4719/* void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params ) */
4720static void
4721android_glTexParameteriv__IILjava_nio_IntBuffer_2
4722  (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
4723    jint _exception = 0;
4724    const char * _exceptionType;
4725    const char * _exceptionMessage;
4726    jarray _array = (jarray) 0;
4727    jint _bufferOffset = (jint) 0;
4728    jint _remaining;
4729    GLint *params = (GLint *) 0;
4730
4731    params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
4732    if (_remaining < 1) {
4733        _exception = 1;
4734        _exceptionType = "java/lang/IllegalArgumentException";
4735        _exceptionMessage = "remaining() < 1 < needed";
4736        goto exit;
4737    }
4738    if (params == NULL) {
4739        char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
4740        params = (GLint *) (_paramsBase + _bufferOffset);
4741    }
4742    glTexParameteriv(
4743        (GLenum)target,
4744        (GLenum)pname,
4745        (GLint *)params
4746    );
4747
4748exit:
4749    if (_array) {
4750        releasePointer(_env, _array, params, JNI_FALSE);
4751    }
4752    if (_exception) {
4753        jniThrowException(_env, _exceptionType, _exceptionMessage);
4754    }
4755}
4756
4757/* void glTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels ) */
4758static void
4759android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2
4760  (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint type, jobject pixels_buf) {
4761    jarray _array = (jarray) 0;
4762    jint _bufferOffset = (jint) 0;
4763    jint _remaining;
4764    GLvoid *pixels = (GLvoid *) 0;
4765
4766    if (pixels_buf) {
4767        pixels = (GLvoid *)getPointer(_env, pixels_buf, &_array, &_remaining, &_bufferOffset);
4768    }
4769    if (pixels_buf && pixels == NULL) {
4770        char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
4771        pixels = (GLvoid *) (_pixelsBase + _bufferOffset);
4772    }
4773    glTexSubImage2D(
4774        (GLenum)target,
4775        (GLint)level,
4776        (GLint)xoffset,
4777        (GLint)yoffset,
4778        (GLsizei)width,
4779        (GLsizei)height,
4780        (GLenum)format,
4781        (GLenum)type,
4782        (GLvoid *)pixels
4783    );
4784    if (_array) {
4785        releasePointer(_env, _array, pixels, JNI_FALSE);
4786    }
4787}
4788
4789/* void glUniform1f ( GLint location, GLfloat x ) */
4790static void
4791android_glUniform1f__IF
4792  (JNIEnv *_env, jobject _this, jint location, jfloat x) {
4793    glUniform1f(
4794        (GLint)location,
4795        (GLfloat)x
4796    );
4797}
4798
4799/* void glUniform1fv ( GLint location, GLsizei count, const GLfloat *v ) */
4800static void
4801android_glUniform1fv__II_3FI
4802  (JNIEnv *_env, jobject _this, jint location, jint count, jfloatArray v_ref, jint offset) {
4803    jint _exception = 0;
4804    const char * _exceptionType;
4805    const char * _exceptionMessage;
4806    GLfloat *v_base = (GLfloat *) 0;
4807    jint _remaining;
4808    GLfloat *v = (GLfloat *) 0;
4809
4810    if (!v_ref) {
4811        _exception = 1;
4812        _exceptionType = "java/lang/IllegalArgumentException";
4813        _exceptionMessage = "v == null";
4814        goto exit;
4815    }
4816    if (offset < 0) {
4817        _exception = 1;
4818        _exceptionType = "java/lang/IllegalArgumentException";
4819        _exceptionMessage = "offset < 0";
4820        goto exit;
4821    }
4822    _remaining = _env->GetArrayLength(v_ref) - offset;
4823    v_base = (GLfloat *)
4824        _env->GetPrimitiveArrayCritical(v_ref, (jboolean *)0);
4825    v = v_base + offset;
4826
4827    glUniform1fv(
4828        (GLint)location,
4829        (GLsizei)count,
4830        (GLfloat *)v
4831    );
4832
4833exit:
4834    if (v_base) {
4835        _env->ReleasePrimitiveArrayCritical(v_ref, v_base,
4836            JNI_ABORT);
4837    }
4838    if (_exception) {
4839        jniThrowException(_env, _exceptionType, _exceptionMessage);
4840    }
4841}
4842
4843/* void glUniform1fv ( GLint location, GLsizei count, const GLfloat *v ) */
4844static void
4845android_glUniform1fv__IILjava_nio_FloatBuffer_2
4846  (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) {
4847    jarray _array = (jarray) 0;
4848    jint _bufferOffset = (jint) 0;
4849    jint _remaining;
4850    GLfloat *v = (GLfloat *) 0;
4851
4852    v = (GLfloat *)getPointer(_env, v_buf, &_array, &_remaining, &_bufferOffset);
4853    if (v == NULL) {
4854        char * _vBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
4855        v = (GLfloat *) (_vBase + _bufferOffset);
4856    }
4857    glUniform1fv(
4858        (GLint)location,
4859        (GLsizei)count,
4860        (GLfloat *)v
4861    );
4862    if (_array) {
4863        releasePointer(_env, _array, v, JNI_FALSE);
4864    }
4865}
4866
4867/* void glUniform1i ( GLint location, GLint x ) */
4868static void
4869android_glUniform1i__II
4870  (JNIEnv *_env, jobject _this, jint location, jint x) {
4871    glUniform1i(
4872        (GLint)location,
4873        (GLint)x
4874    );
4875}
4876
4877/* void glUniform1iv ( GLint location, GLsizei count, const GLint *v ) */
4878static void
4879android_glUniform1iv__II_3II
4880  (JNIEnv *_env, jobject _this, jint location, jint count, jintArray v_ref, jint offset) {
4881    jint _exception = 0;
4882    const char * _exceptionType;
4883    const char * _exceptionMessage;
4884    GLint *v_base = (GLint *) 0;
4885    jint _remaining;
4886    GLint *v = (GLint *) 0;
4887
4888    if (!v_ref) {
4889        _exception = 1;
4890        _exceptionType = "java/lang/IllegalArgumentException";
4891        _exceptionMessage = "v == null";
4892        goto exit;
4893    }
4894    if (offset < 0) {
4895        _exception = 1;
4896        _exceptionType = "java/lang/IllegalArgumentException";
4897        _exceptionMessage = "offset < 0";
4898        goto exit;
4899    }
4900    _remaining = _env->GetArrayLength(v_ref) - offset;
4901    v_base = (GLint *)
4902        _env->GetPrimitiveArrayCritical(v_ref, (jboolean *)0);
4903    v = v_base + offset;
4904
4905    glUniform1iv(
4906        (GLint)location,
4907        (GLsizei)count,
4908        (GLint *)v
4909    );
4910
4911exit:
4912    if (v_base) {
4913        _env->ReleasePrimitiveArrayCritical(v_ref, v_base,
4914            JNI_ABORT);
4915    }
4916    if (_exception) {
4917        jniThrowException(_env, _exceptionType, _exceptionMessage);
4918    }
4919}
4920
4921/* void glUniform1iv ( GLint location, GLsizei count, const GLint *v ) */
4922static void
4923android_glUniform1iv__IILjava_nio_IntBuffer_2
4924  (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) {
4925    jarray _array = (jarray) 0;
4926    jint _bufferOffset = (jint) 0;
4927    jint _remaining;
4928    GLint *v = (GLint *) 0;
4929
4930    v = (GLint *)getPointer(_env, v_buf, &_array, &_remaining, &_bufferOffset);
4931    if (v == NULL) {
4932        char * _vBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
4933        v = (GLint *) (_vBase + _bufferOffset);
4934    }
4935    glUniform1iv(
4936        (GLint)location,
4937        (GLsizei)count,
4938        (GLint *)v
4939    );
4940    if (_array) {
4941        releasePointer(_env, _array, v, JNI_FALSE);
4942    }
4943}
4944
4945/* void glUniform2f ( GLint location, GLfloat x, GLfloat y ) */
4946static void
4947android_glUniform2f__IFF
4948  (JNIEnv *_env, jobject _this, jint location, jfloat x, jfloat y) {
4949    glUniform2f(
4950        (GLint)location,
4951        (GLfloat)x,
4952        (GLfloat)y
4953    );
4954}
4955
4956/* void glUniform2fv ( GLint location, GLsizei count, const GLfloat *v ) */
4957static void
4958android_glUniform2fv__II_3FI
4959  (JNIEnv *_env, jobject _this, jint location, jint count, jfloatArray v_ref, jint offset) {
4960    jint _exception = 0;
4961    const char * _exceptionType;
4962    const char * _exceptionMessage;
4963    GLfloat *v_base = (GLfloat *) 0;
4964    jint _remaining;
4965    GLfloat *v = (GLfloat *) 0;
4966
4967    if (!v_ref) {
4968        _exception = 1;
4969        _exceptionType = "java/lang/IllegalArgumentException";
4970        _exceptionMessage = "v == null";
4971        goto exit;
4972    }
4973    if (offset < 0) {
4974        _exception = 1;
4975        _exceptionType = "java/lang/IllegalArgumentException";
4976        _exceptionMessage = "offset < 0";
4977        goto exit;
4978    }
4979    _remaining = _env->GetArrayLength(v_ref) - offset;
4980    v_base = (GLfloat *)
4981        _env->GetPrimitiveArrayCritical(v_ref, (jboolean *)0);
4982    v = v_base + offset;
4983
4984    glUniform2fv(
4985        (GLint)location,
4986        (GLsizei)count,
4987        (GLfloat *)v
4988    );
4989
4990exit:
4991    if (v_base) {
4992        _env->ReleasePrimitiveArrayCritical(v_ref, v_base,
4993            JNI_ABORT);
4994    }
4995    if (_exception) {
4996        jniThrowException(_env, _exceptionType, _exceptionMessage);
4997    }
4998}
4999
5000/* void glUniform2fv ( GLint location, GLsizei count, const GLfloat *v ) */
5001static void
5002android_glUniform2fv__IILjava_nio_FloatBuffer_2
5003  (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) {
5004    jarray _array = (jarray) 0;
5005    jint _bufferOffset = (jint) 0;
5006    jint _remaining;
5007    GLfloat *v = (GLfloat *) 0;
5008
5009    v = (GLfloat *)getPointer(_env, v_buf, &_array, &_remaining, &_bufferOffset);
5010    if (v == NULL) {
5011        char * _vBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
5012        v = (GLfloat *) (_vBase + _bufferOffset);
5013    }
5014    glUniform2fv(
5015        (GLint)location,
5016        (GLsizei)count,
5017        (GLfloat *)v
5018    );
5019    if (_array) {
5020        releasePointer(_env, _array, v, JNI_FALSE);
5021    }
5022}
5023
5024/* void glUniform2i ( GLint location, GLint x, GLint y ) */
5025static void
5026android_glUniform2i__III
5027  (JNIEnv *_env, jobject _this, jint location, jint x, jint y) {
5028    glUniform2i(
5029        (GLint)location,
5030        (GLint)x,
5031        (GLint)y
5032    );
5033}
5034
5035/* void glUniform2iv ( GLint location, GLsizei count, const GLint *v ) */
5036static void
5037android_glUniform2iv__II_3II
5038  (JNIEnv *_env, jobject _this, jint location, jint count, jintArray v_ref, jint offset) {
5039    jint _exception = 0;
5040    const char * _exceptionType;
5041    const char * _exceptionMessage;
5042    GLint *v_base = (GLint *) 0;
5043    jint _remaining;
5044    GLint *v = (GLint *) 0;
5045
5046    if (!v_ref) {
5047        _exception = 1;
5048        _exceptionType = "java/lang/IllegalArgumentException";
5049        _exceptionMessage = "v == null";
5050        goto exit;
5051    }
5052    if (offset < 0) {
5053        _exception = 1;
5054        _exceptionType = "java/lang/IllegalArgumentException";
5055        _exceptionMessage = "offset < 0";
5056        goto exit;
5057    }
5058    _remaining = _env->GetArrayLength(v_ref) - offset;
5059    v_base = (GLint *)
5060        _env->GetPrimitiveArrayCritical(v_ref, (jboolean *)0);
5061    v = v_base + offset;
5062
5063    glUniform2iv(
5064        (GLint)location,
5065        (GLsizei)count,
5066        (GLint *)v
5067    );
5068
5069exit:
5070    if (v_base) {
5071        _env->ReleasePrimitiveArrayCritical(v_ref, v_base,
5072            JNI_ABORT);
5073    }
5074    if (_exception) {
5075        jniThrowException(_env, _exceptionType, _exceptionMessage);
5076    }
5077}
5078
5079/* void glUniform2iv ( GLint location, GLsizei count, const GLint *v ) */
5080static void
5081android_glUniform2iv__IILjava_nio_IntBuffer_2
5082  (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) {
5083    jarray _array = (jarray) 0;
5084    jint _bufferOffset = (jint) 0;
5085    jint _remaining;
5086    GLint *v = (GLint *) 0;
5087
5088    v = (GLint *)getPointer(_env, v_buf, &_array, &_remaining, &_bufferOffset);
5089    if (v == NULL) {
5090        char * _vBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
5091        v = (GLint *) (_vBase + _bufferOffset);
5092    }
5093    glUniform2iv(
5094        (GLint)location,
5095        (GLsizei)count,
5096        (GLint *)v
5097    );
5098    if (_array) {
5099        releasePointer(_env, _array, v, JNI_FALSE);
5100    }
5101}
5102
5103/* void glUniform3f ( GLint location, GLfloat x, GLfloat y, GLfloat z ) */
5104static void
5105android_glUniform3f__IFFF
5106  (JNIEnv *_env, jobject _this, jint location, jfloat x, jfloat y, jfloat z) {
5107    glUniform3f(
5108        (GLint)location,
5109        (GLfloat)x,
5110        (GLfloat)y,
5111        (GLfloat)z
5112    );
5113}
5114
5115/* void glUniform3fv ( GLint location, GLsizei count, const GLfloat *v ) */
5116static void
5117android_glUniform3fv__II_3FI
5118  (JNIEnv *_env, jobject _this, jint location, jint count, jfloatArray v_ref, jint offset) {
5119    jint _exception = 0;
5120    const char * _exceptionType;
5121    const char * _exceptionMessage;
5122    GLfloat *v_base = (GLfloat *) 0;
5123    jint _remaining;
5124    GLfloat *v = (GLfloat *) 0;
5125
5126    if (!v_ref) {
5127        _exception = 1;
5128        _exceptionType = "java/lang/IllegalArgumentException";
5129        _exceptionMessage = "v == null";
5130        goto exit;
5131    }
5132    if (offset < 0) {
5133        _exception = 1;
5134        _exceptionType = "java/lang/IllegalArgumentException";
5135        _exceptionMessage = "offset < 0";
5136        goto exit;
5137    }
5138    _remaining = _env->GetArrayLength(v_ref) - offset;
5139    v_base = (GLfloat *)
5140        _env->GetPrimitiveArrayCritical(v_ref, (jboolean *)0);
5141    v = v_base + offset;
5142
5143    glUniform3fv(
5144        (GLint)location,
5145        (GLsizei)count,
5146        (GLfloat *)v
5147    );
5148
5149exit:
5150    if (v_base) {
5151        _env->ReleasePrimitiveArrayCritical(v_ref, v_base,
5152            JNI_ABORT);
5153    }
5154    if (_exception) {
5155        jniThrowException(_env, _exceptionType, _exceptionMessage);
5156    }
5157}
5158
5159/* void glUniform3fv ( GLint location, GLsizei count, const GLfloat *v ) */
5160static void
5161android_glUniform3fv__IILjava_nio_FloatBuffer_2
5162  (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) {
5163    jarray _array = (jarray) 0;
5164    jint _bufferOffset = (jint) 0;
5165    jint _remaining;
5166    GLfloat *v = (GLfloat *) 0;
5167
5168    v = (GLfloat *)getPointer(_env, v_buf, &_array, &_remaining, &_bufferOffset);
5169    if (v == NULL) {
5170        char * _vBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
5171        v = (GLfloat *) (_vBase + _bufferOffset);
5172    }
5173    glUniform3fv(
5174        (GLint)location,
5175        (GLsizei)count,
5176        (GLfloat *)v
5177    );
5178    if (_array) {
5179        releasePointer(_env, _array, v, JNI_FALSE);
5180    }
5181}
5182
5183/* void glUniform3i ( GLint location, GLint x, GLint y, GLint z ) */
5184static void
5185android_glUniform3i__IIII
5186  (JNIEnv *_env, jobject _this, jint location, jint x, jint y, jint z) {
5187    glUniform3i(
5188        (GLint)location,
5189        (GLint)x,
5190        (GLint)y,
5191        (GLint)z
5192    );
5193}
5194
5195/* void glUniform3iv ( GLint location, GLsizei count, const GLint *v ) */
5196static void
5197android_glUniform3iv__II_3II
5198  (JNIEnv *_env, jobject _this, jint location, jint count, jintArray v_ref, jint offset) {
5199    jint _exception = 0;
5200    const char * _exceptionType;
5201    const char * _exceptionMessage;
5202    GLint *v_base = (GLint *) 0;
5203    jint _remaining;
5204    GLint *v = (GLint *) 0;
5205
5206    if (!v_ref) {
5207        _exception = 1;
5208        _exceptionType = "java/lang/IllegalArgumentException";
5209        _exceptionMessage = "v == null";
5210        goto exit;
5211    }
5212    if (offset < 0) {
5213        _exception = 1;
5214        _exceptionType = "java/lang/IllegalArgumentException";
5215        _exceptionMessage = "offset < 0";
5216        goto exit;
5217    }
5218    _remaining = _env->GetArrayLength(v_ref) - offset;
5219    v_base = (GLint *)
5220        _env->GetPrimitiveArrayCritical(v_ref, (jboolean *)0);
5221    v = v_base + offset;
5222
5223    glUniform3iv(
5224        (GLint)location,
5225        (GLsizei)count,
5226        (GLint *)v
5227    );
5228
5229exit:
5230    if (v_base) {
5231        _env->ReleasePrimitiveArrayCritical(v_ref, v_base,
5232            JNI_ABORT);
5233    }
5234    if (_exception) {
5235        jniThrowException(_env, _exceptionType, _exceptionMessage);
5236    }
5237}
5238
5239/* void glUniform3iv ( GLint location, GLsizei count, const GLint *v ) */
5240static void
5241android_glUniform3iv__IILjava_nio_IntBuffer_2
5242  (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) {
5243    jarray _array = (jarray) 0;
5244    jint _bufferOffset = (jint) 0;
5245    jint _remaining;
5246    GLint *v = (GLint *) 0;
5247
5248    v = (GLint *)getPointer(_env, v_buf, &_array, &_remaining, &_bufferOffset);
5249    if (v == NULL) {
5250        char * _vBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
5251        v = (GLint *) (_vBase + _bufferOffset);
5252    }
5253    glUniform3iv(
5254        (GLint)location,
5255        (GLsizei)count,
5256        (GLint *)v
5257    );
5258    if (_array) {
5259        releasePointer(_env, _array, v, JNI_FALSE);
5260    }
5261}
5262
5263/* void glUniform4f ( GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) */
5264static void
5265android_glUniform4f__IFFFF
5266  (JNIEnv *_env, jobject _this, jint location, jfloat x, jfloat y, jfloat z, jfloat w) {
5267    glUniform4f(
5268        (GLint)location,
5269        (GLfloat)x,
5270        (GLfloat)y,
5271        (GLfloat)z,
5272        (GLfloat)w
5273    );
5274}
5275
5276/* void glUniform4fv ( GLint location, GLsizei count, const GLfloat *v ) */
5277static void
5278android_glUniform4fv__II_3FI
5279  (JNIEnv *_env, jobject _this, jint location, jint count, jfloatArray v_ref, jint offset) {
5280    jint _exception = 0;
5281    const char * _exceptionType;
5282    const char * _exceptionMessage;
5283    GLfloat *v_base = (GLfloat *) 0;
5284    jint _remaining;
5285    GLfloat *v = (GLfloat *) 0;
5286
5287    if (!v_ref) {
5288        _exception = 1;
5289        _exceptionType = "java/lang/IllegalArgumentException";
5290        _exceptionMessage = "v == null";
5291        goto exit;
5292    }
5293    if (offset < 0) {
5294        _exception = 1;
5295        _exceptionType = "java/lang/IllegalArgumentException";
5296        _exceptionMessage = "offset < 0";
5297        goto exit;
5298    }
5299    _remaining = _env->GetArrayLength(v_ref) - offset;
5300    v_base = (GLfloat *)
5301        _env->GetPrimitiveArrayCritical(v_ref, (jboolean *)0);
5302    v = v_base + offset;
5303
5304    glUniform4fv(
5305        (GLint)location,
5306        (GLsizei)count,
5307        (GLfloat *)v
5308    );
5309
5310exit:
5311    if (v_base) {
5312        _env->ReleasePrimitiveArrayCritical(v_ref, v_base,
5313            JNI_ABORT);
5314    }
5315    if (_exception) {
5316        jniThrowException(_env, _exceptionType, _exceptionMessage);
5317    }
5318}
5319
5320/* void glUniform4fv ( GLint location, GLsizei count, const GLfloat *v ) */
5321static void
5322android_glUniform4fv__IILjava_nio_FloatBuffer_2
5323  (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) {
5324    jarray _array = (jarray) 0;
5325    jint _bufferOffset = (jint) 0;
5326    jint _remaining;
5327    GLfloat *v = (GLfloat *) 0;
5328
5329    v = (GLfloat *)getPointer(_env, v_buf, &_array, &_remaining, &_bufferOffset);
5330    if (v == NULL) {
5331        char * _vBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
5332        v = (GLfloat *) (_vBase + _bufferOffset);
5333    }
5334    glUniform4fv(
5335        (GLint)location,
5336        (GLsizei)count,
5337        (GLfloat *)v
5338    );
5339    if (_array) {
5340        releasePointer(_env, _array, v, JNI_FALSE);
5341    }
5342}
5343
5344/* void glUniform4i ( GLint location, GLint x, GLint y, GLint z, GLint w ) */
5345static void
5346android_glUniform4i__IIIII
5347  (JNIEnv *_env, jobject _this, jint location, jint x, jint y, jint z, jint w) {
5348    glUniform4i(
5349        (GLint)location,
5350        (GLint)x,
5351        (GLint)y,
5352        (GLint)z,
5353        (GLint)w
5354    );
5355}
5356
5357/* void glUniform4iv ( GLint location, GLsizei count, const GLint *v ) */
5358static void
5359android_glUniform4iv__II_3II
5360  (JNIEnv *_env, jobject _this, jint location, jint count, jintArray v_ref, jint offset) {
5361    jint _exception = 0;
5362    const char * _exceptionType;
5363    const char * _exceptionMessage;
5364    GLint *v_base = (GLint *) 0;
5365    jint _remaining;
5366    GLint *v = (GLint *) 0;
5367
5368    if (!v_ref) {
5369        _exception = 1;
5370        _exceptionType = "java/lang/IllegalArgumentException";
5371        _exceptionMessage = "v == null";
5372        goto exit;
5373    }
5374    if (offset < 0) {
5375        _exception = 1;
5376        _exceptionType = "java/lang/IllegalArgumentException";
5377        _exceptionMessage = "offset < 0";
5378        goto exit;
5379    }
5380    _remaining = _env->GetArrayLength(v_ref) - offset;
5381    v_base = (GLint *)
5382        _env->GetPrimitiveArrayCritical(v_ref, (jboolean *)0);
5383    v = v_base + offset;
5384
5385    glUniform4iv(
5386        (GLint)location,
5387        (GLsizei)count,
5388        (GLint *)v
5389    );
5390
5391exit:
5392    if (v_base) {
5393        _env->ReleasePrimitiveArrayCritical(v_ref, v_base,
5394            JNI_ABORT);
5395    }
5396    if (_exception) {
5397        jniThrowException(_env, _exceptionType, _exceptionMessage);
5398    }
5399}
5400
5401/* void glUniform4iv ( GLint location, GLsizei count, const GLint *v ) */
5402static void
5403android_glUniform4iv__IILjava_nio_IntBuffer_2
5404  (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) {
5405    jarray _array = (jarray) 0;
5406    jint _bufferOffset = (jint) 0;
5407    jint _remaining;
5408    GLint *v = (GLint *) 0;
5409
5410    v = (GLint *)getPointer(_env, v_buf, &_array, &_remaining, &_bufferOffset);
5411    if (v == NULL) {
5412        char * _vBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
5413        v = (GLint *) (_vBase + _bufferOffset);
5414    }
5415    glUniform4iv(
5416        (GLint)location,
5417        (GLsizei)count,
5418        (GLint *)v
5419    );
5420    if (_array) {
5421        releasePointer(_env, _array, v, JNI_FALSE);
5422    }
5423}
5424
5425/* void glUniformMatrix2fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
5426static void
5427android_glUniformMatrix2fv__IIZ_3FI
5428  (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) {
5429    jint _exception = 0;
5430    const char * _exceptionType;
5431    const char * _exceptionMessage;
5432    GLfloat *value_base = (GLfloat *) 0;
5433    jint _remaining;
5434    GLfloat *value = (GLfloat *) 0;
5435
5436    if (!value_ref) {
5437        _exception = 1;
5438        _exceptionType = "java/lang/IllegalArgumentException";
5439        _exceptionMessage = "value == null";
5440        goto exit;
5441    }
5442    if (offset < 0) {
5443        _exception = 1;
5444        _exceptionType = "java/lang/IllegalArgumentException";
5445        _exceptionMessage = "offset < 0";
5446        goto exit;
5447    }
5448    _remaining = _env->GetArrayLength(value_ref) - offset;
5449    value_base = (GLfloat *)
5450        _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0);
5451    value = value_base + offset;
5452
5453    glUniformMatrix2fv(
5454        (GLint)location,
5455        (GLsizei)count,
5456        (GLboolean)transpose,
5457        (GLfloat *)value
5458    );
5459
5460exit:
5461    if (value_base) {
5462        _env->ReleasePrimitiveArrayCritical(value_ref, value_base,
5463            JNI_ABORT);
5464    }
5465    if (_exception) {
5466        jniThrowException(_env, _exceptionType, _exceptionMessage);
5467    }
5468}
5469
5470/* void glUniformMatrix2fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
5471static void
5472android_glUniformMatrix2fv__IIZLjava_nio_FloatBuffer_2
5473  (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jobject value_buf) {
5474    jarray _array = (jarray) 0;
5475    jint _bufferOffset = (jint) 0;
5476    jint _remaining;
5477    GLfloat *value = (GLfloat *) 0;
5478
5479    value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset);
5480    if (value == NULL) {
5481        char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
5482        value = (GLfloat *) (_valueBase + _bufferOffset);
5483    }
5484    glUniformMatrix2fv(
5485        (GLint)location,
5486        (GLsizei)count,
5487        (GLboolean)transpose,
5488        (GLfloat *)value
5489    );
5490    if (_array) {
5491        releasePointer(_env, _array, value, JNI_FALSE);
5492    }
5493}
5494
5495/* void glUniformMatrix3fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
5496static void
5497android_glUniformMatrix3fv__IIZ_3FI
5498  (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) {
5499    jint _exception = 0;
5500    const char * _exceptionType;
5501    const char * _exceptionMessage;
5502    GLfloat *value_base = (GLfloat *) 0;
5503    jint _remaining;
5504    GLfloat *value = (GLfloat *) 0;
5505
5506    if (!value_ref) {
5507        _exception = 1;
5508        _exceptionType = "java/lang/IllegalArgumentException";
5509        _exceptionMessage = "value == null";
5510        goto exit;
5511    }
5512    if (offset < 0) {
5513        _exception = 1;
5514        _exceptionType = "java/lang/IllegalArgumentException";
5515        _exceptionMessage = "offset < 0";
5516        goto exit;
5517    }
5518    _remaining = _env->GetArrayLength(value_ref) - offset;
5519    value_base = (GLfloat *)
5520        _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0);
5521    value = value_base + offset;
5522
5523    glUniformMatrix3fv(
5524        (GLint)location,
5525        (GLsizei)count,
5526        (GLboolean)transpose,
5527        (GLfloat *)value
5528    );
5529
5530exit:
5531    if (value_base) {
5532        _env->ReleasePrimitiveArrayCritical(value_ref, value_base,
5533            JNI_ABORT);
5534    }
5535    if (_exception) {
5536        jniThrowException(_env, _exceptionType, _exceptionMessage);
5537    }
5538}
5539
5540/* void glUniformMatrix3fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
5541static void
5542android_glUniformMatrix3fv__IIZLjava_nio_FloatBuffer_2
5543  (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jobject value_buf) {
5544    jarray _array = (jarray) 0;
5545    jint _bufferOffset = (jint) 0;
5546    jint _remaining;
5547    GLfloat *value = (GLfloat *) 0;
5548
5549    value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset);
5550    if (value == NULL) {
5551        char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
5552        value = (GLfloat *) (_valueBase + _bufferOffset);
5553    }
5554    glUniformMatrix3fv(
5555        (GLint)location,
5556        (GLsizei)count,
5557        (GLboolean)transpose,
5558        (GLfloat *)value
5559    );
5560    if (_array) {
5561        releasePointer(_env, _array, value, JNI_FALSE);
5562    }
5563}
5564
5565/* void glUniformMatrix4fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
5566static void
5567android_glUniformMatrix4fv__IIZ_3FI
5568  (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) {
5569    jint _exception = 0;
5570    const char * _exceptionType;
5571    const char * _exceptionMessage;
5572    GLfloat *value_base = (GLfloat *) 0;
5573    jint _remaining;
5574    GLfloat *value = (GLfloat *) 0;
5575
5576    if (!value_ref) {
5577        _exception = 1;
5578        _exceptionType = "java/lang/IllegalArgumentException";
5579        _exceptionMessage = "value == null";
5580        goto exit;
5581    }
5582    if (offset < 0) {
5583        _exception = 1;
5584        _exceptionType = "java/lang/IllegalArgumentException";
5585        _exceptionMessage = "offset < 0";
5586        goto exit;
5587    }
5588    _remaining = _env->GetArrayLength(value_ref) - offset;
5589    value_base = (GLfloat *)
5590        _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0);
5591    value = value_base + offset;
5592
5593    glUniformMatrix4fv(
5594        (GLint)location,
5595        (GLsizei)count,
5596        (GLboolean)transpose,
5597        (GLfloat *)value
5598    );
5599
5600exit:
5601    if (value_base) {
5602        _env->ReleasePrimitiveArrayCritical(value_ref, value_base,
5603            JNI_ABORT);
5604    }
5605    if (_exception) {
5606        jniThrowException(_env, _exceptionType, _exceptionMessage);
5607    }
5608}
5609
5610/* void glUniformMatrix4fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
5611static void
5612android_glUniformMatrix4fv__IIZLjava_nio_FloatBuffer_2
5613  (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jobject value_buf) {
5614    jarray _array = (jarray) 0;
5615    jint _bufferOffset = (jint) 0;
5616    jint _remaining;
5617    GLfloat *value = (GLfloat *) 0;
5618
5619    value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset);
5620    if (value == NULL) {
5621        char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
5622        value = (GLfloat *) (_valueBase + _bufferOffset);
5623    }
5624    glUniformMatrix4fv(
5625        (GLint)location,
5626        (GLsizei)count,
5627        (GLboolean)transpose,
5628        (GLfloat *)value
5629    );
5630    if (_array) {
5631        releasePointer(_env, _array, value, JNI_FALSE);
5632    }
5633}
5634
5635/* void glUseProgram ( GLuint program ) */
5636static void
5637android_glUseProgram__I
5638  (JNIEnv *_env, jobject _this, jint program) {
5639    glUseProgram(
5640        (GLuint)program
5641    );
5642}
5643
5644/* void glValidateProgram ( GLuint program ) */
5645static void
5646android_glValidateProgram__I
5647  (JNIEnv *_env, jobject _this, jint program) {
5648    glValidateProgram(
5649        (GLuint)program
5650    );
5651}
5652
5653/* void glVertexAttrib1f ( GLuint indx, GLfloat x ) */
5654static void
5655android_glVertexAttrib1f__IF
5656  (JNIEnv *_env, jobject _this, jint indx, jfloat x) {
5657    glVertexAttrib1f(
5658        (GLuint)indx,
5659        (GLfloat)x
5660    );
5661}
5662
5663/* void glVertexAttrib1fv ( GLuint indx, const GLfloat *values ) */
5664static void
5665android_glVertexAttrib1fv__I_3FI
5666  (JNIEnv *_env, jobject _this, jint indx, jfloatArray values_ref, jint offset) {
5667    jint _exception = 0;
5668    const char * _exceptionType;
5669    const char * _exceptionMessage;
5670    GLfloat *values_base = (GLfloat *) 0;
5671    jint _remaining;
5672    GLfloat *values = (GLfloat *) 0;
5673
5674    if (!values_ref) {
5675        _exception = 1;
5676        _exceptionType = "java/lang/IllegalArgumentException";
5677        _exceptionMessage = "values == null";
5678        goto exit;
5679    }
5680    if (offset < 0) {
5681        _exception = 1;
5682        _exceptionType = "java/lang/IllegalArgumentException";
5683        _exceptionMessage = "offset < 0";
5684        goto exit;
5685    }
5686    _remaining = _env->GetArrayLength(values_ref) - offset;
5687    values_base = (GLfloat *)
5688        _env->GetPrimitiveArrayCritical(values_ref, (jboolean *)0);
5689    values = values_base + offset;
5690
5691    glVertexAttrib1fv(
5692        (GLuint)indx,
5693        (GLfloat *)values
5694    );
5695
5696exit:
5697    if (values_base) {
5698        _env->ReleasePrimitiveArrayCritical(values_ref, values_base,
5699            JNI_ABORT);
5700    }
5701    if (_exception) {
5702        jniThrowException(_env, _exceptionType, _exceptionMessage);
5703    }
5704}
5705
5706/* void glVertexAttrib1fv ( GLuint indx, const GLfloat *values ) */
5707static void
5708android_glVertexAttrib1fv__ILjava_nio_FloatBuffer_2
5709  (JNIEnv *_env, jobject _this, jint indx, jobject values_buf) {
5710    jarray _array = (jarray) 0;
5711    jint _bufferOffset = (jint) 0;
5712    jint _remaining;
5713    GLfloat *values = (GLfloat *) 0;
5714
5715    values = (GLfloat *)getPointer(_env, values_buf, &_array, &_remaining, &_bufferOffset);
5716    if (values == NULL) {
5717        char * _valuesBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
5718        values = (GLfloat *) (_valuesBase + _bufferOffset);
5719    }
5720    glVertexAttrib1fv(
5721        (GLuint)indx,
5722        (GLfloat *)values
5723    );
5724    if (_array) {
5725        releasePointer(_env, _array, values, JNI_FALSE);
5726    }
5727}
5728
5729/* void glVertexAttrib2f ( GLuint indx, GLfloat x, GLfloat y ) */
5730static void
5731android_glVertexAttrib2f__IFF
5732  (JNIEnv *_env, jobject _this, jint indx, jfloat x, jfloat y) {
5733    glVertexAttrib2f(
5734        (GLuint)indx,
5735        (GLfloat)x,
5736        (GLfloat)y
5737    );
5738}
5739
5740/* void glVertexAttrib2fv ( GLuint indx, const GLfloat *values ) */
5741static void
5742android_glVertexAttrib2fv__I_3FI
5743  (JNIEnv *_env, jobject _this, jint indx, jfloatArray values_ref, jint offset) {
5744    jint _exception = 0;
5745    const char * _exceptionType;
5746    const char * _exceptionMessage;
5747    GLfloat *values_base = (GLfloat *) 0;
5748    jint _remaining;
5749    GLfloat *values = (GLfloat *) 0;
5750
5751    if (!values_ref) {
5752        _exception = 1;
5753        _exceptionType = "java/lang/IllegalArgumentException";
5754        _exceptionMessage = "values == null";
5755        goto exit;
5756    }
5757    if (offset < 0) {
5758        _exception = 1;
5759        _exceptionType = "java/lang/IllegalArgumentException";
5760        _exceptionMessage = "offset < 0";
5761        goto exit;
5762    }
5763    _remaining = _env->GetArrayLength(values_ref) - offset;
5764    values_base = (GLfloat *)
5765        _env->GetPrimitiveArrayCritical(values_ref, (jboolean *)0);
5766    values = values_base + offset;
5767
5768    glVertexAttrib2fv(
5769        (GLuint)indx,
5770        (GLfloat *)values
5771    );
5772
5773exit:
5774    if (values_base) {
5775        _env->ReleasePrimitiveArrayCritical(values_ref, values_base,
5776            JNI_ABORT);
5777    }
5778    if (_exception) {
5779        jniThrowException(_env, _exceptionType, _exceptionMessage);
5780    }
5781}
5782
5783/* void glVertexAttrib2fv ( GLuint indx, const GLfloat *values ) */
5784static void
5785android_glVertexAttrib2fv__ILjava_nio_FloatBuffer_2
5786  (JNIEnv *_env, jobject _this, jint indx, jobject values_buf) {
5787    jarray _array = (jarray) 0;
5788    jint _bufferOffset = (jint) 0;
5789    jint _remaining;
5790    GLfloat *values = (GLfloat *) 0;
5791
5792    values = (GLfloat *)getPointer(_env, values_buf, &_array, &_remaining, &_bufferOffset);
5793    if (values == NULL) {
5794        char * _valuesBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
5795        values = (GLfloat *) (_valuesBase + _bufferOffset);
5796    }
5797    glVertexAttrib2fv(
5798        (GLuint)indx,
5799        (GLfloat *)values
5800    );
5801    if (_array) {
5802        releasePointer(_env, _array, values, JNI_FALSE);
5803    }
5804}
5805
5806/* void glVertexAttrib3f ( GLuint indx, GLfloat x, GLfloat y, GLfloat z ) */
5807static void
5808android_glVertexAttrib3f__IFFF
5809  (JNIEnv *_env, jobject _this, jint indx, jfloat x, jfloat y, jfloat z) {
5810    glVertexAttrib3f(
5811        (GLuint)indx,
5812        (GLfloat)x,
5813        (GLfloat)y,
5814        (GLfloat)z
5815    );
5816}
5817
5818/* void glVertexAttrib3fv ( GLuint indx, const GLfloat *values ) */
5819static void
5820android_glVertexAttrib3fv__I_3FI
5821  (JNIEnv *_env, jobject _this, jint indx, jfloatArray values_ref, jint offset) {
5822    jint _exception = 0;
5823    const char * _exceptionType;
5824    const char * _exceptionMessage;
5825    GLfloat *values_base = (GLfloat *) 0;
5826    jint _remaining;
5827    GLfloat *values = (GLfloat *) 0;
5828
5829    if (!values_ref) {
5830        _exception = 1;
5831        _exceptionType = "java/lang/IllegalArgumentException";
5832        _exceptionMessage = "values == null";
5833        goto exit;
5834    }
5835    if (offset < 0) {
5836        _exception = 1;
5837        _exceptionType = "java/lang/IllegalArgumentException";
5838        _exceptionMessage = "offset < 0";
5839        goto exit;
5840    }
5841    _remaining = _env->GetArrayLength(values_ref) - offset;
5842    values_base = (GLfloat *)
5843        _env->GetPrimitiveArrayCritical(values_ref, (jboolean *)0);
5844    values = values_base + offset;
5845
5846    glVertexAttrib3fv(
5847        (GLuint)indx,
5848        (GLfloat *)values
5849    );
5850
5851exit:
5852    if (values_base) {
5853        _env->ReleasePrimitiveArrayCritical(values_ref, values_base,
5854            JNI_ABORT);
5855    }
5856    if (_exception) {
5857        jniThrowException(_env, _exceptionType, _exceptionMessage);
5858    }
5859}
5860
5861/* void glVertexAttrib3fv ( GLuint indx, const GLfloat *values ) */
5862static void
5863android_glVertexAttrib3fv__ILjava_nio_FloatBuffer_2
5864  (JNIEnv *_env, jobject _this, jint indx, jobject values_buf) {
5865    jarray _array = (jarray) 0;
5866    jint _bufferOffset = (jint) 0;
5867    jint _remaining;
5868    GLfloat *values = (GLfloat *) 0;
5869
5870    values = (GLfloat *)getPointer(_env, values_buf, &_array, &_remaining, &_bufferOffset);
5871    if (values == NULL) {
5872        char * _valuesBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
5873        values = (GLfloat *) (_valuesBase + _bufferOffset);
5874    }
5875    glVertexAttrib3fv(
5876        (GLuint)indx,
5877        (GLfloat *)values
5878    );
5879    if (_array) {
5880        releasePointer(_env, _array, values, JNI_FALSE);
5881    }
5882}
5883
5884/* void glVertexAttrib4f ( GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) */
5885static void
5886android_glVertexAttrib4f__IFFFF
5887  (JNIEnv *_env, jobject _this, jint indx, jfloat x, jfloat y, jfloat z, jfloat w) {
5888    glVertexAttrib4f(
5889        (GLuint)indx,
5890        (GLfloat)x,
5891        (GLfloat)y,
5892        (GLfloat)z,
5893        (GLfloat)w
5894    );
5895}
5896
5897/* void glVertexAttrib4fv ( GLuint indx, const GLfloat *values ) */
5898static void
5899android_glVertexAttrib4fv__I_3FI
5900  (JNIEnv *_env, jobject _this, jint indx, jfloatArray values_ref, jint offset) {
5901    jint _exception = 0;
5902    const char * _exceptionType;
5903    const char * _exceptionMessage;
5904    GLfloat *values_base = (GLfloat *) 0;
5905    jint _remaining;
5906    GLfloat *values = (GLfloat *) 0;
5907
5908    if (!values_ref) {
5909        _exception = 1;
5910        _exceptionType = "java/lang/IllegalArgumentException";
5911        _exceptionMessage = "values == null";
5912        goto exit;
5913    }
5914    if (offset < 0) {
5915        _exception = 1;
5916        _exceptionType = "java/lang/IllegalArgumentException";
5917        _exceptionMessage = "offset < 0";
5918        goto exit;
5919    }
5920    _remaining = _env->GetArrayLength(values_ref) - offset;
5921    values_base = (GLfloat *)
5922        _env->GetPrimitiveArrayCritical(values_ref, (jboolean *)0);
5923    values = values_base + offset;
5924
5925    glVertexAttrib4fv(
5926        (GLuint)indx,
5927        (GLfloat *)values
5928    );
5929
5930exit:
5931    if (values_base) {
5932        _env->ReleasePrimitiveArrayCritical(values_ref, values_base,
5933            JNI_ABORT);
5934    }
5935    if (_exception) {
5936        jniThrowException(_env, _exceptionType, _exceptionMessage);
5937    }
5938}
5939
5940/* void glVertexAttrib4fv ( GLuint indx, const GLfloat *values ) */
5941static void
5942android_glVertexAttrib4fv__ILjava_nio_FloatBuffer_2
5943  (JNIEnv *_env, jobject _this, jint indx, jobject values_buf) {
5944    jarray _array = (jarray) 0;
5945    jint _bufferOffset = (jint) 0;
5946    jint _remaining;
5947    GLfloat *values = (GLfloat *) 0;
5948
5949    values = (GLfloat *)getPointer(_env, values_buf, &_array, &_remaining, &_bufferOffset);
5950    if (values == NULL) {
5951        char * _valuesBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
5952        values = (GLfloat *) (_valuesBase + _bufferOffset);
5953    }
5954    glVertexAttrib4fv(
5955        (GLuint)indx,
5956        (GLfloat *)values
5957    );
5958    if (_array) {
5959        releasePointer(_env, _array, values, JNI_FALSE);
5960    }
5961}
5962
5963/* void glVertexAttribPointer ( GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLint offset ) */
5964static void
5965android_glVertexAttribPointer__IIIZII
5966  (JNIEnv *_env, jobject _this, jint indx, jint size, jint type, jboolean normalized, jint stride, jint offset) {
5967    glVertexAttribPointer(
5968        (GLuint)indx,
5969        (GLint)size,
5970        (GLenum)type,
5971        (GLboolean)normalized,
5972        (GLsizei)stride,
5973        (const GLvoid *)offset
5974    );
5975}
5976
5977/* void glVertexAttribPointer ( GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *ptr ) */
5978static void
5979android_glVertexAttribPointerBounds__IIIZILjava_nio_Buffer_2I
5980  (JNIEnv *_env, jobject _this, jint indx, jint size, jint type, jboolean normalized, jint stride, jobject ptr_buf, jint remaining) {
5981    jarray _array = (jarray) 0;
5982    jint _bufferOffset = (jint) 0;
5983    jint _remaining;
5984    GLvoid *ptr = (GLvoid *) 0;
5985
5986    if (ptr_buf) {
5987        ptr = (GLvoid *) getDirectBufferPointer(_env, ptr_buf);
5988        if ( ! ptr ) {
5989            return;
5990        }
5991    }
5992    glVertexAttribPointerBounds(
5993        (GLuint)indx,
5994        (GLint)size,
5995        (GLenum)type,
5996        (GLboolean)normalized,
5997        (GLsizei)stride,
5998        (GLvoid *)ptr,
5999        (GLsizei)remaining
6000    );
6001}
6002
6003/* void glViewport ( GLint x, GLint y, GLsizei width, GLsizei height ) */
6004static void
6005android_glViewport__IIII
6006  (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height) {
6007    glViewport(
6008        (GLint)x,
6009        (GLint)y,
6010        (GLsizei)width,
6011        (GLsizei)height
6012    );
6013}
6014
6015static const char *classPathName = "android/opengl/GLES20";
6016
6017static JNINativeMethod methods[] = {
6018{"_nativeClassInit", "()V", (void*)nativeClassInit },
6019{"glActiveTexture", "(I)V", (void *) android_glActiveTexture__I },
6020{"glAttachShader", "(II)V", (void *) android_glAttachShader__II },
6021{"glBindAttribLocation", "(IILjava/lang/String;)V", (void *) android_glBindAttribLocation__IILjava_lang_String_2 },
6022{"glBindBuffer", "(II)V", (void *) android_glBindBuffer__II },
6023{"glBindFramebuffer", "(II)V", (void *) android_glBindFramebuffer__II },
6024{"glBindRenderbuffer", "(II)V", (void *) android_glBindRenderbuffer__II },
6025{"glBindTexture", "(II)V", (void *) android_glBindTexture__II },
6026{"glBlendColor", "(FFFF)V", (void *) android_glBlendColor__FFFF },
6027{"glBlendEquation", "(I)V", (void *) android_glBlendEquation__I },
6028{"glBlendEquationSeparate", "(II)V", (void *) android_glBlendEquationSeparate__II },
6029{"glBlendFunc", "(II)V", (void *) android_glBlendFunc__II },
6030{"glBlendFuncSeparate", "(IIII)V", (void *) android_glBlendFuncSeparate__IIII },
6031{"glBufferData", "(IILjava/nio/Buffer;I)V", (void *) android_glBufferData__IILjava_nio_Buffer_2I },
6032{"glBufferSubData", "(IIILjava/nio/Buffer;)V", (void *) android_glBufferSubData__IIILjava_nio_Buffer_2 },
6033{"glCheckFramebufferStatus", "(I)I", (void *) android_glCheckFramebufferStatus__I },
6034{"glClear", "(I)V", (void *) android_glClear__I },
6035{"glClearColor", "(FFFF)V", (void *) android_glClearColor__FFFF },
6036{"glClearDepthf", "(F)V", (void *) android_glClearDepthf__F },
6037{"glClearStencil", "(I)V", (void *) android_glClearStencil__I },
6038{"glColorMask", "(ZZZZ)V", (void *) android_glColorMask__ZZZZ },
6039{"glCompileShader", "(I)V", (void *) android_glCompileShader__I },
6040{"glCompressedTexImage2D", "(IIIIIIILjava/nio/Buffer;)V", (void *) android_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2 },
6041{"glCompressedTexSubImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 },
6042{"glCopyTexImage2D", "(IIIIIIII)V", (void *) android_glCopyTexImage2D__IIIIIIII },
6043{"glCopyTexSubImage2D", "(IIIIIIII)V", (void *) android_glCopyTexSubImage2D__IIIIIIII },
6044{"glCreateProgram", "()I", (void *) android_glCreateProgram__ },
6045{"glCreateShader", "(I)I", (void *) android_glCreateShader__I },
6046{"glCullFace", "(I)V", (void *) android_glCullFace__I },
6047{"glDeleteBuffers", "(I[II)V", (void *) android_glDeleteBuffers__I_3II },
6048{"glDeleteBuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteBuffers__ILjava_nio_IntBuffer_2 },
6049{"glDeleteFramebuffers", "(I[II)V", (void *) android_glDeleteFramebuffers__I_3II },
6050{"glDeleteFramebuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteFramebuffers__ILjava_nio_IntBuffer_2 },
6051{"glDeleteProgram", "(I)V", (void *) android_glDeleteProgram__I },
6052{"glDeleteRenderbuffers", "(I[II)V", (void *) android_glDeleteRenderbuffers__I_3II },
6053{"glDeleteRenderbuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteRenderbuffers__ILjava_nio_IntBuffer_2 },
6054{"glDeleteShader", "(I)V", (void *) android_glDeleteShader__I },
6055{"glDeleteTextures", "(I[II)V", (void *) android_glDeleteTextures__I_3II },
6056{"glDeleteTextures", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteTextures__ILjava_nio_IntBuffer_2 },
6057{"glDepthFunc", "(I)V", (void *) android_glDepthFunc__I },
6058{"glDepthMask", "(Z)V", (void *) android_glDepthMask__Z },
6059{"glDepthRangef", "(FF)V", (void *) android_glDepthRangef__FF },
6060{"glDetachShader", "(II)V", (void *) android_glDetachShader__II },
6061{"glDisable", "(I)V", (void *) android_glDisable__I },
6062{"glDisableVertexAttribArray", "(I)V", (void *) android_glDisableVertexAttribArray__I },
6063{"glDrawArrays", "(III)V", (void *) android_glDrawArrays__III },
6064{"glDrawElements", "(IIII)V", (void *) android_glDrawElements__IIII },
6065{"glDrawElements", "(IIILjava/nio/Buffer;)V", (void *) android_glDrawElements__IIILjava_nio_Buffer_2 },
6066{"glEnable", "(I)V", (void *) android_glEnable__I },
6067{"glEnableVertexAttribArray", "(I)V", (void *) android_glEnableVertexAttribArray__I },
6068{"glFinish", "()V", (void *) android_glFinish__ },
6069{"glFlush", "()V", (void *) android_glFlush__ },
6070{"glFramebufferRenderbuffer", "(IIII)V", (void *) android_glFramebufferRenderbuffer__IIII },
6071{"glFramebufferTexture2D", "(IIIII)V", (void *) android_glFramebufferTexture2D__IIIII },
6072{"glFrontFace", "(I)V", (void *) android_glFrontFace__I },
6073{"glGenBuffers", "(I[II)V", (void *) android_glGenBuffers__I_3II },
6074{"glGenBuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenBuffers__ILjava_nio_IntBuffer_2 },
6075{"glGenerateMipmap", "(I)V", (void *) android_glGenerateMipmap__I },
6076{"glGenFramebuffers", "(I[II)V", (void *) android_glGenFramebuffers__I_3II },
6077{"glGenFramebuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenFramebuffers__ILjava_nio_IntBuffer_2 },
6078{"glGenRenderbuffers", "(I[II)V", (void *) android_glGenRenderbuffers__I_3II },
6079{"glGenRenderbuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenRenderbuffers__ILjava_nio_IntBuffer_2 },
6080{"glGenTextures", "(I[II)V", (void *) android_glGenTextures__I_3II },
6081{"glGenTextures", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenTextures__ILjava_nio_IntBuffer_2 },
6082{"glGetActiveAttrib", "(III[II[II[II[BI)V", (void *) android_glGetActiveAttrib__III_3II_3II_3II_3BI },
6083{"glGetActiveAttrib", "(IIILjava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;B)V", (void *) android_glGetActiveAttrib__IIILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2B },
6084{"glGetActiveAttrib", "(II[II[II)Ljava/lang/String;", (void *) android_glGetActiveAttrib1 },
6085{"glGetActiveAttrib", "(IILjava/nio/IntBuffer;Ljava/nio/IntBuffer;)Ljava/lang/String;", (void *) android_glGetActiveAttrib2 },
6086{"glGetActiveUniform", "(III[II[II[II[BI)V", (void *) android_glGetActiveUniform__III_3II_3II_3II_3BI },
6087{"glGetActiveUniform", "(II[II[II)Ljava/lang/String;", (void *) android_glGetActiveUniform1 },
6088{"glGetActiveUniform", "(IIILjava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;B)V", (void *) android_glGetActiveUniform__IIILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2B },
6089{"glGetActiveUniform", "(IILjava/nio/IntBuffer;Ljava/nio/IntBuffer;)Ljava/lang/String;", (void *) android_glGetActiveUniform2 },
6090{"glGetAttachedShaders", "(II[II[II)V", (void *) android_glGetAttachedShaders__II_3II_3II },
6091{"glGetAttachedShaders", "(IILjava/nio/IntBuffer;Ljava/nio/IntBuffer;)V", (void *) android_glGetAttachedShaders__IILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 },
6092{"glGetAttribLocation", "(ILjava/lang/String;)I", (void *) android_glGetAttribLocation__ILjava_lang_String_2 },
6093{"glGetBooleanv", "(I[ZI)V", (void *) android_glGetBooleanv__I_3ZI },
6094{"glGetBooleanv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetBooleanv__ILjava_nio_IntBuffer_2 },
6095{"glGetBufferParameteriv", "(II[II)V", (void *) android_glGetBufferParameteriv__II_3II },
6096{"glGetBufferParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetBufferParameteriv__IILjava_nio_IntBuffer_2 },
6097{"glGetError", "()I", (void *) android_glGetError__ },
6098{"glGetFloatv", "(I[FI)V", (void *) android_glGetFloatv__I_3FI },
6099{"glGetFloatv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glGetFloatv__ILjava_nio_FloatBuffer_2 },
6100{"glGetFramebufferAttachmentParameteriv", "(III[II)V", (void *) android_glGetFramebufferAttachmentParameteriv__III_3II },
6101{"glGetFramebufferAttachmentParameteriv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetFramebufferAttachmentParameteriv__IIILjava_nio_IntBuffer_2 },
6102{"glGetIntegerv", "(I[II)V", (void *) android_glGetIntegerv__I_3II },
6103{"glGetIntegerv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetIntegerv__ILjava_nio_IntBuffer_2 },
6104{"glGetProgramiv", "(II[II)V", (void *) android_glGetProgramiv__II_3II },
6105{"glGetProgramiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetProgramiv__IILjava_nio_IntBuffer_2 },
6106{"glGetProgramInfoLog", "(I)Ljava/lang/String;", (void *) android_glGetProgramInfoLog },
6107{"glGetRenderbufferParameteriv", "(II[II)V", (void *) android_glGetRenderbufferParameteriv__II_3II },
6108{"glGetRenderbufferParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetRenderbufferParameteriv__IILjava_nio_IntBuffer_2 },
6109{"glGetShaderiv", "(II[II)V", (void *) android_glGetShaderiv__II_3II },
6110{"glGetShaderiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetShaderiv__IILjava_nio_IntBuffer_2 },
6111{"glGetShaderInfoLog", "(I)Ljava/lang/String;", (void *) android_glGetShaderInfoLog },
6112{"glGetShaderPrecisionFormat", "(II[II[II)V", (void *) android_glGetShaderPrecisionFormat__II_3II_3II },
6113{"glGetShaderPrecisionFormat", "(IILjava/nio/IntBuffer;Ljava/nio/IntBuffer;)V", (void *) android_glGetShaderPrecisionFormat__IILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 },
6114{"glGetShaderSource", "(II[II[BI)V", (void *) android_glGetShaderSource__II_3II_3BI },
6115{"glGetShaderSource", "(IILjava/nio/IntBuffer;B)V", (void *) android_glGetShaderSource__IILjava_nio_IntBuffer_2B },
6116{"glGetShaderSource", "(I)Ljava/lang/String;", (void *) android_glGetShaderSource },
6117{"glGetString", "(I)Ljava/lang/String;", (void *) android_glGetString },
6118{"glGetTexParameterfv", "(II[FI)V", (void *) android_glGetTexParameterfv__II_3FI },
6119{"glGetTexParameterfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetTexParameterfv__IILjava_nio_FloatBuffer_2 },
6120{"glGetTexParameteriv", "(II[II)V", (void *) android_glGetTexParameteriv__II_3II },
6121{"glGetTexParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameteriv__IILjava_nio_IntBuffer_2 },
6122{"glGetUniformfv", "(II[FI)V", (void *) android_glGetUniformfv__II_3FI },
6123{"glGetUniformfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetUniformfv__IILjava_nio_FloatBuffer_2 },
6124{"glGetUniformiv", "(II[II)V", (void *) android_glGetUniformiv__II_3II },
6125{"glGetUniformiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetUniformiv__IILjava_nio_IntBuffer_2 },
6126{"glGetUniformLocation", "(ILjava/lang/String;)I", (void *) android_glGetUniformLocation__ILjava_lang_String_2 },
6127{"glGetVertexAttribfv", "(II[FI)V", (void *) android_glGetVertexAttribfv__II_3FI },
6128{"glGetVertexAttribfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetVertexAttribfv__IILjava_nio_FloatBuffer_2 },
6129{"glGetVertexAttribiv", "(II[II)V", (void *) android_glGetVertexAttribiv__II_3II },
6130{"glGetVertexAttribiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetVertexAttribiv__IILjava_nio_IntBuffer_2 },
6131{"glHint", "(II)V", (void *) android_glHint__II },
6132{"glIsBuffer", "(I)Z", (void *) android_glIsBuffer__I },
6133{"glIsEnabled", "(I)Z", (void *) android_glIsEnabled__I },
6134{"glIsFramebuffer", "(I)Z", (void *) android_glIsFramebuffer__I },
6135{"glIsProgram", "(I)Z", (void *) android_glIsProgram__I },
6136{"glIsRenderbuffer", "(I)Z", (void *) android_glIsRenderbuffer__I },
6137{"glIsShader", "(I)Z", (void *) android_glIsShader__I },
6138{"glIsTexture", "(I)Z", (void *) android_glIsTexture__I },
6139{"glLineWidth", "(F)V", (void *) android_glLineWidth__F },
6140{"glLinkProgram", "(I)V", (void *) android_glLinkProgram__I },
6141{"glPixelStorei", "(II)V", (void *) android_glPixelStorei__II },
6142{"glPolygonOffset", "(FF)V", (void *) android_glPolygonOffset__FF },
6143{"glReadPixels", "(IIIIIILjava/nio/Buffer;)V", (void *) android_glReadPixels__IIIIIILjava_nio_Buffer_2 },
6144{"glReleaseShaderCompiler", "()V", (void *) android_glReleaseShaderCompiler__ },
6145{"glRenderbufferStorage", "(IIII)V", (void *) android_glRenderbufferStorage__IIII },
6146{"glSampleCoverage", "(FZ)V", (void *) android_glSampleCoverage__FZ },
6147{"glScissor", "(IIII)V", (void *) android_glScissor__IIII },
6148{"glShaderBinary", "(I[IIILjava/nio/Buffer;I)V", (void *) android_glShaderBinary__I_3IIILjava_nio_Buffer_2I },
6149{"glShaderBinary", "(ILjava/nio/IntBuffer;ILjava/nio/Buffer;I)V", (void *) android_glShaderBinary__ILjava_nio_IntBuffer_2ILjava_nio_Buffer_2I },
6150{"glShaderSource", "(ILjava/lang/String;)V", (void *) android_glShaderSource },
6151{"glStencilFunc", "(III)V", (void *) android_glStencilFunc__III },
6152{"glStencilFuncSeparate", "(IIII)V", (void *) android_glStencilFuncSeparate__IIII },
6153{"glStencilMask", "(I)V", (void *) android_glStencilMask__I },
6154{"glStencilMaskSeparate", "(II)V", (void *) android_glStencilMaskSeparate__II },
6155{"glStencilOp", "(III)V", (void *) android_glStencilOp__III },
6156{"glStencilOpSeparate", "(IIII)V", (void *) android_glStencilOpSeparate__IIII },
6157{"glTexImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2 },
6158{"glTexParameterf", "(IIF)V", (void *) android_glTexParameterf__IIF },
6159{"glTexParameterfv", "(II[FI)V", (void *) android_glTexParameterfv__II_3FI },
6160{"glTexParameterfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexParameterfv__IILjava_nio_FloatBuffer_2 },
6161{"glTexParameteri", "(III)V", (void *) android_glTexParameteri__III },
6162{"glTexParameteriv", "(II[II)V", (void *) android_glTexParameteriv__II_3II },
6163{"glTexParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameteriv__IILjava_nio_IntBuffer_2 },
6164{"glTexSubImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 },
6165{"glUniform1f", "(IF)V", (void *) android_glUniform1f__IF },
6166{"glUniform1fv", "(II[FI)V", (void *) android_glUniform1fv__II_3FI },
6167{"glUniform1fv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glUniform1fv__IILjava_nio_FloatBuffer_2 },
6168{"glUniform1i", "(II)V", (void *) android_glUniform1i__II },
6169{"glUniform1iv", "(II[II)V", (void *) android_glUniform1iv__II_3II },
6170{"glUniform1iv", "(IILjava/nio/IntBuffer;)V", (void *) android_glUniform1iv__IILjava_nio_IntBuffer_2 },
6171{"glUniform2f", "(IFF)V", (void *) android_glUniform2f__IFF },
6172{"glUniform2fv", "(II[FI)V", (void *) android_glUniform2fv__II_3FI },
6173{"glUniform2fv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glUniform2fv__IILjava_nio_FloatBuffer_2 },
6174{"glUniform2i", "(III)V", (void *) android_glUniform2i__III },
6175{"glUniform2iv", "(II[II)V", (void *) android_glUniform2iv__II_3II },
6176{"glUniform2iv", "(IILjava/nio/IntBuffer;)V", (void *) android_glUniform2iv__IILjava_nio_IntBuffer_2 },
6177{"glUniform3f", "(IFFF)V", (void *) android_glUniform3f__IFFF },
6178{"glUniform3fv", "(II[FI)V", (void *) android_glUniform3fv__II_3FI },
6179{"glUniform3fv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glUniform3fv__IILjava_nio_FloatBuffer_2 },
6180{"glUniform3i", "(IIII)V", (void *) android_glUniform3i__IIII },
6181{"glUniform3iv", "(II[II)V", (void *) android_glUniform3iv__II_3II },
6182{"glUniform3iv", "(IILjava/nio/IntBuffer;)V", (void *) android_glUniform3iv__IILjava_nio_IntBuffer_2 },
6183{"glUniform4f", "(IFFFF)V", (void *) android_glUniform4f__IFFFF },
6184{"glUniform4fv", "(II[FI)V", (void *) android_glUniform4fv__II_3FI },
6185{"glUniform4fv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glUniform4fv__IILjava_nio_FloatBuffer_2 },
6186{"glUniform4i", "(IIIII)V", (void *) android_glUniform4i__IIIII },
6187{"glUniform4iv", "(II[II)V", (void *) android_glUniform4iv__II_3II },
6188{"glUniform4iv", "(IILjava/nio/IntBuffer;)V", (void *) android_glUniform4iv__IILjava_nio_IntBuffer_2 },
6189{"glUniformMatrix2fv", "(IIZ[FI)V", (void *) android_glUniformMatrix2fv__IIZ_3FI },
6190{"glUniformMatrix2fv", "(IIZLjava/nio/FloatBuffer;)V", (void *) android_glUniformMatrix2fv__IIZLjava_nio_FloatBuffer_2 },
6191{"glUniformMatrix3fv", "(IIZ[FI)V", (void *) android_glUniformMatrix3fv__IIZ_3FI },
6192{"glUniformMatrix3fv", "(IIZLjava/nio/FloatBuffer;)V", (void *) android_glUniformMatrix3fv__IIZLjava_nio_FloatBuffer_2 },
6193{"glUniformMatrix4fv", "(IIZ[FI)V", (void *) android_glUniformMatrix4fv__IIZ_3FI },
6194{"glUniformMatrix4fv", "(IIZLjava/nio/FloatBuffer;)V", (void *) android_glUniformMatrix4fv__IIZLjava_nio_FloatBuffer_2 },
6195{"glUseProgram", "(I)V", (void *) android_glUseProgram__I },
6196{"glValidateProgram", "(I)V", (void *) android_glValidateProgram__I },
6197{"glVertexAttrib1f", "(IF)V", (void *) android_glVertexAttrib1f__IF },
6198{"glVertexAttrib1fv", "(I[FI)V", (void *) android_glVertexAttrib1fv__I_3FI },
6199{"glVertexAttrib1fv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glVertexAttrib1fv__ILjava_nio_FloatBuffer_2 },
6200{"glVertexAttrib2f", "(IFF)V", (void *) android_glVertexAttrib2f__IFF },
6201{"glVertexAttrib2fv", "(I[FI)V", (void *) android_glVertexAttrib2fv__I_3FI },
6202{"glVertexAttrib2fv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glVertexAttrib2fv__ILjava_nio_FloatBuffer_2 },
6203{"glVertexAttrib3f", "(IFFF)V", (void *) android_glVertexAttrib3f__IFFF },
6204{"glVertexAttrib3fv", "(I[FI)V", (void *) android_glVertexAttrib3fv__I_3FI },
6205{"glVertexAttrib3fv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glVertexAttrib3fv__ILjava_nio_FloatBuffer_2 },
6206{"glVertexAttrib4f", "(IFFFF)V", (void *) android_glVertexAttrib4f__IFFFF },
6207{"glVertexAttrib4fv", "(I[FI)V", (void *) android_glVertexAttrib4fv__I_3FI },
6208{"glVertexAttrib4fv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glVertexAttrib4fv__ILjava_nio_FloatBuffer_2 },
6209{"glVertexAttribPointer", "(IIIZII)V", (void *) android_glVertexAttribPointer__IIIZII },
6210{"glVertexAttribPointerBounds", "(IIIZILjava/nio/Buffer;I)V", (void *) android_glVertexAttribPointerBounds__IIIZILjava_nio_Buffer_2I },
6211{"glViewport", "(IIII)V", (void *) android_glViewport__IIII },
6212};
6213
6214int register_android_opengl_jni_GLES20(JNIEnv *_env)
6215{
6216    int err;
6217    err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));
6218    return err;
6219}
6220