1/*
2 * Copyright 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17// This source file is automatically generated
18
19#pragma GCC diagnostic ignored "-Wunused-variable"
20#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
21#pragma GCC diagnostic ignored "-Wunused-function"
22
23#include <stdint.h>
24#include <GLES3/gl31.h>
25#include <jni.h>
26#include <JNIHelp.h>
27#include <android_runtime/AndroidRuntime.h>
28#include <utils/misc.h>
29#include <assert.h>
30
31static int initialized = 0;
32
33static jclass nioAccessClass;
34static jclass bufferClass;
35static jmethodID getBasePointerID;
36static jmethodID getBaseArrayID;
37static jmethodID getBaseArrayOffsetID;
38static jfieldID positionID;
39static jfieldID limitID;
40static jfieldID elementSizeShiftID;
41
42
43/* special calls implemented in Android's GLES wrapper used to more
44 * efficiently bound-check passed arrays */
45extern "C" {
46#ifdef GL_VERSION_ES_CM_1_1
47GL_API void GL_APIENTRY glColorPointerBounds(GLint size, GLenum type, GLsizei stride,
48        const GLvoid *ptr, GLsizei count);
49GL_API void GL_APIENTRY glNormalPointerBounds(GLenum type, GLsizei stride,
50        const GLvoid *pointer, GLsizei count);
51GL_API void GL_APIENTRY glTexCoordPointerBounds(GLint size, GLenum type,
52        GLsizei stride, const GLvoid *pointer, GLsizei count);
53GL_API void GL_APIENTRY glVertexPointerBounds(GLint size, GLenum type,
54        GLsizei stride, const GLvoid *pointer, GLsizei count);
55GL_API void GL_APIENTRY glPointSizePointerOESBounds(GLenum type,
56        GLsizei stride, const GLvoid *pointer, GLsizei count);
57GL_API void GL_APIENTRY glMatrixIndexPointerOESBounds(GLint size, GLenum type,
58        GLsizei stride, const GLvoid *pointer, GLsizei count);
59GL_API void GL_APIENTRY glWeightPointerOESBounds(GLint size, GLenum type,
60        GLsizei stride, const GLvoid *pointer, GLsizei count);
61#endif
62#ifdef GL_ES_VERSION_2_0
63static void glVertexAttribPointerBounds(GLuint indx, GLint size, GLenum type,
64        GLboolean normalized, GLsizei stride, const GLvoid *pointer, GLsizei count) {
65    glVertexAttribPointer(indx, size, type, normalized, stride, pointer);
66}
67#endif
68#ifdef GL_ES_VERSION_3_0
69static void glVertexAttribIPointerBounds(GLuint indx, GLint size, GLenum type,
70        GLsizei stride, const GLvoid *pointer, GLsizei count) {
71    glVertexAttribIPointer(indx, size, type, stride, pointer);
72}
73#endif
74}
75
76/* Cache method IDs each time the class is loaded. */
77
78static void
79nativeClassInit(JNIEnv *_env, jclass glImplClass)
80{
81    jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess");
82    nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal);
83
84    jclass bufferClassLocal = _env->FindClass("java/nio/Buffer");
85    bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal);
86
87    getBasePointerID = _env->GetStaticMethodID(nioAccessClass,
88            "getBasePointer", "(Ljava/nio/Buffer;)J");
89    getBaseArrayID = _env->GetStaticMethodID(nioAccessClass,
90            "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;");
91    getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass,
92            "getBaseArrayOffset", "(Ljava/nio/Buffer;)I");
93
94    positionID = _env->GetFieldID(bufferClass, "position", "I");
95    limitID = _env->GetFieldID(bufferClass, "limit", "I");
96    elementSizeShiftID =
97        _env->GetFieldID(bufferClass, "_elementSizeShift", "I");
98}
99
100static void *
101getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining, jint *offset)
102{
103    jint position;
104    jint limit;
105    jint elementSizeShift;
106    jlong pointer;
107
108    position = _env->GetIntField(buffer, positionID);
109    limit = _env->GetIntField(buffer, limitID);
110    elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
111    *remaining = (limit - position) << elementSizeShift;
112    pointer = _env->CallStaticLongMethod(nioAccessClass,
113            getBasePointerID, buffer);
114    if (pointer != 0L) {
115        *array = NULL;
116        return reinterpret_cast<void*>(pointer);
117    }
118
119    *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass,
120            getBaseArrayID, buffer);
121    *offset = _env->CallStaticIntMethod(nioAccessClass,
122            getBaseArrayOffsetID, buffer);
123
124    return NULL;
125}
126
127class ByteArrayGetter {
128public:
129    static void* Get(JNIEnv* _env, jbyteArray array, jboolean* is_copy) {
130        return _env->GetByteArrayElements(array, is_copy);
131    }
132};
133class BooleanArrayGetter {
134public:
135    static void* Get(JNIEnv* _env, jbooleanArray array, jboolean* is_copy) {
136        return _env->GetBooleanArrayElements(array, is_copy);
137    }
138};
139class CharArrayGetter {
140public:
141    static void* Get(JNIEnv* _env, jcharArray array, jboolean* is_copy) {
142        return _env->GetCharArrayElements(array, is_copy);
143    }
144};
145class ShortArrayGetter {
146public:
147    static void* Get(JNIEnv* _env, jshortArray array, jboolean* is_copy) {
148        return _env->GetShortArrayElements(array, is_copy);
149    }
150};
151class IntArrayGetter {
152public:
153    static void* Get(JNIEnv* _env, jintArray array, jboolean* is_copy) {
154        return _env->GetIntArrayElements(array, is_copy);
155    }
156};
157class LongArrayGetter {
158public:
159    static void* Get(JNIEnv* _env, jlongArray array, jboolean* is_copy) {
160        return _env->GetLongArrayElements(array, is_copy);
161    }
162};
163class FloatArrayGetter {
164public:
165    static void* Get(JNIEnv* _env, jfloatArray array, jboolean* is_copy) {
166        return _env->GetFloatArrayElements(array, is_copy);
167    }
168};
169class DoubleArrayGetter {
170public:
171    static void* Get(JNIEnv* _env, jdoubleArray array, jboolean* is_copy) {
172        return _env->GetDoubleArrayElements(array, is_copy);
173    }
174};
175
176template<typename JTYPEARRAY, typename ARRAYGETTER>
177static void*
178getArrayPointer(JNIEnv *_env, JTYPEARRAY array, jboolean* is_copy) {
179    return ARRAYGETTER::Get(_env, array, is_copy);
180}
181
182class ByteArrayReleaser {
183public:
184    static void Release(JNIEnv* _env, jbyteArray array, jbyte* data, jboolean commit) {
185        _env->ReleaseByteArrayElements(array, data, commit ? 0 : JNI_ABORT);
186    }
187};
188class BooleanArrayReleaser {
189public:
190    static void Release(JNIEnv* _env, jbooleanArray array, jboolean* data, jboolean commit) {
191        _env->ReleaseBooleanArrayElements(array, data, commit ? 0 : JNI_ABORT);
192    }
193};
194class CharArrayReleaser {
195public:
196    static void Release(JNIEnv* _env, jcharArray array, jchar* data, jboolean commit) {
197        _env->ReleaseCharArrayElements(array, data, commit ? 0 : JNI_ABORT);
198    }
199};
200class ShortArrayReleaser {
201public:
202    static void Release(JNIEnv* _env, jshortArray array, jshort* data, jboolean commit) {
203        _env->ReleaseShortArrayElements(array, data, commit ? 0 : JNI_ABORT);
204    }
205};
206class IntArrayReleaser {
207public:
208    static void Release(JNIEnv* _env, jintArray array, jint* data, jboolean commit) {
209        _env->ReleaseIntArrayElements(array, data, commit ? 0 : JNI_ABORT);
210    }
211};
212class LongArrayReleaser {
213public:
214    static void Release(JNIEnv* _env, jlongArray array, jlong* data, jboolean commit) {
215        _env->ReleaseLongArrayElements(array, data, commit ? 0 : JNI_ABORT);
216    }
217};
218class FloatArrayReleaser {
219public:
220    static void Release(JNIEnv* _env, jfloatArray array, jfloat* data, jboolean commit) {
221        _env->ReleaseFloatArrayElements(array, data, commit ? 0 : JNI_ABORT);
222    }
223};
224class DoubleArrayReleaser {
225public:
226    static void Release(JNIEnv* _env, jdoubleArray array, jdouble* data, jboolean commit) {
227        _env->ReleaseDoubleArrayElements(array, data, commit ? 0 : JNI_ABORT);
228    }
229};
230
231template<typename JTYPEARRAY, typename NTYPEARRAY, typename ARRAYRELEASER>
232static void
233releaseArrayPointer(JNIEnv *_env, JTYPEARRAY array, NTYPEARRAY data, jboolean commit) {
234    ARRAYRELEASER::Release(_env, array, data, commit);
235}
236
237static void
238releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit)
239{
240    _env->ReleasePrimitiveArrayCritical(array, data,
241                       commit ? 0 : JNI_ABORT);
242}
243
244static void *
245getDirectBufferPointer(JNIEnv *_env, jobject buffer) {
246    char* buf = (char*) _env->GetDirectBufferAddress(buffer);
247    if (buf) {
248        jint position = _env->GetIntField(buffer, positionID);
249        jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
250        buf += position << elementSizeShift;
251    } else {
252        jniThrowException(_env, "java/lang/IllegalArgumentException",
253                          "Must use a native order direct Buffer");
254    }
255    return (void*) buf;
256}
257
258// --------------------------------------------------------------------------
259
260/*
261 * returns the number of values glGet returns for a given pname.
262 *
263 * The code below is written such that pnames requiring only one values
264 * are the default (and are not explicitely tested for). This makes the
265 * checking code much shorter/readable/efficient.
266 *
267 * This means that unknown pnames (e.g.: extensions) will default to 1. If
268 * that unknown pname needs more than 1 value, then the validation check
269 * is incomplete and the app may crash if it passed the wrong number params.
270 */
271static int getNeededCount(GLint pname) {
272    int needed = 1;
273#ifdef GL_ES_VERSION_3_0
274    // GLES 3.x pnames
275    switch (pname) {
276        case GL_MAX_VIEWPORT_DIMS:
277            needed = 2;
278            break;
279
280        case GL_PROGRAM_BINARY_FORMATS:
281            glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &needed);
282            break;
283    }
284#endif
285
286#ifdef GL_ES_VERSION_2_0
287    // GLES 2.x pnames
288    switch (pname) {
289        case GL_ALIASED_LINE_WIDTH_RANGE:
290        case GL_ALIASED_POINT_SIZE_RANGE:
291            needed = 2;
292            break;
293
294        case GL_BLEND_COLOR:
295        case GL_COLOR_CLEAR_VALUE:
296        case GL_COLOR_WRITEMASK:
297        case GL_SCISSOR_BOX:
298        case GL_VIEWPORT:
299            needed = 4;
300            break;
301
302        case GL_COMPRESSED_TEXTURE_FORMATS:
303            glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed);
304            break;
305
306        case GL_SHADER_BINARY_FORMATS:
307            glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &needed);
308            break;
309    }
310#endif
311
312#ifdef GL_VERSION_ES_CM_1_1
313    // GLES 1.x pnames
314    switch (pname) {
315        case GL_ALIASED_LINE_WIDTH_RANGE:
316        case GL_ALIASED_POINT_SIZE_RANGE:
317        case GL_DEPTH_RANGE:
318        case GL_SMOOTH_LINE_WIDTH_RANGE:
319        case GL_SMOOTH_POINT_SIZE_RANGE:
320            needed = 2;
321            break;
322
323        case GL_CURRENT_NORMAL:
324        case GL_POINT_DISTANCE_ATTENUATION:
325            needed = 3;
326            break;
327
328        case GL_COLOR_CLEAR_VALUE:
329        case GL_COLOR_WRITEMASK:
330        case GL_CURRENT_COLOR:
331        case GL_CURRENT_TEXTURE_COORDS:
332        case GL_FOG_COLOR:
333        case GL_LIGHT_MODEL_AMBIENT:
334        case GL_SCISSOR_BOX:
335        case GL_VIEWPORT:
336            needed = 4;
337            break;
338
339        case GL_MODELVIEW_MATRIX:
340        case GL_PROJECTION_MATRIX:
341        case GL_TEXTURE_MATRIX:
342            needed = 16;
343            break;
344
345        case GL_COMPRESSED_TEXTURE_FORMATS:
346            glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed);
347            break;
348    }
349#endif
350    return needed;
351}
352
353template <typename JTYPEARRAY, typename ARRAYGETTER, typename NTYPEARRAY,
354          typename ARRAYRELEASER, typename CTYPE, void GET(GLenum, CTYPE*)>
355static void
356get
357  (JNIEnv *_env, jobject _this, jint pname, JTYPEARRAY params_ref, jint offset) {
358    jint _exception = 0;
359    const char * _exceptionType;
360    const char * _exceptionMessage;
361    CTYPE *params_base = (CTYPE *) 0;
362    jint _remaining;
363    CTYPE *params = (CTYPE *) 0;
364    int _needed = 0;
365
366    if (!params_ref) {
367        _exception = 1;
368        _exceptionType = "java/lang/IllegalArgumentException";
369        _exceptionMessage = "params == null";
370        goto exit;
371    }
372    if (offset < 0) {
373        _exception = 1;
374        _exceptionType = "java/lang/IllegalArgumentException";
375        _exceptionMessage = "offset < 0";
376        goto exit;
377    }
378    _remaining = _env->GetArrayLength(params_ref) - offset;
379    _needed = getNeededCount(pname);
380    // if we didn't find this pname, we just assume the user passed
381    // an array of the right size -- this might happen with extensions
382    // or if we forget an enum here.
383    if (_remaining < _needed) {
384        _exception = 1;
385        _exceptionType = "java/lang/IllegalArgumentException";
386        _exceptionMessage = "length - offset < needed";
387        goto exit;
388    }
389    params_base = (CTYPE *) getArrayPointer<JTYPEARRAY, ARRAYGETTER>(
390        _env, params_ref, (jboolean *)0);
391    params = params_base + offset;
392
393    GET(
394        (GLenum)pname,
395        (CTYPE *)params
396    );
397
398exit:
399    if (params_base) {
400        releaseArrayPointer<JTYPEARRAY, NTYPEARRAY, ARRAYRELEASER>(
401            _env, params_ref, params_base, !_exception);
402    }
403    if (_exception) {
404        jniThrowException(_env, _exceptionType, _exceptionMessage);
405    }
406}
407
408
409template <typename CTYPE, typename JTYPEARRAY, typename ARRAYGETTER, typename NTYPEARRAY,
410          typename ARRAYRELEASER, void GET(GLenum, CTYPE*)>
411static void
412getarray
413  (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
414    jint _exception = 0;
415    const char * _exceptionType;
416    const char * _exceptionMessage;
417    JTYPEARRAY _array = (JTYPEARRAY) 0;
418    jint _bufferOffset = (jint) 0;
419    jint _remaining;
420    CTYPE *params = (CTYPE *) 0;
421    int _needed = 0;
422
423    params = (CTYPE *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
424    _remaining /= sizeof(CTYPE);    // convert from bytes to item count
425    _needed = getNeededCount(pname);
426    // if we didn't find this pname, we just assume the user passed
427    // an array of the right size -- this might happen with extensions
428    // or if we forget an enum here.
429    if (_needed>0 && _remaining < _needed) {
430        _exception = 1;
431        _exceptionType = "java/lang/IllegalArgumentException";
432        _exceptionMessage = "remaining() < needed";
433        goto exit;
434    }
435    if (params == NULL) {
436        char * _paramsBase = (char *) getArrayPointer<JTYPEARRAY, ARRAYGETTER>(
437            _env, _array, (jboolean *) 0);
438        params = (CTYPE *) (_paramsBase + _bufferOffset);
439    }
440    GET(
441        (GLenum)pname,
442        (CTYPE *)params
443    );
444
445exit:
446    if (_array) {
447        releaseArrayPointer<JTYPEARRAY, NTYPEARRAY, ARRAYRELEASER>(
448            _env, _array, (NTYPEARRAY)params, _exception ? JNI_FALSE : JNI_TRUE);
449    }
450    if (_exception) {
451        jniThrowException(_env, _exceptionType, _exceptionMessage);
452    }
453}
454
455// --------------------------------------------------------------------------
456/* void glDispatchCompute ( GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z ) */
457static void
458android_glDispatchCompute__III
459  (JNIEnv *_env, jobject _this, jint num_groups_x, jint num_groups_y, jint num_groups_z) {
460    glDispatchCompute(
461        (GLuint)num_groups_x,
462        (GLuint)num_groups_y,
463        (GLuint)num_groups_z
464    );
465}
466
467/* void glDispatchComputeIndirect ( GLintptr indirect ) */
468static void android_glDispatchComputeIndirect(JNIEnv *_env, jobject, jlong indirect) {
469    // 'indirect' is a byte offset, not a pointer. GL checks for negative and too-large values.
470    // Here we only need to check for successful 64-bit to 32-bit conversion.
471    // - jlong is a int64_t (jni.h)
472    // - GLintptr is a long (khrplatform.h)
473    if (sizeof(GLintptr) != sizeof(jlong) && (indirect < LONG_MIN || indirect > LONG_MAX)) {
474        jniThrowException(_env, "java/lang/IllegalArgumentException", "indirect offset too large");
475        return;
476    }
477    glDispatchComputeIndirect((GLintptr)indirect);
478}
479
480/* void glDrawArraysIndirect ( GLenum mode, const void *indirect ) */
481static void android_glDrawArraysIndirect(JNIEnv *_env, jobject, int mode, jlong indirect) {
482    // In OpenGL ES, 'indirect' is a byte offset into a buffer, not a raw pointer.
483    // GL checks for too-large values. Here we only need to check for successful signed 64-bit
484    // to unsigned 32-bit conversion.
485    if (sizeof(void*) != sizeof(jlong) && indirect > static_cast<jlong>(UINT32_MAX)) {
486        jniThrowException(_env, "java/lang/IllegalArgumentException", "indirect offset too large");
487        return;
488    }
489    glDrawArraysIndirect(mode, (const void*)indirect);
490}
491
492/* void glDrawElementsIndirect ( GLenum mode, GLenum type, const void *indirect ) */
493static void android_glDrawElementsIndirect(JNIEnv *_env, jobject, jint mode, jint type, jlong indirect) {
494    // In OpenGL ES, 'indirect' is a byte offset into a buffer, not a raw pointer.
495    // GL checks for too-large values. Here we only need to check for successful signed 64-bit
496    // to unsigned 32-bit conversion.
497    if (sizeof(void*) != sizeof(jlong) && indirect > static_cast<jlong>(UINT32_MAX)) {
498        jniThrowException(_env, "java/lang/IllegalArgumentException", "indirect offset too large");
499        return;
500    }
501    glDrawElementsIndirect(mode, type, (const void*)indirect);
502}
503
504/* void glFramebufferParameteri ( GLenum target, GLenum pname, GLint param ) */
505static void
506android_glFramebufferParameteri__III
507  (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) {
508    glFramebufferParameteri(
509        (GLenum)target,
510        (GLenum)pname,
511        (GLint)param
512    );
513}
514
515/* void glGetFramebufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */
516static void
517android_glGetFramebufferParameteriv__II_3II
518  (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
519    jint _exception = 0;
520    const char * _exceptionType = NULL;
521    const char * _exceptionMessage = NULL;
522    GLint *params_base = (GLint *) 0;
523    jint _remaining;
524    GLint *params = (GLint *) 0;
525
526    if (!params_ref) {
527        _exception = 1;
528        _exceptionType = "java/lang/IllegalArgumentException";
529        _exceptionMessage = "params == null";
530        goto exit;
531    }
532    if (offset < 0) {
533        _exception = 1;
534        _exceptionType = "java/lang/IllegalArgumentException";
535        _exceptionMessage = "offset < 0";
536        goto exit;
537    }
538    _remaining = _env->GetArrayLength(params_ref) - offset;
539    params_base = (GLint *)
540        _env->GetIntArrayElements(params_ref, (jboolean *)0);
541    params = params_base + offset;
542
543    glGetFramebufferParameteriv(
544        (GLenum)target,
545        (GLenum)pname,
546        (GLint *)params
547    );
548
549exit:
550    if (params_base) {
551        _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
552            _exception ? JNI_ABORT: 0);
553    }
554    if (_exception) {
555        jniThrowException(_env, _exceptionType, _exceptionMessage);
556    }
557}
558
559/* void glGetFramebufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */
560static void
561android_glGetFramebufferParameteriv__IILjava_nio_IntBuffer_2
562  (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
563    jint _exception = 0;
564    const char * _exceptionType = NULL;
565    const char * _exceptionMessage = NULL;
566    jintArray _array = (jintArray) 0;
567    jint _bufferOffset = (jint) 0;
568    jint _remaining;
569    GLint *params = (GLint *) 0;
570
571    if (!params_buf) {
572        _exception = 1;
573        _exceptionType = "java/lang/IllegalArgumentException";
574        _exceptionMessage = "params == null";
575        goto exit;
576    }
577    params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
578    if (params == NULL) {
579        char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
580        params = (GLint *) (_paramsBase + _bufferOffset);
581    }
582    glGetFramebufferParameteriv(
583        (GLenum)target,
584        (GLenum)pname,
585        (GLint *)params
586    );
587
588exit:
589    if (_array) {
590        _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
591    }
592    if (_exception) {
593        jniThrowException(_env, _exceptionType, _exceptionMessage);
594    }
595}
596
597/* void glGetProgramInterfaceiv ( GLuint program, GLenum programInterface, GLenum pname, GLint *params ) */
598static void
599android_glGetProgramInterfaceiv__III_3II
600  (JNIEnv *_env, jobject _this, jint program, jint programInterface, jint pname, jintArray params_ref, jint offset) {
601    jint _exception = 0;
602    const char * _exceptionType = NULL;
603    const char * _exceptionMessage = NULL;
604    GLint *params_base = (GLint *) 0;
605    jint _remaining;
606    GLint *params = (GLint *) 0;
607
608    if (!params_ref) {
609        _exception = 1;
610        _exceptionType = "java/lang/IllegalArgumentException";
611        _exceptionMessage = "params == null";
612        goto exit;
613    }
614    if (offset < 0) {
615        _exception = 1;
616        _exceptionType = "java/lang/IllegalArgumentException";
617        _exceptionMessage = "offset < 0";
618        goto exit;
619    }
620    _remaining = _env->GetArrayLength(params_ref) - offset;
621    params_base = (GLint *)
622        _env->GetIntArrayElements(params_ref, (jboolean *)0);
623    params = params_base + offset;
624
625    glGetProgramInterfaceiv(
626        (GLuint)program,
627        (GLenum)programInterface,
628        (GLenum)pname,
629        (GLint *)params
630    );
631
632exit:
633    if (params_base) {
634        _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
635            _exception ? JNI_ABORT: 0);
636    }
637    if (_exception) {
638        jniThrowException(_env, _exceptionType, _exceptionMessage);
639    }
640}
641
642/* void glGetProgramInterfaceiv ( GLuint program, GLenum programInterface, GLenum pname, GLint *params ) */
643static void
644android_glGetProgramInterfaceiv__IIILjava_nio_IntBuffer_2
645  (JNIEnv *_env, jobject _this, jint program, jint programInterface, jint pname, jobject params_buf) {
646    jint _exception = 0;
647    const char * _exceptionType = NULL;
648    const char * _exceptionMessage = NULL;
649    jintArray _array = (jintArray) 0;
650    jint _bufferOffset = (jint) 0;
651    jint _remaining;
652    GLint *params = (GLint *) 0;
653
654    if (!params_buf) {
655        _exception = 1;
656        _exceptionType = "java/lang/IllegalArgumentException";
657        _exceptionMessage = "params == null";
658        goto exit;
659    }
660    params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
661    if (params == NULL) {
662        char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
663        params = (GLint *) (_paramsBase + _bufferOffset);
664    }
665    glGetProgramInterfaceiv(
666        (GLuint)program,
667        (GLenum)programInterface,
668        (GLenum)pname,
669        (GLint *)params
670    );
671
672exit:
673    if (_array) {
674        _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
675    }
676    if (_exception) {
677        jniThrowException(_env, _exceptionType, _exceptionMessage);
678    }
679}
680
681/* GLuint glGetProgramResourceIndex ( GLuint program, GLenum programInterface, const GLchar *name ) */
682static jint
683android_glGetProgramResourceIndex__IILjava_lang_String_2
684  (JNIEnv *_env, jobject _this, jint program, jint programInterface, jstring name) {
685    jint _exception = 0;
686    const char * _exceptionType = NULL;
687    const char * _exceptionMessage = NULL;
688    GLuint _returnValue = 0;
689    const char* _nativename = 0;
690
691    if (!name) {
692        _exception = 1;
693        _exceptionType = "java/lang/IllegalArgumentException";
694        _exceptionMessage = "name == null";
695        goto exit;
696    }
697    _nativename = _env->GetStringUTFChars(name, 0);
698
699    _returnValue = glGetProgramResourceIndex(
700        (GLuint)program,
701        (GLenum)programInterface,
702        (GLchar *)_nativename
703    );
704
705exit:
706    if (_nativename) {
707        _env->ReleaseStringUTFChars(name, _nativename);
708    }
709
710    if (_exception) {
711        jniThrowException(_env, _exceptionType, _exceptionMessage);
712    }
713    return (jint)_returnValue;
714}
715
716/* void glGetProgramResourceName ( GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name ) */
717static jstring
718android_glGetProgramResourceName
719  (JNIEnv *_env, jobject _this, jint program, jint programInterface, jint index) {
720    jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
721    return NULL;
722}
723
724/* void glGetProgramResourceiv ( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params ) */
725static void
726android_glGetProgramResourceiv__IIII_3III_3II_3II
727  (JNIEnv *_env, jobject _this, jint program, jint programInterface, jint index, jint propCount, jintArray props_ref, jint propsOffset, jint bufSize, jintArray length_ref, jint lengthOffset, jintArray params_ref, jint paramsOffset) {
728    jint _exception = 0;
729    const char * _exceptionType = NULL;
730    const char * _exceptionMessage = NULL;
731    GLenum *props_base = (GLenum *) 0;
732    jint _propsRemaining;
733    GLenum *props = (GLenum *) 0;
734    GLsizei *length_base = (GLsizei *) 0;
735    jint _lengthRemaining;
736    GLsizei *length = (GLsizei *) 0;
737    GLint *params_base = (GLint *) 0;
738    jint _paramsRemaining;
739    GLint *params = (GLint *) 0;
740
741    if (!props_ref) {
742        _exception = 1;
743        _exceptionType = "java/lang/IllegalArgumentException";
744        _exceptionMessage = "props == null";
745        goto exit;
746    }
747    if (propsOffset < 0) {
748        _exception = 1;
749        _exceptionType = "java/lang/IllegalArgumentException";
750        _exceptionMessage = "propsOffset < 0";
751        goto exit;
752    }
753    _propsRemaining = _env->GetArrayLength(props_ref) - propsOffset;
754    props_base = (GLenum *)
755        _env->GetIntArrayElements(props_ref, (jboolean *)0);
756    props = props_base + propsOffset;
757
758    if (length_ref) {
759        if (lengthOffset < 0) {
760            _exception = 1;
761            _exceptionType = "java/lang/IllegalArgumentException";
762            _exceptionMessage = "lengthOffset < 0";
763            goto exit;
764        }
765        _lengthRemaining = _env->GetArrayLength(length_ref) - lengthOffset;
766        length_base = (GLsizei *)
767            _env->GetIntArrayElements(length_ref, (jboolean *)0);
768        length = length_base + lengthOffset;
769    }
770
771    if (!params_ref) {
772        _exception = 1;
773        _exceptionType = "java/lang/IllegalArgumentException";
774        _exceptionMessage = "params == null";
775        goto exit;
776    }
777    if (paramsOffset < 0) {
778        _exception = 1;
779        _exceptionType = "java/lang/IllegalArgumentException";
780        _exceptionMessage = "paramsOffset < 0";
781        goto exit;
782    }
783    _paramsRemaining = _env->GetArrayLength(params_ref) - paramsOffset;
784    params_base = (GLint *)
785        _env->GetIntArrayElements(params_ref, (jboolean *)0);
786    params = params_base + paramsOffset;
787
788    glGetProgramResourceiv(
789        (GLuint)program,
790        (GLenum)programInterface,
791        (GLuint)index,
792        (GLsizei)propCount,
793        (GLenum *)props,
794        (GLsizei)bufSize,
795        (GLsizei *)length,
796        (GLint *)params
797    );
798
799exit:
800    if (params_base) {
801        _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
802            _exception ? JNI_ABORT: 0);
803    }
804    if (length_base) {
805        _env->ReleaseIntArrayElements(length_ref, (jint*)length_base,
806            _exception ? JNI_ABORT: 0);
807    }
808    if (props_base) {
809        _env->ReleaseIntArrayElements(props_ref, (jint*)props_base,
810            JNI_ABORT);
811    }
812    if (_exception) {
813        jniThrowException(_env, _exceptionType, _exceptionMessage);
814    }
815}
816
817/* void glGetProgramResourceiv ( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params ) */
818static void
819android_glGetProgramResourceiv__IIIILjava_nio_IntBuffer_2ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2
820  (JNIEnv *_env, jobject _this, jint program, jint programInterface, jint index, jint propCount, jobject props_buf, jint bufSize, jobject length_buf, jobject params_buf) {
821    jint _exception = 0;
822    const char * _exceptionType = NULL;
823    const char * _exceptionMessage = NULL;
824    jintArray _propsArray = (jintArray) 0;
825    jint _propsBufferOffset = (jint) 0;
826    jintArray _lengthArray = (jintArray) 0;
827    jint _lengthBufferOffset = (jint) 0;
828    jintArray _paramsArray = (jintArray) 0;
829    jint _paramsBufferOffset = (jint) 0;
830    jint _propsRemaining;
831    GLenum *props = (GLenum *) 0;
832    jint _lengthRemaining;
833    GLsizei *length = (GLsizei *) 0;
834    jint _paramsRemaining;
835    GLint *params = (GLint *) 0;
836
837    if (!props_buf) {
838        _exception = 1;
839        _exceptionType = "java/lang/IllegalArgumentException";
840        _exceptionMessage = "props == null";
841        goto exit;
842    }
843    props = (GLenum *)getPointer(_env, props_buf, (jarray*)&_propsArray, &_propsRemaining, &_propsBufferOffset);
844    if (length_buf) {
845        length = (GLsizei *)getPointer(_env, length_buf, (jarray*)&_lengthArray, &_lengthRemaining, &_lengthBufferOffset);
846    }
847    if (!params_buf) {
848        _exception = 1;
849        _exceptionType = "java/lang/IllegalArgumentException";
850        _exceptionMessage = "params == null";
851        goto exit;
852    }
853    params = (GLint *)getPointer(_env, params_buf, (jarray*)&_paramsArray, &_paramsRemaining, &_paramsBufferOffset);
854    if (props == NULL) {
855        char * _propsBase = (char *)_env->GetIntArrayElements(_propsArray, (jboolean *) 0);
856        props = (GLenum *) (_propsBase + _propsBufferOffset);
857    }
858    if (length_buf && length == NULL) {
859        char * _lengthBase = (char *)_env->GetIntArrayElements(_lengthArray, (jboolean *) 0);
860        length = (GLsizei *) (_lengthBase + _lengthBufferOffset);
861    }
862    if (params == NULL) {
863        char * _paramsBase = (char *)_env->GetIntArrayElements(_paramsArray, (jboolean *) 0);
864        params = (GLint *) (_paramsBase + _paramsBufferOffset);
865    }
866    glGetProgramResourceiv(
867        (GLuint)program,
868        (GLenum)programInterface,
869        (GLuint)index,
870        (GLsizei)propCount,
871        (GLenum *)props,
872        (GLsizei)bufSize,
873        (GLsizei *)length,
874        (GLint *)params
875    );
876
877exit:
878    if (_paramsArray) {
879        _env->ReleaseIntArrayElements(_paramsArray, (jint*)params, _exception ? JNI_ABORT : 0);
880    }
881    if (_lengthArray) {
882        _env->ReleaseIntArrayElements(_lengthArray, (jint*)length, _exception ? JNI_ABORT : 0);
883    }
884    if (_propsArray) {
885        _env->ReleaseIntArrayElements(_propsArray, (jint*)props, JNI_ABORT);
886    }
887    if (_exception) {
888        jniThrowException(_env, _exceptionType, _exceptionMessage);
889    }
890}
891
892/* GLint glGetProgramResourceLocation ( GLuint program, GLenum programInterface, const GLchar *name ) */
893static jint
894android_glGetProgramResourceLocation__IILjava_lang_String_2
895  (JNIEnv *_env, jobject _this, jint program, jint programInterface, jstring name) {
896    jint _exception = 0;
897    const char * _exceptionType = NULL;
898    const char * _exceptionMessage = NULL;
899    GLint _returnValue = 0;
900    const char* _nativename = 0;
901
902    if (!name) {
903        _exception = 1;
904        _exceptionType = "java/lang/IllegalArgumentException";
905        _exceptionMessage = "name == null";
906        goto exit;
907    }
908    _nativename = _env->GetStringUTFChars(name, 0);
909
910    _returnValue = glGetProgramResourceLocation(
911        (GLuint)program,
912        (GLenum)programInterface,
913        (GLchar *)_nativename
914    );
915
916exit:
917    if (_nativename) {
918        _env->ReleaseStringUTFChars(name, _nativename);
919    }
920
921    if (_exception) {
922        jniThrowException(_env, _exceptionType, _exceptionMessage);
923    }
924    return (jint)_returnValue;
925}
926
927/* void glUseProgramStages ( GLuint pipeline, GLbitfield stages, GLuint program ) */
928static void
929android_glUseProgramStages__III
930  (JNIEnv *_env, jobject _this, jint pipeline, jint stages, jint program) {
931    glUseProgramStages(
932        (GLuint)pipeline,
933        (GLbitfield)stages,
934        (GLuint)program
935    );
936}
937
938/* void glActiveShaderProgram ( GLuint pipeline, GLuint program ) */
939static void
940android_glActiveShaderProgram__II
941  (JNIEnv *_env, jobject _this, jint pipeline, jint program) {
942    glActiveShaderProgram(
943        (GLuint)pipeline,
944        (GLuint)program
945    );
946}
947
948/* GLuint glCreateShaderProgramv ( GLenum type, GLsizei count, const GLchar *const *strings ) */
949static jint
950android_glCreateShaderProgramv
951  (JNIEnv *_env, jobject _this, jint type, jobjectArray strings) {
952    jint _exception = 0;
953    const char * _exceptionType = NULL;
954    const char * _exceptionMessage = NULL;
955    GLsizei _count;
956    const GLchar** _strings = NULL;
957    jstring* _jstrings = NULL;
958    GLuint _returnValue = 0;
959
960    if (!strings) {
961        _exception = 1;
962        _exceptionType = "java/lang/IllegalArgumentException";
963        _exceptionMessage = "strings == null";
964        goto exit;
965    }
966
967    _count = _env->GetArrayLength(strings);
968
969    _strings = (const GLchar**) calloc(_count, sizeof(const GLchar*));
970    if (!_strings) {
971        _exception = 1;
972        _exceptionType = "java/lang/OutOfMemoryError";
973        _exceptionMessage = "out of memory";
974        goto exit;
975    }
976
977    _jstrings = (jstring*) calloc(_count, sizeof(jstring));
978    if (!_jstrings) {
979        _exception = 1;
980        _exceptionType = "java/lang/OutOfMemoryError";
981        _exceptionMessage = "out of memory";
982        goto exit;
983    }
984
985    for(int i = 0; i < _count; i++) {
986        _jstrings[i] = (jstring) _env->GetObjectArrayElement(strings, i);
987        if (!_jstrings[i]) {
988            _exception = 1;
989            _exceptionType = "java/lang/IllegalArgumentException";
990            _exceptionMessage = "strings == null";
991            goto exit;
992        }
993        _strings[i] = _env->GetStringUTFChars(_jstrings[i], 0);
994    }
995
996    _returnValue = glCreateShaderProgramv((GLenum)type, _count, _strings);
997exit:
998    if (_strings && _jstrings) {
999        for(int i = 0; i < _count; i++) {
1000            if (_strings[i] && _jstrings[i]) {
1001                _env->ReleaseStringUTFChars(_jstrings[i], _strings[i]);
1002            }
1003        }
1004    }
1005    if (_strings) {
1006        free(_strings);
1007    }
1008    if (_jstrings) {
1009        free(_jstrings);
1010    }
1011    if (_exception) {
1012        jniThrowException(_env, _exceptionType, _exceptionMessage);
1013    }
1014    return (jint)_returnValue;
1015}
1016/* void glBindProgramPipeline ( GLuint pipeline ) */
1017static void
1018android_glBindProgramPipeline__I
1019  (JNIEnv *_env, jobject _this, jint pipeline) {
1020    glBindProgramPipeline(
1021        (GLuint)pipeline
1022    );
1023}
1024
1025/* void glDeleteProgramPipelines ( GLsizei n, const GLuint *pipelines ) */
1026static void
1027android_glDeleteProgramPipelines__I_3II
1028  (JNIEnv *_env, jobject _this, jint n, jintArray pipelines_ref, jint offset) {
1029    jint _exception = 0;
1030    const char * _exceptionType = NULL;
1031    const char * _exceptionMessage = NULL;
1032    GLuint *pipelines_base = (GLuint *) 0;
1033    jint _remaining;
1034    GLuint *pipelines = (GLuint *) 0;
1035
1036    if (!pipelines_ref) {
1037        _exception = 1;
1038        _exceptionType = "java/lang/IllegalArgumentException";
1039        _exceptionMessage = "pipelines == null";
1040        goto exit;
1041    }
1042    if (offset < 0) {
1043        _exception = 1;
1044        _exceptionType = "java/lang/IllegalArgumentException";
1045        _exceptionMessage = "offset < 0";
1046        goto exit;
1047    }
1048    _remaining = _env->GetArrayLength(pipelines_ref) - offset;
1049    pipelines_base = (GLuint *)
1050        _env->GetIntArrayElements(pipelines_ref, (jboolean *)0);
1051    pipelines = pipelines_base + offset;
1052
1053    glDeleteProgramPipelines(
1054        (GLsizei)n,
1055        (GLuint *)pipelines
1056    );
1057
1058exit:
1059    if (pipelines_base) {
1060        _env->ReleaseIntArrayElements(pipelines_ref, (jint*)pipelines_base,
1061            JNI_ABORT);
1062    }
1063    if (_exception) {
1064        jniThrowException(_env, _exceptionType, _exceptionMessage);
1065    }
1066}
1067
1068/* void glDeleteProgramPipelines ( GLsizei n, const GLuint *pipelines ) */
1069static void
1070android_glDeleteProgramPipelines__ILjava_nio_IntBuffer_2
1071  (JNIEnv *_env, jobject _this, jint n, jobject pipelines_buf) {
1072    jint _exception = 0;
1073    const char * _exceptionType = NULL;
1074    const char * _exceptionMessage = NULL;
1075    jintArray _array = (jintArray) 0;
1076    jint _bufferOffset = (jint) 0;
1077    jint _remaining;
1078    GLuint *pipelines = (GLuint *) 0;
1079
1080    if (!pipelines_buf) {
1081        _exception = 1;
1082        _exceptionType = "java/lang/IllegalArgumentException";
1083        _exceptionMessage = "pipelines == null";
1084        goto exit;
1085    }
1086    pipelines = (GLuint *)getPointer(_env, pipelines_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1087    if (pipelines == NULL) {
1088        char * _pipelinesBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1089        pipelines = (GLuint *) (_pipelinesBase + _bufferOffset);
1090    }
1091    glDeleteProgramPipelines(
1092        (GLsizei)n,
1093        (GLuint *)pipelines
1094    );
1095
1096exit:
1097    if (_array) {
1098        _env->ReleaseIntArrayElements(_array, (jint*)pipelines, JNI_ABORT);
1099    }
1100    if (_exception) {
1101        jniThrowException(_env, _exceptionType, _exceptionMessage);
1102    }
1103}
1104
1105/* void glGenProgramPipelines ( GLsizei n, GLuint *pipelines ) */
1106static void
1107android_glGenProgramPipelines__I_3II
1108  (JNIEnv *_env, jobject _this, jint n, jintArray pipelines_ref, jint offset) {
1109    jint _exception = 0;
1110    const char * _exceptionType = NULL;
1111    const char * _exceptionMessage = NULL;
1112    GLuint *pipelines_base = (GLuint *) 0;
1113    jint _remaining;
1114    GLuint *pipelines = (GLuint *) 0;
1115
1116    if (!pipelines_ref) {
1117        _exception = 1;
1118        _exceptionType = "java/lang/IllegalArgumentException";
1119        _exceptionMessage = "pipelines == null";
1120        goto exit;
1121    }
1122    if (offset < 0) {
1123        _exception = 1;
1124        _exceptionType = "java/lang/IllegalArgumentException";
1125        _exceptionMessage = "offset < 0";
1126        goto exit;
1127    }
1128    _remaining = _env->GetArrayLength(pipelines_ref) - offset;
1129    pipelines_base = (GLuint *)
1130        _env->GetIntArrayElements(pipelines_ref, (jboolean *)0);
1131    pipelines = pipelines_base + offset;
1132
1133    glGenProgramPipelines(
1134        (GLsizei)n,
1135        (GLuint *)pipelines
1136    );
1137
1138exit:
1139    if (pipelines_base) {
1140        _env->ReleaseIntArrayElements(pipelines_ref, (jint*)pipelines_base,
1141            _exception ? JNI_ABORT: 0);
1142    }
1143    if (_exception) {
1144        jniThrowException(_env, _exceptionType, _exceptionMessage);
1145    }
1146}
1147
1148/* void glGenProgramPipelines ( GLsizei n, GLuint *pipelines ) */
1149static void
1150android_glGenProgramPipelines__ILjava_nio_IntBuffer_2
1151  (JNIEnv *_env, jobject _this, jint n, jobject pipelines_buf) {
1152    jint _exception = 0;
1153    const char * _exceptionType = NULL;
1154    const char * _exceptionMessage = NULL;
1155    jintArray _array = (jintArray) 0;
1156    jint _bufferOffset = (jint) 0;
1157    jint _remaining;
1158    GLuint *pipelines = (GLuint *) 0;
1159
1160    if (!pipelines_buf) {
1161        _exception = 1;
1162        _exceptionType = "java/lang/IllegalArgumentException";
1163        _exceptionMessage = "pipelines == null";
1164        goto exit;
1165    }
1166    pipelines = (GLuint *)getPointer(_env, pipelines_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1167    if (pipelines == NULL) {
1168        char * _pipelinesBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1169        pipelines = (GLuint *) (_pipelinesBase + _bufferOffset);
1170    }
1171    glGenProgramPipelines(
1172        (GLsizei)n,
1173        (GLuint *)pipelines
1174    );
1175
1176exit:
1177    if (_array) {
1178        _env->ReleaseIntArrayElements(_array, (jint*)pipelines, _exception ? JNI_ABORT : 0);
1179    }
1180    if (_exception) {
1181        jniThrowException(_env, _exceptionType, _exceptionMessage);
1182    }
1183}
1184
1185/* GLboolean glIsProgramPipeline ( GLuint pipeline ) */
1186static jboolean
1187android_glIsProgramPipeline__I
1188  (JNIEnv *_env, jobject _this, jint pipeline) {
1189    GLboolean _returnValue;
1190    _returnValue = glIsProgramPipeline(
1191        (GLuint)pipeline
1192    );
1193    return (jboolean)_returnValue;
1194}
1195
1196/* void glGetProgramPipelineiv ( GLuint pipeline, GLenum pname, GLint *params ) */
1197static void
1198android_glGetProgramPipelineiv__II_3II
1199  (JNIEnv *_env, jobject _this, jint pipeline, jint pname, jintArray params_ref, jint offset) {
1200    jint _exception = 0;
1201    const char * _exceptionType = NULL;
1202    const char * _exceptionMessage = NULL;
1203    GLint *params_base = (GLint *) 0;
1204    jint _remaining;
1205    GLint *params = (GLint *) 0;
1206
1207    if (!params_ref) {
1208        _exception = 1;
1209        _exceptionType = "java/lang/IllegalArgumentException";
1210        _exceptionMessage = "params == null";
1211        goto exit;
1212    }
1213    if (offset < 0) {
1214        _exception = 1;
1215        _exceptionType = "java/lang/IllegalArgumentException";
1216        _exceptionMessage = "offset < 0";
1217        goto exit;
1218    }
1219    _remaining = _env->GetArrayLength(params_ref) - offset;
1220    params_base = (GLint *)
1221        _env->GetIntArrayElements(params_ref, (jboolean *)0);
1222    params = params_base + offset;
1223
1224    glGetProgramPipelineiv(
1225        (GLuint)pipeline,
1226        (GLenum)pname,
1227        (GLint *)params
1228    );
1229
1230exit:
1231    if (params_base) {
1232        _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
1233            _exception ? JNI_ABORT: 0);
1234    }
1235    if (_exception) {
1236        jniThrowException(_env, _exceptionType, _exceptionMessage);
1237    }
1238}
1239
1240/* void glGetProgramPipelineiv ( GLuint pipeline, GLenum pname, GLint *params ) */
1241static void
1242android_glGetProgramPipelineiv__IILjava_nio_IntBuffer_2
1243  (JNIEnv *_env, jobject _this, jint pipeline, jint pname, jobject params_buf) {
1244    jint _exception = 0;
1245    const char * _exceptionType = NULL;
1246    const char * _exceptionMessage = NULL;
1247    jintArray _array = (jintArray) 0;
1248    jint _bufferOffset = (jint) 0;
1249    jint _remaining;
1250    GLint *params = (GLint *) 0;
1251
1252    if (!params_buf) {
1253        _exception = 1;
1254        _exceptionType = "java/lang/IllegalArgumentException";
1255        _exceptionMessage = "params == null";
1256        goto exit;
1257    }
1258    params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1259    if (params == NULL) {
1260        char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1261        params = (GLint *) (_paramsBase + _bufferOffset);
1262    }
1263    glGetProgramPipelineiv(
1264        (GLuint)pipeline,
1265        (GLenum)pname,
1266        (GLint *)params
1267    );
1268
1269exit:
1270    if (_array) {
1271        _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
1272    }
1273    if (_exception) {
1274        jniThrowException(_env, _exceptionType, _exceptionMessage);
1275    }
1276}
1277
1278/* void glProgramUniform1i ( GLuint program, GLint location, GLint v0 ) */
1279static void
1280android_glProgramUniform1i__III
1281  (JNIEnv *_env, jobject _this, jint program, jint location, jint v0) {
1282    glProgramUniform1i(
1283        (GLuint)program,
1284        (GLint)location,
1285        (GLint)v0
1286    );
1287}
1288
1289/* void glProgramUniform2i ( GLuint program, GLint location, GLint v0, GLint v1 ) */
1290static void
1291android_glProgramUniform2i__IIII
1292  (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1) {
1293    glProgramUniform2i(
1294        (GLuint)program,
1295        (GLint)location,
1296        (GLint)v0,
1297        (GLint)v1
1298    );
1299}
1300
1301/* void glProgramUniform3i ( GLuint program, GLint location, GLint v0, GLint v1, GLint v2 ) */
1302static void
1303android_glProgramUniform3i__IIIII
1304  (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1, jint v2) {
1305    glProgramUniform3i(
1306        (GLuint)program,
1307        (GLint)location,
1308        (GLint)v0,
1309        (GLint)v1,
1310        (GLint)v2
1311    );
1312}
1313
1314/* void glProgramUniform4i ( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 ) */
1315static void
1316android_glProgramUniform4i__IIIIII
1317  (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1, jint v2, jint v3) {
1318    glProgramUniform4i(
1319        (GLuint)program,
1320        (GLint)location,
1321        (GLint)v0,
1322        (GLint)v1,
1323        (GLint)v2,
1324        (GLint)v3
1325    );
1326}
1327
1328/* void glProgramUniform1ui ( GLuint program, GLint location, GLuint v0 ) */
1329static void
1330android_glProgramUniform1ui__III
1331  (JNIEnv *_env, jobject _this, jint program, jint location, jint v0) {
1332    glProgramUniform1ui(
1333        (GLuint)program,
1334        (GLint)location,
1335        (GLuint)v0
1336    );
1337}
1338
1339/* void glProgramUniform2ui ( GLuint program, GLint location, GLuint v0, GLuint v1 ) */
1340static void
1341android_glProgramUniform2ui__IIII
1342  (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1) {
1343    glProgramUniform2ui(
1344        (GLuint)program,
1345        (GLint)location,
1346        (GLuint)v0,
1347        (GLuint)v1
1348    );
1349}
1350
1351/* void glProgramUniform3ui ( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 ) */
1352static void
1353android_glProgramUniform3ui__IIIII
1354  (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1, jint v2) {
1355    glProgramUniform3ui(
1356        (GLuint)program,
1357        (GLint)location,
1358        (GLuint)v0,
1359        (GLuint)v1,
1360        (GLuint)v2
1361    );
1362}
1363
1364/* void glProgramUniform4ui ( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) */
1365static void
1366android_glProgramUniform4ui__IIIIII
1367  (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1, jint v2, jint v3) {
1368    glProgramUniform4ui(
1369        (GLuint)program,
1370        (GLint)location,
1371        (GLuint)v0,
1372        (GLuint)v1,
1373        (GLuint)v2,
1374        (GLuint)v3
1375    );
1376}
1377
1378/* void glProgramUniform1f ( GLuint program, GLint location, GLfloat v0 ) */
1379static void
1380android_glProgramUniform1f__IIF
1381  (JNIEnv *_env, jobject _this, jint program, jint location, jfloat v0) {
1382    glProgramUniform1f(
1383        (GLuint)program,
1384        (GLint)location,
1385        (GLfloat)v0
1386    );
1387}
1388
1389/* void glProgramUniform2f ( GLuint program, GLint location, GLfloat v0, GLfloat v1 ) */
1390static void
1391android_glProgramUniform2f__IIFF
1392  (JNIEnv *_env, jobject _this, jint program, jint location, jfloat v0, jfloat v1) {
1393    glProgramUniform2f(
1394        (GLuint)program,
1395        (GLint)location,
1396        (GLfloat)v0,
1397        (GLfloat)v1
1398    );
1399}
1400
1401/* void glProgramUniform3f ( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 ) */
1402static void
1403android_glProgramUniform3f__IIFFF
1404  (JNIEnv *_env, jobject _this, jint program, jint location, jfloat v0, jfloat v1, jfloat v2) {
1405    glProgramUniform3f(
1406        (GLuint)program,
1407        (GLint)location,
1408        (GLfloat)v0,
1409        (GLfloat)v1,
1410        (GLfloat)v2
1411    );
1412}
1413
1414/* void glProgramUniform4f ( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) */
1415static void
1416android_glProgramUniform4f__IIFFFF
1417  (JNIEnv *_env, jobject _this, jint program, jint location, jfloat v0, jfloat v1, jfloat v2, jfloat v3) {
1418    glProgramUniform4f(
1419        (GLuint)program,
1420        (GLint)location,
1421        (GLfloat)v0,
1422        (GLfloat)v1,
1423        (GLfloat)v2,
1424        (GLfloat)v3
1425    );
1426}
1427
1428/* void glProgramUniform1iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */
1429static void
1430android_glProgramUniform1iv__III_3II
1431  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) {
1432    jint _exception = 0;
1433    const char * _exceptionType = NULL;
1434    const char * _exceptionMessage = NULL;
1435    GLint *value_base = (GLint *) 0;
1436    jint _remaining;
1437    GLint *value = (GLint *) 0;
1438
1439    if (!value_ref) {
1440        _exception = 1;
1441        _exceptionType = "java/lang/IllegalArgumentException";
1442        _exceptionMessage = "value == null";
1443        goto exit;
1444    }
1445    if (offset < 0) {
1446        _exception = 1;
1447        _exceptionType = "java/lang/IllegalArgumentException";
1448        _exceptionMessage = "offset < 0";
1449        goto exit;
1450    }
1451    _remaining = _env->GetArrayLength(value_ref) - offset;
1452    value_base = (GLint *)
1453        _env->GetIntArrayElements(value_ref, (jboolean *)0);
1454    value = value_base + offset;
1455
1456    glProgramUniform1iv(
1457        (GLuint)program,
1458        (GLint)location,
1459        (GLsizei)count,
1460        (GLint *)value
1461    );
1462
1463exit:
1464    if (value_base) {
1465        _env->ReleaseIntArrayElements(value_ref, (jint*)value_base,
1466            JNI_ABORT);
1467    }
1468    if (_exception) {
1469        jniThrowException(_env, _exceptionType, _exceptionMessage);
1470    }
1471}
1472
1473/* void glProgramUniform1iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */
1474static void
1475android_glProgramUniform1iv__IIILjava_nio_IntBuffer_2
1476  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) {
1477    jint _exception = 0;
1478    const char * _exceptionType = NULL;
1479    const char * _exceptionMessage = NULL;
1480    jintArray _array = (jintArray) 0;
1481    jint _bufferOffset = (jint) 0;
1482    jint _remaining;
1483    GLint *value = (GLint *) 0;
1484
1485    if (!value_buf) {
1486        _exception = 1;
1487        _exceptionType = "java/lang/IllegalArgumentException";
1488        _exceptionMessage = "value == null";
1489        goto exit;
1490    }
1491    value = (GLint *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1492    if (value == NULL) {
1493        char * _valueBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1494        value = (GLint *) (_valueBase + _bufferOffset);
1495    }
1496    glProgramUniform1iv(
1497        (GLuint)program,
1498        (GLint)location,
1499        (GLsizei)count,
1500        (GLint *)value
1501    );
1502
1503exit:
1504    if (_array) {
1505        _env->ReleaseIntArrayElements(_array, (jint*)value, JNI_ABORT);
1506    }
1507    if (_exception) {
1508        jniThrowException(_env, _exceptionType, _exceptionMessage);
1509    }
1510}
1511
1512/* void glProgramUniform2iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */
1513static void
1514android_glProgramUniform2iv__III_3II
1515  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) {
1516    jint _exception = 0;
1517    const char * _exceptionType = NULL;
1518    const char * _exceptionMessage = NULL;
1519    GLint *value_base = (GLint *) 0;
1520    jint _remaining;
1521    GLint *value = (GLint *) 0;
1522
1523    if (!value_ref) {
1524        _exception = 1;
1525        _exceptionType = "java/lang/IllegalArgumentException";
1526        _exceptionMessage = "value == null";
1527        goto exit;
1528    }
1529    if (offset < 0) {
1530        _exception = 1;
1531        _exceptionType = "java/lang/IllegalArgumentException";
1532        _exceptionMessage = "offset < 0";
1533        goto exit;
1534    }
1535    _remaining = _env->GetArrayLength(value_ref) - offset;
1536    value_base = (GLint *)
1537        _env->GetIntArrayElements(value_ref, (jboolean *)0);
1538    value = value_base + offset;
1539
1540    glProgramUniform2iv(
1541        (GLuint)program,
1542        (GLint)location,
1543        (GLsizei)count,
1544        (GLint *)value
1545    );
1546
1547exit:
1548    if (value_base) {
1549        _env->ReleaseIntArrayElements(value_ref, (jint*)value_base,
1550            JNI_ABORT);
1551    }
1552    if (_exception) {
1553        jniThrowException(_env, _exceptionType, _exceptionMessage);
1554    }
1555}
1556
1557/* void glProgramUniform2iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */
1558static void
1559android_glProgramUniform2iv__IIILjava_nio_IntBuffer_2
1560  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) {
1561    jint _exception = 0;
1562    const char * _exceptionType = NULL;
1563    const char * _exceptionMessage = NULL;
1564    jintArray _array = (jintArray) 0;
1565    jint _bufferOffset = (jint) 0;
1566    jint _remaining;
1567    GLint *value = (GLint *) 0;
1568
1569    if (!value_buf) {
1570        _exception = 1;
1571        _exceptionType = "java/lang/IllegalArgumentException";
1572        _exceptionMessage = "value == null";
1573        goto exit;
1574    }
1575    value = (GLint *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1576    if (value == NULL) {
1577        char * _valueBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1578        value = (GLint *) (_valueBase + _bufferOffset);
1579    }
1580    glProgramUniform2iv(
1581        (GLuint)program,
1582        (GLint)location,
1583        (GLsizei)count,
1584        (GLint *)value
1585    );
1586
1587exit:
1588    if (_array) {
1589        _env->ReleaseIntArrayElements(_array, (jint*)value, JNI_ABORT);
1590    }
1591    if (_exception) {
1592        jniThrowException(_env, _exceptionType, _exceptionMessage);
1593    }
1594}
1595
1596/* void glProgramUniform3iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */
1597static void
1598android_glProgramUniform3iv__III_3II
1599  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) {
1600    jint _exception = 0;
1601    const char * _exceptionType = NULL;
1602    const char * _exceptionMessage = NULL;
1603    GLint *value_base = (GLint *) 0;
1604    jint _remaining;
1605    GLint *value = (GLint *) 0;
1606
1607    if (!value_ref) {
1608        _exception = 1;
1609        _exceptionType = "java/lang/IllegalArgumentException";
1610        _exceptionMessage = "value == null";
1611        goto exit;
1612    }
1613    if (offset < 0) {
1614        _exception = 1;
1615        _exceptionType = "java/lang/IllegalArgumentException";
1616        _exceptionMessage = "offset < 0";
1617        goto exit;
1618    }
1619    _remaining = _env->GetArrayLength(value_ref) - offset;
1620    value_base = (GLint *)
1621        _env->GetIntArrayElements(value_ref, (jboolean *)0);
1622    value = value_base + offset;
1623
1624    glProgramUniform3iv(
1625        (GLuint)program,
1626        (GLint)location,
1627        (GLsizei)count,
1628        (GLint *)value
1629    );
1630
1631exit:
1632    if (value_base) {
1633        _env->ReleaseIntArrayElements(value_ref, (jint*)value_base,
1634            JNI_ABORT);
1635    }
1636    if (_exception) {
1637        jniThrowException(_env, _exceptionType, _exceptionMessage);
1638    }
1639}
1640
1641/* void glProgramUniform3iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */
1642static void
1643android_glProgramUniform3iv__IIILjava_nio_IntBuffer_2
1644  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) {
1645    jint _exception = 0;
1646    const char * _exceptionType = NULL;
1647    const char * _exceptionMessage = NULL;
1648    jintArray _array = (jintArray) 0;
1649    jint _bufferOffset = (jint) 0;
1650    jint _remaining;
1651    GLint *value = (GLint *) 0;
1652
1653    if (!value_buf) {
1654        _exception = 1;
1655        _exceptionType = "java/lang/IllegalArgumentException";
1656        _exceptionMessage = "value == null";
1657        goto exit;
1658    }
1659    value = (GLint *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1660    if (value == NULL) {
1661        char * _valueBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1662        value = (GLint *) (_valueBase + _bufferOffset);
1663    }
1664    glProgramUniform3iv(
1665        (GLuint)program,
1666        (GLint)location,
1667        (GLsizei)count,
1668        (GLint *)value
1669    );
1670
1671exit:
1672    if (_array) {
1673        _env->ReleaseIntArrayElements(_array, (jint*)value, JNI_ABORT);
1674    }
1675    if (_exception) {
1676        jniThrowException(_env, _exceptionType, _exceptionMessage);
1677    }
1678}
1679
1680/* void glProgramUniform4iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */
1681static void
1682android_glProgramUniform4iv__III_3II
1683  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) {
1684    jint _exception = 0;
1685    const char * _exceptionType = NULL;
1686    const char * _exceptionMessage = NULL;
1687    GLint *value_base = (GLint *) 0;
1688    jint _remaining;
1689    GLint *value = (GLint *) 0;
1690
1691    if (!value_ref) {
1692        _exception = 1;
1693        _exceptionType = "java/lang/IllegalArgumentException";
1694        _exceptionMessage = "value == null";
1695        goto exit;
1696    }
1697    if (offset < 0) {
1698        _exception = 1;
1699        _exceptionType = "java/lang/IllegalArgumentException";
1700        _exceptionMessage = "offset < 0";
1701        goto exit;
1702    }
1703    _remaining = _env->GetArrayLength(value_ref) - offset;
1704    value_base = (GLint *)
1705        _env->GetIntArrayElements(value_ref, (jboolean *)0);
1706    value = value_base + offset;
1707
1708    glProgramUniform4iv(
1709        (GLuint)program,
1710        (GLint)location,
1711        (GLsizei)count,
1712        (GLint *)value
1713    );
1714
1715exit:
1716    if (value_base) {
1717        _env->ReleaseIntArrayElements(value_ref, (jint*)value_base,
1718            JNI_ABORT);
1719    }
1720    if (_exception) {
1721        jniThrowException(_env, _exceptionType, _exceptionMessage);
1722    }
1723}
1724
1725/* void glProgramUniform4iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */
1726static void
1727android_glProgramUniform4iv__IIILjava_nio_IntBuffer_2
1728  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) {
1729    jint _exception = 0;
1730    const char * _exceptionType = NULL;
1731    const char * _exceptionMessage = NULL;
1732    jintArray _array = (jintArray) 0;
1733    jint _bufferOffset = (jint) 0;
1734    jint _remaining;
1735    GLint *value = (GLint *) 0;
1736
1737    if (!value_buf) {
1738        _exception = 1;
1739        _exceptionType = "java/lang/IllegalArgumentException";
1740        _exceptionMessage = "value == null";
1741        goto exit;
1742    }
1743    value = (GLint *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1744    if (value == NULL) {
1745        char * _valueBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1746        value = (GLint *) (_valueBase + _bufferOffset);
1747    }
1748    glProgramUniform4iv(
1749        (GLuint)program,
1750        (GLint)location,
1751        (GLsizei)count,
1752        (GLint *)value
1753    );
1754
1755exit:
1756    if (_array) {
1757        _env->ReleaseIntArrayElements(_array, (jint*)value, JNI_ABORT);
1758    }
1759    if (_exception) {
1760        jniThrowException(_env, _exceptionType, _exceptionMessage);
1761    }
1762}
1763
1764/* void glProgramUniform1uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */
1765static void
1766android_glProgramUniform1uiv__III_3II
1767  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) {
1768    jint _exception = 0;
1769    const char * _exceptionType = NULL;
1770    const char * _exceptionMessage = NULL;
1771    GLuint *value_base = (GLuint *) 0;
1772    jint _remaining;
1773    GLuint *value = (GLuint *) 0;
1774
1775    if (!value_ref) {
1776        _exception = 1;
1777        _exceptionType = "java/lang/IllegalArgumentException";
1778        _exceptionMessage = "value == null";
1779        goto exit;
1780    }
1781    if (offset < 0) {
1782        _exception = 1;
1783        _exceptionType = "java/lang/IllegalArgumentException";
1784        _exceptionMessage = "offset < 0";
1785        goto exit;
1786    }
1787    _remaining = _env->GetArrayLength(value_ref) - offset;
1788    value_base = (GLuint *)
1789        _env->GetIntArrayElements(value_ref, (jboolean *)0);
1790    value = value_base + offset;
1791
1792    glProgramUniform1uiv(
1793        (GLuint)program,
1794        (GLint)location,
1795        (GLsizei)count,
1796        (GLuint *)value
1797    );
1798
1799exit:
1800    if (value_base) {
1801        _env->ReleaseIntArrayElements(value_ref, (jint*)value_base,
1802            JNI_ABORT);
1803    }
1804    if (_exception) {
1805        jniThrowException(_env, _exceptionType, _exceptionMessage);
1806    }
1807}
1808
1809/* void glProgramUniform1uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */
1810static void
1811android_glProgramUniform1uiv__IIILjava_nio_IntBuffer_2
1812  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) {
1813    jint _exception = 0;
1814    const char * _exceptionType = NULL;
1815    const char * _exceptionMessage = NULL;
1816    jintArray _array = (jintArray) 0;
1817    jint _bufferOffset = (jint) 0;
1818    jint _remaining;
1819    GLuint *value = (GLuint *) 0;
1820
1821    if (!value_buf) {
1822        _exception = 1;
1823        _exceptionType = "java/lang/IllegalArgumentException";
1824        _exceptionMessage = "value == null";
1825        goto exit;
1826    }
1827    value = (GLuint *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1828    if (value == NULL) {
1829        char * _valueBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1830        value = (GLuint *) (_valueBase + _bufferOffset);
1831    }
1832    glProgramUniform1uiv(
1833        (GLuint)program,
1834        (GLint)location,
1835        (GLsizei)count,
1836        (GLuint *)value
1837    );
1838
1839exit:
1840    if (_array) {
1841        _env->ReleaseIntArrayElements(_array, (jint*)value, JNI_ABORT);
1842    }
1843    if (_exception) {
1844        jniThrowException(_env, _exceptionType, _exceptionMessage);
1845    }
1846}
1847
1848/* void glProgramUniform2uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */
1849static void
1850android_glProgramUniform2uiv__III_3II
1851  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) {
1852    jint _exception = 0;
1853    const char * _exceptionType = NULL;
1854    const char * _exceptionMessage = NULL;
1855    GLuint *value_base = (GLuint *) 0;
1856    jint _remaining;
1857    GLuint *value = (GLuint *) 0;
1858
1859    if (!value_ref) {
1860        _exception = 1;
1861        _exceptionType = "java/lang/IllegalArgumentException";
1862        _exceptionMessage = "value == null";
1863        goto exit;
1864    }
1865    if (offset < 0) {
1866        _exception = 1;
1867        _exceptionType = "java/lang/IllegalArgumentException";
1868        _exceptionMessage = "offset < 0";
1869        goto exit;
1870    }
1871    _remaining = _env->GetArrayLength(value_ref) - offset;
1872    value_base = (GLuint *)
1873        _env->GetIntArrayElements(value_ref, (jboolean *)0);
1874    value = value_base + offset;
1875
1876    glProgramUniform2uiv(
1877        (GLuint)program,
1878        (GLint)location,
1879        (GLsizei)count,
1880        (GLuint *)value
1881    );
1882
1883exit:
1884    if (value_base) {
1885        _env->ReleaseIntArrayElements(value_ref, (jint*)value_base,
1886            JNI_ABORT);
1887    }
1888    if (_exception) {
1889        jniThrowException(_env, _exceptionType, _exceptionMessage);
1890    }
1891}
1892
1893/* void glProgramUniform2uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */
1894static void
1895android_glProgramUniform2uiv__IIILjava_nio_IntBuffer_2
1896  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) {
1897    jint _exception = 0;
1898    const char * _exceptionType = NULL;
1899    const char * _exceptionMessage = NULL;
1900    jintArray _array = (jintArray) 0;
1901    jint _bufferOffset = (jint) 0;
1902    jint _remaining;
1903    GLuint *value = (GLuint *) 0;
1904
1905    if (!value_buf) {
1906        _exception = 1;
1907        _exceptionType = "java/lang/IllegalArgumentException";
1908        _exceptionMessage = "value == null";
1909        goto exit;
1910    }
1911    value = (GLuint *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1912    if (value == NULL) {
1913        char * _valueBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1914        value = (GLuint *) (_valueBase + _bufferOffset);
1915    }
1916    glProgramUniform2uiv(
1917        (GLuint)program,
1918        (GLint)location,
1919        (GLsizei)count,
1920        (GLuint *)value
1921    );
1922
1923exit:
1924    if (_array) {
1925        _env->ReleaseIntArrayElements(_array, (jint*)value, JNI_ABORT);
1926    }
1927    if (_exception) {
1928        jniThrowException(_env, _exceptionType, _exceptionMessage);
1929    }
1930}
1931
1932/* void glProgramUniform3uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */
1933static void
1934android_glProgramUniform3uiv__III_3II
1935  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) {
1936    jint _exception = 0;
1937    const char * _exceptionType = NULL;
1938    const char * _exceptionMessage = NULL;
1939    GLuint *value_base = (GLuint *) 0;
1940    jint _remaining;
1941    GLuint *value = (GLuint *) 0;
1942
1943    if (!value_ref) {
1944        _exception = 1;
1945        _exceptionType = "java/lang/IllegalArgumentException";
1946        _exceptionMessage = "value == null";
1947        goto exit;
1948    }
1949    if (offset < 0) {
1950        _exception = 1;
1951        _exceptionType = "java/lang/IllegalArgumentException";
1952        _exceptionMessage = "offset < 0";
1953        goto exit;
1954    }
1955    _remaining = _env->GetArrayLength(value_ref) - offset;
1956    value_base = (GLuint *)
1957        _env->GetIntArrayElements(value_ref, (jboolean *)0);
1958    value = value_base + offset;
1959
1960    glProgramUniform3uiv(
1961        (GLuint)program,
1962        (GLint)location,
1963        (GLsizei)count,
1964        (GLuint *)value
1965    );
1966
1967exit:
1968    if (value_base) {
1969        _env->ReleaseIntArrayElements(value_ref, (jint*)value_base,
1970            JNI_ABORT);
1971    }
1972    if (_exception) {
1973        jniThrowException(_env, _exceptionType, _exceptionMessage);
1974    }
1975}
1976
1977/* void glProgramUniform3uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */
1978static void
1979android_glProgramUniform3uiv__IIILjava_nio_IntBuffer_2
1980  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) {
1981    jint _exception = 0;
1982    const char * _exceptionType = NULL;
1983    const char * _exceptionMessage = NULL;
1984    jintArray _array = (jintArray) 0;
1985    jint _bufferOffset = (jint) 0;
1986    jint _remaining;
1987    GLuint *value = (GLuint *) 0;
1988
1989    if (!value_buf) {
1990        _exception = 1;
1991        _exceptionType = "java/lang/IllegalArgumentException";
1992        _exceptionMessage = "value == null";
1993        goto exit;
1994    }
1995    value = (GLuint *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1996    if (value == NULL) {
1997        char * _valueBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1998        value = (GLuint *) (_valueBase + _bufferOffset);
1999    }
2000    glProgramUniform3uiv(
2001        (GLuint)program,
2002        (GLint)location,
2003        (GLsizei)count,
2004        (GLuint *)value
2005    );
2006
2007exit:
2008    if (_array) {
2009        _env->ReleaseIntArrayElements(_array, (jint*)value, JNI_ABORT);
2010    }
2011    if (_exception) {
2012        jniThrowException(_env, _exceptionType, _exceptionMessage);
2013    }
2014}
2015
2016/* void glProgramUniform4uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */
2017static void
2018android_glProgramUniform4uiv__III_3II
2019  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) {
2020    jint _exception = 0;
2021    const char * _exceptionType = NULL;
2022    const char * _exceptionMessage = NULL;
2023    GLuint *value_base = (GLuint *) 0;
2024    jint _remaining;
2025    GLuint *value = (GLuint *) 0;
2026
2027    if (!value_ref) {
2028        _exception = 1;
2029        _exceptionType = "java/lang/IllegalArgumentException";
2030        _exceptionMessage = "value == null";
2031        goto exit;
2032    }
2033    if (offset < 0) {
2034        _exception = 1;
2035        _exceptionType = "java/lang/IllegalArgumentException";
2036        _exceptionMessage = "offset < 0";
2037        goto exit;
2038    }
2039    _remaining = _env->GetArrayLength(value_ref) - offset;
2040    value_base = (GLuint *)
2041        _env->GetIntArrayElements(value_ref, (jboolean *)0);
2042    value = value_base + offset;
2043
2044    glProgramUniform4uiv(
2045        (GLuint)program,
2046        (GLint)location,
2047        (GLsizei)count,
2048        (GLuint *)value
2049    );
2050
2051exit:
2052    if (value_base) {
2053        _env->ReleaseIntArrayElements(value_ref, (jint*)value_base,
2054            JNI_ABORT);
2055    }
2056    if (_exception) {
2057        jniThrowException(_env, _exceptionType, _exceptionMessage);
2058    }
2059}
2060
2061/* void glProgramUniform4uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */
2062static void
2063android_glProgramUniform4uiv__IIILjava_nio_IntBuffer_2
2064  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) {
2065    jint _exception = 0;
2066    const char * _exceptionType = NULL;
2067    const char * _exceptionMessage = NULL;
2068    jintArray _array = (jintArray) 0;
2069    jint _bufferOffset = (jint) 0;
2070    jint _remaining;
2071    GLuint *value = (GLuint *) 0;
2072
2073    if (!value_buf) {
2074        _exception = 1;
2075        _exceptionType = "java/lang/IllegalArgumentException";
2076        _exceptionMessage = "value == null";
2077        goto exit;
2078    }
2079    value = (GLuint *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2080    if (value == NULL) {
2081        char * _valueBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
2082        value = (GLuint *) (_valueBase + _bufferOffset);
2083    }
2084    glProgramUniform4uiv(
2085        (GLuint)program,
2086        (GLint)location,
2087        (GLsizei)count,
2088        (GLuint *)value
2089    );
2090
2091exit:
2092    if (_array) {
2093        _env->ReleaseIntArrayElements(_array, (jint*)value, JNI_ABORT);
2094    }
2095    if (_exception) {
2096        jniThrowException(_env, _exceptionType, _exceptionMessage);
2097    }
2098}
2099
2100/* void glProgramUniform1fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */
2101static void
2102android_glProgramUniform1fv__III_3FI
2103  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jfloatArray value_ref, jint offset) {
2104    jint _exception = 0;
2105    const char * _exceptionType = NULL;
2106    const char * _exceptionMessage = NULL;
2107    GLfloat *value_base = (GLfloat *) 0;
2108    jint _remaining;
2109    GLfloat *value = (GLfloat *) 0;
2110
2111    if (!value_ref) {
2112        _exception = 1;
2113        _exceptionType = "java/lang/IllegalArgumentException";
2114        _exceptionMessage = "value == null";
2115        goto exit;
2116    }
2117    if (offset < 0) {
2118        _exception = 1;
2119        _exceptionType = "java/lang/IllegalArgumentException";
2120        _exceptionMessage = "offset < 0";
2121        goto exit;
2122    }
2123    _remaining = _env->GetArrayLength(value_ref) - offset;
2124    value_base = (GLfloat *)
2125        _env->GetFloatArrayElements(value_ref, (jboolean *)0);
2126    value = value_base + offset;
2127
2128    glProgramUniform1fv(
2129        (GLuint)program,
2130        (GLint)location,
2131        (GLsizei)count,
2132        (GLfloat *)value
2133    );
2134
2135exit:
2136    if (value_base) {
2137        _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base,
2138            JNI_ABORT);
2139    }
2140    if (_exception) {
2141        jniThrowException(_env, _exceptionType, _exceptionMessage);
2142    }
2143}
2144
2145/* void glProgramUniform1fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */
2146static void
2147android_glProgramUniform1fv__IIILjava_nio_FloatBuffer_2
2148  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) {
2149    jint _exception = 0;
2150    const char * _exceptionType = NULL;
2151    const char * _exceptionMessage = NULL;
2152    jfloatArray _array = (jfloatArray) 0;
2153    jint _bufferOffset = (jint) 0;
2154    jint _remaining;
2155    GLfloat *value = (GLfloat *) 0;
2156
2157    if (!value_buf) {
2158        _exception = 1;
2159        _exceptionType = "java/lang/IllegalArgumentException";
2160        _exceptionMessage = "value == null";
2161        goto exit;
2162    }
2163    value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2164    if (value == NULL) {
2165        char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
2166        value = (GLfloat *) (_valueBase + _bufferOffset);
2167    }
2168    glProgramUniform1fv(
2169        (GLuint)program,
2170        (GLint)location,
2171        (GLsizei)count,
2172        (GLfloat *)value
2173    );
2174
2175exit:
2176    if (_array) {
2177        _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT);
2178    }
2179    if (_exception) {
2180        jniThrowException(_env, _exceptionType, _exceptionMessage);
2181    }
2182}
2183
2184/* void glProgramUniform2fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */
2185static void
2186android_glProgramUniform2fv__III_3FI
2187  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jfloatArray value_ref, jint offset) {
2188    jint _exception = 0;
2189    const char * _exceptionType = NULL;
2190    const char * _exceptionMessage = NULL;
2191    GLfloat *value_base = (GLfloat *) 0;
2192    jint _remaining;
2193    GLfloat *value = (GLfloat *) 0;
2194
2195    if (!value_ref) {
2196        _exception = 1;
2197        _exceptionType = "java/lang/IllegalArgumentException";
2198        _exceptionMessage = "value == null";
2199        goto exit;
2200    }
2201    if (offset < 0) {
2202        _exception = 1;
2203        _exceptionType = "java/lang/IllegalArgumentException";
2204        _exceptionMessage = "offset < 0";
2205        goto exit;
2206    }
2207    _remaining = _env->GetArrayLength(value_ref) - offset;
2208    value_base = (GLfloat *)
2209        _env->GetFloatArrayElements(value_ref, (jboolean *)0);
2210    value = value_base + offset;
2211
2212    glProgramUniform2fv(
2213        (GLuint)program,
2214        (GLint)location,
2215        (GLsizei)count,
2216        (GLfloat *)value
2217    );
2218
2219exit:
2220    if (value_base) {
2221        _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base,
2222            JNI_ABORT);
2223    }
2224    if (_exception) {
2225        jniThrowException(_env, _exceptionType, _exceptionMessage);
2226    }
2227}
2228
2229/* void glProgramUniform2fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */
2230static void
2231android_glProgramUniform2fv__IIILjava_nio_FloatBuffer_2
2232  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) {
2233    jint _exception = 0;
2234    const char * _exceptionType = NULL;
2235    const char * _exceptionMessage = NULL;
2236    jfloatArray _array = (jfloatArray) 0;
2237    jint _bufferOffset = (jint) 0;
2238    jint _remaining;
2239    GLfloat *value = (GLfloat *) 0;
2240
2241    if (!value_buf) {
2242        _exception = 1;
2243        _exceptionType = "java/lang/IllegalArgumentException";
2244        _exceptionMessage = "value == null";
2245        goto exit;
2246    }
2247    value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2248    if (value == NULL) {
2249        char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
2250        value = (GLfloat *) (_valueBase + _bufferOffset);
2251    }
2252    glProgramUniform2fv(
2253        (GLuint)program,
2254        (GLint)location,
2255        (GLsizei)count,
2256        (GLfloat *)value
2257    );
2258
2259exit:
2260    if (_array) {
2261        _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT);
2262    }
2263    if (_exception) {
2264        jniThrowException(_env, _exceptionType, _exceptionMessage);
2265    }
2266}
2267
2268/* void glProgramUniform3fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */
2269static void
2270android_glProgramUniform3fv__III_3FI
2271  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jfloatArray value_ref, jint offset) {
2272    jint _exception = 0;
2273    const char * _exceptionType = NULL;
2274    const char * _exceptionMessage = NULL;
2275    GLfloat *value_base = (GLfloat *) 0;
2276    jint _remaining;
2277    GLfloat *value = (GLfloat *) 0;
2278
2279    if (!value_ref) {
2280        _exception = 1;
2281        _exceptionType = "java/lang/IllegalArgumentException";
2282        _exceptionMessage = "value == null";
2283        goto exit;
2284    }
2285    if (offset < 0) {
2286        _exception = 1;
2287        _exceptionType = "java/lang/IllegalArgumentException";
2288        _exceptionMessage = "offset < 0";
2289        goto exit;
2290    }
2291    _remaining = _env->GetArrayLength(value_ref) - offset;
2292    value_base = (GLfloat *)
2293        _env->GetFloatArrayElements(value_ref, (jboolean *)0);
2294    value = value_base + offset;
2295
2296    glProgramUniform3fv(
2297        (GLuint)program,
2298        (GLint)location,
2299        (GLsizei)count,
2300        (GLfloat *)value
2301    );
2302
2303exit:
2304    if (value_base) {
2305        _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base,
2306            JNI_ABORT);
2307    }
2308    if (_exception) {
2309        jniThrowException(_env, _exceptionType, _exceptionMessage);
2310    }
2311}
2312
2313/* void glProgramUniform3fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */
2314static void
2315android_glProgramUniform3fv__IIILjava_nio_FloatBuffer_2
2316  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) {
2317    jint _exception = 0;
2318    const char * _exceptionType = NULL;
2319    const char * _exceptionMessage = NULL;
2320    jfloatArray _array = (jfloatArray) 0;
2321    jint _bufferOffset = (jint) 0;
2322    jint _remaining;
2323    GLfloat *value = (GLfloat *) 0;
2324
2325    if (!value_buf) {
2326        _exception = 1;
2327        _exceptionType = "java/lang/IllegalArgumentException";
2328        _exceptionMessage = "value == null";
2329        goto exit;
2330    }
2331    value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2332    if (value == NULL) {
2333        char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
2334        value = (GLfloat *) (_valueBase + _bufferOffset);
2335    }
2336    glProgramUniform3fv(
2337        (GLuint)program,
2338        (GLint)location,
2339        (GLsizei)count,
2340        (GLfloat *)value
2341    );
2342
2343exit:
2344    if (_array) {
2345        _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT);
2346    }
2347    if (_exception) {
2348        jniThrowException(_env, _exceptionType, _exceptionMessage);
2349    }
2350}
2351
2352/* void glProgramUniform4fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */
2353static void
2354android_glProgramUniform4fv__III_3FI
2355  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jfloatArray value_ref, jint offset) {
2356    jint _exception = 0;
2357    const char * _exceptionType = NULL;
2358    const char * _exceptionMessage = NULL;
2359    GLfloat *value_base = (GLfloat *) 0;
2360    jint _remaining;
2361    GLfloat *value = (GLfloat *) 0;
2362
2363    if (!value_ref) {
2364        _exception = 1;
2365        _exceptionType = "java/lang/IllegalArgumentException";
2366        _exceptionMessage = "value == null";
2367        goto exit;
2368    }
2369    if (offset < 0) {
2370        _exception = 1;
2371        _exceptionType = "java/lang/IllegalArgumentException";
2372        _exceptionMessage = "offset < 0";
2373        goto exit;
2374    }
2375    _remaining = _env->GetArrayLength(value_ref) - offset;
2376    value_base = (GLfloat *)
2377        _env->GetFloatArrayElements(value_ref, (jboolean *)0);
2378    value = value_base + offset;
2379
2380    glProgramUniform4fv(
2381        (GLuint)program,
2382        (GLint)location,
2383        (GLsizei)count,
2384        (GLfloat *)value
2385    );
2386
2387exit:
2388    if (value_base) {
2389        _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base,
2390            JNI_ABORT);
2391    }
2392    if (_exception) {
2393        jniThrowException(_env, _exceptionType, _exceptionMessage);
2394    }
2395}
2396
2397/* void glProgramUniform4fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */
2398static void
2399android_glProgramUniform4fv__IIILjava_nio_FloatBuffer_2
2400  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) {
2401    jint _exception = 0;
2402    const char * _exceptionType = NULL;
2403    const char * _exceptionMessage = NULL;
2404    jfloatArray _array = (jfloatArray) 0;
2405    jint _bufferOffset = (jint) 0;
2406    jint _remaining;
2407    GLfloat *value = (GLfloat *) 0;
2408
2409    if (!value_buf) {
2410        _exception = 1;
2411        _exceptionType = "java/lang/IllegalArgumentException";
2412        _exceptionMessage = "value == null";
2413        goto exit;
2414    }
2415    value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2416    if (value == NULL) {
2417        char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
2418        value = (GLfloat *) (_valueBase + _bufferOffset);
2419    }
2420    glProgramUniform4fv(
2421        (GLuint)program,
2422        (GLint)location,
2423        (GLsizei)count,
2424        (GLfloat *)value
2425    );
2426
2427exit:
2428    if (_array) {
2429        _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT);
2430    }
2431    if (_exception) {
2432        jniThrowException(_env, _exceptionType, _exceptionMessage);
2433    }
2434}
2435
2436/* void glProgramUniformMatrix2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
2437static void
2438android_glProgramUniformMatrix2fv__IIIZ_3FI
2439  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) {
2440    jint _exception = 0;
2441    const char * _exceptionType = NULL;
2442    const char * _exceptionMessage = NULL;
2443    GLfloat *value_base = (GLfloat *) 0;
2444    jint _remaining;
2445    GLfloat *value = (GLfloat *) 0;
2446
2447    if (!value_ref) {
2448        _exception = 1;
2449        _exceptionType = "java/lang/IllegalArgumentException";
2450        _exceptionMessage = "value == null";
2451        goto exit;
2452    }
2453    if (offset < 0) {
2454        _exception = 1;
2455        _exceptionType = "java/lang/IllegalArgumentException";
2456        _exceptionMessage = "offset < 0";
2457        goto exit;
2458    }
2459    _remaining = _env->GetArrayLength(value_ref) - offset;
2460    value_base = (GLfloat *)
2461        _env->GetFloatArrayElements(value_ref, (jboolean *)0);
2462    value = value_base + offset;
2463
2464    glProgramUniformMatrix2fv(
2465        (GLuint)program,
2466        (GLint)location,
2467        (GLsizei)count,
2468        (GLboolean)transpose,
2469        (GLfloat *)value
2470    );
2471
2472exit:
2473    if (value_base) {
2474        _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base,
2475            JNI_ABORT);
2476    }
2477    if (_exception) {
2478        jniThrowException(_env, _exceptionType, _exceptionMessage);
2479    }
2480}
2481
2482/* void glProgramUniformMatrix2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
2483static void
2484android_glProgramUniformMatrix2fv__IIIZLjava_nio_FloatBuffer_2
2485  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) {
2486    jint _exception = 0;
2487    const char * _exceptionType = NULL;
2488    const char * _exceptionMessage = NULL;
2489    jfloatArray _array = (jfloatArray) 0;
2490    jint _bufferOffset = (jint) 0;
2491    jint _remaining;
2492    GLfloat *value = (GLfloat *) 0;
2493
2494    if (!value_buf) {
2495        _exception = 1;
2496        _exceptionType = "java/lang/IllegalArgumentException";
2497        _exceptionMessage = "value == null";
2498        goto exit;
2499    }
2500    value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2501    if (value == NULL) {
2502        char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
2503        value = (GLfloat *) (_valueBase + _bufferOffset);
2504    }
2505    glProgramUniformMatrix2fv(
2506        (GLuint)program,
2507        (GLint)location,
2508        (GLsizei)count,
2509        (GLboolean)transpose,
2510        (GLfloat *)value
2511    );
2512
2513exit:
2514    if (_array) {
2515        _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT);
2516    }
2517    if (_exception) {
2518        jniThrowException(_env, _exceptionType, _exceptionMessage);
2519    }
2520}
2521
2522/* void glProgramUniformMatrix3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
2523static void
2524android_glProgramUniformMatrix3fv__IIIZ_3FI
2525  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) {
2526    jint _exception = 0;
2527    const char * _exceptionType = NULL;
2528    const char * _exceptionMessage = NULL;
2529    GLfloat *value_base = (GLfloat *) 0;
2530    jint _remaining;
2531    GLfloat *value = (GLfloat *) 0;
2532
2533    if (!value_ref) {
2534        _exception = 1;
2535        _exceptionType = "java/lang/IllegalArgumentException";
2536        _exceptionMessage = "value == null";
2537        goto exit;
2538    }
2539    if (offset < 0) {
2540        _exception = 1;
2541        _exceptionType = "java/lang/IllegalArgumentException";
2542        _exceptionMessage = "offset < 0";
2543        goto exit;
2544    }
2545    _remaining = _env->GetArrayLength(value_ref) - offset;
2546    value_base = (GLfloat *)
2547        _env->GetFloatArrayElements(value_ref, (jboolean *)0);
2548    value = value_base + offset;
2549
2550    glProgramUniformMatrix3fv(
2551        (GLuint)program,
2552        (GLint)location,
2553        (GLsizei)count,
2554        (GLboolean)transpose,
2555        (GLfloat *)value
2556    );
2557
2558exit:
2559    if (value_base) {
2560        _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base,
2561            JNI_ABORT);
2562    }
2563    if (_exception) {
2564        jniThrowException(_env, _exceptionType, _exceptionMessage);
2565    }
2566}
2567
2568/* void glProgramUniformMatrix3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
2569static void
2570android_glProgramUniformMatrix3fv__IIIZLjava_nio_FloatBuffer_2
2571  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) {
2572    jint _exception = 0;
2573    const char * _exceptionType = NULL;
2574    const char * _exceptionMessage = NULL;
2575    jfloatArray _array = (jfloatArray) 0;
2576    jint _bufferOffset = (jint) 0;
2577    jint _remaining;
2578    GLfloat *value = (GLfloat *) 0;
2579
2580    if (!value_buf) {
2581        _exception = 1;
2582        _exceptionType = "java/lang/IllegalArgumentException";
2583        _exceptionMessage = "value == null";
2584        goto exit;
2585    }
2586    value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2587    if (value == NULL) {
2588        char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
2589        value = (GLfloat *) (_valueBase + _bufferOffset);
2590    }
2591    glProgramUniformMatrix3fv(
2592        (GLuint)program,
2593        (GLint)location,
2594        (GLsizei)count,
2595        (GLboolean)transpose,
2596        (GLfloat *)value
2597    );
2598
2599exit:
2600    if (_array) {
2601        _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT);
2602    }
2603    if (_exception) {
2604        jniThrowException(_env, _exceptionType, _exceptionMessage);
2605    }
2606}
2607
2608/* void glProgramUniformMatrix4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
2609static void
2610android_glProgramUniformMatrix4fv__IIIZ_3FI
2611  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) {
2612    jint _exception = 0;
2613    const char * _exceptionType = NULL;
2614    const char * _exceptionMessage = NULL;
2615    GLfloat *value_base = (GLfloat *) 0;
2616    jint _remaining;
2617    GLfloat *value = (GLfloat *) 0;
2618
2619    if (!value_ref) {
2620        _exception = 1;
2621        _exceptionType = "java/lang/IllegalArgumentException";
2622        _exceptionMessage = "value == null";
2623        goto exit;
2624    }
2625    if (offset < 0) {
2626        _exception = 1;
2627        _exceptionType = "java/lang/IllegalArgumentException";
2628        _exceptionMessage = "offset < 0";
2629        goto exit;
2630    }
2631    _remaining = _env->GetArrayLength(value_ref) - offset;
2632    value_base = (GLfloat *)
2633        _env->GetFloatArrayElements(value_ref, (jboolean *)0);
2634    value = value_base + offset;
2635
2636    glProgramUniformMatrix4fv(
2637        (GLuint)program,
2638        (GLint)location,
2639        (GLsizei)count,
2640        (GLboolean)transpose,
2641        (GLfloat *)value
2642    );
2643
2644exit:
2645    if (value_base) {
2646        _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base,
2647            JNI_ABORT);
2648    }
2649    if (_exception) {
2650        jniThrowException(_env, _exceptionType, _exceptionMessage);
2651    }
2652}
2653
2654/* void glProgramUniformMatrix4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
2655static void
2656android_glProgramUniformMatrix4fv__IIIZLjava_nio_FloatBuffer_2
2657  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) {
2658    jint _exception = 0;
2659    const char * _exceptionType = NULL;
2660    const char * _exceptionMessage = NULL;
2661    jfloatArray _array = (jfloatArray) 0;
2662    jint _bufferOffset = (jint) 0;
2663    jint _remaining;
2664    GLfloat *value = (GLfloat *) 0;
2665
2666    if (!value_buf) {
2667        _exception = 1;
2668        _exceptionType = "java/lang/IllegalArgumentException";
2669        _exceptionMessage = "value == null";
2670        goto exit;
2671    }
2672    value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2673    if (value == NULL) {
2674        char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
2675        value = (GLfloat *) (_valueBase + _bufferOffset);
2676    }
2677    glProgramUniformMatrix4fv(
2678        (GLuint)program,
2679        (GLint)location,
2680        (GLsizei)count,
2681        (GLboolean)transpose,
2682        (GLfloat *)value
2683    );
2684
2685exit:
2686    if (_array) {
2687        _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT);
2688    }
2689    if (_exception) {
2690        jniThrowException(_env, _exceptionType, _exceptionMessage);
2691    }
2692}
2693
2694/* void glProgramUniformMatrix2x3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
2695static void
2696android_glProgramUniformMatrix2x3fv__IIIZ_3FI
2697  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) {
2698    jint _exception = 0;
2699    const char * _exceptionType = NULL;
2700    const char * _exceptionMessage = NULL;
2701    GLfloat *value_base = (GLfloat *) 0;
2702    jint _remaining;
2703    GLfloat *value = (GLfloat *) 0;
2704
2705    if (!value_ref) {
2706        _exception = 1;
2707        _exceptionType = "java/lang/IllegalArgumentException";
2708        _exceptionMessage = "value == null";
2709        goto exit;
2710    }
2711    if (offset < 0) {
2712        _exception = 1;
2713        _exceptionType = "java/lang/IllegalArgumentException";
2714        _exceptionMessage = "offset < 0";
2715        goto exit;
2716    }
2717    _remaining = _env->GetArrayLength(value_ref) - offset;
2718    value_base = (GLfloat *)
2719        _env->GetFloatArrayElements(value_ref, (jboolean *)0);
2720    value = value_base + offset;
2721
2722    glProgramUniformMatrix2x3fv(
2723        (GLuint)program,
2724        (GLint)location,
2725        (GLsizei)count,
2726        (GLboolean)transpose,
2727        (GLfloat *)value
2728    );
2729
2730exit:
2731    if (value_base) {
2732        _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base,
2733            JNI_ABORT);
2734    }
2735    if (_exception) {
2736        jniThrowException(_env, _exceptionType, _exceptionMessage);
2737    }
2738}
2739
2740/* void glProgramUniformMatrix2x3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
2741static void
2742android_glProgramUniformMatrix2x3fv__IIIZLjava_nio_FloatBuffer_2
2743  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) {
2744    jint _exception = 0;
2745    const char * _exceptionType = NULL;
2746    const char * _exceptionMessage = NULL;
2747    jfloatArray _array = (jfloatArray) 0;
2748    jint _bufferOffset = (jint) 0;
2749    jint _remaining;
2750    GLfloat *value = (GLfloat *) 0;
2751
2752    if (!value_buf) {
2753        _exception = 1;
2754        _exceptionType = "java/lang/IllegalArgumentException";
2755        _exceptionMessage = "value == null";
2756        goto exit;
2757    }
2758    value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2759    if (value == NULL) {
2760        char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
2761        value = (GLfloat *) (_valueBase + _bufferOffset);
2762    }
2763    glProgramUniformMatrix2x3fv(
2764        (GLuint)program,
2765        (GLint)location,
2766        (GLsizei)count,
2767        (GLboolean)transpose,
2768        (GLfloat *)value
2769    );
2770
2771exit:
2772    if (_array) {
2773        _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT);
2774    }
2775    if (_exception) {
2776        jniThrowException(_env, _exceptionType, _exceptionMessage);
2777    }
2778}
2779
2780/* void glProgramUniformMatrix3x2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
2781static void
2782android_glProgramUniformMatrix3x2fv__IIIZ_3FI
2783  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) {
2784    jint _exception = 0;
2785    const char * _exceptionType = NULL;
2786    const char * _exceptionMessage = NULL;
2787    GLfloat *value_base = (GLfloat *) 0;
2788    jint _remaining;
2789    GLfloat *value = (GLfloat *) 0;
2790
2791    if (!value_ref) {
2792        _exception = 1;
2793        _exceptionType = "java/lang/IllegalArgumentException";
2794        _exceptionMessage = "value == null";
2795        goto exit;
2796    }
2797    if (offset < 0) {
2798        _exception = 1;
2799        _exceptionType = "java/lang/IllegalArgumentException";
2800        _exceptionMessage = "offset < 0";
2801        goto exit;
2802    }
2803    _remaining = _env->GetArrayLength(value_ref) - offset;
2804    value_base = (GLfloat *)
2805        _env->GetFloatArrayElements(value_ref, (jboolean *)0);
2806    value = value_base + offset;
2807
2808    glProgramUniformMatrix3x2fv(
2809        (GLuint)program,
2810        (GLint)location,
2811        (GLsizei)count,
2812        (GLboolean)transpose,
2813        (GLfloat *)value
2814    );
2815
2816exit:
2817    if (value_base) {
2818        _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base,
2819            JNI_ABORT);
2820    }
2821    if (_exception) {
2822        jniThrowException(_env, _exceptionType, _exceptionMessage);
2823    }
2824}
2825
2826/* void glProgramUniformMatrix3x2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
2827static void
2828android_glProgramUniformMatrix3x2fv__IIIZLjava_nio_FloatBuffer_2
2829  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) {
2830    jint _exception = 0;
2831    const char * _exceptionType = NULL;
2832    const char * _exceptionMessage = NULL;
2833    jfloatArray _array = (jfloatArray) 0;
2834    jint _bufferOffset = (jint) 0;
2835    jint _remaining;
2836    GLfloat *value = (GLfloat *) 0;
2837
2838    if (!value_buf) {
2839        _exception = 1;
2840        _exceptionType = "java/lang/IllegalArgumentException";
2841        _exceptionMessage = "value == null";
2842        goto exit;
2843    }
2844    value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2845    if (value == NULL) {
2846        char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
2847        value = (GLfloat *) (_valueBase + _bufferOffset);
2848    }
2849    glProgramUniformMatrix3x2fv(
2850        (GLuint)program,
2851        (GLint)location,
2852        (GLsizei)count,
2853        (GLboolean)transpose,
2854        (GLfloat *)value
2855    );
2856
2857exit:
2858    if (_array) {
2859        _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT);
2860    }
2861    if (_exception) {
2862        jniThrowException(_env, _exceptionType, _exceptionMessage);
2863    }
2864}
2865
2866/* void glProgramUniformMatrix2x4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
2867static void
2868android_glProgramUniformMatrix2x4fv__IIIZ_3FI
2869  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) {
2870    jint _exception = 0;
2871    const char * _exceptionType = NULL;
2872    const char * _exceptionMessage = NULL;
2873    GLfloat *value_base = (GLfloat *) 0;
2874    jint _remaining;
2875    GLfloat *value = (GLfloat *) 0;
2876
2877    if (!value_ref) {
2878        _exception = 1;
2879        _exceptionType = "java/lang/IllegalArgumentException";
2880        _exceptionMessage = "value == null";
2881        goto exit;
2882    }
2883    if (offset < 0) {
2884        _exception = 1;
2885        _exceptionType = "java/lang/IllegalArgumentException";
2886        _exceptionMessage = "offset < 0";
2887        goto exit;
2888    }
2889    _remaining = _env->GetArrayLength(value_ref) - offset;
2890    value_base = (GLfloat *)
2891        _env->GetFloatArrayElements(value_ref, (jboolean *)0);
2892    value = value_base + offset;
2893
2894    glProgramUniformMatrix2x4fv(
2895        (GLuint)program,
2896        (GLint)location,
2897        (GLsizei)count,
2898        (GLboolean)transpose,
2899        (GLfloat *)value
2900    );
2901
2902exit:
2903    if (value_base) {
2904        _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base,
2905            JNI_ABORT);
2906    }
2907    if (_exception) {
2908        jniThrowException(_env, _exceptionType, _exceptionMessage);
2909    }
2910}
2911
2912/* void glProgramUniformMatrix2x4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
2913static void
2914android_glProgramUniformMatrix2x4fv__IIIZLjava_nio_FloatBuffer_2
2915  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) {
2916    jint _exception = 0;
2917    const char * _exceptionType = NULL;
2918    const char * _exceptionMessage = NULL;
2919    jfloatArray _array = (jfloatArray) 0;
2920    jint _bufferOffset = (jint) 0;
2921    jint _remaining;
2922    GLfloat *value = (GLfloat *) 0;
2923
2924    if (!value_buf) {
2925        _exception = 1;
2926        _exceptionType = "java/lang/IllegalArgumentException";
2927        _exceptionMessage = "value == null";
2928        goto exit;
2929    }
2930    value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2931    if (value == NULL) {
2932        char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
2933        value = (GLfloat *) (_valueBase + _bufferOffset);
2934    }
2935    glProgramUniformMatrix2x4fv(
2936        (GLuint)program,
2937        (GLint)location,
2938        (GLsizei)count,
2939        (GLboolean)transpose,
2940        (GLfloat *)value
2941    );
2942
2943exit:
2944    if (_array) {
2945        _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT);
2946    }
2947    if (_exception) {
2948        jniThrowException(_env, _exceptionType, _exceptionMessage);
2949    }
2950}
2951
2952/* void glProgramUniformMatrix4x2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
2953static void
2954android_glProgramUniformMatrix4x2fv__IIIZ_3FI
2955  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) {
2956    jint _exception = 0;
2957    const char * _exceptionType = NULL;
2958    const char * _exceptionMessage = NULL;
2959    GLfloat *value_base = (GLfloat *) 0;
2960    jint _remaining;
2961    GLfloat *value = (GLfloat *) 0;
2962
2963    if (!value_ref) {
2964        _exception = 1;
2965        _exceptionType = "java/lang/IllegalArgumentException";
2966        _exceptionMessage = "value == null";
2967        goto exit;
2968    }
2969    if (offset < 0) {
2970        _exception = 1;
2971        _exceptionType = "java/lang/IllegalArgumentException";
2972        _exceptionMessage = "offset < 0";
2973        goto exit;
2974    }
2975    _remaining = _env->GetArrayLength(value_ref) - offset;
2976    value_base = (GLfloat *)
2977        _env->GetFloatArrayElements(value_ref, (jboolean *)0);
2978    value = value_base + offset;
2979
2980    glProgramUniformMatrix4x2fv(
2981        (GLuint)program,
2982        (GLint)location,
2983        (GLsizei)count,
2984        (GLboolean)transpose,
2985        (GLfloat *)value
2986    );
2987
2988exit:
2989    if (value_base) {
2990        _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base,
2991            JNI_ABORT);
2992    }
2993    if (_exception) {
2994        jniThrowException(_env, _exceptionType, _exceptionMessage);
2995    }
2996}
2997
2998/* void glProgramUniformMatrix4x2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
2999static void
3000android_glProgramUniformMatrix4x2fv__IIIZLjava_nio_FloatBuffer_2
3001  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) {
3002    jint _exception = 0;
3003    const char * _exceptionType = NULL;
3004    const char * _exceptionMessage = NULL;
3005    jfloatArray _array = (jfloatArray) 0;
3006    jint _bufferOffset = (jint) 0;
3007    jint _remaining;
3008    GLfloat *value = (GLfloat *) 0;
3009
3010    if (!value_buf) {
3011        _exception = 1;
3012        _exceptionType = "java/lang/IllegalArgumentException";
3013        _exceptionMessage = "value == null";
3014        goto exit;
3015    }
3016    value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
3017    if (value == NULL) {
3018        char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
3019        value = (GLfloat *) (_valueBase + _bufferOffset);
3020    }
3021    glProgramUniformMatrix4x2fv(
3022        (GLuint)program,
3023        (GLint)location,
3024        (GLsizei)count,
3025        (GLboolean)transpose,
3026        (GLfloat *)value
3027    );
3028
3029exit:
3030    if (_array) {
3031        _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT);
3032    }
3033    if (_exception) {
3034        jniThrowException(_env, _exceptionType, _exceptionMessage);
3035    }
3036}
3037
3038/* void glProgramUniformMatrix3x4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
3039static void
3040android_glProgramUniformMatrix3x4fv__IIIZ_3FI
3041  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) {
3042    jint _exception = 0;
3043    const char * _exceptionType = NULL;
3044    const char * _exceptionMessage = NULL;
3045    GLfloat *value_base = (GLfloat *) 0;
3046    jint _remaining;
3047    GLfloat *value = (GLfloat *) 0;
3048
3049    if (!value_ref) {
3050        _exception = 1;
3051        _exceptionType = "java/lang/IllegalArgumentException";
3052        _exceptionMessage = "value == null";
3053        goto exit;
3054    }
3055    if (offset < 0) {
3056        _exception = 1;
3057        _exceptionType = "java/lang/IllegalArgumentException";
3058        _exceptionMessage = "offset < 0";
3059        goto exit;
3060    }
3061    _remaining = _env->GetArrayLength(value_ref) - offset;
3062    value_base = (GLfloat *)
3063        _env->GetFloatArrayElements(value_ref, (jboolean *)0);
3064    value = value_base + offset;
3065
3066    glProgramUniformMatrix3x4fv(
3067        (GLuint)program,
3068        (GLint)location,
3069        (GLsizei)count,
3070        (GLboolean)transpose,
3071        (GLfloat *)value
3072    );
3073
3074exit:
3075    if (value_base) {
3076        _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base,
3077            JNI_ABORT);
3078    }
3079    if (_exception) {
3080        jniThrowException(_env, _exceptionType, _exceptionMessage);
3081    }
3082}
3083
3084/* void glProgramUniformMatrix3x4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
3085static void
3086android_glProgramUniformMatrix3x4fv__IIIZLjava_nio_FloatBuffer_2
3087  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) {
3088    jint _exception = 0;
3089    const char * _exceptionType = NULL;
3090    const char * _exceptionMessage = NULL;
3091    jfloatArray _array = (jfloatArray) 0;
3092    jint _bufferOffset = (jint) 0;
3093    jint _remaining;
3094    GLfloat *value = (GLfloat *) 0;
3095
3096    if (!value_buf) {
3097        _exception = 1;
3098        _exceptionType = "java/lang/IllegalArgumentException";
3099        _exceptionMessage = "value == null";
3100        goto exit;
3101    }
3102    value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
3103    if (value == NULL) {
3104        char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
3105        value = (GLfloat *) (_valueBase + _bufferOffset);
3106    }
3107    glProgramUniformMatrix3x4fv(
3108        (GLuint)program,
3109        (GLint)location,
3110        (GLsizei)count,
3111        (GLboolean)transpose,
3112        (GLfloat *)value
3113    );
3114
3115exit:
3116    if (_array) {
3117        _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT);
3118    }
3119    if (_exception) {
3120        jniThrowException(_env, _exceptionType, _exceptionMessage);
3121    }
3122}
3123
3124/* void glProgramUniformMatrix4x3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
3125static void
3126android_glProgramUniformMatrix4x3fv__IIIZ_3FI
3127  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) {
3128    jint _exception = 0;
3129    const char * _exceptionType = NULL;
3130    const char * _exceptionMessage = NULL;
3131    GLfloat *value_base = (GLfloat *) 0;
3132    jint _remaining;
3133    GLfloat *value = (GLfloat *) 0;
3134
3135    if (!value_ref) {
3136        _exception = 1;
3137        _exceptionType = "java/lang/IllegalArgumentException";
3138        _exceptionMessage = "value == null";
3139        goto exit;
3140    }
3141    if (offset < 0) {
3142        _exception = 1;
3143        _exceptionType = "java/lang/IllegalArgumentException";
3144        _exceptionMessage = "offset < 0";
3145        goto exit;
3146    }
3147    _remaining = _env->GetArrayLength(value_ref) - offset;
3148    value_base = (GLfloat *)
3149        _env->GetFloatArrayElements(value_ref, (jboolean *)0);
3150    value = value_base + offset;
3151
3152    glProgramUniformMatrix4x3fv(
3153        (GLuint)program,
3154        (GLint)location,
3155        (GLsizei)count,
3156        (GLboolean)transpose,
3157        (GLfloat *)value
3158    );
3159
3160exit:
3161    if (value_base) {
3162        _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base,
3163            JNI_ABORT);
3164    }
3165    if (_exception) {
3166        jniThrowException(_env, _exceptionType, _exceptionMessage);
3167    }
3168}
3169
3170/* void glProgramUniformMatrix4x3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
3171static void
3172android_glProgramUniformMatrix4x3fv__IIIZLjava_nio_FloatBuffer_2
3173  (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) {
3174    jint _exception = 0;
3175    const char * _exceptionType = NULL;
3176    const char * _exceptionMessage = NULL;
3177    jfloatArray _array = (jfloatArray) 0;
3178    jint _bufferOffset = (jint) 0;
3179    jint _remaining;
3180    GLfloat *value = (GLfloat *) 0;
3181
3182    if (!value_buf) {
3183        _exception = 1;
3184        _exceptionType = "java/lang/IllegalArgumentException";
3185        _exceptionMessage = "value == null";
3186        goto exit;
3187    }
3188    value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
3189    if (value == NULL) {
3190        char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
3191        value = (GLfloat *) (_valueBase + _bufferOffset);
3192    }
3193    glProgramUniformMatrix4x3fv(
3194        (GLuint)program,
3195        (GLint)location,
3196        (GLsizei)count,
3197        (GLboolean)transpose,
3198        (GLfloat *)value
3199    );
3200
3201exit:
3202    if (_array) {
3203        _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT);
3204    }
3205    if (_exception) {
3206        jniThrowException(_env, _exceptionType, _exceptionMessage);
3207    }
3208}
3209
3210/* void glValidateProgramPipeline ( GLuint pipeline ) */
3211static void
3212android_glValidateProgramPipeline__I
3213  (JNIEnv *_env, jobject _this, jint pipeline) {
3214    glValidateProgramPipeline(
3215        (GLuint)pipeline
3216    );
3217}
3218
3219#include <stdlib.h>
3220
3221/* void glGetProgramPipelineInfoLog ( GLuint shader, GLsizei maxLength, GLsizei* length, GLchar* infoLog ) */
3222static jstring android_glGetProgramPipelineInfoLog(JNIEnv *_env, jobject, jint shader) {
3223    GLint infoLen = 0;
3224    glGetProgramPipelineiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
3225    if (!infoLen) {
3226        return _env->NewStringUTF("");
3227    }
3228    char* buf = (char*) malloc(infoLen);
3229    if (buf == NULL) {
3230        jniThrowException(_env, "java/lang/OutOfMemoryError", "out of memory");
3231        return NULL;
3232    }
3233    glGetProgramPipelineInfoLog(shader, infoLen, NULL, buf);
3234    jstring result = _env->NewStringUTF(buf);
3235    free(buf);
3236    return result;
3237}
3238/* void glBindImageTexture ( GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format ) */
3239static void
3240android_glBindImageTexture__IIIZIII
3241  (JNIEnv *_env, jobject _this, jint unit, jint texture, jint level, jboolean layered, jint layer, jint access, jint format) {
3242    glBindImageTexture(
3243        (GLuint)unit,
3244        (GLuint)texture,
3245        (GLint)level,
3246        (GLboolean)layered,
3247        (GLint)layer,
3248        (GLenum)access,
3249        (GLenum)format
3250    );
3251}
3252
3253/* void glGetBooleani_v ( GLenum target, GLuint index, GLboolean *data ) */
3254static void
3255android_glGetBooleani_v__II_3ZI
3256  (JNIEnv *_env, jobject _this, jint target, jint index, jbooleanArray data_ref, jint offset) {
3257    jint _exception = 0;
3258    const char * _exceptionType = NULL;
3259    const char * _exceptionMessage = NULL;
3260    GLboolean *data_base = (GLboolean *) 0;
3261    jint _remaining;
3262    GLboolean *data = (GLboolean *) 0;
3263
3264    if (!data_ref) {
3265        _exception = 1;
3266        _exceptionType = "java/lang/IllegalArgumentException";
3267        _exceptionMessage = "data == null";
3268        goto exit;
3269    }
3270    if (offset < 0) {
3271        _exception = 1;
3272        _exceptionType = "java/lang/IllegalArgumentException";
3273        _exceptionMessage = "offset < 0";
3274        goto exit;
3275    }
3276    _remaining = _env->GetArrayLength(data_ref) - offset;
3277    data_base = (GLboolean *)
3278        _env->GetBooleanArrayElements(data_ref, (jboolean *)0);
3279    data = data_base + offset;
3280
3281    glGetBooleani_v(
3282        (GLenum)target,
3283        (GLuint)index,
3284        (GLboolean *)data
3285    );
3286
3287exit:
3288    if (data_base) {
3289        _env->ReleaseBooleanArrayElements(data_ref, (jboolean*)data_base,
3290            _exception ? JNI_ABORT: 0);
3291    }
3292    if (_exception) {
3293        jniThrowException(_env, _exceptionType, _exceptionMessage);
3294    }
3295}
3296
3297/* void glGetBooleani_v ( GLenum target, GLuint index, GLboolean *data ) */
3298static void
3299android_glGetBooleani_v__IILjava_nio_IntBuffer_2
3300  (JNIEnv *_env, jobject _this, jint target, jint index, jobject data_buf) {
3301    jint _exception = 0;
3302    const char * _exceptionType = NULL;
3303    const char * _exceptionMessage = NULL;
3304    jintArray _array = (jintArray) 0;
3305    jint _bufferOffset = (jint) 0;
3306    jint _remaining;
3307    GLboolean *data = (GLboolean *) 0;
3308
3309    if (!data_buf) {
3310        _exception = 1;
3311        _exceptionType = "java/lang/IllegalArgumentException";
3312        _exceptionMessage = "data == null";
3313        goto exit;
3314    }
3315    data = (GLboolean *)getPointer(_env, data_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
3316    if (data == NULL) {
3317        char * _dataBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
3318        data = (GLboolean *) (_dataBase + _bufferOffset);
3319    }
3320    glGetBooleani_v(
3321        (GLenum)target,
3322        (GLuint)index,
3323        (GLboolean *)data
3324    );
3325
3326exit:
3327    if (_array) {
3328        _env->ReleaseIntArrayElements(_array, (jint*)data, _exception ? JNI_ABORT : 0);
3329    }
3330    if (_exception) {
3331        jniThrowException(_env, _exceptionType, _exceptionMessage);
3332    }
3333}
3334
3335/* void glMemoryBarrier ( GLbitfield barriers ) */
3336static void
3337android_glMemoryBarrier__I
3338  (JNIEnv *_env, jobject _this, jint barriers) {
3339    glMemoryBarrier(
3340        (GLbitfield)barriers
3341    );
3342}
3343
3344/* void glMemoryBarrierByRegion ( GLbitfield barriers ) */
3345static void
3346android_glMemoryBarrierByRegion__I
3347  (JNIEnv *_env, jobject _this, jint barriers) {
3348    glMemoryBarrierByRegion(
3349        (GLbitfield)barriers
3350    );
3351}
3352
3353/* void glTexStorage2DMultisample ( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations ) */
3354static void
3355android_glTexStorage2DMultisample__IIIIIZ
3356  (JNIEnv *_env, jobject _this, jint target, jint samples, jint internalformat, jint width, jint height, jboolean fixedsamplelocations) {
3357    glTexStorage2DMultisample(
3358        (GLenum)target,
3359        (GLsizei)samples,
3360        (GLenum)internalformat,
3361        (GLsizei)width,
3362        (GLsizei)height,
3363        (GLboolean)fixedsamplelocations
3364    );
3365}
3366
3367/* void glGetMultisamplefv ( GLenum pname, GLuint index, GLfloat *val ) */
3368static void
3369android_glGetMultisamplefv__II_3FI
3370  (JNIEnv *_env, jobject _this, jint pname, jint index, jfloatArray val_ref, jint offset) {
3371    jint _exception = 0;
3372    const char * _exceptionType = NULL;
3373    const char * _exceptionMessage = NULL;
3374    GLfloat *val_base = (GLfloat *) 0;
3375    jint _remaining;
3376    GLfloat *val = (GLfloat *) 0;
3377
3378    if (!val_ref) {
3379        _exception = 1;
3380        _exceptionType = "java/lang/IllegalArgumentException";
3381        _exceptionMessage = "val == null";
3382        goto exit;
3383    }
3384    if (offset < 0) {
3385        _exception = 1;
3386        _exceptionType = "java/lang/IllegalArgumentException";
3387        _exceptionMessage = "offset < 0";
3388        goto exit;
3389    }
3390    _remaining = _env->GetArrayLength(val_ref) - offset;
3391    val_base = (GLfloat *)
3392        _env->GetFloatArrayElements(val_ref, (jboolean *)0);
3393    val = val_base + offset;
3394
3395    glGetMultisamplefv(
3396        (GLenum)pname,
3397        (GLuint)index,
3398        (GLfloat *)val
3399    );
3400
3401exit:
3402    if (val_base) {
3403        _env->ReleaseFloatArrayElements(val_ref, (jfloat*)val_base,
3404            _exception ? JNI_ABORT: 0);
3405    }
3406    if (_exception) {
3407        jniThrowException(_env, _exceptionType, _exceptionMessage);
3408    }
3409}
3410
3411/* void glGetMultisamplefv ( GLenum pname, GLuint index, GLfloat *val ) */
3412static void
3413android_glGetMultisamplefv__IILjava_nio_FloatBuffer_2
3414  (JNIEnv *_env, jobject _this, jint pname, jint index, jobject val_buf) {
3415    jint _exception = 0;
3416    const char * _exceptionType = NULL;
3417    const char * _exceptionMessage = NULL;
3418    jfloatArray _array = (jfloatArray) 0;
3419    jint _bufferOffset = (jint) 0;
3420    jint _remaining;
3421    GLfloat *val = (GLfloat *) 0;
3422
3423    if (!val_buf) {
3424        _exception = 1;
3425        _exceptionType = "java/lang/IllegalArgumentException";
3426        _exceptionMessage = "val == null";
3427        goto exit;
3428    }
3429    val = (GLfloat *)getPointer(_env, val_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
3430    if (val == NULL) {
3431        char * _valBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
3432        val = (GLfloat *) (_valBase + _bufferOffset);
3433    }
3434    glGetMultisamplefv(
3435        (GLenum)pname,
3436        (GLuint)index,
3437        (GLfloat *)val
3438    );
3439
3440exit:
3441    if (_array) {
3442        _env->ReleaseFloatArrayElements(_array, (jfloat*)val, _exception ? JNI_ABORT : 0);
3443    }
3444    if (_exception) {
3445        jniThrowException(_env, _exceptionType, _exceptionMessage);
3446    }
3447}
3448
3449/* void glSampleMaski ( GLuint maskNumber, GLbitfield mask ) */
3450static void
3451android_glSampleMaski__II
3452  (JNIEnv *_env, jobject _this, jint maskNumber, jint mask) {
3453    glSampleMaski(
3454        (GLuint)maskNumber,
3455        (GLbitfield)mask
3456    );
3457}
3458
3459/* void glGetTexLevelParameteriv ( GLenum target, GLint level, GLenum pname, GLint *params ) */
3460static void
3461android_glGetTexLevelParameteriv__III_3II
3462  (JNIEnv *_env, jobject _this, jint target, jint level, jint pname, jintArray params_ref, jint offset) {
3463    jint _exception = 0;
3464    const char * _exceptionType = NULL;
3465    const char * _exceptionMessage = NULL;
3466    GLint *params_base = (GLint *) 0;
3467    jint _remaining;
3468    GLint *params = (GLint *) 0;
3469
3470    if (!params_ref) {
3471        _exception = 1;
3472        _exceptionType = "java/lang/IllegalArgumentException";
3473        _exceptionMessage = "params == null";
3474        goto exit;
3475    }
3476    if (offset < 0) {
3477        _exception = 1;
3478        _exceptionType = "java/lang/IllegalArgumentException";
3479        _exceptionMessage = "offset < 0";
3480        goto exit;
3481    }
3482    _remaining = _env->GetArrayLength(params_ref) - offset;
3483    params_base = (GLint *)
3484        _env->GetIntArrayElements(params_ref, (jboolean *)0);
3485    params = params_base + offset;
3486
3487    glGetTexLevelParameteriv(
3488        (GLenum)target,
3489        (GLint)level,
3490        (GLenum)pname,
3491        (GLint *)params
3492    );
3493
3494exit:
3495    if (params_base) {
3496        _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
3497            _exception ? JNI_ABORT: 0);
3498    }
3499    if (_exception) {
3500        jniThrowException(_env, _exceptionType, _exceptionMessage);
3501    }
3502}
3503
3504/* void glGetTexLevelParameteriv ( GLenum target, GLint level, GLenum pname, GLint *params ) */
3505static void
3506android_glGetTexLevelParameteriv__IIILjava_nio_IntBuffer_2
3507  (JNIEnv *_env, jobject _this, jint target, jint level, jint pname, jobject params_buf) {
3508    jint _exception = 0;
3509    const char * _exceptionType = NULL;
3510    const char * _exceptionMessage = NULL;
3511    jintArray _array = (jintArray) 0;
3512    jint _bufferOffset = (jint) 0;
3513    jint _remaining;
3514    GLint *params = (GLint *) 0;
3515
3516    if (!params_buf) {
3517        _exception = 1;
3518        _exceptionType = "java/lang/IllegalArgumentException";
3519        _exceptionMessage = "params == null";
3520        goto exit;
3521    }
3522    params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
3523    if (params == NULL) {
3524        char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
3525        params = (GLint *) (_paramsBase + _bufferOffset);
3526    }
3527    glGetTexLevelParameteriv(
3528        (GLenum)target,
3529        (GLint)level,
3530        (GLenum)pname,
3531        (GLint *)params
3532    );
3533
3534exit:
3535    if (_array) {
3536        _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
3537    }
3538    if (_exception) {
3539        jniThrowException(_env, _exceptionType, _exceptionMessage);
3540    }
3541}
3542
3543/* void glGetTexLevelParameterfv ( GLenum target, GLint level, GLenum pname, GLfloat *params ) */
3544static void
3545android_glGetTexLevelParameterfv__III_3FI
3546  (JNIEnv *_env, jobject _this, jint target, jint level, jint pname, jfloatArray params_ref, jint offset) {
3547    jint _exception = 0;
3548    const char * _exceptionType = NULL;
3549    const char * _exceptionMessage = NULL;
3550    GLfloat *params_base = (GLfloat *) 0;
3551    jint _remaining;
3552    GLfloat *params = (GLfloat *) 0;
3553
3554    if (!params_ref) {
3555        _exception = 1;
3556        _exceptionType = "java/lang/IllegalArgumentException";
3557        _exceptionMessage = "params == null";
3558        goto exit;
3559    }
3560    if (offset < 0) {
3561        _exception = 1;
3562        _exceptionType = "java/lang/IllegalArgumentException";
3563        _exceptionMessage = "offset < 0";
3564        goto exit;
3565    }
3566    _remaining = _env->GetArrayLength(params_ref) - offset;
3567    params_base = (GLfloat *)
3568        _env->GetFloatArrayElements(params_ref, (jboolean *)0);
3569    params = params_base + offset;
3570
3571    glGetTexLevelParameterfv(
3572        (GLenum)target,
3573        (GLint)level,
3574        (GLenum)pname,
3575        (GLfloat *)params
3576    );
3577
3578exit:
3579    if (params_base) {
3580        _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
3581            _exception ? JNI_ABORT: 0);
3582    }
3583    if (_exception) {
3584        jniThrowException(_env, _exceptionType, _exceptionMessage);
3585    }
3586}
3587
3588/* void glGetTexLevelParameterfv ( GLenum target, GLint level, GLenum pname, GLfloat *params ) */
3589static void
3590android_glGetTexLevelParameterfv__IIILjava_nio_FloatBuffer_2
3591  (JNIEnv *_env, jobject _this, jint target, jint level, jint pname, jobject params_buf) {
3592    jint _exception = 0;
3593    const char * _exceptionType = NULL;
3594    const char * _exceptionMessage = NULL;
3595    jfloatArray _array = (jfloatArray) 0;
3596    jint _bufferOffset = (jint) 0;
3597    jint _remaining;
3598    GLfloat *params = (GLfloat *) 0;
3599
3600    if (!params_buf) {
3601        _exception = 1;
3602        _exceptionType = "java/lang/IllegalArgumentException";
3603        _exceptionMessage = "params == null";
3604        goto exit;
3605    }
3606    params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
3607    if (params == NULL) {
3608        char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
3609        params = (GLfloat *) (_paramsBase + _bufferOffset);
3610    }
3611    glGetTexLevelParameterfv(
3612        (GLenum)target,
3613        (GLint)level,
3614        (GLenum)pname,
3615        (GLfloat *)params
3616    );
3617
3618exit:
3619    if (_array) {
3620        _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0);
3621    }
3622    if (_exception) {
3623        jniThrowException(_env, _exceptionType, _exceptionMessage);
3624    }
3625}
3626
3627/* void glBindVertexBuffer ( GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride ) */
3628static void
3629android_glBindVertexBuffer__IIJI
3630  (JNIEnv *_env, jobject _this, jint bindingindex, jint buffer, jlong offset, jint stride) {
3631    if (sizeof(GLintptr) != sizeof(jlong) && (offset < LONG_MIN || offset > LONG_MAX)) {
3632        jniThrowException(_env, "java/lang/IllegalArgumentException", "offset too large");
3633        return;
3634    }
3635    glBindVertexBuffer(
3636        (GLuint)bindingindex,
3637        (GLuint)buffer,
3638        (GLintptr)offset,
3639        (GLsizei)stride
3640    );
3641}
3642/* void glVertexAttribFormat ( GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset ) */
3643static void
3644android_glVertexAttribFormat__IIIZI
3645  (JNIEnv *_env, jobject _this, jint attribindex, jint size, jint type, jboolean normalized, jint relativeoffset) {
3646    glVertexAttribFormat(
3647        (GLuint)attribindex,
3648        (GLint)size,
3649        (GLenum)type,
3650        (GLboolean)normalized,
3651        (GLuint)relativeoffset
3652    );
3653}
3654
3655/* void glVertexAttribIFormat ( GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset ) */
3656static void
3657android_glVertexAttribIFormat__IIII
3658  (JNIEnv *_env, jobject _this, jint attribindex, jint size, jint type, jint relativeoffset) {
3659    glVertexAttribIFormat(
3660        (GLuint)attribindex,
3661        (GLint)size,
3662        (GLenum)type,
3663        (GLuint)relativeoffset
3664    );
3665}
3666
3667/* void glVertexAttribBinding ( GLuint attribindex, GLuint bindingindex ) */
3668static void
3669android_glVertexAttribBinding__II
3670  (JNIEnv *_env, jobject _this, jint attribindex, jint bindingindex) {
3671    glVertexAttribBinding(
3672        (GLuint)attribindex,
3673        (GLuint)bindingindex
3674    );
3675}
3676
3677/* void glVertexBindingDivisor ( GLuint bindingindex, GLuint divisor ) */
3678static void
3679android_glVertexBindingDivisor__II
3680  (JNIEnv *_env, jobject _this, jint bindingindex, jint divisor) {
3681    glVertexBindingDivisor(
3682        (GLuint)bindingindex,
3683        (GLuint)divisor
3684    );
3685}
3686
3687static const char *classPathName = "android/opengl/GLES31";
3688
3689static const JNINativeMethod methods[] = {
3690{"_nativeClassInit", "()V", (void*)nativeClassInit },
3691{"glDispatchCompute", "(III)V", (void *) android_glDispatchCompute__III },
3692{"glDispatchComputeIndirect", "(J)V", (void *) android_glDispatchComputeIndirect },
3693{"glDrawArraysIndirect", "(IJ)V", (void *) android_glDrawArraysIndirect },
3694{"glDrawElementsIndirect", "(IIJ)V", (void *) android_glDrawElementsIndirect },
3695{"glFramebufferParameteri", "(III)V", (void *) android_glFramebufferParameteri__III },
3696{"glGetFramebufferParameteriv", "(II[II)V", (void *) android_glGetFramebufferParameteriv__II_3II },
3697{"glGetFramebufferParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetFramebufferParameteriv__IILjava_nio_IntBuffer_2 },
3698{"glGetProgramInterfaceiv", "(III[II)V", (void *) android_glGetProgramInterfaceiv__III_3II },
3699{"glGetProgramInterfaceiv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetProgramInterfaceiv__IIILjava_nio_IntBuffer_2 },
3700{"glGetProgramResourceIndex", "(IILjava/lang/String;)I", (void *) android_glGetProgramResourceIndex__IILjava_lang_String_2 },
3701{"glGetProgramResourceName", "(III)Ljava/lang/String;", (void *) android_glGetProgramResourceName },
3702{"glGetProgramResourceiv", "(IIII[III[II[II)V", (void *) android_glGetProgramResourceiv__IIII_3III_3II_3II },
3703{"glGetProgramResourceiv", "(IIIILjava/nio/IntBuffer;ILjava/nio/IntBuffer;Ljava/nio/IntBuffer;)V", (void *) android_glGetProgramResourceiv__IIIILjava_nio_IntBuffer_2ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 },
3704{"glGetProgramResourceLocation", "(IILjava/lang/String;)I", (void *) android_glGetProgramResourceLocation__IILjava_lang_String_2 },
3705{"glUseProgramStages", "(III)V", (void *) android_glUseProgramStages__III },
3706{"glActiveShaderProgram", "(II)V", (void *) android_glActiveShaderProgram__II },
3707{"glCreateShaderProgramv", "(I[Ljava/lang/String;)I", (void *) android_glCreateShaderProgramv },
3708{"glBindProgramPipeline", "(I)V", (void *) android_glBindProgramPipeline__I },
3709{"glDeleteProgramPipelines", "(I[II)V", (void *) android_glDeleteProgramPipelines__I_3II },
3710{"glDeleteProgramPipelines", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteProgramPipelines__ILjava_nio_IntBuffer_2 },
3711{"glGenProgramPipelines", "(I[II)V", (void *) android_glGenProgramPipelines__I_3II },
3712{"glGenProgramPipelines", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenProgramPipelines__ILjava_nio_IntBuffer_2 },
3713{"glIsProgramPipeline", "(I)Z", (void *) android_glIsProgramPipeline__I },
3714{"glGetProgramPipelineiv", "(II[II)V", (void *) android_glGetProgramPipelineiv__II_3II },
3715{"glGetProgramPipelineiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetProgramPipelineiv__IILjava_nio_IntBuffer_2 },
3716{"glProgramUniform1i", "(III)V", (void *) android_glProgramUniform1i__III },
3717{"glProgramUniform2i", "(IIII)V", (void *) android_glProgramUniform2i__IIII },
3718{"glProgramUniform3i", "(IIIII)V", (void *) android_glProgramUniform3i__IIIII },
3719{"glProgramUniform4i", "(IIIIII)V", (void *) android_glProgramUniform4i__IIIIII },
3720{"glProgramUniform1ui", "(III)V", (void *) android_glProgramUniform1ui__III },
3721{"glProgramUniform2ui", "(IIII)V", (void *) android_glProgramUniform2ui__IIII },
3722{"glProgramUniform3ui", "(IIIII)V", (void *) android_glProgramUniform3ui__IIIII },
3723{"glProgramUniform4ui", "(IIIIII)V", (void *) android_glProgramUniform4ui__IIIIII },
3724{"glProgramUniform1f", "(IIF)V", (void *) android_glProgramUniform1f__IIF },
3725{"glProgramUniform2f", "(IIFF)V", (void *) android_glProgramUniform2f__IIFF },
3726{"glProgramUniform3f", "(IIFFF)V", (void *) android_glProgramUniform3f__IIFFF },
3727{"glProgramUniform4f", "(IIFFFF)V", (void *) android_glProgramUniform4f__IIFFFF },
3728{"glProgramUniform1iv", "(III[II)V", (void *) android_glProgramUniform1iv__III_3II },
3729{"glProgramUniform1iv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform1iv__IIILjava_nio_IntBuffer_2 },
3730{"glProgramUniform2iv", "(III[II)V", (void *) android_glProgramUniform2iv__III_3II },
3731{"glProgramUniform2iv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform2iv__IIILjava_nio_IntBuffer_2 },
3732{"glProgramUniform3iv", "(III[II)V", (void *) android_glProgramUniform3iv__III_3II },
3733{"glProgramUniform3iv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform3iv__IIILjava_nio_IntBuffer_2 },
3734{"glProgramUniform4iv", "(III[II)V", (void *) android_glProgramUniform4iv__III_3II },
3735{"glProgramUniform4iv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform4iv__IIILjava_nio_IntBuffer_2 },
3736{"glProgramUniform1uiv", "(III[II)V", (void *) android_glProgramUniform1uiv__III_3II },
3737{"glProgramUniform1uiv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform1uiv__IIILjava_nio_IntBuffer_2 },
3738{"glProgramUniform2uiv", "(III[II)V", (void *) android_glProgramUniform2uiv__III_3II },
3739{"glProgramUniform2uiv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform2uiv__IIILjava_nio_IntBuffer_2 },
3740{"glProgramUniform3uiv", "(III[II)V", (void *) android_glProgramUniform3uiv__III_3II },
3741{"glProgramUniform3uiv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform3uiv__IIILjava_nio_IntBuffer_2 },
3742{"glProgramUniform4uiv", "(III[II)V", (void *) android_glProgramUniform4uiv__III_3II },
3743{"glProgramUniform4uiv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform4uiv__IIILjava_nio_IntBuffer_2 },
3744{"glProgramUniform1fv", "(III[FI)V", (void *) android_glProgramUniform1fv__III_3FI },
3745{"glProgramUniform1fv", "(IIILjava/nio/FloatBuffer;)V", (void *) android_glProgramUniform1fv__IIILjava_nio_FloatBuffer_2 },
3746{"glProgramUniform2fv", "(III[FI)V", (void *) android_glProgramUniform2fv__III_3FI },
3747{"glProgramUniform2fv", "(IIILjava/nio/FloatBuffer;)V", (void *) android_glProgramUniform2fv__IIILjava_nio_FloatBuffer_2 },
3748{"glProgramUniform3fv", "(III[FI)V", (void *) android_glProgramUniform3fv__III_3FI },
3749{"glProgramUniform3fv", "(IIILjava/nio/FloatBuffer;)V", (void *) android_glProgramUniform3fv__IIILjava_nio_FloatBuffer_2 },
3750{"glProgramUniform4fv", "(III[FI)V", (void *) android_glProgramUniform4fv__III_3FI },
3751{"glProgramUniform4fv", "(IIILjava/nio/FloatBuffer;)V", (void *) android_glProgramUniform4fv__IIILjava_nio_FloatBuffer_2 },
3752{"glProgramUniformMatrix2fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix2fv__IIIZ_3FI },
3753{"glProgramUniformMatrix2fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix2fv__IIIZLjava_nio_FloatBuffer_2 },
3754{"glProgramUniformMatrix3fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix3fv__IIIZ_3FI },
3755{"glProgramUniformMatrix3fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix3fv__IIIZLjava_nio_FloatBuffer_2 },
3756{"glProgramUniformMatrix4fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix4fv__IIIZ_3FI },
3757{"glProgramUniformMatrix4fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix4fv__IIIZLjava_nio_FloatBuffer_2 },
3758{"glProgramUniformMatrix2x3fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix2x3fv__IIIZ_3FI },
3759{"glProgramUniformMatrix2x3fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix2x3fv__IIIZLjava_nio_FloatBuffer_2 },
3760{"glProgramUniformMatrix3x2fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix3x2fv__IIIZ_3FI },
3761{"glProgramUniformMatrix3x2fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix3x2fv__IIIZLjava_nio_FloatBuffer_2 },
3762{"glProgramUniformMatrix2x4fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix2x4fv__IIIZ_3FI },
3763{"glProgramUniformMatrix2x4fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix2x4fv__IIIZLjava_nio_FloatBuffer_2 },
3764{"glProgramUniformMatrix4x2fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix4x2fv__IIIZ_3FI },
3765{"glProgramUniformMatrix4x2fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix4x2fv__IIIZLjava_nio_FloatBuffer_2 },
3766{"glProgramUniformMatrix3x4fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix3x4fv__IIIZ_3FI },
3767{"glProgramUniformMatrix3x4fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix3x4fv__IIIZLjava_nio_FloatBuffer_2 },
3768{"glProgramUniformMatrix4x3fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix4x3fv__IIIZ_3FI },
3769{"glProgramUniformMatrix4x3fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix4x3fv__IIIZLjava_nio_FloatBuffer_2 },
3770{"glValidateProgramPipeline", "(I)V", (void *) android_glValidateProgramPipeline__I },
3771{"glGetProgramPipelineInfoLog", "(I)Ljava/lang/String;", (void *) android_glGetProgramPipelineInfoLog },
3772{"glBindImageTexture", "(IIIZIII)V", (void *) android_glBindImageTexture__IIIZIII },
3773{"glGetBooleani_v", "(II[ZI)V", (void *) android_glGetBooleani_v__II_3ZI },
3774{"glGetBooleani_v", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetBooleani_v__IILjava_nio_IntBuffer_2 },
3775{"glMemoryBarrier", "(I)V", (void *) android_glMemoryBarrier__I },
3776{"glMemoryBarrierByRegion", "(I)V", (void *) android_glMemoryBarrierByRegion__I },
3777{"glTexStorage2DMultisample", "(IIIIIZ)V", (void *) android_glTexStorage2DMultisample__IIIIIZ },
3778{"glGetMultisamplefv", "(II[FI)V", (void *) android_glGetMultisamplefv__II_3FI },
3779{"glGetMultisamplefv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetMultisamplefv__IILjava_nio_FloatBuffer_2 },
3780{"glSampleMaski", "(II)V", (void *) android_glSampleMaski__II },
3781{"glGetTexLevelParameteriv", "(III[II)V", (void *) android_glGetTexLevelParameteriv__III_3II },
3782{"glGetTexLevelParameteriv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetTexLevelParameteriv__IIILjava_nio_IntBuffer_2 },
3783{"glGetTexLevelParameterfv", "(III[FI)V", (void *) android_glGetTexLevelParameterfv__III_3FI },
3784{"glGetTexLevelParameterfv", "(IIILjava/nio/FloatBuffer;)V", (void *) android_glGetTexLevelParameterfv__IIILjava_nio_FloatBuffer_2 },
3785{"glBindVertexBuffer", "(IIJI)V", (void *) android_glBindVertexBuffer__IIJI },
3786{"glVertexAttribFormat", "(IIIZI)V", (void *) android_glVertexAttribFormat__IIIZI },
3787{"glVertexAttribIFormat", "(IIII)V", (void *) android_glVertexAttribIFormat__IIII },
3788{"glVertexAttribBinding", "(II)V", (void *) android_glVertexAttribBinding__II },
3789{"glVertexBindingDivisor", "(II)V", (void *) android_glVertexBindingDivisor__II },
3790};
3791
3792int register_android_opengl_jni_GLES31(JNIEnv *_env)
3793{
3794    int err;
3795    err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));
3796    return err;
3797}
3798