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