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