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