1 /* //device/libs/android_runtime/com_google_android_gles_jni_GLImpl.cpp
2 **
3 ** Copyright 2006, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 **     http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17 
18 // This source file is automatically generated
19 
20 #pragma GCC diagnostic ignored "-Wunused-variable"
21 #pragma GCC diagnostic ignored "-Wunused-function"
22 
23 #include "jni.h"
24 #include <nativehelper/JNIHelp.h>
25 #include <android_runtime/AndroidRuntime.h>
26 #include <utils/misc.h>
27 
28 #include <assert.h>
29 #include <GLES/gl.h>
30 #include <GLES/glext.h>
31 
32 // Work around differences between the generated name and the actual name.
33 
34 #define glBlendEquation glBlendEquationOES
35 #define glBlendEquationSeparate glBlendEquationSeparateOES
36 #define glBlendFuncSeparate glBlendFuncSeparateOES
37 #define glGetTexGenfv glGetTexGenfvOES
38 #define glGetTexGeniv glGetTexGenivOES
39 #define glGetTexGenxv glGetTexGenxvOES
40 #define glTexGenf glTexGenfOES
41 #define glTexGenfv glTexGenfvOES
42 #define glTexGeni glTexGeniOES
43 #define glTexGeniv glTexGenivOES
44 #define glTexGenx glTexGenxOES
45 #define glTexGenxv glTexGenxvOES
46 
47 
48 
49 /* special calls implemented in Android's GLES wrapper used to more
50  * efficiently bound-check passed arrays */
51 extern "C" {
52 GL_API void GL_APIENTRY glColorPointerBounds(GLint size, GLenum type, GLsizei stride,
53         const GLvoid *ptr, GLsizei count);
54 GL_API void GL_APIENTRY glNormalPointerBounds(GLenum type, GLsizei stride,
55         const GLvoid *pointer, GLsizei count);
56 GL_API void GL_APIENTRY glTexCoordPointerBounds(GLint size, GLenum type,
57         GLsizei stride, const GLvoid *pointer, GLsizei count);
58 GL_API void GL_APIENTRY glVertexPointerBounds(GLint size, GLenum type,
59         GLsizei stride, const GLvoid *pointer, GLsizei count);
60 GL_API void GL_APIENTRY glPointSizePointerOESBounds(GLenum type,
61         GLsizei stride, const GLvoid *pointer, GLsizei count);
62 GL_API void GL_APIENTRY glMatrixIndexPointerOESBounds(GLint size, GLenum type,
63         GLsizei stride, const GLvoid *pointer, GLsizei count);
64 GL_API void GL_APIENTRY glWeightPointerOESBounds(GLint size, GLenum type,
65         GLsizei stride, const GLvoid *pointer, GLsizei count);
66 }
67 
68 static int initialized = 0;
69 
70 static jclass nioAccessClass;
71 static jclass bufferClass;
72 static jclass G11ImplClass;
73 static jmethodID getBasePointerID;
74 static jmethodID getBaseArrayID;
75 static jmethodID getBaseArrayOffsetID;
76 static jmethodID allowIndirectBuffersID;
77 static jfieldID positionID;
78 static jfieldID limitID;
79 static jfieldID elementSizeShiftID;
80 static jfieldID haveCheckedExtensionsID;
81 static jfieldID have_OES_blend_equation_separateID;
82 static jfieldID have_OES_blend_subtractID;
83 static jfieldID have_OES_framebuffer_objectID;
84 static jfieldID have_OES_texture_cube_mapID;
85 
86 /* Cache method IDs each time the class is loaded. */
87 
88 static void
nativeClassInit(JNIEnv * _env,jclass glImplClass)89 nativeClassInit(JNIEnv *_env, jclass glImplClass)
90 {
91     jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess");
92     nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal);
93 
94     jclass bufferClassLocal = _env->FindClass("java/nio/Buffer");
95     bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal);
96 
97     jclass g11impClassLocal = _env->FindClass("com/google/android/gles_jni/GLImpl");
98     G11ImplClass = (jclass) _env->NewGlobalRef(g11impClassLocal);
99     haveCheckedExtensionsID =  _env->GetFieldID(G11ImplClass, "haveCheckedExtensions", "Z");
100     have_OES_blend_equation_separateID =  _env->GetFieldID(G11ImplClass, "have_OES_blend_equation_separate", "Z");
101     have_OES_blend_subtractID =  _env->GetFieldID(G11ImplClass, "have_OES_blend_subtract", "Z");
102     have_OES_framebuffer_objectID =  _env->GetFieldID(G11ImplClass, "have_OES_framebuffer_object", "Z");
103     have_OES_texture_cube_mapID =  _env->GetFieldID(G11ImplClass, "have_OES_texture_cube_map", "Z");
104 
105     getBasePointerID = _env->GetStaticMethodID(nioAccessClass,
106             "getBasePointer", "(Ljava/nio/Buffer;)J");
107     getBaseArrayID = _env->GetStaticMethodID(nioAccessClass,
108             "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;");
109     getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass,
110             "getBaseArrayOffset", "(Ljava/nio/Buffer;)I");
111     allowIndirectBuffersID = _env->GetStaticMethodID(g11impClassLocal,
112             "allowIndirectBuffers", "(Ljava/lang/String;)Z");
113     positionID = _env->GetFieldID(bufferClass, "position", "I");
114     limitID = _env->GetFieldID(bufferClass, "limit", "I");
115     elementSizeShiftID =
116         _env->GetFieldID(bufferClass, "_elementSizeShift", "I");
117 }
118 
119 static void *
getPointer(JNIEnv * _env,jobject buffer,jarray * array,jint * remaining,jint * offset)120 getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining, jint *offset)
121 {
122     jint position;
123     jint limit;
124     jint elementSizeShift;
125     jlong pointer;
126 
127     position = _env->GetIntField(buffer, positionID);
128     limit = _env->GetIntField(buffer, limitID);
129     elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
130     *remaining = (limit - position) << elementSizeShift;
131     pointer = _env->CallStaticLongMethod(nioAccessClass,
132             getBasePointerID, buffer);
133     if (pointer != 0L) {
134         *offset = 0;
135         *array = NULL;
136         return reinterpret_cast<void *>(pointer);
137     }
138 
139     *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass,
140             getBaseArrayID, buffer);
141     if (*array == NULL) {
142         *offset = 0;
143         return (void*) NULL;
144     }
145     *offset = _env->CallStaticIntMethod(nioAccessClass,
146             getBaseArrayOffsetID, buffer);
147 
148     return NULL;
149 }
150 
151 static void
releasePointer(JNIEnv * _env,jarray array,void * data,jboolean commit)152 releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit)
153 {
154     _env->ReleasePrimitiveArrayCritical(array, data,
155 					   commit ? 0 : JNI_ABORT);
156 }
157 
158 extern "C" {
159 extern char*  __progname;
160 }
161 
162 static bool
allowIndirectBuffers(JNIEnv * _env)163 allowIndirectBuffers(JNIEnv *_env) {
164     static jint sIndirectBufferCompatability;
165     if (sIndirectBufferCompatability == 0) {
166         jobject appName = _env->NewStringUTF(::__progname);
167         sIndirectBufferCompatability = _env->CallStaticBooleanMethod(G11ImplClass, allowIndirectBuffersID, appName) ? 2 : 1;
168     }
169     return sIndirectBufferCompatability == 2;
170 }
171 
172 static void *
getDirectBufferPointer(JNIEnv * _env,jobject buffer)173 getDirectBufferPointer(JNIEnv *_env, jobject buffer) {
174     if (!buffer) {
175         return NULL;
176     }
177     void* buf = _env->GetDirectBufferAddress(buffer);
178     if (buf) {
179         jint position = _env->GetIntField(buffer, positionID);
180         jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
181         buf = ((char*) buf) + (position << elementSizeShift);
182     } else {
183         if (allowIndirectBuffers(_env)) {
184             jarray array = 0;
185             jint remaining;
186             jint offset;
187             buf = getPointer(_env, buffer, &array, &remaining, &offset);
188             if (array) {
189                 releasePointer(_env, array, buf, 0);
190             }
191             buf = (char*)buf + offset;
192         } else {
193             jniThrowException(_env, "java/lang/IllegalArgumentException",
194                               "Must use a native order direct Buffer");
195         }
196     }
197     return buf;
198 }
199 
200 static int
getNumCompressedTextureFormats()201 getNumCompressedTextureFormats() {
202     int numCompressedTextureFormats = 0;
203     glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numCompressedTextureFormats);
204     return numCompressedTextureFormats;
205 }
206 
207 // Check if the extension at the head of pExtensions is pExtension. Note that pExtensions is
208 // terminated by either 0 or space, while pExtension is terminated by 0.
209 
210 static bool
extensionEqual(const GLubyte * pExtensions,const GLubyte * pExtension)211 extensionEqual(const GLubyte* pExtensions, const GLubyte* pExtension) {
212     while (true) {
213         char a = *pExtensions++;
214         char b = *pExtension++;
215         bool aEnd = a == '\0' || a == ' ';
216         bool bEnd = b == '\0';
217         if ( aEnd || bEnd) {
218             return aEnd == bEnd;
219         }
220         if ( a != b ) {
221             return false;
222         }
223     }
224 }
225 
226 static const GLubyte*
nextExtension(const GLubyte * pExtensions)227 nextExtension(const GLubyte* pExtensions) {
228     while (true) {
229         char a = *pExtensions++;
230         if ( a == '\0') {
231             return pExtensions-1;
232         } else if ( a == ' ') {
233             return pExtensions;
234         }
235     }
236 }
237 
238 static bool
checkForExtension(const GLubyte * pExtensions,const GLubyte * pExtension)239 checkForExtension(const GLubyte* pExtensions, const GLubyte* pExtension) {
240     for (;*pExtensions != '\0'; pExtensions = nextExtension(pExtensions)) {
241         if (extensionEqual(pExtensions, pExtension)) {
242             return true;
243         }
244     }
245     return false;
246 }
247 
248 static bool
supportsExtension(JNIEnv * _env,jobject impl,jfieldID fieldId)249 supportsExtension(JNIEnv *_env, jobject impl, jfieldID fieldId) {
250     if (!_env->GetBooleanField(impl, haveCheckedExtensionsID)) {
251         _env->SetBooleanField(impl, haveCheckedExtensionsID, true);
252         const GLubyte* sExtensions = glGetString(GL_EXTENSIONS);
253         _env->SetBooleanField(impl, have_OES_blend_equation_separateID,
254             checkForExtension(sExtensions, (const GLubyte*) "GL_OES_blend_equation_separate"));
255         _env->SetBooleanField(impl, have_OES_blend_subtractID,
256             checkForExtension(sExtensions, (const GLubyte*) "GL_OES_blend_subtract"));
257         _env->SetBooleanField(impl, have_OES_framebuffer_objectID,
258             checkForExtension(sExtensions, (const GLubyte*) "GL_OES_framebuffer_object"));
259         _env->SetBooleanField(impl, have_OES_texture_cube_mapID,
260             checkForExtension(sExtensions, (const GLubyte*) "GL_OES_texture_cube_map"));
261     }
262     return _env->GetBooleanField(impl, fieldId);
263 }
264 
265 // --------------------------------------------------------------------------
266 /* void glActiveTexture ( GLenum texture ) */
267 static void
android_glActiveTexture__I(JNIEnv * _env,jobject _this,jint texture)268 android_glActiveTexture__I
269   (JNIEnv *_env, jobject _this, jint texture) {
270     glActiveTexture(
271         (GLenum)texture
272     );
273 }
274 
275 /* void glAlphaFunc ( GLenum func, GLclampf ref ) */
276 static void
android_glAlphaFunc__IF(JNIEnv * _env,jobject _this,jint func,jfloat ref)277 android_glAlphaFunc__IF
278   (JNIEnv *_env, jobject _this, jint func, jfloat ref) {
279     glAlphaFunc(
280         (GLenum)func,
281         (GLclampf)ref
282     );
283 }
284 
285 /* void glAlphaFuncx ( GLenum func, GLclampx ref ) */
286 static void
android_glAlphaFuncx__II(JNIEnv * _env,jobject _this,jint func,jint ref)287 android_glAlphaFuncx__II
288   (JNIEnv *_env, jobject _this, jint func, jint ref) {
289     glAlphaFuncx(
290         (GLenum)func,
291         (GLclampx)ref
292     );
293 }
294 
295 /* void glBindTexture ( GLenum target, GLuint texture ) */
296 static void
android_glBindTexture__II(JNIEnv * _env,jobject _this,jint target,jint texture)297 android_glBindTexture__II
298   (JNIEnv *_env, jobject _this, jint target, jint texture) {
299     glBindTexture(
300         (GLenum)target,
301         (GLuint)texture
302     );
303 }
304 
305 /* void glBlendFunc ( GLenum sfactor, GLenum dfactor ) */
306 static void
android_glBlendFunc__II(JNIEnv * _env,jobject _this,jint sfactor,jint dfactor)307 android_glBlendFunc__II
308   (JNIEnv *_env, jobject _this, jint sfactor, jint dfactor) {
309     glBlendFunc(
310         (GLenum)sfactor,
311         (GLenum)dfactor
312     );
313 }
314 
315 /* void glClear ( GLbitfield mask ) */
316 static void
android_glClear__I(JNIEnv * _env,jobject _this,jint mask)317 android_glClear__I
318   (JNIEnv *_env, jobject _this, jint mask) {
319     glClear(
320         (GLbitfield)mask
321     );
322 }
323 
324 /* void glClearColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) */
325 static void
android_glClearColor__FFFF(JNIEnv * _env,jobject _this,jfloat red,jfloat green,jfloat blue,jfloat alpha)326 android_glClearColor__FFFF
327   (JNIEnv *_env, jobject _this, jfloat red, jfloat green, jfloat blue, jfloat alpha) {
328     glClearColor(
329         (GLclampf)red,
330         (GLclampf)green,
331         (GLclampf)blue,
332         (GLclampf)alpha
333     );
334 }
335 
336 /* void glClearColorx ( GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha ) */
337 static void
android_glClearColorx__IIII(JNIEnv * _env,jobject _this,jint red,jint green,jint blue,jint alpha)338 android_glClearColorx__IIII
339   (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) {
340     glClearColorx(
341         (GLclampx)red,
342         (GLclampx)green,
343         (GLclampx)blue,
344         (GLclampx)alpha
345     );
346 }
347 
348 /* void glClearDepthf ( GLclampf depth ) */
349 static void
android_glClearDepthf__F(JNIEnv * _env,jobject _this,jfloat depth)350 android_glClearDepthf__F
351   (JNIEnv *_env, jobject _this, jfloat depth) {
352     glClearDepthf(
353         (GLclampf)depth
354     );
355 }
356 
357 /* void glClearDepthx ( GLclampx depth ) */
358 static void
android_glClearDepthx__I(JNIEnv * _env,jobject _this,jint depth)359 android_glClearDepthx__I
360   (JNIEnv *_env, jobject _this, jint depth) {
361     glClearDepthx(
362         (GLclampx)depth
363     );
364 }
365 
366 /* void glClearStencil ( GLint s ) */
367 static void
android_glClearStencil__I(JNIEnv * _env,jobject _this,jint s)368 android_glClearStencil__I
369   (JNIEnv *_env, jobject _this, jint s) {
370     glClearStencil(
371         (GLint)s
372     );
373 }
374 
375 /* void glClientActiveTexture ( GLenum texture ) */
376 static void
android_glClientActiveTexture__I(JNIEnv * _env,jobject _this,jint texture)377 android_glClientActiveTexture__I
378   (JNIEnv *_env, jobject _this, jint texture) {
379     glClientActiveTexture(
380         (GLenum)texture
381     );
382 }
383 
384 /* void glColor4f ( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) */
385 static void
android_glColor4f__FFFF(JNIEnv * _env,jobject _this,jfloat red,jfloat green,jfloat blue,jfloat alpha)386 android_glColor4f__FFFF
387   (JNIEnv *_env, jobject _this, jfloat red, jfloat green, jfloat blue, jfloat alpha) {
388     glColor4f(
389         (GLfloat)red,
390         (GLfloat)green,
391         (GLfloat)blue,
392         (GLfloat)alpha
393     );
394 }
395 
396 /* void glColor4x ( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) */
397 static void
android_glColor4x__IIII(JNIEnv * _env,jobject _this,jint red,jint green,jint blue,jint alpha)398 android_glColor4x__IIII
399   (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) {
400     glColor4x(
401         (GLfixed)red,
402         (GLfixed)green,
403         (GLfixed)blue,
404         (GLfixed)alpha
405     );
406 }
407 
408 /* void glColorMask ( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) */
409 static void
android_glColorMask__ZZZZ(JNIEnv * _env,jobject _this,jboolean red,jboolean green,jboolean blue,jboolean alpha)410 android_glColorMask__ZZZZ
411   (JNIEnv *_env, jobject _this, jboolean red, jboolean green, jboolean blue, jboolean alpha) {
412     glColorMask(
413         (GLboolean)red,
414         (GLboolean)green,
415         (GLboolean)blue,
416         (GLboolean)alpha
417     );
418 }
419 
420 /* void glColorPointer ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
421 static void
android_glColorPointerBounds__IIILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint size,jint type,jint stride,jobject pointer_buf,jint remaining)422 android_glColorPointerBounds__IIILjava_nio_Buffer_2I
423   (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
424     jint _exception = 0;
425     const char * _exceptionType = NULL;
426     const char * _exceptionMessage = NULL;
427     jarray _array = (jarray) 0;
428     jint _bufferOffset = (jint) 0;
429     jint _remaining;
430     GLvoid *pointer = (GLvoid *) 0;
431 
432     if (pointer_buf) {
433         pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
434         if ( ! pointer ) {
435             return;
436         }
437     }
438     glColorPointerBounds(
439         (GLint)size,
440         (GLenum)type,
441         (GLsizei)stride,
442         (GLvoid *)pointer,
443         (GLsizei)remaining
444     );
445     if (_exception) {
446         jniThrowException(_env, _exceptionType, _exceptionMessage);
447     }
448 }
449 
450 /* void glCompressedTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data ) */
451 static void
android_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint target,jint level,jint internalformat,jint width,jint height,jint border,jint imageSize,jobject data_buf)452 android_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2
453   (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint imageSize, jobject data_buf) {
454     jint _exception = 0;
455     const char * _exceptionType = NULL;
456     const char * _exceptionMessage = NULL;
457     jarray _array = (jarray) 0;
458     jint _bufferOffset = (jint) 0;
459     jint _remaining;
460     GLvoid *data = (GLvoid *) 0;
461 
462     if (!data_buf) {
463         _exception = 1;
464         _exceptionType = "java/lang/IllegalArgumentException";
465         _exceptionMessage = "data == null";
466         goto exit;
467     }
468     data = (GLvoid *)getPointer(_env, data_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
469     if (data == NULL) {
470         char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
471         data = (GLvoid *) (_dataBase + _bufferOffset);
472     }
473     glCompressedTexImage2D(
474         (GLenum)target,
475         (GLint)level,
476         (GLenum)internalformat,
477         (GLsizei)width,
478         (GLsizei)height,
479         (GLint)border,
480         (GLsizei)imageSize,
481         (GLvoid *)data
482     );
483 
484 exit:
485     if (_array) {
486         releasePointer(_env, _array, data, JNI_FALSE);
487     }
488     if (_exception) {
489         jniThrowException(_env, _exceptionType, _exceptionMessage);
490     }
491 }
492 
493 /* void glCompressedTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data ) */
494 static void
android_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint target,jint level,jint xoffset,jint yoffset,jint width,jint height,jint format,jint imageSize,jobject data_buf)495 android_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2
496   (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint imageSize, jobject data_buf) {
497     jint _exception = 0;
498     const char * _exceptionType = NULL;
499     const char * _exceptionMessage = NULL;
500     jarray _array = (jarray) 0;
501     jint _bufferOffset = (jint) 0;
502     jint _remaining;
503     GLvoid *data = (GLvoid *) 0;
504 
505     if (!data_buf) {
506         _exception = 1;
507         _exceptionType = "java/lang/IllegalArgumentException";
508         _exceptionMessage = "data == null";
509         goto exit;
510     }
511     data = (GLvoid *)getPointer(_env, data_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
512     if (data == NULL) {
513         char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
514         data = (GLvoid *) (_dataBase + _bufferOffset);
515     }
516     glCompressedTexSubImage2D(
517         (GLenum)target,
518         (GLint)level,
519         (GLint)xoffset,
520         (GLint)yoffset,
521         (GLsizei)width,
522         (GLsizei)height,
523         (GLenum)format,
524         (GLsizei)imageSize,
525         (GLvoid *)data
526     );
527 
528 exit:
529     if (_array) {
530         releasePointer(_env, _array, data, JNI_FALSE);
531     }
532     if (_exception) {
533         jniThrowException(_env, _exceptionType, _exceptionMessage);
534     }
535 }
536 
537 /* void glCopyTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) */
538 static void
android_glCopyTexImage2D__IIIIIIII(JNIEnv * _env,jobject _this,jint target,jint level,jint internalformat,jint x,jint y,jint width,jint height,jint border)539 android_glCopyTexImage2D__IIIIIIII
540   (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint x, jint y, jint width, jint height, jint border) {
541     glCopyTexImage2D(
542         (GLenum)target,
543         (GLint)level,
544         (GLenum)internalformat,
545         (GLint)x,
546         (GLint)y,
547         (GLsizei)width,
548         (GLsizei)height,
549         (GLint)border
550     );
551 }
552 
553 /* void glCopyTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) */
554 static void
android_glCopyTexSubImage2D__IIIIIIII(JNIEnv * _env,jobject _this,jint target,jint level,jint xoffset,jint yoffset,jint x,jint y,jint width,jint height)555 android_glCopyTexSubImage2D__IIIIIIII
556   (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint x, jint y, jint width, jint height) {
557     glCopyTexSubImage2D(
558         (GLenum)target,
559         (GLint)level,
560         (GLint)xoffset,
561         (GLint)yoffset,
562         (GLint)x,
563         (GLint)y,
564         (GLsizei)width,
565         (GLsizei)height
566     );
567 }
568 
569 /* void glCullFace ( GLenum mode ) */
570 static void
android_glCullFace__I(JNIEnv * _env,jobject _this,jint mode)571 android_glCullFace__I
572   (JNIEnv *_env, jobject _this, jint mode) {
573     glCullFace(
574         (GLenum)mode
575     );
576 }
577 
578 /* void glDeleteTextures ( GLsizei n, const GLuint *textures ) */
579 static void
android_glDeleteTextures__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray textures_ref,jint offset)580 android_glDeleteTextures__I_3II
581   (JNIEnv *_env, jobject _this, jint n, jintArray textures_ref, jint offset) {
582     jint _exception = 0;
583     const char * _exceptionType = NULL;
584     const char * _exceptionMessage = NULL;
585     GLuint *textures_base = (GLuint *) 0;
586     jint _remaining;
587     GLuint *textures = (GLuint *) 0;
588 
589     if (!textures_ref) {
590         _exception = 1;
591         _exceptionType = "java/lang/IllegalArgumentException";
592         _exceptionMessage = "textures == null";
593         goto exit;
594     }
595     if (offset < 0) {
596         _exception = 1;
597         _exceptionType = "java/lang/IllegalArgumentException";
598         _exceptionMessage = "offset < 0";
599         goto exit;
600     }
601     _remaining = _env->GetArrayLength(textures_ref) - offset;
602     if (_remaining < n) {
603         _exception = 1;
604         _exceptionType = "java/lang/IllegalArgumentException";
605         _exceptionMessage = "length - offset < n < needed";
606         goto exit;
607     }
608     textures_base = (GLuint *)
609         _env->GetIntArrayElements(textures_ref, (jboolean *)0);
610     textures = textures_base + offset;
611 
612     glDeleteTextures(
613         (GLsizei)n,
614         (GLuint *)textures
615     );
616 
617 exit:
618     if (textures_base) {
619         _env->ReleaseIntArrayElements(textures_ref, (jint*)textures_base,
620             JNI_ABORT);
621     }
622     if (_exception) {
623         jniThrowException(_env, _exceptionType, _exceptionMessage);
624     }
625 }
626 
627 /* void glDeleteTextures ( GLsizei n, const GLuint *textures ) */
628 static void
android_glDeleteTextures__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject textures_buf)629 android_glDeleteTextures__ILjava_nio_IntBuffer_2
630   (JNIEnv *_env, jobject _this, jint n, jobject textures_buf) {
631     jint _exception = 0;
632     const char * _exceptionType = NULL;
633     const char * _exceptionMessage = NULL;
634     jintArray _array = (jintArray) 0;
635     jint _bufferOffset = (jint) 0;
636     jint _remaining;
637     GLuint *textures = (GLuint *) 0;
638 
639     if (!textures_buf) {
640         _exception = 1;
641         _exceptionType = "java/lang/IllegalArgumentException";
642         _exceptionMessage = "textures == null";
643         goto exit;
644     }
645     textures = (GLuint *)getPointer(_env, textures_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
646     if (_remaining < n) {
647         _exception = 1;
648         _exceptionType = "java/lang/IllegalArgumentException";
649         _exceptionMessage = "remaining() < n < needed";
650         goto exit;
651     }
652     if (textures == NULL) {
653         char * _texturesBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
654         textures = (GLuint *) (_texturesBase + _bufferOffset);
655     }
656     glDeleteTextures(
657         (GLsizei)n,
658         (GLuint *)textures
659     );
660 
661 exit:
662     if (_array) {
663         _env->ReleaseIntArrayElements(_array, (jint*)textures, JNI_ABORT);
664     }
665     if (_exception) {
666         jniThrowException(_env, _exceptionType, _exceptionMessage);
667     }
668 }
669 
670 /* void glDepthFunc ( GLenum func ) */
671 static void
android_glDepthFunc__I(JNIEnv * _env,jobject _this,jint func)672 android_glDepthFunc__I
673   (JNIEnv *_env, jobject _this, jint func) {
674     glDepthFunc(
675         (GLenum)func
676     );
677 }
678 
679 /* void glDepthMask ( GLboolean flag ) */
680 static void
android_glDepthMask__Z(JNIEnv * _env,jobject _this,jboolean flag)681 android_glDepthMask__Z
682   (JNIEnv *_env, jobject _this, jboolean flag) {
683     glDepthMask(
684         (GLboolean)flag
685     );
686 }
687 
688 /* void glDepthRangef ( GLclampf zNear, GLclampf zFar ) */
689 static void
android_glDepthRangef__FF(JNIEnv * _env,jobject _this,jfloat zNear,jfloat zFar)690 android_glDepthRangef__FF
691   (JNIEnv *_env, jobject _this, jfloat zNear, jfloat zFar) {
692     glDepthRangef(
693         (GLclampf)zNear,
694         (GLclampf)zFar
695     );
696 }
697 
698 /* void glDepthRangex ( GLclampx zNear, GLclampx zFar ) */
699 static void
android_glDepthRangex__II(JNIEnv * _env,jobject _this,jint zNear,jint zFar)700 android_glDepthRangex__II
701   (JNIEnv *_env, jobject _this, jint zNear, jint zFar) {
702     glDepthRangex(
703         (GLclampx)zNear,
704         (GLclampx)zFar
705     );
706 }
707 
708 /* void glDisable ( GLenum cap ) */
709 static void
android_glDisable__I(JNIEnv * _env,jobject _this,jint cap)710 android_glDisable__I
711   (JNIEnv *_env, jobject _this, jint cap) {
712     glDisable(
713         (GLenum)cap
714     );
715 }
716 
717 /* void glDisableClientState ( GLenum array ) */
718 static void
android_glDisableClientState__I(JNIEnv * _env,jobject _this,jint array)719 android_glDisableClientState__I
720   (JNIEnv *_env, jobject _this, jint array) {
721     glDisableClientState(
722         (GLenum)array
723     );
724 }
725 
726 /* void glDrawArrays ( GLenum mode, GLint first, GLsizei count ) */
727 static void
android_glDrawArrays__III(JNIEnv * _env,jobject _this,jint mode,jint first,jint count)728 android_glDrawArrays__III
729   (JNIEnv *_env, jobject _this, jint mode, jint first, jint count) {
730     glDrawArrays(
731         (GLenum)mode,
732         (GLint)first,
733         (GLsizei)count
734     );
735 }
736 
737 /* void glDrawElements ( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices ) */
738 static void
android_glDrawElements__IIILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint mode,jint count,jint type,jobject indices_buf)739 android_glDrawElements__IIILjava_nio_Buffer_2
740   (JNIEnv *_env, jobject _this, jint mode, jint count, jint type, jobject indices_buf) {
741     jint _exception = 0;
742     const char * _exceptionType = NULL;
743     const char * _exceptionMessage = NULL;
744     jarray _array = (jarray) 0;
745     jint _bufferOffset = (jint) 0;
746     jint _remaining;
747     GLvoid *indices = (GLvoid *) 0;
748 
749     if (!indices_buf) {
750         _exception = 1;
751         _exceptionType = "java/lang/IllegalArgumentException";
752         _exceptionMessage = "indices == null";
753         goto exit;
754     }
755     indices = (GLvoid *)getPointer(_env, indices_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
756     if (_remaining < count) {
757         _exception = 1;
758         _exceptionType = "java/lang/ArrayIndexOutOfBoundsException";
759         _exceptionMessage = "remaining() < count < needed";
760         goto exit;
761     }
762     if (indices == NULL) {
763         char * _indicesBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
764         indices = (GLvoid *) (_indicesBase + _bufferOffset);
765     }
766     glDrawElements(
767         (GLenum)mode,
768         (GLsizei)count,
769         (GLenum)type,
770         (GLvoid *)indices
771     );
772 
773 exit:
774     if (_array) {
775         releasePointer(_env, _array, indices, JNI_FALSE);
776     }
777     if (_exception) {
778         jniThrowException(_env, _exceptionType, _exceptionMessage);
779     }
780 }
781 
782 /* void glEnable ( GLenum cap ) */
783 static void
android_glEnable__I(JNIEnv * _env,jobject _this,jint cap)784 android_glEnable__I
785   (JNIEnv *_env, jobject _this, jint cap) {
786     glEnable(
787         (GLenum)cap
788     );
789 }
790 
791 /* void glEnableClientState ( GLenum array ) */
792 static void
android_glEnableClientState__I(JNIEnv * _env,jobject _this,jint array)793 android_glEnableClientState__I
794   (JNIEnv *_env, jobject _this, jint array) {
795     glEnableClientState(
796         (GLenum)array
797     );
798 }
799 
800 /* void glFinish ( void ) */
801 static void
android_glFinish__(JNIEnv * _env,jobject _this)802 android_glFinish__
803   (JNIEnv *_env, jobject _this) {
804     glFinish();
805 }
806 
807 /* void glFlush ( void ) */
808 static void
android_glFlush__(JNIEnv * _env,jobject _this)809 android_glFlush__
810   (JNIEnv *_env, jobject _this) {
811     glFlush();
812 }
813 
814 /* void glFogf ( GLenum pname, GLfloat param ) */
815 static void
android_glFogf__IF(JNIEnv * _env,jobject _this,jint pname,jfloat param)816 android_glFogf__IF
817   (JNIEnv *_env, jobject _this, jint pname, jfloat param) {
818     glFogf(
819         (GLenum)pname,
820         (GLfloat)param
821     );
822 }
823 
824 /* void glFogfv ( GLenum pname, const GLfloat *params ) */
825 static void
android_glFogfv__I_3FI(JNIEnv * _env,jobject _this,jint pname,jfloatArray params_ref,jint offset)826 android_glFogfv__I_3FI
827   (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) {
828     jint _exception = 0;
829     const char * _exceptionType = NULL;
830     const char * _exceptionMessage = NULL;
831     GLfloat *params_base = (GLfloat *) 0;
832     jint _remaining;
833     GLfloat *params = (GLfloat *) 0;
834 
835     if (!params_ref) {
836         _exception = 1;
837         _exceptionType = "java/lang/IllegalArgumentException";
838         _exceptionMessage = "params == null";
839         goto exit;
840     }
841     if (offset < 0) {
842         _exception = 1;
843         _exceptionType = "java/lang/IllegalArgumentException";
844         _exceptionMessage = "offset < 0";
845         goto exit;
846     }
847     _remaining = _env->GetArrayLength(params_ref) - offset;
848     int _needed;
849     switch (pname) {
850 #if defined(GL_FOG_MODE)
851         case GL_FOG_MODE:
852 #endif // defined(GL_FOG_MODE)
853 #if defined(GL_FOG_DENSITY)
854         case GL_FOG_DENSITY:
855 #endif // defined(GL_FOG_DENSITY)
856 #if defined(GL_FOG_START)
857         case GL_FOG_START:
858 #endif // defined(GL_FOG_START)
859 #if defined(GL_FOG_END)
860         case GL_FOG_END:
861 #endif // defined(GL_FOG_END)
862             _needed = 1;
863             break;
864 #if defined(GL_FOG_COLOR)
865         case GL_FOG_COLOR:
866 #endif // defined(GL_FOG_COLOR)
867             _needed = 4;
868             break;
869         default:
870             _needed = 1;
871             break;
872     }
873     if (_remaining < _needed) {
874         _exception = 1;
875         _exceptionType = "java/lang/IllegalArgumentException";
876         _exceptionMessage = "length - offset < needed";
877         goto exit;
878     }
879     params_base = (GLfloat *)
880         _env->GetFloatArrayElements(params_ref, (jboolean *)0);
881     params = params_base + offset;
882 
883     glFogfv(
884         (GLenum)pname,
885         (GLfloat *)params
886     );
887 
888 exit:
889     if (params_base) {
890         _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
891             JNI_ABORT);
892     }
893     if (_exception) {
894         jniThrowException(_env, _exceptionType, _exceptionMessage);
895     }
896 }
897 
898 /* void glFogfv ( GLenum pname, const GLfloat *params ) */
899 static void
android_glFogfv__ILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)900 android_glFogfv__ILjava_nio_FloatBuffer_2
901   (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
902     jint _exception = 0;
903     const char * _exceptionType = NULL;
904     const char * _exceptionMessage = NULL;
905     jfloatArray _array = (jfloatArray) 0;
906     jint _bufferOffset = (jint) 0;
907     jint _remaining;
908     GLfloat *params = (GLfloat *) 0;
909 
910     if (!params_buf) {
911         _exception = 1;
912         _exceptionType = "java/lang/IllegalArgumentException";
913         _exceptionMessage = "params == null";
914         goto exit;
915     }
916     params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
917     int _needed;
918     switch (pname) {
919 #if defined(GL_FOG_MODE)
920         case GL_FOG_MODE:
921 #endif // defined(GL_FOG_MODE)
922 #if defined(GL_FOG_DENSITY)
923         case GL_FOG_DENSITY:
924 #endif // defined(GL_FOG_DENSITY)
925 #if defined(GL_FOG_START)
926         case GL_FOG_START:
927 #endif // defined(GL_FOG_START)
928 #if defined(GL_FOG_END)
929         case GL_FOG_END:
930 #endif // defined(GL_FOG_END)
931             _needed = 1;
932             break;
933 #if defined(GL_FOG_COLOR)
934         case GL_FOG_COLOR:
935 #endif // defined(GL_FOG_COLOR)
936             _needed = 4;
937             break;
938         default:
939             _needed = 1;
940             break;
941     }
942     if (_remaining < _needed) {
943         _exception = 1;
944         _exceptionType = "java/lang/IllegalArgumentException";
945         _exceptionMessage = "remaining() < needed";
946         goto exit;
947     }
948     if (params == NULL) {
949         char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
950         params = (GLfloat *) (_paramsBase + _bufferOffset);
951     }
952     glFogfv(
953         (GLenum)pname,
954         (GLfloat *)params
955     );
956 
957 exit:
958     if (_array) {
959         _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT);
960     }
961     if (_exception) {
962         jniThrowException(_env, _exceptionType, _exceptionMessage);
963     }
964 }
965 
966 /* void glFogx ( GLenum pname, GLfixed param ) */
967 static void
android_glFogx__II(JNIEnv * _env,jobject _this,jint pname,jint param)968 android_glFogx__II
969   (JNIEnv *_env, jobject _this, jint pname, jint param) {
970     glFogx(
971         (GLenum)pname,
972         (GLfixed)param
973     );
974 }
975 
976 /* void glFogxv ( GLenum pname, const GLfixed *params ) */
977 static void
android_glFogxv__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray params_ref,jint offset)978 android_glFogxv__I_3II
979   (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
980     jint _exception = 0;
981     const char * _exceptionType = NULL;
982     const char * _exceptionMessage = NULL;
983     GLfixed *params_base = (GLfixed *) 0;
984     jint _remaining;
985     GLfixed *params = (GLfixed *) 0;
986 
987     if (!params_ref) {
988         _exception = 1;
989         _exceptionType = "java/lang/IllegalArgumentException";
990         _exceptionMessage = "params == null";
991         goto exit;
992     }
993     if (offset < 0) {
994         _exception = 1;
995         _exceptionType = "java/lang/IllegalArgumentException";
996         _exceptionMessage = "offset < 0";
997         goto exit;
998     }
999     _remaining = _env->GetArrayLength(params_ref) - offset;
1000     int _needed;
1001     switch (pname) {
1002 #if defined(GL_FOG_MODE)
1003         case GL_FOG_MODE:
1004 #endif // defined(GL_FOG_MODE)
1005 #if defined(GL_FOG_DENSITY)
1006         case GL_FOG_DENSITY:
1007 #endif // defined(GL_FOG_DENSITY)
1008 #if defined(GL_FOG_START)
1009         case GL_FOG_START:
1010 #endif // defined(GL_FOG_START)
1011 #if defined(GL_FOG_END)
1012         case GL_FOG_END:
1013 #endif // defined(GL_FOG_END)
1014             _needed = 1;
1015             break;
1016 #if defined(GL_FOG_COLOR)
1017         case GL_FOG_COLOR:
1018 #endif // defined(GL_FOG_COLOR)
1019             _needed = 4;
1020             break;
1021         default:
1022             _needed = 1;
1023             break;
1024     }
1025     if (_remaining < _needed) {
1026         _exception = 1;
1027         _exceptionType = "java/lang/IllegalArgumentException";
1028         _exceptionMessage = "length - offset < needed";
1029         goto exit;
1030     }
1031     params_base = (GLfixed *)
1032         _env->GetIntArrayElements(params_ref, (jboolean *)0);
1033     params = params_base + offset;
1034 
1035     glFogxv(
1036         (GLenum)pname,
1037         (GLfixed *)params
1038     );
1039 
1040 exit:
1041     if (params_base) {
1042         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
1043             JNI_ABORT);
1044     }
1045     if (_exception) {
1046         jniThrowException(_env, _exceptionType, _exceptionMessage);
1047     }
1048 }
1049 
1050 /* void glFogxv ( GLenum pname, const GLfixed *params ) */
1051 static void
android_glFogxv__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)1052 android_glFogxv__ILjava_nio_IntBuffer_2
1053   (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
1054     jint _exception = 0;
1055     const char * _exceptionType = NULL;
1056     const char * _exceptionMessage = NULL;
1057     jintArray _array = (jintArray) 0;
1058     jint _bufferOffset = (jint) 0;
1059     jint _remaining;
1060     GLfixed *params = (GLfixed *) 0;
1061 
1062     if (!params_buf) {
1063         _exception = 1;
1064         _exceptionType = "java/lang/IllegalArgumentException";
1065         _exceptionMessage = "params == null";
1066         goto exit;
1067     }
1068     params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1069     int _needed;
1070     switch (pname) {
1071 #if defined(GL_FOG_MODE)
1072         case GL_FOG_MODE:
1073 #endif // defined(GL_FOG_MODE)
1074 #if defined(GL_FOG_DENSITY)
1075         case GL_FOG_DENSITY:
1076 #endif // defined(GL_FOG_DENSITY)
1077 #if defined(GL_FOG_START)
1078         case GL_FOG_START:
1079 #endif // defined(GL_FOG_START)
1080 #if defined(GL_FOG_END)
1081         case GL_FOG_END:
1082 #endif // defined(GL_FOG_END)
1083             _needed = 1;
1084             break;
1085 #if defined(GL_FOG_COLOR)
1086         case GL_FOG_COLOR:
1087 #endif // defined(GL_FOG_COLOR)
1088             _needed = 4;
1089             break;
1090         default:
1091             _needed = 1;
1092             break;
1093     }
1094     if (_remaining < _needed) {
1095         _exception = 1;
1096         _exceptionType = "java/lang/IllegalArgumentException";
1097         _exceptionMessage = "remaining() < needed";
1098         goto exit;
1099     }
1100     if (params == NULL) {
1101         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1102         params = (GLfixed *) (_paramsBase + _bufferOffset);
1103     }
1104     glFogxv(
1105         (GLenum)pname,
1106         (GLfixed *)params
1107     );
1108 
1109 exit:
1110     if (_array) {
1111         _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT);
1112     }
1113     if (_exception) {
1114         jniThrowException(_env, _exceptionType, _exceptionMessage);
1115     }
1116 }
1117 
1118 /* void glFrontFace ( GLenum mode ) */
1119 static void
android_glFrontFace__I(JNIEnv * _env,jobject _this,jint mode)1120 android_glFrontFace__I
1121   (JNIEnv *_env, jobject _this, jint mode) {
1122     glFrontFace(
1123         (GLenum)mode
1124     );
1125 }
1126 
1127 /* void glFrustumf ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */
1128 static void
android_glFrustumf__FFFFFF(JNIEnv * _env,jobject _this,jfloat left,jfloat right,jfloat bottom,jfloat top,jfloat zNear,jfloat zFar)1129 android_glFrustumf__FFFFFF
1130   (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) {
1131     glFrustumf(
1132         (GLfloat)left,
1133         (GLfloat)right,
1134         (GLfloat)bottom,
1135         (GLfloat)top,
1136         (GLfloat)zNear,
1137         (GLfloat)zFar
1138     );
1139 }
1140 
1141 /* void glFrustumx ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */
1142 static void
android_glFrustumx__IIIIII(JNIEnv * _env,jobject _this,jint left,jint right,jint bottom,jint top,jint zNear,jint zFar)1143 android_glFrustumx__IIIIII
1144   (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) {
1145     glFrustumx(
1146         (GLfixed)left,
1147         (GLfixed)right,
1148         (GLfixed)bottom,
1149         (GLfixed)top,
1150         (GLfixed)zNear,
1151         (GLfixed)zFar
1152     );
1153 }
1154 
1155 /* void glGenTextures ( GLsizei n, GLuint *textures ) */
1156 static void
android_glGenTextures__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray textures_ref,jint offset)1157 android_glGenTextures__I_3II
1158   (JNIEnv *_env, jobject _this, jint n, jintArray textures_ref, jint offset) {
1159     jint _exception = 0;
1160     const char * _exceptionType = NULL;
1161     const char * _exceptionMessage = NULL;
1162     GLuint *textures_base = (GLuint *) 0;
1163     jint _remaining;
1164     GLuint *textures = (GLuint *) 0;
1165 
1166     if (!textures_ref) {
1167         _exception = 1;
1168         _exceptionType = "java/lang/IllegalArgumentException";
1169         _exceptionMessage = "textures == null";
1170         goto exit;
1171     }
1172     if (offset < 0) {
1173         _exception = 1;
1174         _exceptionType = "java/lang/IllegalArgumentException";
1175         _exceptionMessage = "offset < 0";
1176         goto exit;
1177     }
1178     _remaining = _env->GetArrayLength(textures_ref) - offset;
1179     if (_remaining < n) {
1180         _exception = 1;
1181         _exceptionType = "java/lang/IllegalArgumentException";
1182         _exceptionMessage = "length - offset < n < needed";
1183         goto exit;
1184     }
1185     textures_base = (GLuint *)
1186         _env->GetIntArrayElements(textures_ref, (jboolean *)0);
1187     textures = textures_base + offset;
1188 
1189     glGenTextures(
1190         (GLsizei)n,
1191         (GLuint *)textures
1192     );
1193 
1194 exit:
1195     if (textures_base) {
1196         _env->ReleaseIntArrayElements(textures_ref, (jint*)textures_base,
1197             _exception ? JNI_ABORT: 0);
1198     }
1199     if (_exception) {
1200         jniThrowException(_env, _exceptionType, _exceptionMessage);
1201     }
1202 }
1203 
1204 /* void glGenTextures ( GLsizei n, GLuint *textures ) */
1205 static void
android_glGenTextures__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject textures_buf)1206 android_glGenTextures__ILjava_nio_IntBuffer_2
1207   (JNIEnv *_env, jobject _this, jint n, jobject textures_buf) {
1208     jint _exception = 0;
1209     const char * _exceptionType = NULL;
1210     const char * _exceptionMessage = NULL;
1211     jintArray _array = (jintArray) 0;
1212     jint _bufferOffset = (jint) 0;
1213     jint _remaining;
1214     GLuint *textures = (GLuint *) 0;
1215 
1216     if (!textures_buf) {
1217         _exception = 1;
1218         _exceptionType = "java/lang/IllegalArgumentException";
1219         _exceptionMessage = "textures == null";
1220         goto exit;
1221     }
1222     textures = (GLuint *)getPointer(_env, textures_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1223     if (_remaining < n) {
1224         _exception = 1;
1225         _exceptionType = "java/lang/IllegalArgumentException";
1226         _exceptionMessage = "remaining() < n < needed";
1227         goto exit;
1228     }
1229     if (textures == NULL) {
1230         char * _texturesBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1231         textures = (GLuint *) (_texturesBase + _bufferOffset);
1232     }
1233     glGenTextures(
1234         (GLsizei)n,
1235         (GLuint *)textures
1236     );
1237 
1238 exit:
1239     if (_array) {
1240         _env->ReleaseIntArrayElements(_array, (jint*)textures, _exception ? JNI_ABORT : 0);
1241     }
1242     if (_exception) {
1243         jniThrowException(_env, _exceptionType, _exceptionMessage);
1244     }
1245 }
1246 
1247 /* GLenum glGetError ( void ) */
1248 static jint
android_glGetError__(JNIEnv * _env,jobject _this)1249 android_glGetError__
1250   (JNIEnv *_env, jobject _this) {
1251     GLenum _returnValue;
1252     _returnValue = glGetError();
1253     return (jint)_returnValue;
1254 }
1255 
1256 /* void glGetIntegerv ( GLenum pname, GLint *params ) */
1257 static void
android_glGetIntegerv__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray params_ref,jint offset)1258 android_glGetIntegerv__I_3II
1259   (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
1260     jint _exception = 0;
1261     const char * _exceptionType = NULL;
1262     const char * _exceptionMessage = NULL;
1263     GLint *params_base = (GLint *) 0;
1264     jint _remaining;
1265     GLint *params = (GLint *) 0;
1266 
1267     if (!params_ref) {
1268         _exception = 1;
1269         _exceptionType = "java/lang/IllegalArgumentException";
1270         _exceptionMessage = "params == null";
1271         goto exit;
1272     }
1273     if (offset < 0) {
1274         _exception = 1;
1275         _exceptionType = "java/lang/IllegalArgumentException";
1276         _exceptionMessage = "offset < 0";
1277         goto exit;
1278     }
1279     _remaining = _env->GetArrayLength(params_ref) - offset;
1280     int _needed;
1281     switch (pname) {
1282 #if defined(GL_ALPHA_BITS)
1283         case GL_ALPHA_BITS:
1284 #endif // defined(GL_ALPHA_BITS)
1285 #if defined(GL_ALPHA_TEST_FUNC)
1286         case GL_ALPHA_TEST_FUNC:
1287 #endif // defined(GL_ALPHA_TEST_FUNC)
1288 #if defined(GL_ALPHA_TEST_REF)
1289         case GL_ALPHA_TEST_REF:
1290 #endif // defined(GL_ALPHA_TEST_REF)
1291 #if defined(GL_BLEND_DST)
1292         case GL_BLEND_DST:
1293 #endif // defined(GL_BLEND_DST)
1294 #if defined(GL_BLUE_BITS)
1295         case GL_BLUE_BITS:
1296 #endif // defined(GL_BLUE_BITS)
1297 #if defined(GL_COLOR_ARRAY_BUFFER_BINDING)
1298         case GL_COLOR_ARRAY_BUFFER_BINDING:
1299 #endif // defined(GL_COLOR_ARRAY_BUFFER_BINDING)
1300 #if defined(GL_COLOR_ARRAY_SIZE)
1301         case GL_COLOR_ARRAY_SIZE:
1302 #endif // defined(GL_COLOR_ARRAY_SIZE)
1303 #if defined(GL_COLOR_ARRAY_STRIDE)
1304         case GL_COLOR_ARRAY_STRIDE:
1305 #endif // defined(GL_COLOR_ARRAY_STRIDE)
1306 #if defined(GL_COLOR_ARRAY_TYPE)
1307         case GL_COLOR_ARRAY_TYPE:
1308 #endif // defined(GL_COLOR_ARRAY_TYPE)
1309 #if defined(GL_CULL_FACE)
1310         case GL_CULL_FACE:
1311 #endif // defined(GL_CULL_FACE)
1312 #if defined(GL_DEPTH_BITS)
1313         case GL_DEPTH_BITS:
1314 #endif // defined(GL_DEPTH_BITS)
1315 #if defined(GL_DEPTH_CLEAR_VALUE)
1316         case GL_DEPTH_CLEAR_VALUE:
1317 #endif // defined(GL_DEPTH_CLEAR_VALUE)
1318 #if defined(GL_DEPTH_FUNC)
1319         case GL_DEPTH_FUNC:
1320 #endif // defined(GL_DEPTH_FUNC)
1321 #if defined(GL_DEPTH_WRITEMASK)
1322         case GL_DEPTH_WRITEMASK:
1323 #endif // defined(GL_DEPTH_WRITEMASK)
1324 #if defined(GL_FOG_DENSITY)
1325         case GL_FOG_DENSITY:
1326 #endif // defined(GL_FOG_DENSITY)
1327 #if defined(GL_FOG_END)
1328         case GL_FOG_END:
1329 #endif // defined(GL_FOG_END)
1330 #if defined(GL_FOG_MODE)
1331         case GL_FOG_MODE:
1332 #endif // defined(GL_FOG_MODE)
1333 #if defined(GL_FOG_START)
1334         case GL_FOG_START:
1335 #endif // defined(GL_FOG_START)
1336 #if defined(GL_FRONT_FACE)
1337         case GL_FRONT_FACE:
1338 #endif // defined(GL_FRONT_FACE)
1339 #if defined(GL_GREEN_BITS)
1340         case GL_GREEN_BITS:
1341 #endif // defined(GL_GREEN_BITS)
1342 #if defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES)
1343         case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
1344 #endif // defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES)
1345 #if defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES)
1346         case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
1347 #endif // defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES)
1348 #if defined(GL_LIGHT_MODEL_COLOR_CONTROL)
1349         case GL_LIGHT_MODEL_COLOR_CONTROL:
1350 #endif // defined(GL_LIGHT_MODEL_COLOR_CONTROL)
1351 #if defined(GL_LIGHT_MODEL_LOCAL_VIEWER)
1352         case GL_LIGHT_MODEL_LOCAL_VIEWER:
1353 #endif // defined(GL_LIGHT_MODEL_LOCAL_VIEWER)
1354 #if defined(GL_LIGHT_MODEL_TWO_SIDE)
1355         case GL_LIGHT_MODEL_TWO_SIDE:
1356 #endif // defined(GL_LIGHT_MODEL_TWO_SIDE)
1357 #if defined(GL_LINE_SMOOTH_HINT)
1358         case GL_LINE_SMOOTH_HINT:
1359 #endif // defined(GL_LINE_SMOOTH_HINT)
1360 #if defined(GL_LINE_WIDTH)
1361         case GL_LINE_WIDTH:
1362 #endif // defined(GL_LINE_WIDTH)
1363 #if defined(GL_LOGIC_OP_MODE)
1364         case GL_LOGIC_OP_MODE:
1365 #endif // defined(GL_LOGIC_OP_MODE)
1366 #if defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES)
1367         case GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES:
1368 #endif // defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES)
1369 #if defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES)
1370         case GL_MATRIX_INDEX_ARRAY_SIZE_OES:
1371 #endif // defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES)
1372 #if defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES)
1373         case GL_MATRIX_INDEX_ARRAY_STRIDE_OES:
1374 #endif // defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES)
1375 #if defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES)
1376         case GL_MATRIX_INDEX_ARRAY_TYPE_OES:
1377 #endif // defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES)
1378 #if defined(GL_MATRIX_MODE)
1379         case GL_MATRIX_MODE:
1380 #endif // defined(GL_MATRIX_MODE)
1381 #if defined(GL_MAX_CLIP_PLANES)
1382         case GL_MAX_CLIP_PLANES:
1383 #endif // defined(GL_MAX_CLIP_PLANES)
1384 #if defined(GL_MAX_ELEMENTS_INDICES)
1385         case GL_MAX_ELEMENTS_INDICES:
1386 #endif // defined(GL_MAX_ELEMENTS_INDICES)
1387 #if defined(GL_MAX_ELEMENTS_VERTICES)
1388         case GL_MAX_ELEMENTS_VERTICES:
1389 #endif // defined(GL_MAX_ELEMENTS_VERTICES)
1390 #if defined(GL_MAX_LIGHTS)
1391         case GL_MAX_LIGHTS:
1392 #endif // defined(GL_MAX_LIGHTS)
1393 #if defined(GL_MAX_MODELVIEW_STACK_DEPTH)
1394         case GL_MAX_MODELVIEW_STACK_DEPTH:
1395 #endif // defined(GL_MAX_MODELVIEW_STACK_DEPTH)
1396 #if defined(GL_MAX_PALETTE_MATRICES_OES)
1397         case GL_MAX_PALETTE_MATRICES_OES:
1398 #endif // defined(GL_MAX_PALETTE_MATRICES_OES)
1399 #if defined(GL_MAX_PROJECTION_STACK_DEPTH)
1400         case GL_MAX_PROJECTION_STACK_DEPTH:
1401 #endif // defined(GL_MAX_PROJECTION_STACK_DEPTH)
1402 #if defined(GL_MAX_TEXTURE_SIZE)
1403         case GL_MAX_TEXTURE_SIZE:
1404 #endif // defined(GL_MAX_TEXTURE_SIZE)
1405 #if defined(GL_MAX_TEXTURE_STACK_DEPTH)
1406         case GL_MAX_TEXTURE_STACK_DEPTH:
1407 #endif // defined(GL_MAX_TEXTURE_STACK_DEPTH)
1408 #if defined(GL_MAX_TEXTURE_UNITS)
1409         case GL_MAX_TEXTURE_UNITS:
1410 #endif // defined(GL_MAX_TEXTURE_UNITS)
1411 #if defined(GL_MAX_VERTEX_UNITS_OES)
1412         case GL_MAX_VERTEX_UNITS_OES:
1413 #endif // defined(GL_MAX_VERTEX_UNITS_OES)
1414 #if defined(GL_MODELVIEW_STACK_DEPTH)
1415         case GL_MODELVIEW_STACK_DEPTH:
1416 #endif // defined(GL_MODELVIEW_STACK_DEPTH)
1417 #if defined(GL_NORMAL_ARRAY_BUFFER_BINDING)
1418         case GL_NORMAL_ARRAY_BUFFER_BINDING:
1419 #endif // defined(GL_NORMAL_ARRAY_BUFFER_BINDING)
1420 #if defined(GL_NORMAL_ARRAY_STRIDE)
1421         case GL_NORMAL_ARRAY_STRIDE:
1422 #endif // defined(GL_NORMAL_ARRAY_STRIDE)
1423 #if defined(GL_NORMAL_ARRAY_TYPE)
1424         case GL_NORMAL_ARRAY_TYPE:
1425 #endif // defined(GL_NORMAL_ARRAY_TYPE)
1426 #if defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS)
1427         case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
1428 #endif // defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS)
1429 #if defined(GL_PACK_ALIGNMENT)
1430         case GL_PACK_ALIGNMENT:
1431 #endif // defined(GL_PACK_ALIGNMENT)
1432 #if defined(GL_PERSPECTIVE_CORRECTION_HINT)
1433         case GL_PERSPECTIVE_CORRECTION_HINT:
1434 #endif // defined(GL_PERSPECTIVE_CORRECTION_HINT)
1435 #if defined(GL_POINT_SIZE)
1436         case GL_POINT_SIZE:
1437 #endif // defined(GL_POINT_SIZE)
1438 #if defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES)
1439         case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
1440 #endif // defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES)
1441 #if defined(GL_POINT_SIZE_ARRAY_STRIDE_OES)
1442         case GL_POINT_SIZE_ARRAY_STRIDE_OES:
1443 #endif // defined(GL_POINT_SIZE_ARRAY_STRIDE_OES)
1444 #if defined(GL_POINT_SIZE_ARRAY_TYPE_OES)
1445         case GL_POINT_SIZE_ARRAY_TYPE_OES:
1446 #endif // defined(GL_POINT_SIZE_ARRAY_TYPE_OES)
1447 #if defined(GL_POINT_SMOOTH_HINT)
1448         case GL_POINT_SMOOTH_HINT:
1449 #endif // defined(GL_POINT_SMOOTH_HINT)
1450 #if defined(GL_POLYGON_OFFSET_FACTOR)
1451         case GL_POLYGON_OFFSET_FACTOR:
1452 #endif // defined(GL_POLYGON_OFFSET_FACTOR)
1453 #if defined(GL_POLYGON_OFFSET_UNITS)
1454         case GL_POLYGON_OFFSET_UNITS:
1455 #endif // defined(GL_POLYGON_OFFSET_UNITS)
1456 #if defined(GL_PROJECTION_STACK_DEPTH)
1457         case GL_PROJECTION_STACK_DEPTH:
1458 #endif // defined(GL_PROJECTION_STACK_DEPTH)
1459 #if defined(GL_RED_BITS)
1460         case GL_RED_BITS:
1461 #endif // defined(GL_RED_BITS)
1462 #if defined(GL_SHADE_MODEL)
1463         case GL_SHADE_MODEL:
1464 #endif // defined(GL_SHADE_MODEL)
1465 #if defined(GL_STENCIL_BITS)
1466         case GL_STENCIL_BITS:
1467 #endif // defined(GL_STENCIL_BITS)
1468 #if defined(GL_STENCIL_CLEAR_VALUE)
1469         case GL_STENCIL_CLEAR_VALUE:
1470 #endif // defined(GL_STENCIL_CLEAR_VALUE)
1471 #if defined(GL_STENCIL_FAIL)
1472         case GL_STENCIL_FAIL:
1473 #endif // defined(GL_STENCIL_FAIL)
1474 #if defined(GL_STENCIL_FUNC)
1475         case GL_STENCIL_FUNC:
1476 #endif // defined(GL_STENCIL_FUNC)
1477 #if defined(GL_STENCIL_PASS_DEPTH_FAIL)
1478         case GL_STENCIL_PASS_DEPTH_FAIL:
1479 #endif // defined(GL_STENCIL_PASS_DEPTH_FAIL)
1480 #if defined(GL_STENCIL_PASS_DEPTH_PASS)
1481         case GL_STENCIL_PASS_DEPTH_PASS:
1482 #endif // defined(GL_STENCIL_PASS_DEPTH_PASS)
1483 #if defined(GL_STENCIL_REF)
1484         case GL_STENCIL_REF:
1485 #endif // defined(GL_STENCIL_REF)
1486 #if defined(GL_STENCIL_VALUE_MASK)
1487         case GL_STENCIL_VALUE_MASK:
1488 #endif // defined(GL_STENCIL_VALUE_MASK)
1489 #if defined(GL_STENCIL_WRITEMASK)
1490         case GL_STENCIL_WRITEMASK:
1491 #endif // defined(GL_STENCIL_WRITEMASK)
1492 #if defined(GL_SUBPIXEL_BITS)
1493         case GL_SUBPIXEL_BITS:
1494 #endif // defined(GL_SUBPIXEL_BITS)
1495 #if defined(GL_TEXTURE_BINDING_2D)
1496         case GL_TEXTURE_BINDING_2D:
1497 #endif // defined(GL_TEXTURE_BINDING_2D)
1498 #if defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING)
1499         case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:
1500 #endif // defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING)
1501 #if defined(GL_TEXTURE_COORD_ARRAY_SIZE)
1502         case GL_TEXTURE_COORD_ARRAY_SIZE:
1503 #endif // defined(GL_TEXTURE_COORD_ARRAY_SIZE)
1504 #if defined(GL_TEXTURE_COORD_ARRAY_STRIDE)
1505         case GL_TEXTURE_COORD_ARRAY_STRIDE:
1506 #endif // defined(GL_TEXTURE_COORD_ARRAY_STRIDE)
1507 #if defined(GL_TEXTURE_COORD_ARRAY_TYPE)
1508         case GL_TEXTURE_COORD_ARRAY_TYPE:
1509 #endif // defined(GL_TEXTURE_COORD_ARRAY_TYPE)
1510 #if defined(GL_TEXTURE_STACK_DEPTH)
1511         case GL_TEXTURE_STACK_DEPTH:
1512 #endif // defined(GL_TEXTURE_STACK_DEPTH)
1513 #if defined(GL_UNPACK_ALIGNMENT)
1514         case GL_UNPACK_ALIGNMENT:
1515 #endif // defined(GL_UNPACK_ALIGNMENT)
1516 #if defined(GL_VERTEX_ARRAY_BUFFER_BINDING)
1517         case GL_VERTEX_ARRAY_BUFFER_BINDING:
1518 #endif // defined(GL_VERTEX_ARRAY_BUFFER_BINDING)
1519 #if defined(GL_VERTEX_ARRAY_SIZE)
1520         case GL_VERTEX_ARRAY_SIZE:
1521 #endif // defined(GL_VERTEX_ARRAY_SIZE)
1522 #if defined(GL_VERTEX_ARRAY_STRIDE)
1523         case GL_VERTEX_ARRAY_STRIDE:
1524 #endif // defined(GL_VERTEX_ARRAY_STRIDE)
1525 #if defined(GL_VERTEX_ARRAY_TYPE)
1526         case GL_VERTEX_ARRAY_TYPE:
1527 #endif // defined(GL_VERTEX_ARRAY_TYPE)
1528 #if defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES)
1529         case GL_WEIGHT_ARRAY_BUFFER_BINDING_OES:
1530 #endif // defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES)
1531 #if defined(GL_WEIGHT_ARRAY_SIZE_OES)
1532         case GL_WEIGHT_ARRAY_SIZE_OES:
1533 #endif // defined(GL_WEIGHT_ARRAY_SIZE_OES)
1534 #if defined(GL_WEIGHT_ARRAY_STRIDE_OES)
1535         case GL_WEIGHT_ARRAY_STRIDE_OES:
1536 #endif // defined(GL_WEIGHT_ARRAY_STRIDE_OES)
1537 #if defined(GL_WEIGHT_ARRAY_TYPE_OES)
1538         case GL_WEIGHT_ARRAY_TYPE_OES:
1539 #endif // defined(GL_WEIGHT_ARRAY_TYPE_OES)
1540             _needed = 1;
1541             break;
1542 #if defined(GL_ALIASED_POINT_SIZE_RANGE)
1543         case GL_ALIASED_POINT_SIZE_RANGE:
1544 #endif // defined(GL_ALIASED_POINT_SIZE_RANGE)
1545 #if defined(GL_ALIASED_LINE_WIDTH_RANGE)
1546         case GL_ALIASED_LINE_WIDTH_RANGE:
1547 #endif // defined(GL_ALIASED_LINE_WIDTH_RANGE)
1548 #if defined(GL_DEPTH_RANGE)
1549         case GL_DEPTH_RANGE:
1550 #endif // defined(GL_DEPTH_RANGE)
1551 #if defined(GL_MAX_VIEWPORT_DIMS)
1552         case GL_MAX_VIEWPORT_DIMS:
1553 #endif // defined(GL_MAX_VIEWPORT_DIMS)
1554 #if defined(GL_SMOOTH_LINE_WIDTH_RANGE)
1555         case GL_SMOOTH_LINE_WIDTH_RANGE:
1556 #endif // defined(GL_SMOOTH_LINE_WIDTH_RANGE)
1557 #if defined(GL_SMOOTH_POINT_SIZE_RANGE)
1558         case GL_SMOOTH_POINT_SIZE_RANGE:
1559 #endif // defined(GL_SMOOTH_POINT_SIZE_RANGE)
1560             _needed = 2;
1561             break;
1562 #if defined(GL_COLOR_CLEAR_VALUE)
1563         case GL_COLOR_CLEAR_VALUE:
1564 #endif // defined(GL_COLOR_CLEAR_VALUE)
1565 #if defined(GL_COLOR_WRITEMASK)
1566         case GL_COLOR_WRITEMASK:
1567 #endif // defined(GL_COLOR_WRITEMASK)
1568 #if defined(GL_FOG_COLOR)
1569         case GL_FOG_COLOR:
1570 #endif // defined(GL_FOG_COLOR)
1571 #if defined(GL_LIGHT_MODEL_AMBIENT)
1572         case GL_LIGHT_MODEL_AMBIENT:
1573 #endif // defined(GL_LIGHT_MODEL_AMBIENT)
1574 #if defined(GL_SCISSOR_BOX)
1575         case GL_SCISSOR_BOX:
1576 #endif // defined(GL_SCISSOR_BOX)
1577 #if defined(GL_VIEWPORT)
1578         case GL_VIEWPORT:
1579 #endif // defined(GL_VIEWPORT)
1580             _needed = 4;
1581             break;
1582 #if defined(GL_MODELVIEW_MATRIX)
1583         case GL_MODELVIEW_MATRIX:
1584 #endif // defined(GL_MODELVIEW_MATRIX)
1585 #if defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES)
1586         case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES:
1587 #endif // defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES)
1588 #if defined(GL_PROJECTION_MATRIX)
1589         case GL_PROJECTION_MATRIX:
1590 #endif // defined(GL_PROJECTION_MATRIX)
1591 #if defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES)
1592         case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES:
1593 #endif // defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES)
1594 #if defined(GL_TEXTURE_MATRIX)
1595         case GL_TEXTURE_MATRIX:
1596 #endif // defined(GL_TEXTURE_MATRIX)
1597 #if defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES)
1598         case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES:
1599 #endif // defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES)
1600             _needed = 16;
1601             break;
1602 #if defined(GL_COMPRESSED_TEXTURE_FORMATS)
1603         case GL_COMPRESSED_TEXTURE_FORMATS:
1604 #endif // defined(GL_COMPRESSED_TEXTURE_FORMATS)
1605             _needed = getNumCompressedTextureFormats();
1606             break;
1607         default:
1608             _needed = 1;
1609             break;
1610     }
1611     if (_remaining < _needed) {
1612         _exception = 1;
1613         _exceptionType = "java/lang/IllegalArgumentException";
1614         _exceptionMessage = "length - offset < needed";
1615         goto exit;
1616     }
1617     params_base = (GLint *)
1618         _env->GetIntArrayElements(params_ref, (jboolean *)0);
1619     params = params_base + offset;
1620 
1621     glGetIntegerv(
1622         (GLenum)pname,
1623         (GLint *)params
1624     );
1625 
1626 exit:
1627     if (params_base) {
1628         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
1629             _exception ? JNI_ABORT: 0);
1630     }
1631     if (_exception) {
1632         jniThrowException(_env, _exceptionType, _exceptionMessage);
1633     }
1634 }
1635 
1636 /* void glGetIntegerv ( GLenum pname, GLint *params ) */
1637 static void
android_glGetIntegerv__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)1638 android_glGetIntegerv__ILjava_nio_IntBuffer_2
1639   (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
1640     jint _exception = 0;
1641     const char * _exceptionType = NULL;
1642     const char * _exceptionMessage = NULL;
1643     jintArray _array = (jintArray) 0;
1644     jint _bufferOffset = (jint) 0;
1645     jint _remaining;
1646     GLint *params = (GLint *) 0;
1647 
1648     if (!params_buf) {
1649         _exception = 1;
1650         _exceptionType = "java/lang/IllegalArgumentException";
1651         _exceptionMessage = "params == null";
1652         goto exit;
1653     }
1654     params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1655     int _needed;
1656     switch (pname) {
1657 #if defined(GL_ALPHA_BITS)
1658         case GL_ALPHA_BITS:
1659 #endif // defined(GL_ALPHA_BITS)
1660 #if defined(GL_ALPHA_TEST_FUNC)
1661         case GL_ALPHA_TEST_FUNC:
1662 #endif // defined(GL_ALPHA_TEST_FUNC)
1663 #if defined(GL_ALPHA_TEST_REF)
1664         case GL_ALPHA_TEST_REF:
1665 #endif // defined(GL_ALPHA_TEST_REF)
1666 #if defined(GL_BLEND_DST)
1667         case GL_BLEND_DST:
1668 #endif // defined(GL_BLEND_DST)
1669 #if defined(GL_BLUE_BITS)
1670         case GL_BLUE_BITS:
1671 #endif // defined(GL_BLUE_BITS)
1672 #if defined(GL_COLOR_ARRAY_BUFFER_BINDING)
1673         case GL_COLOR_ARRAY_BUFFER_BINDING:
1674 #endif // defined(GL_COLOR_ARRAY_BUFFER_BINDING)
1675 #if defined(GL_COLOR_ARRAY_SIZE)
1676         case GL_COLOR_ARRAY_SIZE:
1677 #endif // defined(GL_COLOR_ARRAY_SIZE)
1678 #if defined(GL_COLOR_ARRAY_STRIDE)
1679         case GL_COLOR_ARRAY_STRIDE:
1680 #endif // defined(GL_COLOR_ARRAY_STRIDE)
1681 #if defined(GL_COLOR_ARRAY_TYPE)
1682         case GL_COLOR_ARRAY_TYPE:
1683 #endif // defined(GL_COLOR_ARRAY_TYPE)
1684 #if defined(GL_CULL_FACE)
1685         case GL_CULL_FACE:
1686 #endif // defined(GL_CULL_FACE)
1687 #if defined(GL_DEPTH_BITS)
1688         case GL_DEPTH_BITS:
1689 #endif // defined(GL_DEPTH_BITS)
1690 #if defined(GL_DEPTH_CLEAR_VALUE)
1691         case GL_DEPTH_CLEAR_VALUE:
1692 #endif // defined(GL_DEPTH_CLEAR_VALUE)
1693 #if defined(GL_DEPTH_FUNC)
1694         case GL_DEPTH_FUNC:
1695 #endif // defined(GL_DEPTH_FUNC)
1696 #if defined(GL_DEPTH_WRITEMASK)
1697         case GL_DEPTH_WRITEMASK:
1698 #endif // defined(GL_DEPTH_WRITEMASK)
1699 #if defined(GL_FOG_DENSITY)
1700         case GL_FOG_DENSITY:
1701 #endif // defined(GL_FOG_DENSITY)
1702 #if defined(GL_FOG_END)
1703         case GL_FOG_END:
1704 #endif // defined(GL_FOG_END)
1705 #if defined(GL_FOG_MODE)
1706         case GL_FOG_MODE:
1707 #endif // defined(GL_FOG_MODE)
1708 #if defined(GL_FOG_START)
1709         case GL_FOG_START:
1710 #endif // defined(GL_FOG_START)
1711 #if defined(GL_FRONT_FACE)
1712         case GL_FRONT_FACE:
1713 #endif // defined(GL_FRONT_FACE)
1714 #if defined(GL_GREEN_BITS)
1715         case GL_GREEN_BITS:
1716 #endif // defined(GL_GREEN_BITS)
1717 #if defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES)
1718         case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
1719 #endif // defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES)
1720 #if defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES)
1721         case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
1722 #endif // defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES)
1723 #if defined(GL_LIGHT_MODEL_COLOR_CONTROL)
1724         case GL_LIGHT_MODEL_COLOR_CONTROL:
1725 #endif // defined(GL_LIGHT_MODEL_COLOR_CONTROL)
1726 #if defined(GL_LIGHT_MODEL_LOCAL_VIEWER)
1727         case GL_LIGHT_MODEL_LOCAL_VIEWER:
1728 #endif // defined(GL_LIGHT_MODEL_LOCAL_VIEWER)
1729 #if defined(GL_LIGHT_MODEL_TWO_SIDE)
1730         case GL_LIGHT_MODEL_TWO_SIDE:
1731 #endif // defined(GL_LIGHT_MODEL_TWO_SIDE)
1732 #if defined(GL_LINE_SMOOTH_HINT)
1733         case GL_LINE_SMOOTH_HINT:
1734 #endif // defined(GL_LINE_SMOOTH_HINT)
1735 #if defined(GL_LINE_WIDTH)
1736         case GL_LINE_WIDTH:
1737 #endif // defined(GL_LINE_WIDTH)
1738 #if defined(GL_LOGIC_OP_MODE)
1739         case GL_LOGIC_OP_MODE:
1740 #endif // defined(GL_LOGIC_OP_MODE)
1741 #if defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES)
1742         case GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES:
1743 #endif // defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES)
1744 #if defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES)
1745         case GL_MATRIX_INDEX_ARRAY_SIZE_OES:
1746 #endif // defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES)
1747 #if defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES)
1748         case GL_MATRIX_INDEX_ARRAY_STRIDE_OES:
1749 #endif // defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES)
1750 #if defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES)
1751         case GL_MATRIX_INDEX_ARRAY_TYPE_OES:
1752 #endif // defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES)
1753 #if defined(GL_MATRIX_MODE)
1754         case GL_MATRIX_MODE:
1755 #endif // defined(GL_MATRIX_MODE)
1756 #if defined(GL_MAX_CLIP_PLANES)
1757         case GL_MAX_CLIP_PLANES:
1758 #endif // defined(GL_MAX_CLIP_PLANES)
1759 #if defined(GL_MAX_ELEMENTS_INDICES)
1760         case GL_MAX_ELEMENTS_INDICES:
1761 #endif // defined(GL_MAX_ELEMENTS_INDICES)
1762 #if defined(GL_MAX_ELEMENTS_VERTICES)
1763         case GL_MAX_ELEMENTS_VERTICES:
1764 #endif // defined(GL_MAX_ELEMENTS_VERTICES)
1765 #if defined(GL_MAX_LIGHTS)
1766         case GL_MAX_LIGHTS:
1767 #endif // defined(GL_MAX_LIGHTS)
1768 #if defined(GL_MAX_MODELVIEW_STACK_DEPTH)
1769         case GL_MAX_MODELVIEW_STACK_DEPTH:
1770 #endif // defined(GL_MAX_MODELVIEW_STACK_DEPTH)
1771 #if defined(GL_MAX_PALETTE_MATRICES_OES)
1772         case GL_MAX_PALETTE_MATRICES_OES:
1773 #endif // defined(GL_MAX_PALETTE_MATRICES_OES)
1774 #if defined(GL_MAX_PROJECTION_STACK_DEPTH)
1775         case GL_MAX_PROJECTION_STACK_DEPTH:
1776 #endif // defined(GL_MAX_PROJECTION_STACK_DEPTH)
1777 #if defined(GL_MAX_TEXTURE_SIZE)
1778         case GL_MAX_TEXTURE_SIZE:
1779 #endif // defined(GL_MAX_TEXTURE_SIZE)
1780 #if defined(GL_MAX_TEXTURE_STACK_DEPTH)
1781         case GL_MAX_TEXTURE_STACK_DEPTH:
1782 #endif // defined(GL_MAX_TEXTURE_STACK_DEPTH)
1783 #if defined(GL_MAX_TEXTURE_UNITS)
1784         case GL_MAX_TEXTURE_UNITS:
1785 #endif // defined(GL_MAX_TEXTURE_UNITS)
1786 #if defined(GL_MAX_VERTEX_UNITS_OES)
1787         case GL_MAX_VERTEX_UNITS_OES:
1788 #endif // defined(GL_MAX_VERTEX_UNITS_OES)
1789 #if defined(GL_MODELVIEW_STACK_DEPTH)
1790         case GL_MODELVIEW_STACK_DEPTH:
1791 #endif // defined(GL_MODELVIEW_STACK_DEPTH)
1792 #if defined(GL_NORMAL_ARRAY_BUFFER_BINDING)
1793         case GL_NORMAL_ARRAY_BUFFER_BINDING:
1794 #endif // defined(GL_NORMAL_ARRAY_BUFFER_BINDING)
1795 #if defined(GL_NORMAL_ARRAY_STRIDE)
1796         case GL_NORMAL_ARRAY_STRIDE:
1797 #endif // defined(GL_NORMAL_ARRAY_STRIDE)
1798 #if defined(GL_NORMAL_ARRAY_TYPE)
1799         case GL_NORMAL_ARRAY_TYPE:
1800 #endif // defined(GL_NORMAL_ARRAY_TYPE)
1801 #if defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS)
1802         case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
1803 #endif // defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS)
1804 #if defined(GL_PACK_ALIGNMENT)
1805         case GL_PACK_ALIGNMENT:
1806 #endif // defined(GL_PACK_ALIGNMENT)
1807 #if defined(GL_PERSPECTIVE_CORRECTION_HINT)
1808         case GL_PERSPECTIVE_CORRECTION_HINT:
1809 #endif // defined(GL_PERSPECTIVE_CORRECTION_HINT)
1810 #if defined(GL_POINT_SIZE)
1811         case GL_POINT_SIZE:
1812 #endif // defined(GL_POINT_SIZE)
1813 #if defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES)
1814         case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
1815 #endif // defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES)
1816 #if defined(GL_POINT_SIZE_ARRAY_STRIDE_OES)
1817         case GL_POINT_SIZE_ARRAY_STRIDE_OES:
1818 #endif // defined(GL_POINT_SIZE_ARRAY_STRIDE_OES)
1819 #if defined(GL_POINT_SIZE_ARRAY_TYPE_OES)
1820         case GL_POINT_SIZE_ARRAY_TYPE_OES:
1821 #endif // defined(GL_POINT_SIZE_ARRAY_TYPE_OES)
1822 #if defined(GL_POINT_SMOOTH_HINT)
1823         case GL_POINT_SMOOTH_HINT:
1824 #endif // defined(GL_POINT_SMOOTH_HINT)
1825 #if defined(GL_POLYGON_OFFSET_FACTOR)
1826         case GL_POLYGON_OFFSET_FACTOR:
1827 #endif // defined(GL_POLYGON_OFFSET_FACTOR)
1828 #if defined(GL_POLYGON_OFFSET_UNITS)
1829         case GL_POLYGON_OFFSET_UNITS:
1830 #endif // defined(GL_POLYGON_OFFSET_UNITS)
1831 #if defined(GL_PROJECTION_STACK_DEPTH)
1832         case GL_PROJECTION_STACK_DEPTH:
1833 #endif // defined(GL_PROJECTION_STACK_DEPTH)
1834 #if defined(GL_RED_BITS)
1835         case GL_RED_BITS:
1836 #endif // defined(GL_RED_BITS)
1837 #if defined(GL_SHADE_MODEL)
1838         case GL_SHADE_MODEL:
1839 #endif // defined(GL_SHADE_MODEL)
1840 #if defined(GL_STENCIL_BITS)
1841         case GL_STENCIL_BITS:
1842 #endif // defined(GL_STENCIL_BITS)
1843 #if defined(GL_STENCIL_CLEAR_VALUE)
1844         case GL_STENCIL_CLEAR_VALUE:
1845 #endif // defined(GL_STENCIL_CLEAR_VALUE)
1846 #if defined(GL_STENCIL_FAIL)
1847         case GL_STENCIL_FAIL:
1848 #endif // defined(GL_STENCIL_FAIL)
1849 #if defined(GL_STENCIL_FUNC)
1850         case GL_STENCIL_FUNC:
1851 #endif // defined(GL_STENCIL_FUNC)
1852 #if defined(GL_STENCIL_PASS_DEPTH_FAIL)
1853         case GL_STENCIL_PASS_DEPTH_FAIL:
1854 #endif // defined(GL_STENCIL_PASS_DEPTH_FAIL)
1855 #if defined(GL_STENCIL_PASS_DEPTH_PASS)
1856         case GL_STENCIL_PASS_DEPTH_PASS:
1857 #endif // defined(GL_STENCIL_PASS_DEPTH_PASS)
1858 #if defined(GL_STENCIL_REF)
1859         case GL_STENCIL_REF:
1860 #endif // defined(GL_STENCIL_REF)
1861 #if defined(GL_STENCIL_VALUE_MASK)
1862         case GL_STENCIL_VALUE_MASK:
1863 #endif // defined(GL_STENCIL_VALUE_MASK)
1864 #if defined(GL_STENCIL_WRITEMASK)
1865         case GL_STENCIL_WRITEMASK:
1866 #endif // defined(GL_STENCIL_WRITEMASK)
1867 #if defined(GL_SUBPIXEL_BITS)
1868         case GL_SUBPIXEL_BITS:
1869 #endif // defined(GL_SUBPIXEL_BITS)
1870 #if defined(GL_TEXTURE_BINDING_2D)
1871         case GL_TEXTURE_BINDING_2D:
1872 #endif // defined(GL_TEXTURE_BINDING_2D)
1873 #if defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING)
1874         case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:
1875 #endif // defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING)
1876 #if defined(GL_TEXTURE_COORD_ARRAY_SIZE)
1877         case GL_TEXTURE_COORD_ARRAY_SIZE:
1878 #endif // defined(GL_TEXTURE_COORD_ARRAY_SIZE)
1879 #if defined(GL_TEXTURE_COORD_ARRAY_STRIDE)
1880         case GL_TEXTURE_COORD_ARRAY_STRIDE:
1881 #endif // defined(GL_TEXTURE_COORD_ARRAY_STRIDE)
1882 #if defined(GL_TEXTURE_COORD_ARRAY_TYPE)
1883         case GL_TEXTURE_COORD_ARRAY_TYPE:
1884 #endif // defined(GL_TEXTURE_COORD_ARRAY_TYPE)
1885 #if defined(GL_TEXTURE_STACK_DEPTH)
1886         case GL_TEXTURE_STACK_DEPTH:
1887 #endif // defined(GL_TEXTURE_STACK_DEPTH)
1888 #if defined(GL_UNPACK_ALIGNMENT)
1889         case GL_UNPACK_ALIGNMENT:
1890 #endif // defined(GL_UNPACK_ALIGNMENT)
1891 #if defined(GL_VERTEX_ARRAY_BUFFER_BINDING)
1892         case GL_VERTEX_ARRAY_BUFFER_BINDING:
1893 #endif // defined(GL_VERTEX_ARRAY_BUFFER_BINDING)
1894 #if defined(GL_VERTEX_ARRAY_SIZE)
1895         case GL_VERTEX_ARRAY_SIZE:
1896 #endif // defined(GL_VERTEX_ARRAY_SIZE)
1897 #if defined(GL_VERTEX_ARRAY_STRIDE)
1898         case GL_VERTEX_ARRAY_STRIDE:
1899 #endif // defined(GL_VERTEX_ARRAY_STRIDE)
1900 #if defined(GL_VERTEX_ARRAY_TYPE)
1901         case GL_VERTEX_ARRAY_TYPE:
1902 #endif // defined(GL_VERTEX_ARRAY_TYPE)
1903 #if defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES)
1904         case GL_WEIGHT_ARRAY_BUFFER_BINDING_OES:
1905 #endif // defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES)
1906 #if defined(GL_WEIGHT_ARRAY_SIZE_OES)
1907         case GL_WEIGHT_ARRAY_SIZE_OES:
1908 #endif // defined(GL_WEIGHT_ARRAY_SIZE_OES)
1909 #if defined(GL_WEIGHT_ARRAY_STRIDE_OES)
1910         case GL_WEIGHT_ARRAY_STRIDE_OES:
1911 #endif // defined(GL_WEIGHT_ARRAY_STRIDE_OES)
1912 #if defined(GL_WEIGHT_ARRAY_TYPE_OES)
1913         case GL_WEIGHT_ARRAY_TYPE_OES:
1914 #endif // defined(GL_WEIGHT_ARRAY_TYPE_OES)
1915             _needed = 1;
1916             break;
1917 #if defined(GL_ALIASED_POINT_SIZE_RANGE)
1918         case GL_ALIASED_POINT_SIZE_RANGE:
1919 #endif // defined(GL_ALIASED_POINT_SIZE_RANGE)
1920 #if defined(GL_ALIASED_LINE_WIDTH_RANGE)
1921         case GL_ALIASED_LINE_WIDTH_RANGE:
1922 #endif // defined(GL_ALIASED_LINE_WIDTH_RANGE)
1923 #if defined(GL_DEPTH_RANGE)
1924         case GL_DEPTH_RANGE:
1925 #endif // defined(GL_DEPTH_RANGE)
1926 #if defined(GL_MAX_VIEWPORT_DIMS)
1927         case GL_MAX_VIEWPORT_DIMS:
1928 #endif // defined(GL_MAX_VIEWPORT_DIMS)
1929 #if defined(GL_SMOOTH_LINE_WIDTH_RANGE)
1930         case GL_SMOOTH_LINE_WIDTH_RANGE:
1931 #endif // defined(GL_SMOOTH_LINE_WIDTH_RANGE)
1932 #if defined(GL_SMOOTH_POINT_SIZE_RANGE)
1933         case GL_SMOOTH_POINT_SIZE_RANGE:
1934 #endif // defined(GL_SMOOTH_POINT_SIZE_RANGE)
1935             _needed = 2;
1936             break;
1937 #if defined(GL_COLOR_CLEAR_VALUE)
1938         case GL_COLOR_CLEAR_VALUE:
1939 #endif // defined(GL_COLOR_CLEAR_VALUE)
1940 #if defined(GL_COLOR_WRITEMASK)
1941         case GL_COLOR_WRITEMASK:
1942 #endif // defined(GL_COLOR_WRITEMASK)
1943 #if defined(GL_FOG_COLOR)
1944         case GL_FOG_COLOR:
1945 #endif // defined(GL_FOG_COLOR)
1946 #if defined(GL_LIGHT_MODEL_AMBIENT)
1947         case GL_LIGHT_MODEL_AMBIENT:
1948 #endif // defined(GL_LIGHT_MODEL_AMBIENT)
1949 #if defined(GL_SCISSOR_BOX)
1950         case GL_SCISSOR_BOX:
1951 #endif // defined(GL_SCISSOR_BOX)
1952 #if defined(GL_VIEWPORT)
1953         case GL_VIEWPORT:
1954 #endif // defined(GL_VIEWPORT)
1955             _needed = 4;
1956             break;
1957 #if defined(GL_MODELVIEW_MATRIX)
1958         case GL_MODELVIEW_MATRIX:
1959 #endif // defined(GL_MODELVIEW_MATRIX)
1960 #if defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES)
1961         case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES:
1962 #endif // defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES)
1963 #if defined(GL_PROJECTION_MATRIX)
1964         case GL_PROJECTION_MATRIX:
1965 #endif // defined(GL_PROJECTION_MATRIX)
1966 #if defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES)
1967         case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES:
1968 #endif // defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES)
1969 #if defined(GL_TEXTURE_MATRIX)
1970         case GL_TEXTURE_MATRIX:
1971 #endif // defined(GL_TEXTURE_MATRIX)
1972 #if defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES)
1973         case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES:
1974 #endif // defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES)
1975             _needed = 16;
1976             break;
1977 #if defined(GL_COMPRESSED_TEXTURE_FORMATS)
1978         case GL_COMPRESSED_TEXTURE_FORMATS:
1979 #endif // defined(GL_COMPRESSED_TEXTURE_FORMATS)
1980             _needed = getNumCompressedTextureFormats();
1981             break;
1982         default:
1983             _needed = 1;
1984             break;
1985     }
1986     if (_remaining < _needed) {
1987         _exception = 1;
1988         _exceptionType = "java/lang/IllegalArgumentException";
1989         _exceptionMessage = "remaining() < needed";
1990         goto exit;
1991     }
1992     if (params == NULL) {
1993         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1994         params = (GLint *) (_paramsBase + _bufferOffset);
1995     }
1996     glGetIntegerv(
1997         (GLenum)pname,
1998         (GLint *)params
1999     );
2000 
2001 exit:
2002     if (_array) {
2003         _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
2004     }
2005     if (_exception) {
2006         jniThrowException(_env, _exceptionType, _exceptionMessage);
2007     }
2008 }
2009 
2010 /* const GLubyte * glGetString ( GLenum name ) */
android_glGetString(JNIEnv * _env,jobject,jint name)2011 static jstring android_glGetString(JNIEnv *_env, jobject, jint name) {
2012     const char* chars = (const char*) glGetString((GLenum) name);
2013     return _env->NewStringUTF(chars);
2014 }
2015 /* void glHint ( GLenum target, GLenum mode ) */
2016 static void
android_glHint__II(JNIEnv * _env,jobject _this,jint target,jint mode)2017 android_glHint__II
2018   (JNIEnv *_env, jobject _this, jint target, jint mode) {
2019     glHint(
2020         (GLenum)target,
2021         (GLenum)mode
2022     );
2023 }
2024 
2025 /* void glLightModelf ( GLenum pname, GLfloat param ) */
2026 static void
android_glLightModelf__IF(JNIEnv * _env,jobject _this,jint pname,jfloat param)2027 android_glLightModelf__IF
2028   (JNIEnv *_env, jobject _this, jint pname, jfloat param) {
2029     glLightModelf(
2030         (GLenum)pname,
2031         (GLfloat)param
2032     );
2033 }
2034 
2035 /* void glLightModelfv ( GLenum pname, const GLfloat *params ) */
2036 static void
android_glLightModelfv__I_3FI(JNIEnv * _env,jobject _this,jint pname,jfloatArray params_ref,jint offset)2037 android_glLightModelfv__I_3FI
2038   (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) {
2039     jint _exception = 0;
2040     const char * _exceptionType = NULL;
2041     const char * _exceptionMessage = NULL;
2042     GLfloat *params_base = (GLfloat *) 0;
2043     jint _remaining;
2044     GLfloat *params = (GLfloat *) 0;
2045 
2046     if (!params_ref) {
2047         _exception = 1;
2048         _exceptionType = "java/lang/IllegalArgumentException";
2049         _exceptionMessage = "params == null";
2050         goto exit;
2051     }
2052     if (offset < 0) {
2053         _exception = 1;
2054         _exceptionType = "java/lang/IllegalArgumentException";
2055         _exceptionMessage = "offset < 0";
2056         goto exit;
2057     }
2058     _remaining = _env->GetArrayLength(params_ref) - offset;
2059     int _needed;
2060     switch (pname) {
2061 #if defined(GL_LIGHT_MODEL_TWO_SIDE)
2062         case GL_LIGHT_MODEL_TWO_SIDE:
2063 #endif // defined(GL_LIGHT_MODEL_TWO_SIDE)
2064             _needed = 1;
2065             break;
2066 #if defined(GL_LIGHT_MODEL_AMBIENT)
2067         case GL_LIGHT_MODEL_AMBIENT:
2068 #endif // defined(GL_LIGHT_MODEL_AMBIENT)
2069             _needed = 4;
2070             break;
2071         default:
2072             _needed = 1;
2073             break;
2074     }
2075     if (_remaining < _needed) {
2076         _exception = 1;
2077         _exceptionType = "java/lang/IllegalArgumentException";
2078         _exceptionMessage = "length - offset < needed";
2079         goto exit;
2080     }
2081     params_base = (GLfloat *)
2082         _env->GetFloatArrayElements(params_ref, (jboolean *)0);
2083     params = params_base + offset;
2084 
2085     glLightModelfv(
2086         (GLenum)pname,
2087         (GLfloat *)params
2088     );
2089 
2090 exit:
2091     if (params_base) {
2092         _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
2093             JNI_ABORT);
2094     }
2095     if (_exception) {
2096         jniThrowException(_env, _exceptionType, _exceptionMessage);
2097     }
2098 }
2099 
2100 /* void glLightModelfv ( GLenum pname, const GLfloat *params ) */
2101 static void
android_glLightModelfv__ILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)2102 android_glLightModelfv__ILjava_nio_FloatBuffer_2
2103   (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
2104     jint _exception = 0;
2105     const char * _exceptionType = NULL;
2106     const char * _exceptionMessage = NULL;
2107     jfloatArray _array = (jfloatArray) 0;
2108     jint _bufferOffset = (jint) 0;
2109     jint _remaining;
2110     GLfloat *params = (GLfloat *) 0;
2111 
2112     if (!params_buf) {
2113         _exception = 1;
2114         _exceptionType = "java/lang/IllegalArgumentException";
2115         _exceptionMessage = "params == null";
2116         goto exit;
2117     }
2118     params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2119     int _needed;
2120     switch (pname) {
2121 #if defined(GL_LIGHT_MODEL_TWO_SIDE)
2122         case GL_LIGHT_MODEL_TWO_SIDE:
2123 #endif // defined(GL_LIGHT_MODEL_TWO_SIDE)
2124             _needed = 1;
2125             break;
2126 #if defined(GL_LIGHT_MODEL_AMBIENT)
2127         case GL_LIGHT_MODEL_AMBIENT:
2128 #endif // defined(GL_LIGHT_MODEL_AMBIENT)
2129             _needed = 4;
2130             break;
2131         default:
2132             _needed = 1;
2133             break;
2134     }
2135     if (_remaining < _needed) {
2136         _exception = 1;
2137         _exceptionType = "java/lang/IllegalArgumentException";
2138         _exceptionMessage = "remaining() < needed";
2139         goto exit;
2140     }
2141     if (params == NULL) {
2142         char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
2143         params = (GLfloat *) (_paramsBase + _bufferOffset);
2144     }
2145     glLightModelfv(
2146         (GLenum)pname,
2147         (GLfloat *)params
2148     );
2149 
2150 exit:
2151     if (_array) {
2152         _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT);
2153     }
2154     if (_exception) {
2155         jniThrowException(_env, _exceptionType, _exceptionMessage);
2156     }
2157 }
2158 
2159 /* void glLightModelx ( GLenum pname, GLfixed param ) */
2160 static void
android_glLightModelx__II(JNIEnv * _env,jobject _this,jint pname,jint param)2161 android_glLightModelx__II
2162   (JNIEnv *_env, jobject _this, jint pname, jint param) {
2163     glLightModelx(
2164         (GLenum)pname,
2165         (GLfixed)param
2166     );
2167 }
2168 
2169 /* void glLightModelxv ( GLenum pname, const GLfixed *params ) */
2170 static void
android_glLightModelxv__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray params_ref,jint offset)2171 android_glLightModelxv__I_3II
2172   (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
2173     jint _exception = 0;
2174     const char * _exceptionType = NULL;
2175     const char * _exceptionMessage = NULL;
2176     GLfixed *params_base = (GLfixed *) 0;
2177     jint _remaining;
2178     GLfixed *params = (GLfixed *) 0;
2179 
2180     if (!params_ref) {
2181         _exception = 1;
2182         _exceptionType = "java/lang/IllegalArgumentException";
2183         _exceptionMessage = "params == null";
2184         goto exit;
2185     }
2186     if (offset < 0) {
2187         _exception = 1;
2188         _exceptionType = "java/lang/IllegalArgumentException";
2189         _exceptionMessage = "offset < 0";
2190         goto exit;
2191     }
2192     _remaining = _env->GetArrayLength(params_ref) - offset;
2193     int _needed;
2194     switch (pname) {
2195 #if defined(GL_LIGHT_MODEL_TWO_SIDE)
2196         case GL_LIGHT_MODEL_TWO_SIDE:
2197 #endif // defined(GL_LIGHT_MODEL_TWO_SIDE)
2198             _needed = 1;
2199             break;
2200 #if defined(GL_LIGHT_MODEL_AMBIENT)
2201         case GL_LIGHT_MODEL_AMBIENT:
2202 #endif // defined(GL_LIGHT_MODEL_AMBIENT)
2203             _needed = 4;
2204             break;
2205         default:
2206             _needed = 1;
2207             break;
2208     }
2209     if (_remaining < _needed) {
2210         _exception = 1;
2211         _exceptionType = "java/lang/IllegalArgumentException";
2212         _exceptionMessage = "length - offset < needed";
2213         goto exit;
2214     }
2215     params_base = (GLfixed *)
2216         _env->GetIntArrayElements(params_ref, (jboolean *)0);
2217     params = params_base + offset;
2218 
2219     glLightModelxv(
2220         (GLenum)pname,
2221         (GLfixed *)params
2222     );
2223 
2224 exit:
2225     if (params_base) {
2226         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
2227             JNI_ABORT);
2228     }
2229     if (_exception) {
2230         jniThrowException(_env, _exceptionType, _exceptionMessage);
2231     }
2232 }
2233 
2234 /* void glLightModelxv ( GLenum pname, const GLfixed *params ) */
2235 static void
android_glLightModelxv__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)2236 android_glLightModelxv__ILjava_nio_IntBuffer_2
2237   (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
2238     jint _exception = 0;
2239     const char * _exceptionType = NULL;
2240     const char * _exceptionMessage = NULL;
2241     jintArray _array = (jintArray) 0;
2242     jint _bufferOffset = (jint) 0;
2243     jint _remaining;
2244     GLfixed *params = (GLfixed *) 0;
2245 
2246     if (!params_buf) {
2247         _exception = 1;
2248         _exceptionType = "java/lang/IllegalArgumentException";
2249         _exceptionMessage = "params == null";
2250         goto exit;
2251     }
2252     params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2253     int _needed;
2254     switch (pname) {
2255 #if defined(GL_LIGHT_MODEL_TWO_SIDE)
2256         case GL_LIGHT_MODEL_TWO_SIDE:
2257 #endif // defined(GL_LIGHT_MODEL_TWO_SIDE)
2258             _needed = 1;
2259             break;
2260 #if defined(GL_LIGHT_MODEL_AMBIENT)
2261         case GL_LIGHT_MODEL_AMBIENT:
2262 #endif // defined(GL_LIGHT_MODEL_AMBIENT)
2263             _needed = 4;
2264             break;
2265         default:
2266             _needed = 1;
2267             break;
2268     }
2269     if (_remaining < _needed) {
2270         _exception = 1;
2271         _exceptionType = "java/lang/IllegalArgumentException";
2272         _exceptionMessage = "remaining() < needed";
2273         goto exit;
2274     }
2275     if (params == NULL) {
2276         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
2277         params = (GLfixed *) (_paramsBase + _bufferOffset);
2278     }
2279     glLightModelxv(
2280         (GLenum)pname,
2281         (GLfixed *)params
2282     );
2283 
2284 exit:
2285     if (_array) {
2286         _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT);
2287     }
2288     if (_exception) {
2289         jniThrowException(_env, _exceptionType, _exceptionMessage);
2290     }
2291 }
2292 
2293 /* void glLightf ( GLenum light, GLenum pname, GLfloat param ) */
2294 static void
android_glLightf__IIF(JNIEnv * _env,jobject _this,jint light,jint pname,jfloat param)2295 android_glLightf__IIF
2296   (JNIEnv *_env, jobject _this, jint light, jint pname, jfloat param) {
2297     glLightf(
2298         (GLenum)light,
2299         (GLenum)pname,
2300         (GLfloat)param
2301     );
2302 }
2303 
2304 /* void glLightfv ( GLenum light, GLenum pname, const GLfloat *params ) */
2305 static void
android_glLightfv__II_3FI(JNIEnv * _env,jobject _this,jint light,jint pname,jfloatArray params_ref,jint offset)2306 android_glLightfv__II_3FI
2307   (JNIEnv *_env, jobject _this, jint light, jint pname, jfloatArray params_ref, jint offset) {
2308     jint _exception = 0;
2309     const char * _exceptionType = NULL;
2310     const char * _exceptionMessage = NULL;
2311     GLfloat *params_base = (GLfloat *) 0;
2312     jint _remaining;
2313     GLfloat *params = (GLfloat *) 0;
2314 
2315     if (!params_ref) {
2316         _exception = 1;
2317         _exceptionType = "java/lang/IllegalArgumentException";
2318         _exceptionMessage = "params == null";
2319         goto exit;
2320     }
2321     if (offset < 0) {
2322         _exception = 1;
2323         _exceptionType = "java/lang/IllegalArgumentException";
2324         _exceptionMessage = "offset < 0";
2325         goto exit;
2326     }
2327     _remaining = _env->GetArrayLength(params_ref) - offset;
2328     int _needed;
2329     switch (pname) {
2330 #if defined(GL_SPOT_EXPONENT)
2331         case GL_SPOT_EXPONENT:
2332 #endif // defined(GL_SPOT_EXPONENT)
2333 #if defined(GL_SPOT_CUTOFF)
2334         case GL_SPOT_CUTOFF:
2335 #endif // defined(GL_SPOT_CUTOFF)
2336 #if defined(GL_CONSTANT_ATTENUATION)
2337         case GL_CONSTANT_ATTENUATION:
2338 #endif // defined(GL_CONSTANT_ATTENUATION)
2339 #if defined(GL_LINEAR_ATTENUATION)
2340         case GL_LINEAR_ATTENUATION:
2341 #endif // defined(GL_LINEAR_ATTENUATION)
2342 #if defined(GL_QUADRATIC_ATTENUATION)
2343         case GL_QUADRATIC_ATTENUATION:
2344 #endif // defined(GL_QUADRATIC_ATTENUATION)
2345             _needed = 1;
2346             break;
2347 #if defined(GL_SPOT_DIRECTION)
2348         case GL_SPOT_DIRECTION:
2349 #endif // defined(GL_SPOT_DIRECTION)
2350             _needed = 3;
2351             break;
2352 #if defined(GL_AMBIENT)
2353         case GL_AMBIENT:
2354 #endif // defined(GL_AMBIENT)
2355 #if defined(GL_DIFFUSE)
2356         case GL_DIFFUSE:
2357 #endif // defined(GL_DIFFUSE)
2358 #if defined(GL_SPECULAR)
2359         case GL_SPECULAR:
2360 #endif // defined(GL_SPECULAR)
2361 #if defined(GL_EMISSION)
2362         case GL_EMISSION:
2363 #endif // defined(GL_EMISSION)
2364             _needed = 4;
2365             break;
2366         default:
2367             _needed = 1;
2368             break;
2369     }
2370     if (_remaining < _needed) {
2371         _exception = 1;
2372         _exceptionType = "java/lang/IllegalArgumentException";
2373         _exceptionMessage = "length - offset < needed";
2374         goto exit;
2375     }
2376     params_base = (GLfloat *)
2377         _env->GetFloatArrayElements(params_ref, (jboolean *)0);
2378     params = params_base + offset;
2379 
2380     glLightfv(
2381         (GLenum)light,
2382         (GLenum)pname,
2383         (GLfloat *)params
2384     );
2385 
2386 exit:
2387     if (params_base) {
2388         _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
2389             JNI_ABORT);
2390     }
2391     if (_exception) {
2392         jniThrowException(_env, _exceptionType, _exceptionMessage);
2393     }
2394 }
2395 
2396 /* void glLightfv ( GLenum light, GLenum pname, const GLfloat *params ) */
2397 static void
android_glLightfv__IILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint light,jint pname,jobject params_buf)2398 android_glLightfv__IILjava_nio_FloatBuffer_2
2399   (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) {
2400     jint _exception = 0;
2401     const char * _exceptionType = NULL;
2402     const char * _exceptionMessage = NULL;
2403     jfloatArray _array = (jfloatArray) 0;
2404     jint _bufferOffset = (jint) 0;
2405     jint _remaining;
2406     GLfloat *params = (GLfloat *) 0;
2407 
2408     if (!params_buf) {
2409         _exception = 1;
2410         _exceptionType = "java/lang/IllegalArgumentException";
2411         _exceptionMessage = "params == null";
2412         goto exit;
2413     }
2414     params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2415     int _needed;
2416     switch (pname) {
2417 #if defined(GL_SPOT_EXPONENT)
2418         case GL_SPOT_EXPONENT:
2419 #endif // defined(GL_SPOT_EXPONENT)
2420 #if defined(GL_SPOT_CUTOFF)
2421         case GL_SPOT_CUTOFF:
2422 #endif // defined(GL_SPOT_CUTOFF)
2423 #if defined(GL_CONSTANT_ATTENUATION)
2424         case GL_CONSTANT_ATTENUATION:
2425 #endif // defined(GL_CONSTANT_ATTENUATION)
2426 #if defined(GL_LINEAR_ATTENUATION)
2427         case GL_LINEAR_ATTENUATION:
2428 #endif // defined(GL_LINEAR_ATTENUATION)
2429 #if defined(GL_QUADRATIC_ATTENUATION)
2430         case GL_QUADRATIC_ATTENUATION:
2431 #endif // defined(GL_QUADRATIC_ATTENUATION)
2432             _needed = 1;
2433             break;
2434 #if defined(GL_SPOT_DIRECTION)
2435         case GL_SPOT_DIRECTION:
2436 #endif // defined(GL_SPOT_DIRECTION)
2437             _needed = 3;
2438             break;
2439 #if defined(GL_AMBIENT)
2440         case GL_AMBIENT:
2441 #endif // defined(GL_AMBIENT)
2442 #if defined(GL_DIFFUSE)
2443         case GL_DIFFUSE:
2444 #endif // defined(GL_DIFFUSE)
2445 #if defined(GL_SPECULAR)
2446         case GL_SPECULAR:
2447 #endif // defined(GL_SPECULAR)
2448 #if defined(GL_EMISSION)
2449         case GL_EMISSION:
2450 #endif // defined(GL_EMISSION)
2451             _needed = 4;
2452             break;
2453         default:
2454             _needed = 1;
2455             break;
2456     }
2457     if (_remaining < _needed) {
2458         _exception = 1;
2459         _exceptionType = "java/lang/IllegalArgumentException";
2460         _exceptionMessage = "remaining() < needed";
2461         goto exit;
2462     }
2463     if (params == NULL) {
2464         char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
2465         params = (GLfloat *) (_paramsBase + _bufferOffset);
2466     }
2467     glLightfv(
2468         (GLenum)light,
2469         (GLenum)pname,
2470         (GLfloat *)params
2471     );
2472 
2473 exit:
2474     if (_array) {
2475         _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT);
2476     }
2477     if (_exception) {
2478         jniThrowException(_env, _exceptionType, _exceptionMessage);
2479     }
2480 }
2481 
2482 /* void glLightx ( GLenum light, GLenum pname, GLfixed param ) */
2483 static void
android_glLightx__III(JNIEnv * _env,jobject _this,jint light,jint pname,jint param)2484 android_glLightx__III
2485   (JNIEnv *_env, jobject _this, jint light, jint pname, jint param) {
2486     glLightx(
2487         (GLenum)light,
2488         (GLenum)pname,
2489         (GLfixed)param
2490     );
2491 }
2492 
2493 /* void glLightxv ( GLenum light, GLenum pname, const GLfixed *params ) */
2494 static void
android_glLightxv__II_3II(JNIEnv * _env,jobject _this,jint light,jint pname,jintArray params_ref,jint offset)2495 android_glLightxv__II_3II
2496   (JNIEnv *_env, jobject _this, jint light, jint pname, jintArray params_ref, jint offset) {
2497     jint _exception = 0;
2498     const char * _exceptionType = NULL;
2499     const char * _exceptionMessage = NULL;
2500     GLfixed *params_base = (GLfixed *) 0;
2501     jint _remaining;
2502     GLfixed *params = (GLfixed *) 0;
2503 
2504     if (!params_ref) {
2505         _exception = 1;
2506         _exceptionType = "java/lang/IllegalArgumentException";
2507         _exceptionMessage = "params == null";
2508         goto exit;
2509     }
2510     if (offset < 0) {
2511         _exception = 1;
2512         _exceptionType = "java/lang/IllegalArgumentException";
2513         _exceptionMessage = "offset < 0";
2514         goto exit;
2515     }
2516     _remaining = _env->GetArrayLength(params_ref) - offset;
2517     int _needed;
2518     switch (pname) {
2519 #if defined(GL_SPOT_EXPONENT)
2520         case GL_SPOT_EXPONENT:
2521 #endif // defined(GL_SPOT_EXPONENT)
2522 #if defined(GL_SPOT_CUTOFF)
2523         case GL_SPOT_CUTOFF:
2524 #endif // defined(GL_SPOT_CUTOFF)
2525 #if defined(GL_CONSTANT_ATTENUATION)
2526         case GL_CONSTANT_ATTENUATION:
2527 #endif // defined(GL_CONSTANT_ATTENUATION)
2528 #if defined(GL_LINEAR_ATTENUATION)
2529         case GL_LINEAR_ATTENUATION:
2530 #endif // defined(GL_LINEAR_ATTENUATION)
2531 #if defined(GL_QUADRATIC_ATTENUATION)
2532         case GL_QUADRATIC_ATTENUATION:
2533 #endif // defined(GL_QUADRATIC_ATTENUATION)
2534             _needed = 1;
2535             break;
2536 #if defined(GL_SPOT_DIRECTION)
2537         case GL_SPOT_DIRECTION:
2538 #endif // defined(GL_SPOT_DIRECTION)
2539             _needed = 3;
2540             break;
2541 #if defined(GL_AMBIENT)
2542         case GL_AMBIENT:
2543 #endif // defined(GL_AMBIENT)
2544 #if defined(GL_DIFFUSE)
2545         case GL_DIFFUSE:
2546 #endif // defined(GL_DIFFUSE)
2547 #if defined(GL_SPECULAR)
2548         case GL_SPECULAR:
2549 #endif // defined(GL_SPECULAR)
2550 #if defined(GL_EMISSION)
2551         case GL_EMISSION:
2552 #endif // defined(GL_EMISSION)
2553             _needed = 4;
2554             break;
2555         default:
2556             _needed = 1;
2557             break;
2558     }
2559     if (_remaining < _needed) {
2560         _exception = 1;
2561         _exceptionType = "java/lang/IllegalArgumentException";
2562         _exceptionMessage = "length - offset < needed";
2563         goto exit;
2564     }
2565     params_base = (GLfixed *)
2566         _env->GetIntArrayElements(params_ref, (jboolean *)0);
2567     params = params_base + offset;
2568 
2569     glLightxv(
2570         (GLenum)light,
2571         (GLenum)pname,
2572         (GLfixed *)params
2573     );
2574 
2575 exit:
2576     if (params_base) {
2577         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
2578             JNI_ABORT);
2579     }
2580     if (_exception) {
2581         jniThrowException(_env, _exceptionType, _exceptionMessage);
2582     }
2583 }
2584 
2585 /* void glLightxv ( GLenum light, GLenum pname, const GLfixed *params ) */
2586 static void
android_glLightxv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint light,jint pname,jobject params_buf)2587 android_glLightxv__IILjava_nio_IntBuffer_2
2588   (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) {
2589     jint _exception = 0;
2590     const char * _exceptionType = NULL;
2591     const char * _exceptionMessage = NULL;
2592     jintArray _array = (jintArray) 0;
2593     jint _bufferOffset = (jint) 0;
2594     jint _remaining;
2595     GLfixed *params = (GLfixed *) 0;
2596 
2597     if (!params_buf) {
2598         _exception = 1;
2599         _exceptionType = "java/lang/IllegalArgumentException";
2600         _exceptionMessage = "params == null";
2601         goto exit;
2602     }
2603     params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2604     int _needed;
2605     switch (pname) {
2606 #if defined(GL_SPOT_EXPONENT)
2607         case GL_SPOT_EXPONENT:
2608 #endif // defined(GL_SPOT_EXPONENT)
2609 #if defined(GL_SPOT_CUTOFF)
2610         case GL_SPOT_CUTOFF:
2611 #endif // defined(GL_SPOT_CUTOFF)
2612 #if defined(GL_CONSTANT_ATTENUATION)
2613         case GL_CONSTANT_ATTENUATION:
2614 #endif // defined(GL_CONSTANT_ATTENUATION)
2615 #if defined(GL_LINEAR_ATTENUATION)
2616         case GL_LINEAR_ATTENUATION:
2617 #endif // defined(GL_LINEAR_ATTENUATION)
2618 #if defined(GL_QUADRATIC_ATTENUATION)
2619         case GL_QUADRATIC_ATTENUATION:
2620 #endif // defined(GL_QUADRATIC_ATTENUATION)
2621             _needed = 1;
2622             break;
2623 #if defined(GL_SPOT_DIRECTION)
2624         case GL_SPOT_DIRECTION:
2625 #endif // defined(GL_SPOT_DIRECTION)
2626             _needed = 3;
2627             break;
2628 #if defined(GL_AMBIENT)
2629         case GL_AMBIENT:
2630 #endif // defined(GL_AMBIENT)
2631 #if defined(GL_DIFFUSE)
2632         case GL_DIFFUSE:
2633 #endif // defined(GL_DIFFUSE)
2634 #if defined(GL_SPECULAR)
2635         case GL_SPECULAR:
2636 #endif // defined(GL_SPECULAR)
2637 #if defined(GL_EMISSION)
2638         case GL_EMISSION:
2639 #endif // defined(GL_EMISSION)
2640             _needed = 4;
2641             break;
2642         default:
2643             _needed = 1;
2644             break;
2645     }
2646     if (_remaining < _needed) {
2647         _exception = 1;
2648         _exceptionType = "java/lang/IllegalArgumentException";
2649         _exceptionMessage = "remaining() < needed";
2650         goto exit;
2651     }
2652     if (params == NULL) {
2653         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
2654         params = (GLfixed *) (_paramsBase + _bufferOffset);
2655     }
2656     glLightxv(
2657         (GLenum)light,
2658         (GLenum)pname,
2659         (GLfixed *)params
2660     );
2661 
2662 exit:
2663     if (_array) {
2664         _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT);
2665     }
2666     if (_exception) {
2667         jniThrowException(_env, _exceptionType, _exceptionMessage);
2668     }
2669 }
2670 
2671 /* void glLineWidth ( GLfloat width ) */
2672 static void
android_glLineWidth__F(JNIEnv * _env,jobject _this,jfloat width)2673 android_glLineWidth__F
2674   (JNIEnv *_env, jobject _this, jfloat width) {
2675     glLineWidth(
2676         (GLfloat)width
2677     );
2678 }
2679 
2680 /* void glLineWidthx ( GLfixed width ) */
2681 static void
android_glLineWidthx__I(JNIEnv * _env,jobject _this,jint width)2682 android_glLineWidthx__I
2683   (JNIEnv *_env, jobject _this, jint width) {
2684     glLineWidthx(
2685         (GLfixed)width
2686     );
2687 }
2688 
2689 /* void glLoadIdentity ( void ) */
2690 static void
android_glLoadIdentity__(JNIEnv * _env,jobject _this)2691 android_glLoadIdentity__
2692   (JNIEnv *_env, jobject _this) {
2693     glLoadIdentity();
2694 }
2695 
2696 /* void glLoadMatrixf ( const GLfloat *m ) */
2697 static void
android_glLoadMatrixf___3FI(JNIEnv * _env,jobject _this,jfloatArray m_ref,jint offset)2698 android_glLoadMatrixf___3FI
2699   (JNIEnv *_env, jobject _this, jfloatArray m_ref, jint offset) {
2700     jint _exception = 0;
2701     const char * _exceptionType = NULL;
2702     const char * _exceptionMessage = NULL;
2703     GLfloat *m_base = (GLfloat *) 0;
2704     jint _remaining;
2705     GLfloat *m = (GLfloat *) 0;
2706 
2707     if (!m_ref) {
2708         _exception = 1;
2709         _exceptionType = "java/lang/IllegalArgumentException";
2710         _exceptionMessage = "m == null";
2711         goto exit;
2712     }
2713     if (offset < 0) {
2714         _exception = 1;
2715         _exceptionType = "java/lang/IllegalArgumentException";
2716         _exceptionMessage = "offset < 0";
2717         goto exit;
2718     }
2719     _remaining = _env->GetArrayLength(m_ref) - offset;
2720     m_base = (GLfloat *)
2721         _env->GetFloatArrayElements(m_ref, (jboolean *)0);
2722     m = m_base + offset;
2723 
2724     glLoadMatrixf(
2725         (GLfloat *)m
2726     );
2727 
2728 exit:
2729     if (m_base) {
2730         _env->ReleaseFloatArrayElements(m_ref, (jfloat*)m_base,
2731             JNI_ABORT);
2732     }
2733     if (_exception) {
2734         jniThrowException(_env, _exceptionType, _exceptionMessage);
2735     }
2736 }
2737 
2738 /* void glLoadMatrixf ( const GLfloat *m ) */
2739 static void
android_glLoadMatrixf__Ljava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jobject m_buf)2740 android_glLoadMatrixf__Ljava_nio_FloatBuffer_2
2741   (JNIEnv *_env, jobject _this, jobject m_buf) {
2742     jint _exception = 0;
2743     const char * _exceptionType = NULL;
2744     const char * _exceptionMessage = NULL;
2745     jfloatArray _array = (jfloatArray) 0;
2746     jint _bufferOffset = (jint) 0;
2747     jint _remaining;
2748     GLfloat *m = (GLfloat *) 0;
2749 
2750     if (!m_buf) {
2751         _exception = 1;
2752         _exceptionType = "java/lang/IllegalArgumentException";
2753         _exceptionMessage = "m == null";
2754         goto exit;
2755     }
2756     m = (GLfloat *)getPointer(_env, m_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2757     if (m == NULL) {
2758         char * _mBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
2759         m = (GLfloat *) (_mBase + _bufferOffset);
2760     }
2761     glLoadMatrixf(
2762         (GLfloat *)m
2763     );
2764 
2765 exit:
2766     if (_array) {
2767         _env->ReleaseFloatArrayElements(_array, (jfloat*)m, JNI_ABORT);
2768     }
2769     if (_exception) {
2770         jniThrowException(_env, _exceptionType, _exceptionMessage);
2771     }
2772 }
2773 
2774 /* void glLoadMatrixx ( const GLfixed *m ) */
2775 static void
android_glLoadMatrixx___3II(JNIEnv * _env,jobject _this,jintArray m_ref,jint offset)2776 android_glLoadMatrixx___3II
2777   (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) {
2778     jint _exception = 0;
2779     const char * _exceptionType = NULL;
2780     const char * _exceptionMessage = NULL;
2781     GLfixed *m_base = (GLfixed *) 0;
2782     jint _remaining;
2783     GLfixed *m = (GLfixed *) 0;
2784 
2785     if (!m_ref) {
2786         _exception = 1;
2787         _exceptionType = "java/lang/IllegalArgumentException";
2788         _exceptionMessage = "m == null";
2789         goto exit;
2790     }
2791     if (offset < 0) {
2792         _exception = 1;
2793         _exceptionType = "java/lang/IllegalArgumentException";
2794         _exceptionMessage = "offset < 0";
2795         goto exit;
2796     }
2797     _remaining = _env->GetArrayLength(m_ref) - offset;
2798     m_base = (GLfixed *)
2799         _env->GetIntArrayElements(m_ref, (jboolean *)0);
2800     m = m_base + offset;
2801 
2802     glLoadMatrixx(
2803         (GLfixed *)m
2804     );
2805 
2806 exit:
2807     if (m_base) {
2808         _env->ReleaseIntArrayElements(m_ref, (jint*)m_base,
2809             JNI_ABORT);
2810     }
2811     if (_exception) {
2812         jniThrowException(_env, _exceptionType, _exceptionMessage);
2813     }
2814 }
2815 
2816 /* void glLoadMatrixx ( const GLfixed *m ) */
2817 static void
android_glLoadMatrixx__Ljava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jobject m_buf)2818 android_glLoadMatrixx__Ljava_nio_IntBuffer_2
2819   (JNIEnv *_env, jobject _this, jobject m_buf) {
2820     jint _exception = 0;
2821     const char * _exceptionType = NULL;
2822     const char * _exceptionMessage = NULL;
2823     jintArray _array = (jintArray) 0;
2824     jint _bufferOffset = (jint) 0;
2825     jint _remaining;
2826     GLfixed *m = (GLfixed *) 0;
2827 
2828     if (!m_buf) {
2829         _exception = 1;
2830         _exceptionType = "java/lang/IllegalArgumentException";
2831         _exceptionMessage = "m == null";
2832         goto exit;
2833     }
2834     m = (GLfixed *)getPointer(_env, m_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2835     if (m == NULL) {
2836         char * _mBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
2837         m = (GLfixed *) (_mBase + _bufferOffset);
2838     }
2839     glLoadMatrixx(
2840         (GLfixed *)m
2841     );
2842 
2843 exit:
2844     if (_array) {
2845         _env->ReleaseIntArrayElements(_array, (jint*)m, JNI_ABORT);
2846     }
2847     if (_exception) {
2848         jniThrowException(_env, _exceptionType, _exceptionMessage);
2849     }
2850 }
2851 
2852 /* void glLogicOp ( GLenum opcode ) */
2853 static void
android_glLogicOp__I(JNIEnv * _env,jobject _this,jint opcode)2854 android_glLogicOp__I
2855   (JNIEnv *_env, jobject _this, jint opcode) {
2856     glLogicOp(
2857         (GLenum)opcode
2858     );
2859 }
2860 
2861 /* void glMaterialf ( GLenum face, GLenum pname, GLfloat param ) */
2862 static void
android_glMaterialf__IIF(JNIEnv * _env,jobject _this,jint face,jint pname,jfloat param)2863 android_glMaterialf__IIF
2864   (JNIEnv *_env, jobject _this, jint face, jint pname, jfloat param) {
2865     glMaterialf(
2866         (GLenum)face,
2867         (GLenum)pname,
2868         (GLfloat)param
2869     );
2870 }
2871 
2872 /* void glMaterialfv ( GLenum face, GLenum pname, const GLfloat *params ) */
2873 static void
android_glMaterialfv__II_3FI(JNIEnv * _env,jobject _this,jint face,jint pname,jfloatArray params_ref,jint offset)2874 android_glMaterialfv__II_3FI
2875   (JNIEnv *_env, jobject _this, jint face, jint pname, jfloatArray params_ref, jint offset) {
2876     jint _exception = 0;
2877     const char * _exceptionType = NULL;
2878     const char * _exceptionMessage = NULL;
2879     GLfloat *params_base = (GLfloat *) 0;
2880     jint _remaining;
2881     GLfloat *params = (GLfloat *) 0;
2882 
2883     if (!params_ref) {
2884         _exception = 1;
2885         _exceptionType = "java/lang/IllegalArgumentException";
2886         _exceptionMessage = "params == null";
2887         goto exit;
2888     }
2889     if (offset < 0) {
2890         _exception = 1;
2891         _exceptionType = "java/lang/IllegalArgumentException";
2892         _exceptionMessage = "offset < 0";
2893         goto exit;
2894     }
2895     _remaining = _env->GetArrayLength(params_ref) - offset;
2896     int _needed;
2897     switch (pname) {
2898 #if defined(GL_SHININESS)
2899         case GL_SHININESS:
2900 #endif // defined(GL_SHININESS)
2901             _needed = 1;
2902             break;
2903 #if defined(GL_AMBIENT)
2904         case GL_AMBIENT:
2905 #endif // defined(GL_AMBIENT)
2906 #if defined(GL_DIFFUSE)
2907         case GL_DIFFUSE:
2908 #endif // defined(GL_DIFFUSE)
2909 #if defined(GL_SPECULAR)
2910         case GL_SPECULAR:
2911 #endif // defined(GL_SPECULAR)
2912 #if defined(GL_EMISSION)
2913         case GL_EMISSION:
2914 #endif // defined(GL_EMISSION)
2915 #if defined(GL_AMBIENT_AND_DIFFUSE)
2916         case GL_AMBIENT_AND_DIFFUSE:
2917 #endif // defined(GL_AMBIENT_AND_DIFFUSE)
2918             _needed = 4;
2919             break;
2920         default:
2921             _needed = 1;
2922             break;
2923     }
2924     if (_remaining < _needed) {
2925         _exception = 1;
2926         _exceptionType = "java/lang/IllegalArgumentException";
2927         _exceptionMessage = "length - offset < needed";
2928         goto exit;
2929     }
2930     params_base = (GLfloat *)
2931         _env->GetFloatArrayElements(params_ref, (jboolean *)0);
2932     params = params_base + offset;
2933 
2934     glMaterialfv(
2935         (GLenum)face,
2936         (GLenum)pname,
2937         (GLfloat *)params
2938     );
2939 
2940 exit:
2941     if (params_base) {
2942         _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
2943             JNI_ABORT);
2944     }
2945     if (_exception) {
2946         jniThrowException(_env, _exceptionType, _exceptionMessage);
2947     }
2948 }
2949 
2950 /* void glMaterialfv ( GLenum face, GLenum pname, const GLfloat *params ) */
2951 static void
android_glMaterialfv__IILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint face,jint pname,jobject params_buf)2952 android_glMaterialfv__IILjava_nio_FloatBuffer_2
2953   (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) {
2954     jint _exception = 0;
2955     const char * _exceptionType = NULL;
2956     const char * _exceptionMessage = NULL;
2957     jfloatArray _array = (jfloatArray) 0;
2958     jint _bufferOffset = (jint) 0;
2959     jint _remaining;
2960     GLfloat *params = (GLfloat *) 0;
2961 
2962     if (!params_buf) {
2963         _exception = 1;
2964         _exceptionType = "java/lang/IllegalArgumentException";
2965         _exceptionMessage = "params == null";
2966         goto exit;
2967     }
2968     params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2969     int _needed;
2970     switch (pname) {
2971 #if defined(GL_SHININESS)
2972         case GL_SHININESS:
2973 #endif // defined(GL_SHININESS)
2974             _needed = 1;
2975             break;
2976 #if defined(GL_AMBIENT)
2977         case GL_AMBIENT:
2978 #endif // defined(GL_AMBIENT)
2979 #if defined(GL_DIFFUSE)
2980         case GL_DIFFUSE:
2981 #endif // defined(GL_DIFFUSE)
2982 #if defined(GL_SPECULAR)
2983         case GL_SPECULAR:
2984 #endif // defined(GL_SPECULAR)
2985 #if defined(GL_EMISSION)
2986         case GL_EMISSION:
2987 #endif // defined(GL_EMISSION)
2988 #if defined(GL_AMBIENT_AND_DIFFUSE)
2989         case GL_AMBIENT_AND_DIFFUSE:
2990 #endif // defined(GL_AMBIENT_AND_DIFFUSE)
2991             _needed = 4;
2992             break;
2993         default:
2994             _needed = 1;
2995             break;
2996     }
2997     if (_remaining < _needed) {
2998         _exception = 1;
2999         _exceptionType = "java/lang/IllegalArgumentException";
3000         _exceptionMessage = "remaining() < needed";
3001         goto exit;
3002     }
3003     if (params == NULL) {
3004         char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
3005         params = (GLfloat *) (_paramsBase + _bufferOffset);
3006     }
3007     glMaterialfv(
3008         (GLenum)face,
3009         (GLenum)pname,
3010         (GLfloat *)params
3011     );
3012 
3013 exit:
3014     if (_array) {
3015         _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT);
3016     }
3017     if (_exception) {
3018         jniThrowException(_env, _exceptionType, _exceptionMessage);
3019     }
3020 }
3021 
3022 /* void glMaterialx ( GLenum face, GLenum pname, GLfixed param ) */
3023 static void
android_glMaterialx__III(JNIEnv * _env,jobject _this,jint face,jint pname,jint param)3024 android_glMaterialx__III
3025   (JNIEnv *_env, jobject _this, jint face, jint pname, jint param) {
3026     glMaterialx(
3027         (GLenum)face,
3028         (GLenum)pname,
3029         (GLfixed)param
3030     );
3031 }
3032 
3033 /* void glMaterialxv ( GLenum face, GLenum pname, const GLfixed *params ) */
3034 static void
android_glMaterialxv__II_3II(JNIEnv * _env,jobject _this,jint face,jint pname,jintArray params_ref,jint offset)3035 android_glMaterialxv__II_3II
3036   (JNIEnv *_env, jobject _this, jint face, jint pname, jintArray params_ref, jint offset) {
3037     jint _exception = 0;
3038     const char * _exceptionType = NULL;
3039     const char * _exceptionMessage = NULL;
3040     GLfixed *params_base = (GLfixed *) 0;
3041     jint _remaining;
3042     GLfixed *params = (GLfixed *) 0;
3043 
3044     if (!params_ref) {
3045         _exception = 1;
3046         _exceptionType = "java/lang/IllegalArgumentException";
3047         _exceptionMessage = "params == null";
3048         goto exit;
3049     }
3050     if (offset < 0) {
3051         _exception = 1;
3052         _exceptionType = "java/lang/IllegalArgumentException";
3053         _exceptionMessage = "offset < 0";
3054         goto exit;
3055     }
3056     _remaining = _env->GetArrayLength(params_ref) - offset;
3057     int _needed;
3058     switch (pname) {
3059 #if defined(GL_SHININESS)
3060         case GL_SHININESS:
3061 #endif // defined(GL_SHININESS)
3062             _needed = 1;
3063             break;
3064 #if defined(GL_AMBIENT)
3065         case GL_AMBIENT:
3066 #endif // defined(GL_AMBIENT)
3067 #if defined(GL_DIFFUSE)
3068         case GL_DIFFUSE:
3069 #endif // defined(GL_DIFFUSE)
3070 #if defined(GL_SPECULAR)
3071         case GL_SPECULAR:
3072 #endif // defined(GL_SPECULAR)
3073 #if defined(GL_EMISSION)
3074         case GL_EMISSION:
3075 #endif // defined(GL_EMISSION)
3076 #if defined(GL_AMBIENT_AND_DIFFUSE)
3077         case GL_AMBIENT_AND_DIFFUSE:
3078 #endif // defined(GL_AMBIENT_AND_DIFFUSE)
3079             _needed = 4;
3080             break;
3081         default:
3082             _needed = 1;
3083             break;
3084     }
3085     if (_remaining < _needed) {
3086         _exception = 1;
3087         _exceptionType = "java/lang/IllegalArgumentException";
3088         _exceptionMessage = "length - offset < needed";
3089         goto exit;
3090     }
3091     params_base = (GLfixed *)
3092         _env->GetIntArrayElements(params_ref, (jboolean *)0);
3093     params = params_base + offset;
3094 
3095     glMaterialxv(
3096         (GLenum)face,
3097         (GLenum)pname,
3098         (GLfixed *)params
3099     );
3100 
3101 exit:
3102     if (params_base) {
3103         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
3104             JNI_ABORT);
3105     }
3106     if (_exception) {
3107         jniThrowException(_env, _exceptionType, _exceptionMessage);
3108     }
3109 }
3110 
3111 /* void glMaterialxv ( GLenum face, GLenum pname, const GLfixed *params ) */
3112 static void
android_glMaterialxv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint face,jint pname,jobject params_buf)3113 android_glMaterialxv__IILjava_nio_IntBuffer_2
3114   (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) {
3115     jint _exception = 0;
3116     const char * _exceptionType = NULL;
3117     const char * _exceptionMessage = NULL;
3118     jintArray _array = (jintArray) 0;
3119     jint _bufferOffset = (jint) 0;
3120     jint _remaining;
3121     GLfixed *params = (GLfixed *) 0;
3122 
3123     if (!params_buf) {
3124         _exception = 1;
3125         _exceptionType = "java/lang/IllegalArgumentException";
3126         _exceptionMessage = "params == null";
3127         goto exit;
3128     }
3129     params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
3130     int _needed;
3131     switch (pname) {
3132 #if defined(GL_SHININESS)
3133         case GL_SHININESS:
3134 #endif // defined(GL_SHININESS)
3135             _needed = 1;
3136             break;
3137 #if defined(GL_AMBIENT)
3138         case GL_AMBIENT:
3139 #endif // defined(GL_AMBIENT)
3140 #if defined(GL_DIFFUSE)
3141         case GL_DIFFUSE:
3142 #endif // defined(GL_DIFFUSE)
3143 #if defined(GL_SPECULAR)
3144         case GL_SPECULAR:
3145 #endif // defined(GL_SPECULAR)
3146 #if defined(GL_EMISSION)
3147         case GL_EMISSION:
3148 #endif // defined(GL_EMISSION)
3149 #if defined(GL_AMBIENT_AND_DIFFUSE)
3150         case GL_AMBIENT_AND_DIFFUSE:
3151 #endif // defined(GL_AMBIENT_AND_DIFFUSE)
3152             _needed = 4;
3153             break;
3154         default:
3155             _needed = 1;
3156             break;
3157     }
3158     if (_remaining < _needed) {
3159         _exception = 1;
3160         _exceptionType = "java/lang/IllegalArgumentException";
3161         _exceptionMessage = "remaining() < needed";
3162         goto exit;
3163     }
3164     if (params == NULL) {
3165         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
3166         params = (GLfixed *) (_paramsBase + _bufferOffset);
3167     }
3168     glMaterialxv(
3169         (GLenum)face,
3170         (GLenum)pname,
3171         (GLfixed *)params
3172     );
3173 
3174 exit:
3175     if (_array) {
3176         _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT);
3177     }
3178     if (_exception) {
3179         jniThrowException(_env, _exceptionType, _exceptionMessage);
3180     }
3181 }
3182 
3183 /* void glMatrixMode ( GLenum mode ) */
3184 static void
android_glMatrixMode__I(JNIEnv * _env,jobject _this,jint mode)3185 android_glMatrixMode__I
3186   (JNIEnv *_env, jobject _this, jint mode) {
3187     glMatrixMode(
3188         (GLenum)mode
3189     );
3190 }
3191 
3192 /* void glMultMatrixf ( const GLfloat *m ) */
3193 static void
android_glMultMatrixf___3FI(JNIEnv * _env,jobject _this,jfloatArray m_ref,jint offset)3194 android_glMultMatrixf___3FI
3195   (JNIEnv *_env, jobject _this, jfloatArray m_ref, jint offset) {
3196     jint _exception = 0;
3197     const char * _exceptionType = NULL;
3198     const char * _exceptionMessage = NULL;
3199     GLfloat *m_base = (GLfloat *) 0;
3200     jint _remaining;
3201     GLfloat *m = (GLfloat *) 0;
3202 
3203     if (!m_ref) {
3204         _exception = 1;
3205         _exceptionType = "java/lang/IllegalArgumentException";
3206         _exceptionMessage = "m == null";
3207         goto exit;
3208     }
3209     if (offset < 0) {
3210         _exception = 1;
3211         _exceptionType = "java/lang/IllegalArgumentException";
3212         _exceptionMessage = "offset < 0";
3213         goto exit;
3214     }
3215     _remaining = _env->GetArrayLength(m_ref) - offset;
3216     m_base = (GLfloat *)
3217         _env->GetFloatArrayElements(m_ref, (jboolean *)0);
3218     m = m_base + offset;
3219 
3220     glMultMatrixf(
3221         (GLfloat *)m
3222     );
3223 
3224 exit:
3225     if (m_base) {
3226         _env->ReleaseFloatArrayElements(m_ref, (jfloat*)m_base,
3227             JNI_ABORT);
3228     }
3229     if (_exception) {
3230         jniThrowException(_env, _exceptionType, _exceptionMessage);
3231     }
3232 }
3233 
3234 /* void glMultMatrixf ( const GLfloat *m ) */
3235 static void
android_glMultMatrixf__Ljava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jobject m_buf)3236 android_glMultMatrixf__Ljava_nio_FloatBuffer_2
3237   (JNIEnv *_env, jobject _this, jobject m_buf) {
3238     jint _exception = 0;
3239     const char * _exceptionType = NULL;
3240     const char * _exceptionMessage = NULL;
3241     jfloatArray _array = (jfloatArray) 0;
3242     jint _bufferOffset = (jint) 0;
3243     jint _remaining;
3244     GLfloat *m = (GLfloat *) 0;
3245 
3246     if (!m_buf) {
3247         _exception = 1;
3248         _exceptionType = "java/lang/IllegalArgumentException";
3249         _exceptionMessage = "m == null";
3250         goto exit;
3251     }
3252     m = (GLfloat *)getPointer(_env, m_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
3253     if (m == NULL) {
3254         char * _mBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
3255         m = (GLfloat *) (_mBase + _bufferOffset);
3256     }
3257     glMultMatrixf(
3258         (GLfloat *)m
3259     );
3260 
3261 exit:
3262     if (_array) {
3263         _env->ReleaseFloatArrayElements(_array, (jfloat*)m, JNI_ABORT);
3264     }
3265     if (_exception) {
3266         jniThrowException(_env, _exceptionType, _exceptionMessage);
3267     }
3268 }
3269 
3270 /* void glMultMatrixx ( const GLfixed *m ) */
3271 static void
android_glMultMatrixx___3II(JNIEnv * _env,jobject _this,jintArray m_ref,jint offset)3272 android_glMultMatrixx___3II
3273   (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) {
3274     jint _exception = 0;
3275     const char * _exceptionType = NULL;
3276     const char * _exceptionMessage = NULL;
3277     GLfixed *m_base = (GLfixed *) 0;
3278     jint _remaining;
3279     GLfixed *m = (GLfixed *) 0;
3280 
3281     if (!m_ref) {
3282         _exception = 1;
3283         _exceptionType = "java/lang/IllegalArgumentException";
3284         _exceptionMessage = "m == null";
3285         goto exit;
3286     }
3287     if (offset < 0) {
3288         _exception = 1;
3289         _exceptionType = "java/lang/IllegalArgumentException";
3290         _exceptionMessage = "offset < 0";
3291         goto exit;
3292     }
3293     _remaining = _env->GetArrayLength(m_ref) - offset;
3294     m_base = (GLfixed *)
3295         _env->GetIntArrayElements(m_ref, (jboolean *)0);
3296     m = m_base + offset;
3297 
3298     glMultMatrixx(
3299         (GLfixed *)m
3300     );
3301 
3302 exit:
3303     if (m_base) {
3304         _env->ReleaseIntArrayElements(m_ref, (jint*)m_base,
3305             JNI_ABORT);
3306     }
3307     if (_exception) {
3308         jniThrowException(_env, _exceptionType, _exceptionMessage);
3309     }
3310 }
3311 
3312 /* void glMultMatrixx ( const GLfixed *m ) */
3313 static void
android_glMultMatrixx__Ljava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jobject m_buf)3314 android_glMultMatrixx__Ljava_nio_IntBuffer_2
3315   (JNIEnv *_env, jobject _this, jobject m_buf) {
3316     jint _exception = 0;
3317     const char * _exceptionType = NULL;
3318     const char * _exceptionMessage = NULL;
3319     jintArray _array = (jintArray) 0;
3320     jint _bufferOffset = (jint) 0;
3321     jint _remaining;
3322     GLfixed *m = (GLfixed *) 0;
3323 
3324     if (!m_buf) {
3325         _exception = 1;
3326         _exceptionType = "java/lang/IllegalArgumentException";
3327         _exceptionMessage = "m == null";
3328         goto exit;
3329     }
3330     m = (GLfixed *)getPointer(_env, m_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
3331     if (m == NULL) {
3332         char * _mBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
3333         m = (GLfixed *) (_mBase + _bufferOffset);
3334     }
3335     glMultMatrixx(
3336         (GLfixed *)m
3337     );
3338 
3339 exit:
3340     if (_array) {
3341         _env->ReleaseIntArrayElements(_array, (jint*)m, JNI_ABORT);
3342     }
3343     if (_exception) {
3344         jniThrowException(_env, _exceptionType, _exceptionMessage);
3345     }
3346 }
3347 
3348 /* void glMultiTexCoord4f ( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q ) */
3349 static void
android_glMultiTexCoord4f__IFFFF(JNIEnv * _env,jobject _this,jint target,jfloat s,jfloat t,jfloat r,jfloat q)3350 android_glMultiTexCoord4f__IFFFF
3351   (JNIEnv *_env, jobject _this, jint target, jfloat s, jfloat t, jfloat r, jfloat q) {
3352     glMultiTexCoord4f(
3353         (GLenum)target,
3354         (GLfloat)s,
3355         (GLfloat)t,
3356         (GLfloat)r,
3357         (GLfloat)q
3358     );
3359 }
3360 
3361 /* void glMultiTexCoord4x ( GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q ) */
3362 static void
android_glMultiTexCoord4x__IIIII(JNIEnv * _env,jobject _this,jint target,jint s,jint t,jint r,jint q)3363 android_glMultiTexCoord4x__IIIII
3364   (JNIEnv *_env, jobject _this, jint target, jint s, jint t, jint r, jint q) {
3365     glMultiTexCoord4x(
3366         (GLenum)target,
3367         (GLfixed)s,
3368         (GLfixed)t,
3369         (GLfixed)r,
3370         (GLfixed)q
3371     );
3372 }
3373 
3374 /* void glNormal3f ( GLfloat nx, GLfloat ny, GLfloat nz ) */
3375 static void
android_glNormal3f__FFF(JNIEnv * _env,jobject _this,jfloat nx,jfloat ny,jfloat nz)3376 android_glNormal3f__FFF
3377   (JNIEnv *_env, jobject _this, jfloat nx, jfloat ny, jfloat nz) {
3378     glNormal3f(
3379         (GLfloat)nx,
3380         (GLfloat)ny,
3381         (GLfloat)nz
3382     );
3383 }
3384 
3385 /* void glNormal3x ( GLfixed nx, GLfixed ny, GLfixed nz ) */
3386 static void
android_glNormal3x__III(JNIEnv * _env,jobject _this,jint nx,jint ny,jint nz)3387 android_glNormal3x__III
3388   (JNIEnv *_env, jobject _this, jint nx, jint ny, jint nz) {
3389     glNormal3x(
3390         (GLfixed)nx,
3391         (GLfixed)ny,
3392         (GLfixed)nz
3393     );
3394 }
3395 
3396 /* void glNormalPointer ( GLenum type, GLsizei stride, const GLvoid *pointer ) */
3397 static void
android_glNormalPointerBounds__IILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint type,jint stride,jobject pointer_buf,jint remaining)3398 android_glNormalPointerBounds__IILjava_nio_Buffer_2I
3399   (JNIEnv *_env, jobject _this, jint type, jint stride, jobject pointer_buf, jint remaining) {
3400     jint _exception = 0;
3401     const char * _exceptionType = NULL;
3402     const char * _exceptionMessage = NULL;
3403     jarray _array = (jarray) 0;
3404     jint _bufferOffset = (jint) 0;
3405     jint _remaining;
3406     GLvoid *pointer = (GLvoid *) 0;
3407 
3408     if (pointer_buf) {
3409         pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
3410         if ( ! pointer ) {
3411             return;
3412         }
3413     }
3414     glNormalPointerBounds(
3415         (GLenum)type,
3416         (GLsizei)stride,
3417         (GLvoid *)pointer,
3418         (GLsizei)remaining
3419     );
3420     if (_exception) {
3421         jniThrowException(_env, _exceptionType, _exceptionMessage);
3422     }
3423 }
3424 
3425 /* void glOrthof ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */
3426 static void
android_glOrthof__FFFFFF(JNIEnv * _env,jobject _this,jfloat left,jfloat right,jfloat bottom,jfloat top,jfloat zNear,jfloat zFar)3427 android_glOrthof__FFFFFF
3428   (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) {
3429     glOrthof(
3430         (GLfloat)left,
3431         (GLfloat)right,
3432         (GLfloat)bottom,
3433         (GLfloat)top,
3434         (GLfloat)zNear,
3435         (GLfloat)zFar
3436     );
3437 }
3438 
3439 /* void glOrthox ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */
3440 static void
android_glOrthox__IIIIII(JNIEnv * _env,jobject _this,jint left,jint right,jint bottom,jint top,jint zNear,jint zFar)3441 android_glOrthox__IIIIII
3442   (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) {
3443     glOrthox(
3444         (GLfixed)left,
3445         (GLfixed)right,
3446         (GLfixed)bottom,
3447         (GLfixed)top,
3448         (GLfixed)zNear,
3449         (GLfixed)zFar
3450     );
3451 }
3452 
3453 /* void glPixelStorei ( GLenum pname, GLint param ) */
3454 static void
android_glPixelStorei__II(JNIEnv * _env,jobject _this,jint pname,jint param)3455 android_glPixelStorei__II
3456   (JNIEnv *_env, jobject _this, jint pname, jint param) {
3457     glPixelStorei(
3458         (GLenum)pname,
3459         (GLint)param
3460     );
3461 }
3462 
3463 /* void glPointSize ( GLfloat size ) */
3464 static void
android_glPointSize__F(JNIEnv * _env,jobject _this,jfloat size)3465 android_glPointSize__F
3466   (JNIEnv *_env, jobject _this, jfloat size) {
3467     glPointSize(
3468         (GLfloat)size
3469     );
3470 }
3471 
3472 /* void glPointSizex ( GLfixed size ) */
3473 static void
android_glPointSizex__I(JNIEnv * _env,jobject _this,jint size)3474 android_glPointSizex__I
3475   (JNIEnv *_env, jobject _this, jint size) {
3476     glPointSizex(
3477         (GLfixed)size
3478     );
3479 }
3480 
3481 /* void glPolygonOffset ( GLfloat factor, GLfloat units ) */
3482 static void
android_glPolygonOffset__FF(JNIEnv * _env,jobject _this,jfloat factor,jfloat units)3483 android_glPolygonOffset__FF
3484   (JNIEnv *_env, jobject _this, jfloat factor, jfloat units) {
3485     glPolygonOffset(
3486         (GLfloat)factor,
3487         (GLfloat)units
3488     );
3489 }
3490 
3491 /* void glPolygonOffsetx ( GLfixed factor, GLfixed units ) */
3492 static void
android_glPolygonOffsetx__II(JNIEnv * _env,jobject _this,jint factor,jint units)3493 android_glPolygonOffsetx__II
3494   (JNIEnv *_env, jobject _this, jint factor, jint units) {
3495     glPolygonOffsetx(
3496         (GLfixed)factor,
3497         (GLfixed)units
3498     );
3499 }
3500 
3501 /* void glPopMatrix ( void ) */
3502 static void
android_glPopMatrix__(JNIEnv * _env,jobject _this)3503 android_glPopMatrix__
3504   (JNIEnv *_env, jobject _this) {
3505     glPopMatrix();
3506 }
3507 
3508 /* void glPushMatrix ( void ) */
3509 static void
android_glPushMatrix__(JNIEnv * _env,jobject _this)3510 android_glPushMatrix__
3511   (JNIEnv *_env, jobject _this) {
3512     glPushMatrix();
3513 }
3514 
3515 /* void glReadPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) */
3516 static void
android_glReadPixels__IIIIIILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint x,jint y,jint width,jint height,jint format,jint type,jobject pixels_buf)3517 android_glReadPixels__IIIIIILjava_nio_Buffer_2
3518   (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height, jint format, jint type, jobject pixels_buf) {
3519     jint _exception = 0;
3520     const char * _exceptionType = NULL;
3521     const char * _exceptionMessage = NULL;
3522     jarray _array = (jarray) 0;
3523     jint _bufferOffset = (jint) 0;
3524     jint _remaining;
3525     GLvoid *pixels = (GLvoid *) 0;
3526 
3527     if (!pixels_buf) {
3528         _exception = 1;
3529         _exceptionType = "java/lang/IllegalArgumentException";
3530         _exceptionMessage = "pixels == null";
3531         goto exit;
3532     }
3533     pixels = (GLvoid *)getPointer(_env, pixels_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
3534     if (pixels == NULL) {
3535         char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3536         pixels = (GLvoid *) (_pixelsBase + _bufferOffset);
3537     }
3538     glReadPixels(
3539         (GLint)x,
3540         (GLint)y,
3541         (GLsizei)width,
3542         (GLsizei)height,
3543         (GLenum)format,
3544         (GLenum)type,
3545         (GLvoid *)pixels
3546     );
3547 
3548 exit:
3549     if (_array) {
3550         releasePointer(_env, _array, pixels, _exception ? JNI_FALSE : JNI_TRUE);
3551     }
3552     if (_exception) {
3553         jniThrowException(_env, _exceptionType, _exceptionMessage);
3554     }
3555 }
3556 
3557 /* void glRotatef ( GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) */
3558 static void
android_glRotatef__FFFF(JNIEnv * _env,jobject _this,jfloat angle,jfloat x,jfloat y,jfloat z)3559 android_glRotatef__FFFF
3560   (JNIEnv *_env, jobject _this, jfloat angle, jfloat x, jfloat y, jfloat z) {
3561     glRotatef(
3562         (GLfloat)angle,
3563         (GLfloat)x,
3564         (GLfloat)y,
3565         (GLfloat)z
3566     );
3567 }
3568 
3569 /* void glRotatex ( GLfixed angle, GLfixed x, GLfixed y, GLfixed z ) */
3570 static void
android_glRotatex__IIII(JNIEnv * _env,jobject _this,jint angle,jint x,jint y,jint z)3571 android_glRotatex__IIII
3572   (JNIEnv *_env, jobject _this, jint angle, jint x, jint y, jint z) {
3573     glRotatex(
3574         (GLfixed)angle,
3575         (GLfixed)x,
3576         (GLfixed)y,
3577         (GLfixed)z
3578     );
3579 }
3580 
3581 /* void glSampleCoverage ( GLclampf value, GLboolean invert ) */
3582 static void
android_glSampleCoverage__FZ(JNIEnv * _env,jobject _this,jfloat value,jboolean invert)3583 android_glSampleCoverage__FZ
3584   (JNIEnv *_env, jobject _this, jfloat value, jboolean invert) {
3585     glSampleCoverage(
3586         (GLclampf)value,
3587         (GLboolean)invert
3588     );
3589 }
3590 
3591 /* void glSampleCoveragex ( GLclampx value, GLboolean invert ) */
3592 static void
android_glSampleCoveragex__IZ(JNIEnv * _env,jobject _this,jint value,jboolean invert)3593 android_glSampleCoveragex__IZ
3594   (JNIEnv *_env, jobject _this, jint value, jboolean invert) {
3595     glSampleCoveragex(
3596         (GLclampx)value,
3597         (GLboolean)invert
3598     );
3599 }
3600 
3601 /* void glScalef ( GLfloat x, GLfloat y, GLfloat z ) */
3602 static void
android_glScalef__FFF(JNIEnv * _env,jobject _this,jfloat x,jfloat y,jfloat z)3603 android_glScalef__FFF
3604   (JNIEnv *_env, jobject _this, jfloat x, jfloat y, jfloat z) {
3605     glScalef(
3606         (GLfloat)x,
3607         (GLfloat)y,
3608         (GLfloat)z
3609     );
3610 }
3611 
3612 /* void glScalex ( GLfixed x, GLfixed y, GLfixed z ) */
3613 static void
android_glScalex__III(JNIEnv * _env,jobject _this,jint x,jint y,jint z)3614 android_glScalex__III
3615   (JNIEnv *_env, jobject _this, jint x, jint y, jint z) {
3616     glScalex(
3617         (GLfixed)x,
3618         (GLfixed)y,
3619         (GLfixed)z
3620     );
3621 }
3622 
3623 /* void glScissor ( GLint x, GLint y, GLsizei width, GLsizei height ) */
3624 static void
android_glScissor__IIII(JNIEnv * _env,jobject _this,jint x,jint y,jint width,jint height)3625 android_glScissor__IIII
3626   (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height) {
3627     glScissor(
3628         (GLint)x,
3629         (GLint)y,
3630         (GLsizei)width,
3631         (GLsizei)height
3632     );
3633 }
3634 
3635 /* void glShadeModel ( GLenum mode ) */
3636 static void
android_glShadeModel__I(JNIEnv * _env,jobject _this,jint mode)3637 android_glShadeModel__I
3638   (JNIEnv *_env, jobject _this, jint mode) {
3639     glShadeModel(
3640         (GLenum)mode
3641     );
3642 }
3643 
3644 /* void glStencilFunc ( GLenum func, GLint ref, GLuint mask ) */
3645 static void
android_glStencilFunc__III(JNIEnv * _env,jobject _this,jint func,jint ref,jint mask)3646 android_glStencilFunc__III
3647   (JNIEnv *_env, jobject _this, jint func, jint ref, jint mask) {
3648     glStencilFunc(
3649         (GLenum)func,
3650         (GLint)ref,
3651         (GLuint)mask
3652     );
3653 }
3654 
3655 /* void glStencilMask ( GLuint mask ) */
3656 static void
android_glStencilMask__I(JNIEnv * _env,jobject _this,jint mask)3657 android_glStencilMask__I
3658   (JNIEnv *_env, jobject _this, jint mask) {
3659     glStencilMask(
3660         (GLuint)mask
3661     );
3662 }
3663 
3664 /* void glStencilOp ( GLenum fail, GLenum zfail, GLenum zpass ) */
3665 static void
android_glStencilOp__III(JNIEnv * _env,jobject _this,jint fail,jint zfail,jint zpass)3666 android_glStencilOp__III
3667   (JNIEnv *_env, jobject _this, jint fail, jint zfail, jint zpass) {
3668     glStencilOp(
3669         (GLenum)fail,
3670         (GLenum)zfail,
3671         (GLenum)zpass
3672     );
3673 }
3674 
3675 /* void glTexCoordPointer ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
3676 static void
android_glTexCoordPointerBounds__IIILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint size,jint type,jint stride,jobject pointer_buf,jint remaining)3677 android_glTexCoordPointerBounds__IIILjava_nio_Buffer_2I
3678   (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
3679     jint _exception = 0;
3680     const char * _exceptionType = NULL;
3681     const char * _exceptionMessage = NULL;
3682     jarray _array = (jarray) 0;
3683     jint _bufferOffset = (jint) 0;
3684     jint _remaining;
3685     GLvoid *pointer = (GLvoid *) 0;
3686 
3687     if (pointer_buf) {
3688         pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
3689         if ( ! pointer ) {
3690             return;
3691         }
3692     }
3693     glTexCoordPointerBounds(
3694         (GLint)size,
3695         (GLenum)type,
3696         (GLsizei)stride,
3697         (GLvoid *)pointer,
3698         (GLsizei)remaining
3699     );
3700     if (_exception) {
3701         jniThrowException(_env, _exceptionType, _exceptionMessage);
3702     }
3703 }
3704 
3705 /* void glTexEnvf ( GLenum target, GLenum pname, GLfloat param ) */
3706 static void
android_glTexEnvf__IIF(JNIEnv * _env,jobject _this,jint target,jint pname,jfloat param)3707 android_glTexEnvf__IIF
3708   (JNIEnv *_env, jobject _this, jint target, jint pname, jfloat param) {
3709     glTexEnvf(
3710         (GLenum)target,
3711         (GLenum)pname,
3712         (GLfloat)param
3713     );
3714 }
3715 
3716 /* void glTexEnvfv ( GLenum target, GLenum pname, const GLfloat *params ) */
3717 static void
android_glTexEnvfv__II_3FI(JNIEnv * _env,jobject _this,jint target,jint pname,jfloatArray params_ref,jint offset)3718 android_glTexEnvfv__II_3FI
3719   (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) {
3720     jint _exception = 0;
3721     const char * _exceptionType = NULL;
3722     const char * _exceptionMessage = NULL;
3723     GLfloat *params_base = (GLfloat *) 0;
3724     jint _remaining;
3725     GLfloat *params = (GLfloat *) 0;
3726 
3727     if (!params_ref) {
3728         _exception = 1;
3729         _exceptionType = "java/lang/IllegalArgumentException";
3730         _exceptionMessage = "params == null";
3731         goto exit;
3732     }
3733     if (offset < 0) {
3734         _exception = 1;
3735         _exceptionType = "java/lang/IllegalArgumentException";
3736         _exceptionMessage = "offset < 0";
3737         goto exit;
3738     }
3739     _remaining = _env->GetArrayLength(params_ref) - offset;
3740     int _needed;
3741     switch (pname) {
3742 #if defined(GL_TEXTURE_ENV_MODE)
3743         case GL_TEXTURE_ENV_MODE:
3744 #endif // defined(GL_TEXTURE_ENV_MODE)
3745 #if defined(GL_COMBINE_RGB)
3746         case GL_COMBINE_RGB:
3747 #endif // defined(GL_COMBINE_RGB)
3748 #if defined(GL_COMBINE_ALPHA)
3749         case GL_COMBINE_ALPHA:
3750 #endif // defined(GL_COMBINE_ALPHA)
3751             _needed = 1;
3752             break;
3753 #if defined(GL_TEXTURE_ENV_COLOR)
3754         case GL_TEXTURE_ENV_COLOR:
3755 #endif // defined(GL_TEXTURE_ENV_COLOR)
3756             _needed = 4;
3757             break;
3758         default:
3759             _needed = 1;
3760             break;
3761     }
3762     if (_remaining < _needed) {
3763         _exception = 1;
3764         _exceptionType = "java/lang/IllegalArgumentException";
3765         _exceptionMessage = "length - offset < needed";
3766         goto exit;
3767     }
3768     params_base = (GLfloat *)
3769         _env->GetFloatArrayElements(params_ref, (jboolean *)0);
3770     params = params_base + offset;
3771 
3772     glTexEnvfv(
3773         (GLenum)target,
3774         (GLenum)pname,
3775         (GLfloat *)params
3776     );
3777 
3778 exit:
3779     if (params_base) {
3780         _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
3781             JNI_ABORT);
3782     }
3783     if (_exception) {
3784         jniThrowException(_env, _exceptionType, _exceptionMessage);
3785     }
3786 }
3787 
3788 /* void glTexEnvfv ( GLenum target, GLenum pname, const GLfloat *params ) */
3789 static void
android_glTexEnvfv__IILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)3790 android_glTexEnvfv__IILjava_nio_FloatBuffer_2
3791   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
3792     jint _exception = 0;
3793     const char * _exceptionType = NULL;
3794     const char * _exceptionMessage = NULL;
3795     jfloatArray _array = (jfloatArray) 0;
3796     jint _bufferOffset = (jint) 0;
3797     jint _remaining;
3798     GLfloat *params = (GLfloat *) 0;
3799 
3800     if (!params_buf) {
3801         _exception = 1;
3802         _exceptionType = "java/lang/IllegalArgumentException";
3803         _exceptionMessage = "params == null";
3804         goto exit;
3805     }
3806     params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
3807     int _needed;
3808     switch (pname) {
3809 #if defined(GL_TEXTURE_ENV_MODE)
3810         case GL_TEXTURE_ENV_MODE:
3811 #endif // defined(GL_TEXTURE_ENV_MODE)
3812 #if defined(GL_COMBINE_RGB)
3813         case GL_COMBINE_RGB:
3814 #endif // defined(GL_COMBINE_RGB)
3815 #if defined(GL_COMBINE_ALPHA)
3816         case GL_COMBINE_ALPHA:
3817 #endif // defined(GL_COMBINE_ALPHA)
3818             _needed = 1;
3819             break;
3820 #if defined(GL_TEXTURE_ENV_COLOR)
3821         case GL_TEXTURE_ENV_COLOR:
3822 #endif // defined(GL_TEXTURE_ENV_COLOR)
3823             _needed = 4;
3824             break;
3825         default:
3826             _needed = 1;
3827             break;
3828     }
3829     if (_remaining < _needed) {
3830         _exception = 1;
3831         _exceptionType = "java/lang/IllegalArgumentException";
3832         _exceptionMessage = "remaining() < needed";
3833         goto exit;
3834     }
3835     if (params == NULL) {
3836         char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
3837         params = (GLfloat *) (_paramsBase + _bufferOffset);
3838     }
3839     glTexEnvfv(
3840         (GLenum)target,
3841         (GLenum)pname,
3842         (GLfloat *)params
3843     );
3844 
3845 exit:
3846     if (_array) {
3847         _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT);
3848     }
3849     if (_exception) {
3850         jniThrowException(_env, _exceptionType, _exceptionMessage);
3851     }
3852 }
3853 
3854 /* void glTexEnvx ( GLenum target, GLenum pname, GLfixed param ) */
3855 static void
android_glTexEnvx__III(JNIEnv * _env,jobject _this,jint target,jint pname,jint param)3856 android_glTexEnvx__III
3857   (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) {
3858     glTexEnvx(
3859         (GLenum)target,
3860         (GLenum)pname,
3861         (GLfixed)param
3862     );
3863 }
3864 
3865 /* void glTexEnvxv ( GLenum target, GLenum pname, const GLfixed *params ) */
3866 static void
android_glTexEnvxv__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)3867 android_glTexEnvxv__II_3II
3868   (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
3869     jint _exception = 0;
3870     const char * _exceptionType = NULL;
3871     const char * _exceptionMessage = NULL;
3872     GLfixed *params_base = (GLfixed *) 0;
3873     jint _remaining;
3874     GLfixed *params = (GLfixed *) 0;
3875 
3876     if (!params_ref) {
3877         _exception = 1;
3878         _exceptionType = "java/lang/IllegalArgumentException";
3879         _exceptionMessage = "params == null";
3880         goto exit;
3881     }
3882     if (offset < 0) {
3883         _exception = 1;
3884         _exceptionType = "java/lang/IllegalArgumentException";
3885         _exceptionMessage = "offset < 0";
3886         goto exit;
3887     }
3888     _remaining = _env->GetArrayLength(params_ref) - offset;
3889     int _needed;
3890     switch (pname) {
3891 #if defined(GL_TEXTURE_ENV_MODE)
3892         case GL_TEXTURE_ENV_MODE:
3893 #endif // defined(GL_TEXTURE_ENV_MODE)
3894 #if defined(GL_COMBINE_RGB)
3895         case GL_COMBINE_RGB:
3896 #endif // defined(GL_COMBINE_RGB)
3897 #if defined(GL_COMBINE_ALPHA)
3898         case GL_COMBINE_ALPHA:
3899 #endif // defined(GL_COMBINE_ALPHA)
3900             _needed = 1;
3901             break;
3902 #if defined(GL_TEXTURE_ENV_COLOR)
3903         case GL_TEXTURE_ENV_COLOR:
3904 #endif // defined(GL_TEXTURE_ENV_COLOR)
3905             _needed = 4;
3906             break;
3907         default:
3908             _needed = 1;
3909             break;
3910     }
3911     if (_remaining < _needed) {
3912         _exception = 1;
3913         _exceptionType = "java/lang/IllegalArgumentException";
3914         _exceptionMessage = "length - offset < needed";
3915         goto exit;
3916     }
3917     params_base = (GLfixed *)
3918         _env->GetIntArrayElements(params_ref, (jboolean *)0);
3919     params = params_base + offset;
3920 
3921     glTexEnvxv(
3922         (GLenum)target,
3923         (GLenum)pname,
3924         (GLfixed *)params
3925     );
3926 
3927 exit:
3928     if (params_base) {
3929         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
3930             JNI_ABORT);
3931     }
3932     if (_exception) {
3933         jniThrowException(_env, _exceptionType, _exceptionMessage);
3934     }
3935 }
3936 
3937 /* void glTexEnvxv ( GLenum target, GLenum pname, const GLfixed *params ) */
3938 static void
android_glTexEnvxv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)3939 android_glTexEnvxv__IILjava_nio_IntBuffer_2
3940   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
3941     jint _exception = 0;
3942     const char * _exceptionType = NULL;
3943     const char * _exceptionMessage = NULL;
3944     jintArray _array = (jintArray) 0;
3945     jint _bufferOffset = (jint) 0;
3946     jint _remaining;
3947     GLfixed *params = (GLfixed *) 0;
3948 
3949     if (!params_buf) {
3950         _exception = 1;
3951         _exceptionType = "java/lang/IllegalArgumentException";
3952         _exceptionMessage = "params == null";
3953         goto exit;
3954     }
3955     params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
3956     int _needed;
3957     switch (pname) {
3958 #if defined(GL_TEXTURE_ENV_MODE)
3959         case GL_TEXTURE_ENV_MODE:
3960 #endif // defined(GL_TEXTURE_ENV_MODE)
3961 #if defined(GL_COMBINE_RGB)
3962         case GL_COMBINE_RGB:
3963 #endif // defined(GL_COMBINE_RGB)
3964 #if defined(GL_COMBINE_ALPHA)
3965         case GL_COMBINE_ALPHA:
3966 #endif // defined(GL_COMBINE_ALPHA)
3967             _needed = 1;
3968             break;
3969 #if defined(GL_TEXTURE_ENV_COLOR)
3970         case GL_TEXTURE_ENV_COLOR:
3971 #endif // defined(GL_TEXTURE_ENV_COLOR)
3972             _needed = 4;
3973             break;
3974         default:
3975             _needed = 1;
3976             break;
3977     }
3978     if (_remaining < _needed) {
3979         _exception = 1;
3980         _exceptionType = "java/lang/IllegalArgumentException";
3981         _exceptionMessage = "remaining() < needed";
3982         goto exit;
3983     }
3984     if (params == NULL) {
3985         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
3986         params = (GLfixed *) (_paramsBase + _bufferOffset);
3987     }
3988     glTexEnvxv(
3989         (GLenum)target,
3990         (GLenum)pname,
3991         (GLfixed *)params
3992     );
3993 
3994 exit:
3995     if (_array) {
3996         _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT);
3997     }
3998     if (_exception) {
3999         jniThrowException(_env, _exceptionType, _exceptionMessage);
4000     }
4001 }
4002 
4003 /* void glTexImage2D ( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) */
4004 static void
android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint target,jint level,jint internalformat,jint width,jint height,jint border,jint format,jint type,jobject pixels_buf)4005 android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2
4006   (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint format, jint type, jobject pixels_buf) {
4007     jint _exception = 0;
4008     const char * _exceptionType = NULL;
4009     const char * _exceptionMessage = NULL;
4010     jarray _array = (jarray) 0;
4011     jint _bufferOffset = (jint) 0;
4012     jint _remaining;
4013     GLvoid *pixels = (GLvoid *) 0;
4014 
4015     if (pixels_buf) {
4016         pixels = (GLvoid *)getPointer(_env, pixels_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
4017     }
4018     if (pixels_buf && pixels == NULL) {
4019         char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
4020         pixels = (GLvoid *) (_pixelsBase + _bufferOffset);
4021     }
4022     glTexImage2D(
4023         (GLenum)target,
4024         (GLint)level,
4025         (GLint)internalformat,
4026         (GLsizei)width,
4027         (GLsizei)height,
4028         (GLint)border,
4029         (GLenum)format,
4030         (GLenum)type,
4031         (GLvoid *)pixels
4032     );
4033     if (_array) {
4034         releasePointer(_env, _array, pixels, JNI_FALSE);
4035     }
4036     if (_exception) {
4037         jniThrowException(_env, _exceptionType, _exceptionMessage);
4038     }
4039 }
4040 
4041 /* void glTexParameterf ( GLenum target, GLenum pname, GLfloat param ) */
4042 static void
android_glTexParameterf__IIF(JNIEnv * _env,jobject _this,jint target,jint pname,jfloat param)4043 android_glTexParameterf__IIF
4044   (JNIEnv *_env, jobject _this, jint target, jint pname, jfloat param) {
4045     glTexParameterf(
4046         (GLenum)target,
4047         (GLenum)pname,
4048         (GLfloat)param
4049     );
4050 }
4051 
4052 /* void glTexParameterx ( GLenum target, GLenum pname, GLfixed param ) */
4053 static void
android_glTexParameterx__III(JNIEnv * _env,jobject _this,jint target,jint pname,jint param)4054 android_glTexParameterx__III
4055   (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) {
4056     glTexParameterx(
4057         (GLenum)target,
4058         (GLenum)pname,
4059         (GLfixed)param
4060     );
4061 }
4062 
4063 /* void glTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels ) */
4064 static void
android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint target,jint level,jint xoffset,jint yoffset,jint width,jint height,jint format,jint type,jobject pixels_buf)4065 android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2
4066   (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint type, jobject pixels_buf) {
4067     jint _exception = 0;
4068     const char * _exceptionType = NULL;
4069     const char * _exceptionMessage = NULL;
4070     jarray _array = (jarray) 0;
4071     jint _bufferOffset = (jint) 0;
4072     jint _remaining;
4073     GLvoid *pixels = (GLvoid *) 0;
4074 
4075     if (pixels_buf) {
4076         pixels = (GLvoid *)getPointer(_env, pixels_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
4077     }
4078     if (pixels_buf && pixels == NULL) {
4079         char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
4080         pixels = (GLvoid *) (_pixelsBase + _bufferOffset);
4081     }
4082     glTexSubImage2D(
4083         (GLenum)target,
4084         (GLint)level,
4085         (GLint)xoffset,
4086         (GLint)yoffset,
4087         (GLsizei)width,
4088         (GLsizei)height,
4089         (GLenum)format,
4090         (GLenum)type,
4091         (GLvoid *)pixels
4092     );
4093     if (_array) {
4094         releasePointer(_env, _array, pixels, JNI_FALSE);
4095     }
4096     if (_exception) {
4097         jniThrowException(_env, _exceptionType, _exceptionMessage);
4098     }
4099 }
4100 
4101 /* void glTranslatef ( GLfloat x, GLfloat y, GLfloat z ) */
4102 static void
android_glTranslatef__FFF(JNIEnv * _env,jobject _this,jfloat x,jfloat y,jfloat z)4103 android_glTranslatef__FFF
4104   (JNIEnv *_env, jobject _this, jfloat x, jfloat y, jfloat z) {
4105     glTranslatef(
4106         (GLfloat)x,
4107         (GLfloat)y,
4108         (GLfloat)z
4109     );
4110 }
4111 
4112 /* void glTranslatex ( GLfixed x, GLfixed y, GLfixed z ) */
4113 static void
android_glTranslatex__III(JNIEnv * _env,jobject _this,jint x,jint y,jint z)4114 android_glTranslatex__III
4115   (JNIEnv *_env, jobject _this, jint x, jint y, jint z) {
4116     glTranslatex(
4117         (GLfixed)x,
4118         (GLfixed)y,
4119         (GLfixed)z
4120     );
4121 }
4122 
4123 /* void glVertexPointer ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
4124 static void
android_glVertexPointerBounds__IIILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint size,jint type,jint stride,jobject pointer_buf,jint remaining)4125 android_glVertexPointerBounds__IIILjava_nio_Buffer_2I
4126   (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
4127     jint _exception = 0;
4128     const char * _exceptionType = NULL;
4129     const char * _exceptionMessage = NULL;
4130     jarray _array = (jarray) 0;
4131     jint _bufferOffset = (jint) 0;
4132     jint _remaining;
4133     GLvoid *pointer = (GLvoid *) 0;
4134 
4135     if (pointer_buf) {
4136         pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
4137         if ( ! pointer ) {
4138             return;
4139         }
4140     }
4141     glVertexPointerBounds(
4142         (GLint)size,
4143         (GLenum)type,
4144         (GLsizei)stride,
4145         (GLvoid *)pointer,
4146         (GLsizei)remaining
4147     );
4148     if (_exception) {
4149         jniThrowException(_env, _exceptionType, _exceptionMessage);
4150     }
4151 }
4152 
4153 /* void glViewport ( GLint x, GLint y, GLsizei width, GLsizei height ) */
4154 static void
android_glViewport__IIII(JNIEnv * _env,jobject _this,jint x,jint y,jint width,jint height)4155 android_glViewport__IIII
4156   (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height) {
4157     glViewport(
4158         (GLint)x,
4159         (GLint)y,
4160         (GLsizei)width,
4161         (GLsizei)height
4162     );
4163 }
4164 
4165 /* GLbitfield glQueryMatrixxOES ( GLfixed *mantissa, GLint *exponent ) */
4166 static jint
android_glQueryMatrixxOES___3II_3II(JNIEnv * _env,jobject _this,jintArray mantissa_ref,jint mantissaOffset,jintArray exponent_ref,jint exponentOffset)4167 android_glQueryMatrixxOES___3II_3II
4168   (JNIEnv *_env, jobject _this, jintArray mantissa_ref, jint mantissaOffset, jintArray exponent_ref, jint exponentOffset) {
4169     jint _exception = 0;
4170     const char * _exceptionType = NULL;
4171     const char * _exceptionMessage = NULL;
4172     GLbitfield _returnValue = -1;
4173     GLfixed *mantissa_base = (GLfixed *) 0;
4174     jint _mantissaRemaining;
4175     GLfixed *mantissa = (GLfixed *) 0;
4176     GLint *exponent_base = (GLint *) 0;
4177     jint _exponentRemaining;
4178     GLint *exponent = (GLint *) 0;
4179 
4180     if (!mantissa_ref) {
4181         _exception = 1;
4182         _exceptionType = "java/lang/IllegalArgumentException";
4183         _exceptionMessage = "mantissa == null";
4184         goto exit;
4185     }
4186     if (mantissaOffset < 0) {
4187         _exception = 1;
4188         _exceptionType = "java/lang/IllegalArgumentException";
4189         _exceptionMessage = "mantissaOffset < 0";
4190         goto exit;
4191     }
4192     _mantissaRemaining = _env->GetArrayLength(mantissa_ref) - mantissaOffset;
4193     if (_mantissaRemaining < 16) {
4194         _exception = 1;
4195         _exceptionType = "java/lang/IllegalArgumentException";
4196         _exceptionMessage = "length - mantissaOffset < 16 < needed";
4197         goto exit;
4198     }
4199     mantissa_base = (GLfixed *)
4200         _env->GetIntArrayElements(mantissa_ref, (jboolean *)0);
4201     mantissa = mantissa_base + mantissaOffset;
4202 
4203     if (!exponent_ref) {
4204         _exception = 1;
4205         _exceptionType = "java/lang/IllegalArgumentException";
4206         _exceptionMessage = "exponent == null";
4207         goto exit;
4208     }
4209     if (exponentOffset < 0) {
4210         _exception = 1;
4211         _exceptionType = "java/lang/IllegalArgumentException";
4212         _exceptionMessage = "exponentOffset < 0";
4213         goto exit;
4214     }
4215     _exponentRemaining = _env->GetArrayLength(exponent_ref) - exponentOffset;
4216     if (_exponentRemaining < 16) {
4217         _exception = 1;
4218         _exceptionType = "java/lang/IllegalArgumentException";
4219         _exceptionMessage = "length - exponentOffset < 16 < needed";
4220         goto exit;
4221     }
4222     exponent_base = (GLint *)
4223         _env->GetIntArrayElements(exponent_ref, (jboolean *)0);
4224     exponent = exponent_base + exponentOffset;
4225 
4226     _returnValue = glQueryMatrixxOES(
4227         (GLfixed *)mantissa,
4228         (GLint *)exponent
4229     );
4230 
4231 exit:
4232     if (exponent_base) {
4233         _env->ReleaseIntArrayElements(exponent_ref, (jint*)exponent_base,
4234             _exception ? JNI_ABORT: 0);
4235     }
4236     if (mantissa_base) {
4237         _env->ReleaseIntArrayElements(mantissa_ref, (jint*)mantissa_base,
4238             _exception ? JNI_ABORT: 0);
4239     }
4240     if (_exception) {
4241         jniThrowException(_env, _exceptionType, _exceptionMessage);
4242     }
4243     return (jint)_returnValue;
4244 }
4245 
4246 /* GLbitfield glQueryMatrixxOES ( GLfixed *mantissa, GLint *exponent ) */
4247 static jint
android_glQueryMatrixxOES__Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jobject mantissa_buf,jobject exponent_buf)4248 android_glQueryMatrixxOES__Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2
4249   (JNIEnv *_env, jobject _this, jobject mantissa_buf, jobject exponent_buf) {
4250     jint _exception = 0;
4251     const char * _exceptionType = NULL;
4252     const char * _exceptionMessage = NULL;
4253     jintArray _mantissaArray = (jintArray) 0;
4254     jint _mantissaBufferOffset = (jint) 0;
4255     jintArray _exponentArray = (jintArray) 0;
4256     jint _exponentBufferOffset = (jint) 0;
4257     GLbitfield _returnValue = -1;
4258     jint _mantissaRemaining;
4259     GLfixed *mantissa = (GLfixed *) 0;
4260     jint _exponentRemaining;
4261     GLint *exponent = (GLint *) 0;
4262 
4263     if (!mantissa_buf) {
4264         _exception = 1;
4265         _exceptionType = "java/lang/IllegalArgumentException";
4266         _exceptionMessage = "mantissa == null";
4267         goto exit;
4268     }
4269     mantissa = (GLfixed *)getPointer(_env, mantissa_buf, (jarray*)&_mantissaArray, &_mantissaRemaining, &_mantissaBufferOffset);
4270     if (_mantissaRemaining < 16) {
4271         _exception = 1;
4272         _exceptionType = "java/lang/IllegalArgumentException";
4273         _exceptionMessage = "remaining() < 16 < needed";
4274         goto exit;
4275     }
4276     if (!exponent_buf) {
4277         _exception = 1;
4278         _exceptionType = "java/lang/IllegalArgumentException";
4279         _exceptionMessage = "exponent == null";
4280         goto exit;
4281     }
4282     exponent = (GLint *)getPointer(_env, exponent_buf, (jarray*)&_exponentArray, &_exponentRemaining, &_exponentBufferOffset);
4283     if (_exponentRemaining < 16) {
4284         _exception = 1;
4285         _exceptionType = "java/lang/IllegalArgumentException";
4286         _exceptionMessage = "remaining() < 16 < needed";
4287         goto exit;
4288     }
4289     if (mantissa == NULL) {
4290         char * _mantissaBase = (char *)_env->GetIntArrayElements(_mantissaArray, (jboolean *) 0);
4291         mantissa = (GLfixed *) (_mantissaBase + _mantissaBufferOffset);
4292     }
4293     if (exponent == NULL) {
4294         char * _exponentBase = (char *)_env->GetIntArrayElements(_exponentArray, (jboolean *) 0);
4295         exponent = (GLint *) (_exponentBase + _exponentBufferOffset);
4296     }
4297     _returnValue = glQueryMatrixxOES(
4298         (GLfixed *)mantissa,
4299         (GLint *)exponent
4300     );
4301 
4302 exit:
4303     if (_exponentArray) {
4304         _env->ReleaseIntArrayElements(_exponentArray, (jint*)exponent, _exception ? JNI_ABORT : 0);
4305     }
4306     if (_mantissaArray) {
4307         _env->ReleaseIntArrayElements(_mantissaArray, (jint*)mantissa, _exception ? JNI_ABORT : 0);
4308     }
4309     if (_exception) {
4310         jniThrowException(_env, _exceptionType, _exceptionMessage);
4311     }
4312     return (jint)_returnValue;
4313 }
4314 
4315 /* void glBindBuffer ( GLenum target, GLuint buffer ) */
4316 static void
android_glBindBuffer__II(JNIEnv * _env,jobject _this,jint target,jint buffer)4317 android_glBindBuffer__II
4318   (JNIEnv *_env, jobject _this, jint target, jint buffer) {
4319     glBindBuffer(
4320         (GLenum)target,
4321         (GLuint)buffer
4322     );
4323 }
4324 
4325 /* void glBufferData ( GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage ) */
4326 static void
android_glBufferData__IILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint target,jint size,jobject data_buf,jint usage)4327 android_glBufferData__IILjava_nio_Buffer_2I
4328   (JNIEnv *_env, jobject _this, jint target, jint size, jobject data_buf, jint usage) {
4329     jint _exception = 0;
4330     const char * _exceptionType = NULL;
4331     const char * _exceptionMessage = NULL;
4332     jarray _array = (jarray) 0;
4333     jint _bufferOffset = (jint) 0;
4334     jint _remaining;
4335     GLvoid *data = (GLvoid *) 0;
4336 
4337     if (data_buf) {
4338         data = (GLvoid *)getPointer(_env, data_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
4339         if (_remaining < size) {
4340             _exception = 1;
4341             _exceptionType = "java/lang/IllegalArgumentException";
4342             _exceptionMessage = "remaining() < size < needed";
4343             goto exit;
4344         }
4345     }
4346     if (data_buf && data == NULL) {
4347         char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
4348         data = (GLvoid *) (_dataBase + _bufferOffset);
4349     }
4350     glBufferData(
4351         (GLenum)target,
4352         (GLsizeiptr)size,
4353         (GLvoid *)data,
4354         (GLenum)usage
4355     );
4356 
4357 exit:
4358     if (_array) {
4359         releasePointer(_env, _array, data, JNI_FALSE);
4360     }
4361     if (_exception) {
4362         jniThrowException(_env, _exceptionType, _exceptionMessage);
4363     }
4364 }
4365 
4366 /* void glBufferSubData ( GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data ) */
4367 static void
android_glBufferSubData__IIILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint target,jint offset,jint size,jobject data_buf)4368 android_glBufferSubData__IIILjava_nio_Buffer_2
4369   (JNIEnv *_env, jobject _this, jint target, jint offset, jint size, jobject data_buf) {
4370     jint _exception = 0;
4371     const char * _exceptionType = NULL;
4372     const char * _exceptionMessage = NULL;
4373     jarray _array = (jarray) 0;
4374     jint _bufferOffset = (jint) 0;
4375     jint _remaining;
4376     GLvoid *data = (GLvoid *) 0;
4377 
4378     if (!data_buf) {
4379         _exception = 1;
4380         _exceptionType = "java/lang/IllegalArgumentException";
4381         _exceptionMessage = "data == null";
4382         goto exit;
4383     }
4384     data = (GLvoid *)getPointer(_env, data_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
4385     if (_remaining < size) {
4386         _exception = 1;
4387         _exceptionType = "java/lang/IllegalArgumentException";
4388         _exceptionMessage = "remaining() < size < needed";
4389         goto exit;
4390     }
4391     if (data == NULL) {
4392         char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
4393         data = (GLvoid *) (_dataBase + _bufferOffset);
4394     }
4395     glBufferSubData(
4396         (GLenum)target,
4397         (GLintptr)offset,
4398         (GLsizeiptr)size,
4399         (GLvoid *)data
4400     );
4401 
4402 exit:
4403     if (_array) {
4404         releasePointer(_env, _array, data, JNI_FALSE);
4405     }
4406     if (_exception) {
4407         jniThrowException(_env, _exceptionType, _exceptionMessage);
4408     }
4409 }
4410 
4411 /* void glClipPlanef ( GLenum plane, const GLfloat *equation ) */
4412 static void
android_glClipPlanef__I_3FI(JNIEnv * _env,jobject _this,jint plane,jfloatArray equation_ref,jint offset)4413 android_glClipPlanef__I_3FI
4414   (JNIEnv *_env, jobject _this, jint plane, jfloatArray equation_ref, jint offset) {
4415     jint _exception = 0;
4416     const char * _exceptionType = NULL;
4417     const char * _exceptionMessage = NULL;
4418     GLfloat *equation_base = (GLfloat *) 0;
4419     jint _remaining;
4420     GLfloat *equation = (GLfloat *) 0;
4421 
4422     if (!equation_ref) {
4423         _exception = 1;
4424         _exceptionType = "java/lang/IllegalArgumentException";
4425         _exceptionMessage = "equation == null";
4426         goto exit;
4427     }
4428     if (offset < 0) {
4429         _exception = 1;
4430         _exceptionType = "java/lang/IllegalArgumentException";
4431         _exceptionMessage = "offset < 0";
4432         goto exit;
4433     }
4434     _remaining = _env->GetArrayLength(equation_ref) - offset;
4435     if (_remaining < 4) {
4436         _exception = 1;
4437         _exceptionType = "java/lang/IllegalArgumentException";
4438         _exceptionMessage = "length - offset < 4 < needed";
4439         goto exit;
4440     }
4441     equation_base = (GLfloat *)
4442         _env->GetFloatArrayElements(equation_ref, (jboolean *)0);
4443     equation = equation_base + offset;
4444 
4445     glClipPlanef(
4446         (GLenum)plane,
4447         (GLfloat *)equation
4448     );
4449 
4450 exit:
4451     if (equation_base) {
4452         _env->ReleaseFloatArrayElements(equation_ref, (jfloat*)equation_base,
4453             JNI_ABORT);
4454     }
4455     if (_exception) {
4456         jniThrowException(_env, _exceptionType, _exceptionMessage);
4457     }
4458 }
4459 
4460 /* void glClipPlanef ( GLenum plane, const GLfloat *equation ) */
4461 static void
android_glClipPlanef__ILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint plane,jobject equation_buf)4462 android_glClipPlanef__ILjava_nio_FloatBuffer_2
4463   (JNIEnv *_env, jobject _this, jint plane, jobject equation_buf) {
4464     jint _exception = 0;
4465     const char * _exceptionType = NULL;
4466     const char * _exceptionMessage = NULL;
4467     jfloatArray _array = (jfloatArray) 0;
4468     jint _bufferOffset = (jint) 0;
4469     jint _remaining;
4470     GLfloat *equation = (GLfloat *) 0;
4471 
4472     if (!equation_buf) {
4473         _exception = 1;
4474         _exceptionType = "java/lang/IllegalArgumentException";
4475         _exceptionMessage = "equation == null";
4476         goto exit;
4477     }
4478     equation = (GLfloat *)getPointer(_env, equation_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
4479     if (_remaining < 4) {
4480         _exception = 1;
4481         _exceptionType = "java/lang/IllegalArgumentException";
4482         _exceptionMessage = "remaining() < 4 < needed";
4483         goto exit;
4484     }
4485     if (equation == NULL) {
4486         char * _equationBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
4487         equation = (GLfloat *) (_equationBase + _bufferOffset);
4488     }
4489     glClipPlanef(
4490         (GLenum)plane,
4491         (GLfloat *)equation
4492     );
4493 
4494 exit:
4495     if (_array) {
4496         _env->ReleaseFloatArrayElements(_array, (jfloat*)equation, JNI_ABORT);
4497     }
4498     if (_exception) {
4499         jniThrowException(_env, _exceptionType, _exceptionMessage);
4500     }
4501 }
4502 
4503 /* void glClipPlanex ( GLenum plane, const GLfixed *equation ) */
4504 static void
android_glClipPlanex__I_3II(JNIEnv * _env,jobject _this,jint plane,jintArray equation_ref,jint offset)4505 android_glClipPlanex__I_3II
4506   (JNIEnv *_env, jobject _this, jint plane, jintArray equation_ref, jint offset) {
4507     jint _exception = 0;
4508     const char * _exceptionType = NULL;
4509     const char * _exceptionMessage = NULL;
4510     GLfixed *equation_base = (GLfixed *) 0;
4511     jint _remaining;
4512     GLfixed *equation = (GLfixed *) 0;
4513 
4514     if (!equation_ref) {
4515         _exception = 1;
4516         _exceptionType = "java/lang/IllegalArgumentException";
4517         _exceptionMessage = "equation == null";
4518         goto exit;
4519     }
4520     if (offset < 0) {
4521         _exception = 1;
4522         _exceptionType = "java/lang/IllegalArgumentException";
4523         _exceptionMessage = "offset < 0";
4524         goto exit;
4525     }
4526     _remaining = _env->GetArrayLength(equation_ref) - offset;
4527     if (_remaining < 4) {
4528         _exception = 1;
4529         _exceptionType = "java/lang/IllegalArgumentException";
4530         _exceptionMessage = "length - offset < 4 < needed";
4531         goto exit;
4532     }
4533     equation_base = (GLfixed *)
4534         _env->GetIntArrayElements(equation_ref, (jboolean *)0);
4535     equation = equation_base + offset;
4536 
4537     glClipPlanex(
4538         (GLenum)plane,
4539         (GLfixed *)equation
4540     );
4541 
4542 exit:
4543     if (equation_base) {
4544         _env->ReleaseIntArrayElements(equation_ref, (jint*)equation_base,
4545             JNI_ABORT);
4546     }
4547     if (_exception) {
4548         jniThrowException(_env, _exceptionType, _exceptionMessage);
4549     }
4550 }
4551 
4552 /* void glClipPlanex ( GLenum plane, const GLfixed *equation ) */
4553 static void
android_glClipPlanex__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint plane,jobject equation_buf)4554 android_glClipPlanex__ILjava_nio_IntBuffer_2
4555   (JNIEnv *_env, jobject _this, jint plane, jobject equation_buf) {
4556     jint _exception = 0;
4557     const char * _exceptionType = NULL;
4558     const char * _exceptionMessage = NULL;
4559     jintArray _array = (jintArray) 0;
4560     jint _bufferOffset = (jint) 0;
4561     jint _remaining;
4562     GLfixed *equation = (GLfixed *) 0;
4563 
4564     if (!equation_buf) {
4565         _exception = 1;
4566         _exceptionType = "java/lang/IllegalArgumentException";
4567         _exceptionMessage = "equation == null";
4568         goto exit;
4569     }
4570     equation = (GLfixed *)getPointer(_env, equation_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
4571     if (_remaining < 4) {
4572         _exception = 1;
4573         _exceptionType = "java/lang/IllegalArgumentException";
4574         _exceptionMessage = "remaining() < 4 < needed";
4575         goto exit;
4576     }
4577     if (equation == NULL) {
4578         char * _equationBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
4579         equation = (GLfixed *) (_equationBase + _bufferOffset);
4580     }
4581     glClipPlanex(
4582         (GLenum)plane,
4583         (GLfixed *)equation
4584     );
4585 
4586 exit:
4587     if (_array) {
4588         _env->ReleaseIntArrayElements(_array, (jint*)equation, JNI_ABORT);
4589     }
4590     if (_exception) {
4591         jniThrowException(_env, _exceptionType, _exceptionMessage);
4592     }
4593 }
4594 
4595 /* void glColor4ub ( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha ) */
4596 static void
android_glColor4ub__BBBB(JNIEnv * _env,jobject _this,jbyte red,jbyte green,jbyte blue,jbyte alpha)4597 android_glColor4ub__BBBB
4598   (JNIEnv *_env, jobject _this, jbyte red, jbyte green, jbyte blue, jbyte alpha) {
4599     glColor4ub(
4600         (GLubyte)red,
4601         (GLubyte)green,
4602         (GLubyte)blue,
4603         (GLubyte)alpha
4604     );
4605 }
4606 
4607 /* void glColorPointer ( GLint size, GLenum type, GLsizei stride, GLint offset ) */
4608 static void
android_glColorPointer__IIII(JNIEnv * _env,jobject _this,jint size,jint type,jint stride,jint offset)4609 android_glColorPointer__IIII
4610   (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jint offset) {
4611     glColorPointer(
4612         (GLint)size,
4613         (GLenum)type,
4614         (GLsizei)stride,
4615         reinterpret_cast<GLvoid *>(offset)
4616     );
4617 }
4618 
4619 /* void glDeleteBuffers ( GLsizei n, const GLuint *buffers ) */
4620 static void
android_glDeleteBuffers__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray buffers_ref,jint offset)4621 android_glDeleteBuffers__I_3II
4622   (JNIEnv *_env, jobject _this, jint n, jintArray buffers_ref, jint offset) {
4623     jint _exception = 0;
4624     const char * _exceptionType = NULL;
4625     const char * _exceptionMessage = NULL;
4626     GLuint *buffers_base = (GLuint *) 0;
4627     jint _remaining;
4628     GLuint *buffers = (GLuint *) 0;
4629 
4630     if (!buffers_ref) {
4631         _exception = 1;
4632         _exceptionType = "java/lang/IllegalArgumentException";
4633         _exceptionMessage = "buffers == null";
4634         goto exit;
4635     }
4636     if (offset < 0) {
4637         _exception = 1;
4638         _exceptionType = "java/lang/IllegalArgumentException";
4639         _exceptionMessage = "offset < 0";
4640         goto exit;
4641     }
4642     _remaining = _env->GetArrayLength(buffers_ref) - offset;
4643     if (_remaining < n) {
4644         _exception = 1;
4645         _exceptionType = "java/lang/IllegalArgumentException";
4646         _exceptionMessage = "length - offset < n < needed";
4647         goto exit;
4648     }
4649     buffers_base = (GLuint *)
4650         _env->GetIntArrayElements(buffers_ref, (jboolean *)0);
4651     buffers = buffers_base + offset;
4652 
4653     glDeleteBuffers(
4654         (GLsizei)n,
4655         (GLuint *)buffers
4656     );
4657 
4658 exit:
4659     if (buffers_base) {
4660         _env->ReleaseIntArrayElements(buffers_ref, (jint*)buffers_base,
4661             JNI_ABORT);
4662     }
4663     if (_exception) {
4664         jniThrowException(_env, _exceptionType, _exceptionMessage);
4665     }
4666 }
4667 
4668 /* void glDeleteBuffers ( GLsizei n, const GLuint *buffers ) */
4669 static void
android_glDeleteBuffers__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject buffers_buf)4670 android_glDeleteBuffers__ILjava_nio_IntBuffer_2
4671   (JNIEnv *_env, jobject _this, jint n, jobject buffers_buf) {
4672     jint _exception = 0;
4673     const char * _exceptionType = NULL;
4674     const char * _exceptionMessage = NULL;
4675     jintArray _array = (jintArray) 0;
4676     jint _bufferOffset = (jint) 0;
4677     jint _remaining;
4678     GLuint *buffers = (GLuint *) 0;
4679 
4680     if (!buffers_buf) {
4681         _exception = 1;
4682         _exceptionType = "java/lang/IllegalArgumentException";
4683         _exceptionMessage = "buffers == null";
4684         goto exit;
4685     }
4686     buffers = (GLuint *)getPointer(_env, buffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
4687     if (_remaining < n) {
4688         _exception = 1;
4689         _exceptionType = "java/lang/IllegalArgumentException";
4690         _exceptionMessage = "remaining() < n < needed";
4691         goto exit;
4692     }
4693     if (buffers == NULL) {
4694         char * _buffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
4695         buffers = (GLuint *) (_buffersBase + _bufferOffset);
4696     }
4697     glDeleteBuffers(
4698         (GLsizei)n,
4699         (GLuint *)buffers
4700     );
4701 
4702 exit:
4703     if (_array) {
4704         _env->ReleaseIntArrayElements(_array, (jint*)buffers, JNI_ABORT);
4705     }
4706     if (_exception) {
4707         jniThrowException(_env, _exceptionType, _exceptionMessage);
4708     }
4709 }
4710 
4711 /* void glDrawElements ( GLenum mode, GLsizei count, GLenum type, GLint offset ) */
4712 static void
android_glDrawElements__IIII(JNIEnv * _env,jobject _this,jint mode,jint count,jint type,jint offset)4713 android_glDrawElements__IIII
4714   (JNIEnv *_env, jobject _this, jint mode, jint count, jint type, jint offset) {
4715     jint _exception = 0;
4716     const char * _exceptionType = NULL;
4717     const char * _exceptionMessage = NULL;
4718     glDrawElements(
4719         (GLenum)mode,
4720         (GLsizei)count,
4721         (GLenum)type,
4722         reinterpret_cast<GLvoid *>(offset)
4723     );
4724     if (_exception) {
4725         jniThrowException(_env, _exceptionType, _exceptionMessage);
4726     }
4727 }
4728 
4729 /* void glGenBuffers ( GLsizei n, GLuint *buffers ) */
4730 static void
android_glGenBuffers__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray buffers_ref,jint offset)4731 android_glGenBuffers__I_3II
4732   (JNIEnv *_env, jobject _this, jint n, jintArray buffers_ref, jint offset) {
4733     jint _exception = 0;
4734     const char * _exceptionType = NULL;
4735     const char * _exceptionMessage = NULL;
4736     GLuint *buffers_base = (GLuint *) 0;
4737     jint _remaining;
4738     GLuint *buffers = (GLuint *) 0;
4739 
4740     if (!buffers_ref) {
4741         _exception = 1;
4742         _exceptionType = "java/lang/IllegalArgumentException";
4743         _exceptionMessage = "buffers == null";
4744         goto exit;
4745     }
4746     if (offset < 0) {
4747         _exception = 1;
4748         _exceptionType = "java/lang/IllegalArgumentException";
4749         _exceptionMessage = "offset < 0";
4750         goto exit;
4751     }
4752     _remaining = _env->GetArrayLength(buffers_ref) - offset;
4753     if (_remaining < n) {
4754         _exception = 1;
4755         _exceptionType = "java/lang/IllegalArgumentException";
4756         _exceptionMessage = "length - offset < n < needed";
4757         goto exit;
4758     }
4759     buffers_base = (GLuint *)
4760         _env->GetIntArrayElements(buffers_ref, (jboolean *)0);
4761     buffers = buffers_base + offset;
4762 
4763     glGenBuffers(
4764         (GLsizei)n,
4765         (GLuint *)buffers
4766     );
4767 
4768 exit:
4769     if (buffers_base) {
4770         _env->ReleaseIntArrayElements(buffers_ref, (jint*)buffers_base,
4771             _exception ? JNI_ABORT: 0);
4772     }
4773     if (_exception) {
4774         jniThrowException(_env, _exceptionType, _exceptionMessage);
4775     }
4776 }
4777 
4778 /* void glGenBuffers ( GLsizei n, GLuint *buffers ) */
4779 static void
android_glGenBuffers__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject buffers_buf)4780 android_glGenBuffers__ILjava_nio_IntBuffer_2
4781   (JNIEnv *_env, jobject _this, jint n, jobject buffers_buf) {
4782     jint _exception = 0;
4783     const char * _exceptionType = NULL;
4784     const char * _exceptionMessage = NULL;
4785     jintArray _array = (jintArray) 0;
4786     jint _bufferOffset = (jint) 0;
4787     jint _remaining;
4788     GLuint *buffers = (GLuint *) 0;
4789 
4790     if (!buffers_buf) {
4791         _exception = 1;
4792         _exceptionType = "java/lang/IllegalArgumentException";
4793         _exceptionMessage = "buffers == null";
4794         goto exit;
4795     }
4796     buffers = (GLuint *)getPointer(_env, buffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
4797     if (_remaining < n) {
4798         _exception = 1;
4799         _exceptionType = "java/lang/IllegalArgumentException";
4800         _exceptionMessage = "remaining() < n < needed";
4801         goto exit;
4802     }
4803     if (buffers == NULL) {
4804         char * _buffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
4805         buffers = (GLuint *) (_buffersBase + _bufferOffset);
4806     }
4807     glGenBuffers(
4808         (GLsizei)n,
4809         (GLuint *)buffers
4810     );
4811 
4812 exit:
4813     if (_array) {
4814         _env->ReleaseIntArrayElements(_array, (jint*)buffers, _exception ? JNI_ABORT : 0);
4815     }
4816     if (_exception) {
4817         jniThrowException(_env, _exceptionType, _exceptionMessage);
4818     }
4819 }
4820 
4821 /* void glGetBooleanv ( GLenum pname, GLboolean *params ) */
4822 static void
android_glGetBooleanv__I_3ZI(JNIEnv * _env,jobject _this,jint pname,jbooleanArray params_ref,jint offset)4823 android_glGetBooleanv__I_3ZI
4824   (JNIEnv *_env, jobject _this, jint pname, jbooleanArray params_ref, jint offset) {
4825     jint _exception = 0;
4826     const char * _exceptionType = NULL;
4827     const char * _exceptionMessage = NULL;
4828     GLboolean *params_base = (GLboolean *) 0;
4829     jint _remaining;
4830     GLboolean *params = (GLboolean *) 0;
4831 
4832     if (!params_ref) {
4833         _exception = 1;
4834         _exceptionType = "java/lang/IllegalArgumentException";
4835         _exceptionMessage = "params == null";
4836         goto exit;
4837     }
4838     if (offset < 0) {
4839         _exception = 1;
4840         _exceptionType = "java/lang/IllegalArgumentException";
4841         _exceptionMessage = "offset < 0";
4842         goto exit;
4843     }
4844     _remaining = _env->GetArrayLength(params_ref) - offset;
4845     params_base = (GLboolean *)
4846         _env->GetBooleanArrayElements(params_ref, (jboolean *)0);
4847     params = params_base + offset;
4848 
4849     glGetBooleanv(
4850         (GLenum)pname,
4851         (GLboolean *)params
4852     );
4853 
4854 exit:
4855     if (params_base) {
4856         _env->ReleaseBooleanArrayElements(params_ref, (jboolean*)params_base,
4857             _exception ? JNI_ABORT: 0);
4858     }
4859     if (_exception) {
4860         jniThrowException(_env, _exceptionType, _exceptionMessage);
4861     }
4862 }
4863 
4864 /* void glGetBooleanv ( GLenum pname, GLboolean *params ) */
4865 static void
android_glGetBooleanv__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)4866 android_glGetBooleanv__ILjava_nio_IntBuffer_2
4867   (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
4868     jint _exception = 0;
4869     const char * _exceptionType = NULL;
4870     const char * _exceptionMessage = NULL;
4871     jintArray _array = (jintArray) 0;
4872     jint _bufferOffset = (jint) 0;
4873     jint _remaining;
4874     GLboolean *params = (GLboolean *) 0;
4875 
4876     if (!params_buf) {
4877         _exception = 1;
4878         _exceptionType = "java/lang/IllegalArgumentException";
4879         _exceptionMessage = "params == null";
4880         goto exit;
4881     }
4882     params = (GLboolean *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
4883     if (params == NULL) {
4884         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
4885         params = (GLboolean *) (_paramsBase + _bufferOffset);
4886     }
4887     glGetBooleanv(
4888         (GLenum)pname,
4889         (GLboolean *)params
4890     );
4891 
4892 exit:
4893     if (_array) {
4894         _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
4895     }
4896     if (_exception) {
4897         jniThrowException(_env, _exceptionType, _exceptionMessage);
4898     }
4899 }
4900 
4901 /* void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */
4902 static void
android_glGetBufferParameteriv__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)4903 android_glGetBufferParameteriv__II_3II
4904   (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
4905     jniThrowException(_env, "java/lang/UnsupportedOperationException",
4906         "glGetBufferParameteriv");
4907 }
4908 
4909 /* void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */
4910 static void
android_glGetBufferParameteriv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)4911 android_glGetBufferParameteriv__IILjava_nio_IntBuffer_2
4912   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
4913     jniThrowException(_env, "java/lang/UnsupportedOperationException",
4914         "glGetBufferParameteriv");
4915 }
4916 
4917 /* void glGetClipPlanef ( GLenum pname, GLfloat *eqn ) */
4918 static void
android_glGetClipPlanef__I_3FI(JNIEnv * _env,jobject _this,jint pname,jfloatArray eqn_ref,jint offset)4919 android_glGetClipPlanef__I_3FI
4920   (JNIEnv *_env, jobject _this, jint pname, jfloatArray eqn_ref, jint offset) {
4921     jint _exception = 0;
4922     const char * _exceptionType = NULL;
4923     const char * _exceptionMessage = NULL;
4924     GLfloat *eqn_base = (GLfloat *) 0;
4925     jint _remaining;
4926     GLfloat *eqn = (GLfloat *) 0;
4927 
4928     if (!eqn_ref) {
4929         _exception = 1;
4930         _exceptionType = "java/lang/IllegalArgumentException";
4931         _exceptionMessage = "eqn == null";
4932         goto exit;
4933     }
4934     if (offset < 0) {
4935         _exception = 1;
4936         _exceptionType = "java/lang/IllegalArgumentException";
4937         _exceptionMessage = "offset < 0";
4938         goto exit;
4939     }
4940     _remaining = _env->GetArrayLength(eqn_ref) - offset;
4941     eqn_base = (GLfloat *)
4942         _env->GetFloatArrayElements(eqn_ref, (jboolean *)0);
4943     eqn = eqn_base + offset;
4944 
4945     glGetClipPlanef(
4946         (GLenum)pname,
4947         (GLfloat *)eqn
4948     );
4949 
4950 exit:
4951     if (eqn_base) {
4952         _env->ReleaseFloatArrayElements(eqn_ref, (jfloat*)eqn_base,
4953             _exception ? JNI_ABORT: 0);
4954     }
4955     if (_exception) {
4956         jniThrowException(_env, _exceptionType, _exceptionMessage);
4957     }
4958 }
4959 
4960 /* void glGetClipPlanef ( GLenum pname, GLfloat *eqn ) */
4961 static void
android_glGetClipPlanef__ILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject eqn_buf)4962 android_glGetClipPlanef__ILjava_nio_FloatBuffer_2
4963   (JNIEnv *_env, jobject _this, jint pname, jobject eqn_buf) {
4964     jint _exception = 0;
4965     const char * _exceptionType = NULL;
4966     const char * _exceptionMessage = NULL;
4967     jfloatArray _array = (jfloatArray) 0;
4968     jint _bufferOffset = (jint) 0;
4969     jint _remaining;
4970     GLfloat *eqn = (GLfloat *) 0;
4971 
4972     if (!eqn_buf) {
4973         _exception = 1;
4974         _exceptionType = "java/lang/IllegalArgumentException";
4975         _exceptionMessage = "eqn == null";
4976         goto exit;
4977     }
4978     eqn = (GLfloat *)getPointer(_env, eqn_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
4979     if (eqn == NULL) {
4980         char * _eqnBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
4981         eqn = (GLfloat *) (_eqnBase + _bufferOffset);
4982     }
4983     glGetClipPlanef(
4984         (GLenum)pname,
4985         (GLfloat *)eqn
4986     );
4987 
4988 exit:
4989     if (_array) {
4990         _env->ReleaseFloatArrayElements(_array, (jfloat*)eqn, _exception ? JNI_ABORT : 0);
4991     }
4992     if (_exception) {
4993         jniThrowException(_env, _exceptionType, _exceptionMessage);
4994     }
4995 }
4996 
4997 /* void glGetClipPlanex ( GLenum pname, GLfixed *eqn ) */
4998 static void
android_glGetClipPlanex__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray eqn_ref,jint offset)4999 android_glGetClipPlanex__I_3II
5000   (JNIEnv *_env, jobject _this, jint pname, jintArray eqn_ref, jint offset) {
5001     jint _exception = 0;
5002     const char * _exceptionType = NULL;
5003     const char * _exceptionMessage = NULL;
5004     GLfixed *eqn_base = (GLfixed *) 0;
5005     jint _remaining;
5006     GLfixed *eqn = (GLfixed *) 0;
5007 
5008     if (!eqn_ref) {
5009         _exception = 1;
5010         _exceptionType = "java/lang/IllegalArgumentException";
5011         _exceptionMessage = "eqn == null";
5012         goto exit;
5013     }
5014     if (offset < 0) {
5015         _exception = 1;
5016         _exceptionType = "java/lang/IllegalArgumentException";
5017         _exceptionMessage = "offset < 0";
5018         goto exit;
5019     }
5020     _remaining = _env->GetArrayLength(eqn_ref) - offset;
5021     eqn_base = (GLfixed *)
5022         _env->GetIntArrayElements(eqn_ref, (jboolean *)0);
5023     eqn = eqn_base + offset;
5024 
5025     glGetClipPlanex(
5026         (GLenum)pname,
5027         (GLfixed *)eqn
5028     );
5029 
5030 exit:
5031     if (eqn_base) {
5032         _env->ReleaseIntArrayElements(eqn_ref, (jint*)eqn_base,
5033             _exception ? JNI_ABORT: 0);
5034     }
5035     if (_exception) {
5036         jniThrowException(_env, _exceptionType, _exceptionMessage);
5037     }
5038 }
5039 
5040 /* void glGetClipPlanex ( GLenum pname, GLfixed *eqn ) */
5041 static void
android_glGetClipPlanex__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject eqn_buf)5042 android_glGetClipPlanex__ILjava_nio_IntBuffer_2
5043   (JNIEnv *_env, jobject _this, jint pname, jobject eqn_buf) {
5044     jint _exception = 0;
5045     const char * _exceptionType = NULL;
5046     const char * _exceptionMessage = NULL;
5047     jintArray _array = (jintArray) 0;
5048     jint _bufferOffset = (jint) 0;
5049     jint _remaining;
5050     GLfixed *eqn = (GLfixed *) 0;
5051 
5052     if (!eqn_buf) {
5053         _exception = 1;
5054         _exceptionType = "java/lang/IllegalArgumentException";
5055         _exceptionMessage = "eqn == null";
5056         goto exit;
5057     }
5058     eqn = (GLfixed *)getPointer(_env, eqn_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
5059     if (eqn == NULL) {
5060         char * _eqnBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
5061         eqn = (GLfixed *) (_eqnBase + _bufferOffset);
5062     }
5063     glGetClipPlanex(
5064         (GLenum)pname,
5065         (GLfixed *)eqn
5066     );
5067 
5068 exit:
5069     if (_array) {
5070         _env->ReleaseIntArrayElements(_array, (jint*)eqn, _exception ? JNI_ABORT : 0);
5071     }
5072     if (_exception) {
5073         jniThrowException(_env, _exceptionType, _exceptionMessage);
5074     }
5075 }
5076 
5077 /* void glGetFixedv ( GLenum pname, GLfixed *params ) */
5078 static void
android_glGetFixedv__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray params_ref,jint offset)5079 android_glGetFixedv__I_3II
5080   (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
5081     jint _exception = 0;
5082     const char * _exceptionType = NULL;
5083     const char * _exceptionMessage = NULL;
5084     GLfixed *params_base = (GLfixed *) 0;
5085     jint _remaining;
5086     GLfixed *params = (GLfixed *) 0;
5087 
5088     if (!params_ref) {
5089         _exception = 1;
5090         _exceptionType = "java/lang/IllegalArgumentException";
5091         _exceptionMessage = "params == null";
5092         goto exit;
5093     }
5094     if (offset < 0) {
5095         _exception = 1;
5096         _exceptionType = "java/lang/IllegalArgumentException";
5097         _exceptionMessage = "offset < 0";
5098         goto exit;
5099     }
5100     _remaining = _env->GetArrayLength(params_ref) - offset;
5101     params_base = (GLfixed *)
5102         _env->GetIntArrayElements(params_ref, (jboolean *)0);
5103     params = params_base + offset;
5104 
5105     glGetFixedv(
5106         (GLenum)pname,
5107         (GLfixed *)params
5108     );
5109 
5110 exit:
5111     if (params_base) {
5112         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
5113             _exception ? JNI_ABORT: 0);
5114     }
5115     if (_exception) {
5116         jniThrowException(_env, _exceptionType, _exceptionMessage);
5117     }
5118 }
5119 
5120 /* void glGetFixedv ( GLenum pname, GLfixed *params ) */
5121 static void
android_glGetFixedv__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)5122 android_glGetFixedv__ILjava_nio_IntBuffer_2
5123   (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
5124     jint _exception = 0;
5125     const char * _exceptionType = NULL;
5126     const char * _exceptionMessage = NULL;
5127     jintArray _array = (jintArray) 0;
5128     jint _bufferOffset = (jint) 0;
5129     jint _remaining;
5130     GLfixed *params = (GLfixed *) 0;
5131 
5132     if (!params_buf) {
5133         _exception = 1;
5134         _exceptionType = "java/lang/IllegalArgumentException";
5135         _exceptionMessage = "params == null";
5136         goto exit;
5137     }
5138     params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
5139     if (params == NULL) {
5140         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
5141         params = (GLfixed *) (_paramsBase + _bufferOffset);
5142     }
5143     glGetFixedv(
5144         (GLenum)pname,
5145         (GLfixed *)params
5146     );
5147 
5148 exit:
5149     if (_array) {
5150         _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
5151     }
5152     if (_exception) {
5153         jniThrowException(_env, _exceptionType, _exceptionMessage);
5154     }
5155 }
5156 
5157 /* void glGetFloatv ( GLenum pname, GLfloat *params ) */
5158 static void
android_glGetFloatv__I_3FI(JNIEnv * _env,jobject _this,jint pname,jfloatArray params_ref,jint offset)5159 android_glGetFloatv__I_3FI
5160   (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) {
5161     jint _exception = 0;
5162     const char * _exceptionType = NULL;
5163     const char * _exceptionMessage = NULL;
5164     GLfloat *params_base = (GLfloat *) 0;
5165     jint _remaining;
5166     GLfloat *params = (GLfloat *) 0;
5167 
5168     if (!params_ref) {
5169         _exception = 1;
5170         _exceptionType = "java/lang/IllegalArgumentException";
5171         _exceptionMessage = "params == null";
5172         goto exit;
5173     }
5174     if (offset < 0) {
5175         _exception = 1;
5176         _exceptionType = "java/lang/IllegalArgumentException";
5177         _exceptionMessage = "offset < 0";
5178         goto exit;
5179     }
5180     _remaining = _env->GetArrayLength(params_ref) - offset;
5181     params_base = (GLfloat *)
5182         _env->GetFloatArrayElements(params_ref, (jboolean *)0);
5183     params = params_base + offset;
5184 
5185     glGetFloatv(
5186         (GLenum)pname,
5187         (GLfloat *)params
5188     );
5189 
5190 exit:
5191     if (params_base) {
5192         _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
5193             _exception ? JNI_ABORT: 0);
5194     }
5195     if (_exception) {
5196         jniThrowException(_env, _exceptionType, _exceptionMessage);
5197     }
5198 }
5199 
5200 /* void glGetFloatv ( GLenum pname, GLfloat *params ) */
5201 static void
android_glGetFloatv__ILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)5202 android_glGetFloatv__ILjava_nio_FloatBuffer_2
5203   (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
5204     jint _exception = 0;
5205     const char * _exceptionType = NULL;
5206     const char * _exceptionMessage = NULL;
5207     jfloatArray _array = (jfloatArray) 0;
5208     jint _bufferOffset = (jint) 0;
5209     jint _remaining;
5210     GLfloat *params = (GLfloat *) 0;
5211 
5212     if (!params_buf) {
5213         _exception = 1;
5214         _exceptionType = "java/lang/IllegalArgumentException";
5215         _exceptionMessage = "params == null";
5216         goto exit;
5217     }
5218     params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
5219     if (params == NULL) {
5220         char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
5221         params = (GLfloat *) (_paramsBase + _bufferOffset);
5222     }
5223     glGetFloatv(
5224         (GLenum)pname,
5225         (GLfloat *)params
5226     );
5227 
5228 exit:
5229     if (_array) {
5230         _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0);
5231     }
5232     if (_exception) {
5233         jniThrowException(_env, _exceptionType, _exceptionMessage);
5234     }
5235 }
5236 
5237 /* void glGetLightfv ( GLenum light, GLenum pname, GLfloat *params ) */
5238 static void
android_glGetLightfv__II_3FI(JNIEnv * _env,jobject _this,jint light,jint pname,jfloatArray params_ref,jint offset)5239 android_glGetLightfv__II_3FI
5240   (JNIEnv *_env, jobject _this, jint light, jint pname, jfloatArray params_ref, jint offset) {
5241     jint _exception = 0;
5242     const char * _exceptionType = NULL;
5243     const char * _exceptionMessage = NULL;
5244     GLfloat *params_base = (GLfloat *) 0;
5245     jint _remaining;
5246     GLfloat *params = (GLfloat *) 0;
5247 
5248     if (!params_ref) {
5249         _exception = 1;
5250         _exceptionType = "java/lang/IllegalArgumentException";
5251         _exceptionMessage = "params == null";
5252         goto exit;
5253     }
5254     if (offset < 0) {
5255         _exception = 1;
5256         _exceptionType = "java/lang/IllegalArgumentException";
5257         _exceptionMessage = "offset < 0";
5258         goto exit;
5259     }
5260     _remaining = _env->GetArrayLength(params_ref) - offset;
5261     int _needed;
5262     switch (pname) {
5263 #if defined(GL_SPOT_EXPONENT)
5264         case GL_SPOT_EXPONENT:
5265 #endif // defined(GL_SPOT_EXPONENT)
5266 #if defined(GL_SPOT_CUTOFF)
5267         case GL_SPOT_CUTOFF:
5268 #endif // defined(GL_SPOT_CUTOFF)
5269 #if defined(GL_CONSTANT_ATTENUATION)
5270         case GL_CONSTANT_ATTENUATION:
5271 #endif // defined(GL_CONSTANT_ATTENUATION)
5272 #if defined(GL_LINEAR_ATTENUATION)
5273         case GL_LINEAR_ATTENUATION:
5274 #endif // defined(GL_LINEAR_ATTENUATION)
5275 #if defined(GL_QUADRATIC_ATTENUATION)
5276         case GL_QUADRATIC_ATTENUATION:
5277 #endif // defined(GL_QUADRATIC_ATTENUATION)
5278             _needed = 1;
5279             break;
5280 #if defined(GL_SPOT_DIRECTION)
5281         case GL_SPOT_DIRECTION:
5282 #endif // defined(GL_SPOT_DIRECTION)
5283             _needed = 3;
5284             break;
5285 #if defined(GL_AMBIENT)
5286         case GL_AMBIENT:
5287 #endif // defined(GL_AMBIENT)
5288 #if defined(GL_DIFFUSE)
5289         case GL_DIFFUSE:
5290 #endif // defined(GL_DIFFUSE)
5291 #if defined(GL_SPECULAR)
5292         case GL_SPECULAR:
5293 #endif // defined(GL_SPECULAR)
5294 #if defined(GL_EMISSION)
5295         case GL_EMISSION:
5296 #endif // defined(GL_EMISSION)
5297             _needed = 4;
5298             break;
5299         default:
5300             _needed = 1;
5301             break;
5302     }
5303     if (_remaining < _needed) {
5304         _exception = 1;
5305         _exceptionType = "java/lang/IllegalArgumentException";
5306         _exceptionMessage = "length - offset < needed";
5307         goto exit;
5308     }
5309     params_base = (GLfloat *)
5310         _env->GetFloatArrayElements(params_ref, (jboolean *)0);
5311     params = params_base + offset;
5312 
5313     glGetLightfv(
5314         (GLenum)light,
5315         (GLenum)pname,
5316         (GLfloat *)params
5317     );
5318 
5319 exit:
5320     if (params_base) {
5321         _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
5322             _exception ? JNI_ABORT: 0);
5323     }
5324     if (_exception) {
5325         jniThrowException(_env, _exceptionType, _exceptionMessage);
5326     }
5327 }
5328 
5329 /* void glGetLightfv ( GLenum light, GLenum pname, GLfloat *params ) */
5330 static void
android_glGetLightfv__IILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint light,jint pname,jobject params_buf)5331 android_glGetLightfv__IILjava_nio_FloatBuffer_2
5332   (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) {
5333     jint _exception = 0;
5334     const char * _exceptionType = NULL;
5335     const char * _exceptionMessage = NULL;
5336     jfloatArray _array = (jfloatArray) 0;
5337     jint _bufferOffset = (jint) 0;
5338     jint _remaining;
5339     GLfloat *params = (GLfloat *) 0;
5340 
5341     if (!params_buf) {
5342         _exception = 1;
5343         _exceptionType = "java/lang/IllegalArgumentException";
5344         _exceptionMessage = "params == null";
5345         goto exit;
5346     }
5347     params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
5348     int _needed;
5349     switch (pname) {
5350 #if defined(GL_SPOT_EXPONENT)
5351         case GL_SPOT_EXPONENT:
5352 #endif // defined(GL_SPOT_EXPONENT)
5353 #if defined(GL_SPOT_CUTOFF)
5354         case GL_SPOT_CUTOFF:
5355 #endif // defined(GL_SPOT_CUTOFF)
5356 #if defined(GL_CONSTANT_ATTENUATION)
5357         case GL_CONSTANT_ATTENUATION:
5358 #endif // defined(GL_CONSTANT_ATTENUATION)
5359 #if defined(GL_LINEAR_ATTENUATION)
5360         case GL_LINEAR_ATTENUATION:
5361 #endif // defined(GL_LINEAR_ATTENUATION)
5362 #if defined(GL_QUADRATIC_ATTENUATION)
5363         case GL_QUADRATIC_ATTENUATION:
5364 #endif // defined(GL_QUADRATIC_ATTENUATION)
5365             _needed = 1;
5366             break;
5367 #if defined(GL_SPOT_DIRECTION)
5368         case GL_SPOT_DIRECTION:
5369 #endif // defined(GL_SPOT_DIRECTION)
5370             _needed = 3;
5371             break;
5372 #if defined(GL_AMBIENT)
5373         case GL_AMBIENT:
5374 #endif // defined(GL_AMBIENT)
5375 #if defined(GL_DIFFUSE)
5376         case GL_DIFFUSE:
5377 #endif // defined(GL_DIFFUSE)
5378 #if defined(GL_SPECULAR)
5379         case GL_SPECULAR:
5380 #endif // defined(GL_SPECULAR)
5381 #if defined(GL_EMISSION)
5382         case GL_EMISSION:
5383 #endif // defined(GL_EMISSION)
5384             _needed = 4;
5385             break;
5386         default:
5387             _needed = 1;
5388             break;
5389     }
5390     if (_remaining < _needed) {
5391         _exception = 1;
5392         _exceptionType = "java/lang/IllegalArgumentException";
5393         _exceptionMessage = "remaining() < needed";
5394         goto exit;
5395     }
5396     if (params == NULL) {
5397         char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
5398         params = (GLfloat *) (_paramsBase + _bufferOffset);
5399     }
5400     glGetLightfv(
5401         (GLenum)light,
5402         (GLenum)pname,
5403         (GLfloat *)params
5404     );
5405 
5406 exit:
5407     if (_array) {
5408         _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0);
5409     }
5410     if (_exception) {
5411         jniThrowException(_env, _exceptionType, _exceptionMessage);
5412     }
5413 }
5414 
5415 /* void glGetLightxv ( GLenum light, GLenum pname, GLfixed *params ) */
5416 static void
android_glGetLightxv__II_3II(JNIEnv * _env,jobject _this,jint light,jint pname,jintArray params_ref,jint offset)5417 android_glGetLightxv__II_3II
5418   (JNIEnv *_env, jobject _this, jint light, jint pname, jintArray params_ref, jint offset) {
5419     jint _exception = 0;
5420     const char * _exceptionType = NULL;
5421     const char * _exceptionMessage = NULL;
5422     GLfixed *params_base = (GLfixed *) 0;
5423     jint _remaining;
5424     GLfixed *params = (GLfixed *) 0;
5425 
5426     if (!params_ref) {
5427         _exception = 1;
5428         _exceptionType = "java/lang/IllegalArgumentException";
5429         _exceptionMessage = "params == null";
5430         goto exit;
5431     }
5432     if (offset < 0) {
5433         _exception = 1;
5434         _exceptionType = "java/lang/IllegalArgumentException";
5435         _exceptionMessage = "offset < 0";
5436         goto exit;
5437     }
5438     _remaining = _env->GetArrayLength(params_ref) - offset;
5439     int _needed;
5440     switch (pname) {
5441 #if defined(GL_SPOT_EXPONENT)
5442         case GL_SPOT_EXPONENT:
5443 #endif // defined(GL_SPOT_EXPONENT)
5444 #if defined(GL_SPOT_CUTOFF)
5445         case GL_SPOT_CUTOFF:
5446 #endif // defined(GL_SPOT_CUTOFF)
5447 #if defined(GL_CONSTANT_ATTENUATION)
5448         case GL_CONSTANT_ATTENUATION:
5449 #endif // defined(GL_CONSTANT_ATTENUATION)
5450 #if defined(GL_LINEAR_ATTENUATION)
5451         case GL_LINEAR_ATTENUATION:
5452 #endif // defined(GL_LINEAR_ATTENUATION)
5453 #if defined(GL_QUADRATIC_ATTENUATION)
5454         case GL_QUADRATIC_ATTENUATION:
5455 #endif // defined(GL_QUADRATIC_ATTENUATION)
5456             _needed = 1;
5457             break;
5458 #if defined(GL_SPOT_DIRECTION)
5459         case GL_SPOT_DIRECTION:
5460 #endif // defined(GL_SPOT_DIRECTION)
5461             _needed = 3;
5462             break;
5463 #if defined(GL_AMBIENT)
5464         case GL_AMBIENT:
5465 #endif // defined(GL_AMBIENT)
5466 #if defined(GL_DIFFUSE)
5467         case GL_DIFFUSE:
5468 #endif // defined(GL_DIFFUSE)
5469 #if defined(GL_SPECULAR)
5470         case GL_SPECULAR:
5471 #endif // defined(GL_SPECULAR)
5472 #if defined(GL_EMISSION)
5473         case GL_EMISSION:
5474 #endif // defined(GL_EMISSION)
5475             _needed = 4;
5476             break;
5477         default:
5478             _needed = 1;
5479             break;
5480     }
5481     if (_remaining < _needed) {
5482         _exception = 1;
5483         _exceptionType = "java/lang/IllegalArgumentException";
5484         _exceptionMessage = "length - offset < needed";
5485         goto exit;
5486     }
5487     params_base = (GLfixed *)
5488         _env->GetIntArrayElements(params_ref, (jboolean *)0);
5489     params = params_base + offset;
5490 
5491     glGetLightxv(
5492         (GLenum)light,
5493         (GLenum)pname,
5494         (GLfixed *)params
5495     );
5496 
5497 exit:
5498     if (params_base) {
5499         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
5500             _exception ? JNI_ABORT: 0);
5501     }
5502     if (_exception) {
5503         jniThrowException(_env, _exceptionType, _exceptionMessage);
5504     }
5505 }
5506 
5507 /* void glGetLightxv ( GLenum light, GLenum pname, GLfixed *params ) */
5508 static void
android_glGetLightxv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint light,jint pname,jobject params_buf)5509 android_glGetLightxv__IILjava_nio_IntBuffer_2
5510   (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) {
5511     jint _exception = 0;
5512     const char * _exceptionType = NULL;
5513     const char * _exceptionMessage = NULL;
5514     jintArray _array = (jintArray) 0;
5515     jint _bufferOffset = (jint) 0;
5516     jint _remaining;
5517     GLfixed *params = (GLfixed *) 0;
5518 
5519     if (!params_buf) {
5520         _exception = 1;
5521         _exceptionType = "java/lang/IllegalArgumentException";
5522         _exceptionMessage = "params == null";
5523         goto exit;
5524     }
5525     params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
5526     int _needed;
5527     switch (pname) {
5528 #if defined(GL_SPOT_EXPONENT)
5529         case GL_SPOT_EXPONENT:
5530 #endif // defined(GL_SPOT_EXPONENT)
5531 #if defined(GL_SPOT_CUTOFF)
5532         case GL_SPOT_CUTOFF:
5533 #endif // defined(GL_SPOT_CUTOFF)
5534 #if defined(GL_CONSTANT_ATTENUATION)
5535         case GL_CONSTANT_ATTENUATION:
5536 #endif // defined(GL_CONSTANT_ATTENUATION)
5537 #if defined(GL_LINEAR_ATTENUATION)
5538         case GL_LINEAR_ATTENUATION:
5539 #endif // defined(GL_LINEAR_ATTENUATION)
5540 #if defined(GL_QUADRATIC_ATTENUATION)
5541         case GL_QUADRATIC_ATTENUATION:
5542 #endif // defined(GL_QUADRATIC_ATTENUATION)
5543             _needed = 1;
5544             break;
5545 #if defined(GL_SPOT_DIRECTION)
5546         case GL_SPOT_DIRECTION:
5547 #endif // defined(GL_SPOT_DIRECTION)
5548             _needed = 3;
5549             break;
5550 #if defined(GL_AMBIENT)
5551         case GL_AMBIENT:
5552 #endif // defined(GL_AMBIENT)
5553 #if defined(GL_DIFFUSE)
5554         case GL_DIFFUSE:
5555 #endif // defined(GL_DIFFUSE)
5556 #if defined(GL_SPECULAR)
5557         case GL_SPECULAR:
5558 #endif // defined(GL_SPECULAR)
5559 #if defined(GL_EMISSION)
5560         case GL_EMISSION:
5561 #endif // defined(GL_EMISSION)
5562             _needed = 4;
5563             break;
5564         default:
5565             _needed = 1;
5566             break;
5567     }
5568     if (_remaining < _needed) {
5569         _exception = 1;
5570         _exceptionType = "java/lang/IllegalArgumentException";
5571         _exceptionMessage = "remaining() < needed";
5572         goto exit;
5573     }
5574     if (params == NULL) {
5575         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
5576         params = (GLfixed *) (_paramsBase + _bufferOffset);
5577     }
5578     glGetLightxv(
5579         (GLenum)light,
5580         (GLenum)pname,
5581         (GLfixed *)params
5582     );
5583 
5584 exit:
5585     if (_array) {
5586         _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
5587     }
5588     if (_exception) {
5589         jniThrowException(_env, _exceptionType, _exceptionMessage);
5590     }
5591 }
5592 
5593 /* void glGetMaterialfv ( GLenum face, GLenum pname, GLfloat *params ) */
5594 static void
android_glGetMaterialfv__II_3FI(JNIEnv * _env,jobject _this,jint face,jint pname,jfloatArray params_ref,jint offset)5595 android_glGetMaterialfv__II_3FI
5596   (JNIEnv *_env, jobject _this, jint face, jint pname, jfloatArray params_ref, jint offset) {
5597     jint _exception = 0;
5598     const char * _exceptionType = NULL;
5599     const char * _exceptionMessage = NULL;
5600     GLfloat *params_base = (GLfloat *) 0;
5601     jint _remaining;
5602     GLfloat *params = (GLfloat *) 0;
5603 
5604     if (!params_ref) {
5605         _exception = 1;
5606         _exceptionType = "java/lang/IllegalArgumentException";
5607         _exceptionMessage = "params == null";
5608         goto exit;
5609     }
5610     if (offset < 0) {
5611         _exception = 1;
5612         _exceptionType = "java/lang/IllegalArgumentException";
5613         _exceptionMessage = "offset < 0";
5614         goto exit;
5615     }
5616     _remaining = _env->GetArrayLength(params_ref) - offset;
5617     int _needed;
5618     switch (pname) {
5619 #if defined(GL_SHININESS)
5620         case GL_SHININESS:
5621 #endif // defined(GL_SHININESS)
5622             _needed = 1;
5623             break;
5624 #if defined(GL_AMBIENT)
5625         case GL_AMBIENT:
5626 #endif // defined(GL_AMBIENT)
5627 #if defined(GL_DIFFUSE)
5628         case GL_DIFFUSE:
5629 #endif // defined(GL_DIFFUSE)
5630 #if defined(GL_SPECULAR)
5631         case GL_SPECULAR:
5632 #endif // defined(GL_SPECULAR)
5633 #if defined(GL_EMISSION)
5634         case GL_EMISSION:
5635 #endif // defined(GL_EMISSION)
5636 #if defined(GL_AMBIENT_AND_DIFFUSE)
5637         case GL_AMBIENT_AND_DIFFUSE:
5638 #endif // defined(GL_AMBIENT_AND_DIFFUSE)
5639             _needed = 4;
5640             break;
5641         default:
5642             _needed = 1;
5643             break;
5644     }
5645     if (_remaining < _needed) {
5646         _exception = 1;
5647         _exceptionType = "java/lang/IllegalArgumentException";
5648         _exceptionMessage = "length - offset < needed";
5649         goto exit;
5650     }
5651     params_base = (GLfloat *)
5652         _env->GetFloatArrayElements(params_ref, (jboolean *)0);
5653     params = params_base + offset;
5654 
5655     glGetMaterialfv(
5656         (GLenum)face,
5657         (GLenum)pname,
5658         (GLfloat *)params
5659     );
5660 
5661 exit:
5662     if (params_base) {
5663         _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
5664             _exception ? JNI_ABORT: 0);
5665     }
5666     if (_exception) {
5667         jniThrowException(_env, _exceptionType, _exceptionMessage);
5668     }
5669 }
5670 
5671 /* void glGetMaterialfv ( GLenum face, GLenum pname, GLfloat *params ) */
5672 static void
android_glGetMaterialfv__IILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint face,jint pname,jobject params_buf)5673 android_glGetMaterialfv__IILjava_nio_FloatBuffer_2
5674   (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) {
5675     jint _exception = 0;
5676     const char * _exceptionType = NULL;
5677     const char * _exceptionMessage = NULL;
5678     jfloatArray _array = (jfloatArray) 0;
5679     jint _bufferOffset = (jint) 0;
5680     jint _remaining;
5681     GLfloat *params = (GLfloat *) 0;
5682 
5683     if (!params_buf) {
5684         _exception = 1;
5685         _exceptionType = "java/lang/IllegalArgumentException";
5686         _exceptionMessage = "params == null";
5687         goto exit;
5688     }
5689     params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
5690     int _needed;
5691     switch (pname) {
5692 #if defined(GL_SHININESS)
5693         case GL_SHININESS:
5694 #endif // defined(GL_SHININESS)
5695             _needed = 1;
5696             break;
5697 #if defined(GL_AMBIENT)
5698         case GL_AMBIENT:
5699 #endif // defined(GL_AMBIENT)
5700 #if defined(GL_DIFFUSE)
5701         case GL_DIFFUSE:
5702 #endif // defined(GL_DIFFUSE)
5703 #if defined(GL_SPECULAR)
5704         case GL_SPECULAR:
5705 #endif // defined(GL_SPECULAR)
5706 #if defined(GL_EMISSION)
5707         case GL_EMISSION:
5708 #endif // defined(GL_EMISSION)
5709 #if defined(GL_AMBIENT_AND_DIFFUSE)
5710         case GL_AMBIENT_AND_DIFFUSE:
5711 #endif // defined(GL_AMBIENT_AND_DIFFUSE)
5712             _needed = 4;
5713             break;
5714         default:
5715             _needed = 1;
5716             break;
5717     }
5718     if (_remaining < _needed) {
5719         _exception = 1;
5720         _exceptionType = "java/lang/IllegalArgumentException";
5721         _exceptionMessage = "remaining() < needed";
5722         goto exit;
5723     }
5724     if (params == NULL) {
5725         char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
5726         params = (GLfloat *) (_paramsBase + _bufferOffset);
5727     }
5728     glGetMaterialfv(
5729         (GLenum)face,
5730         (GLenum)pname,
5731         (GLfloat *)params
5732     );
5733 
5734 exit:
5735     if (_array) {
5736         _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0);
5737     }
5738     if (_exception) {
5739         jniThrowException(_env, _exceptionType, _exceptionMessage);
5740     }
5741 }
5742 
5743 /* void glGetMaterialxv ( GLenum face, GLenum pname, GLfixed *params ) */
5744 static void
android_glGetMaterialxv__II_3II(JNIEnv * _env,jobject _this,jint face,jint pname,jintArray params_ref,jint offset)5745 android_glGetMaterialxv__II_3II
5746   (JNIEnv *_env, jobject _this, jint face, jint pname, jintArray params_ref, jint offset) {
5747     jint _exception = 0;
5748     const char * _exceptionType = NULL;
5749     const char * _exceptionMessage = NULL;
5750     GLfixed *params_base = (GLfixed *) 0;
5751     jint _remaining;
5752     GLfixed *params = (GLfixed *) 0;
5753 
5754     if (!params_ref) {
5755         _exception = 1;
5756         _exceptionType = "java/lang/IllegalArgumentException";
5757         _exceptionMessage = "params == null";
5758         goto exit;
5759     }
5760     if (offset < 0) {
5761         _exception = 1;
5762         _exceptionType = "java/lang/IllegalArgumentException";
5763         _exceptionMessage = "offset < 0";
5764         goto exit;
5765     }
5766     _remaining = _env->GetArrayLength(params_ref) - offset;
5767     int _needed;
5768     switch (pname) {
5769 #if defined(GL_SHININESS)
5770         case GL_SHININESS:
5771 #endif // defined(GL_SHININESS)
5772             _needed = 1;
5773             break;
5774 #if defined(GL_AMBIENT)
5775         case GL_AMBIENT:
5776 #endif // defined(GL_AMBIENT)
5777 #if defined(GL_DIFFUSE)
5778         case GL_DIFFUSE:
5779 #endif // defined(GL_DIFFUSE)
5780 #if defined(GL_SPECULAR)
5781         case GL_SPECULAR:
5782 #endif // defined(GL_SPECULAR)
5783 #if defined(GL_EMISSION)
5784         case GL_EMISSION:
5785 #endif // defined(GL_EMISSION)
5786 #if defined(GL_AMBIENT_AND_DIFFUSE)
5787         case GL_AMBIENT_AND_DIFFUSE:
5788 #endif // defined(GL_AMBIENT_AND_DIFFUSE)
5789             _needed = 4;
5790             break;
5791         default:
5792             _needed = 1;
5793             break;
5794     }
5795     if (_remaining < _needed) {
5796         _exception = 1;
5797         _exceptionType = "java/lang/IllegalArgumentException";
5798         _exceptionMessage = "length - offset < needed";
5799         goto exit;
5800     }
5801     params_base = (GLfixed *)
5802         _env->GetIntArrayElements(params_ref, (jboolean *)0);
5803     params = params_base + offset;
5804 
5805     glGetMaterialxv(
5806         (GLenum)face,
5807         (GLenum)pname,
5808         (GLfixed *)params
5809     );
5810 
5811 exit:
5812     if (params_base) {
5813         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
5814             _exception ? JNI_ABORT: 0);
5815     }
5816     if (_exception) {
5817         jniThrowException(_env, _exceptionType, _exceptionMessage);
5818     }
5819 }
5820 
5821 /* void glGetMaterialxv ( GLenum face, GLenum pname, GLfixed *params ) */
5822 static void
android_glGetMaterialxv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint face,jint pname,jobject params_buf)5823 android_glGetMaterialxv__IILjava_nio_IntBuffer_2
5824   (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) {
5825     jint _exception = 0;
5826     const char * _exceptionType = NULL;
5827     const char * _exceptionMessage = NULL;
5828     jintArray _array = (jintArray) 0;
5829     jint _bufferOffset = (jint) 0;
5830     jint _remaining;
5831     GLfixed *params = (GLfixed *) 0;
5832 
5833     if (!params_buf) {
5834         _exception = 1;
5835         _exceptionType = "java/lang/IllegalArgumentException";
5836         _exceptionMessage = "params == null";
5837         goto exit;
5838     }
5839     params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
5840     int _needed;
5841     switch (pname) {
5842 #if defined(GL_SHININESS)
5843         case GL_SHININESS:
5844 #endif // defined(GL_SHININESS)
5845             _needed = 1;
5846             break;
5847 #if defined(GL_AMBIENT)
5848         case GL_AMBIENT:
5849 #endif // defined(GL_AMBIENT)
5850 #if defined(GL_DIFFUSE)
5851         case GL_DIFFUSE:
5852 #endif // defined(GL_DIFFUSE)
5853 #if defined(GL_SPECULAR)
5854         case GL_SPECULAR:
5855 #endif // defined(GL_SPECULAR)
5856 #if defined(GL_EMISSION)
5857         case GL_EMISSION:
5858 #endif // defined(GL_EMISSION)
5859 #if defined(GL_AMBIENT_AND_DIFFUSE)
5860         case GL_AMBIENT_AND_DIFFUSE:
5861 #endif // defined(GL_AMBIENT_AND_DIFFUSE)
5862             _needed = 4;
5863             break;
5864         default:
5865             _needed = 1;
5866             break;
5867     }
5868     if (_remaining < _needed) {
5869         _exception = 1;
5870         _exceptionType = "java/lang/IllegalArgumentException";
5871         _exceptionMessage = "remaining() < needed";
5872         goto exit;
5873     }
5874     if (params == NULL) {
5875         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
5876         params = (GLfixed *) (_paramsBase + _bufferOffset);
5877     }
5878     glGetMaterialxv(
5879         (GLenum)face,
5880         (GLenum)pname,
5881         (GLfixed *)params
5882     );
5883 
5884 exit:
5885     if (_array) {
5886         _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
5887     }
5888     if (_exception) {
5889         jniThrowException(_env, _exceptionType, _exceptionMessage);
5890     }
5891 }
5892 
5893 /* void glGetTexEnviv ( GLenum env, GLenum pname, GLint *params ) */
5894 static void
android_glGetTexEnviv__II_3II(JNIEnv * _env,jobject _this,jint env,jint pname,jintArray params_ref,jint offset)5895 android_glGetTexEnviv__II_3II
5896   (JNIEnv *_env, jobject _this, jint env, jint pname, jintArray params_ref, jint offset) {
5897     jint _exception = 0;
5898     const char * _exceptionType = NULL;
5899     const char * _exceptionMessage = NULL;
5900     GLint *params_base = (GLint *) 0;
5901     jint _remaining;
5902     GLint *params = (GLint *) 0;
5903 
5904     if (!params_ref) {
5905         _exception = 1;
5906         _exceptionType = "java/lang/IllegalArgumentException";
5907         _exceptionMessage = "params == null";
5908         goto exit;
5909     }
5910     if (offset < 0) {
5911         _exception = 1;
5912         _exceptionType = "java/lang/IllegalArgumentException";
5913         _exceptionMessage = "offset < 0";
5914         goto exit;
5915     }
5916     _remaining = _env->GetArrayLength(params_ref) - offset;
5917     int _needed;
5918     switch (pname) {
5919 #if defined(GL_TEXTURE_ENV_MODE)
5920         case GL_TEXTURE_ENV_MODE:
5921 #endif // defined(GL_TEXTURE_ENV_MODE)
5922 #if defined(GL_COMBINE_RGB)
5923         case GL_COMBINE_RGB:
5924 #endif // defined(GL_COMBINE_RGB)
5925 #if defined(GL_COMBINE_ALPHA)
5926         case GL_COMBINE_ALPHA:
5927 #endif // defined(GL_COMBINE_ALPHA)
5928             _needed = 1;
5929             break;
5930 #if defined(GL_TEXTURE_ENV_COLOR)
5931         case GL_TEXTURE_ENV_COLOR:
5932 #endif // defined(GL_TEXTURE_ENV_COLOR)
5933             _needed = 4;
5934             break;
5935         default:
5936             _needed = 1;
5937             break;
5938     }
5939     if (_remaining < _needed) {
5940         _exception = 1;
5941         _exceptionType = "java/lang/IllegalArgumentException";
5942         _exceptionMessage = "length - offset < needed";
5943         goto exit;
5944     }
5945     params_base = (GLint *)
5946         _env->GetIntArrayElements(params_ref, (jboolean *)0);
5947     params = params_base + offset;
5948 
5949     glGetTexEnviv(
5950         (GLenum)env,
5951         (GLenum)pname,
5952         (GLint *)params
5953     );
5954 
5955 exit:
5956     if (params_base) {
5957         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
5958             _exception ? JNI_ABORT: 0);
5959     }
5960     if (_exception) {
5961         jniThrowException(_env, _exceptionType, _exceptionMessage);
5962     }
5963 }
5964 
5965 /* void glGetTexEnviv ( GLenum env, GLenum pname, GLint *params ) */
5966 static void
android_glGetTexEnviv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint env,jint pname,jobject params_buf)5967 android_glGetTexEnviv__IILjava_nio_IntBuffer_2
5968   (JNIEnv *_env, jobject _this, jint env, jint pname, jobject params_buf) {
5969     jint _exception = 0;
5970     const char * _exceptionType = NULL;
5971     const char * _exceptionMessage = NULL;
5972     jintArray _array = (jintArray) 0;
5973     jint _bufferOffset = (jint) 0;
5974     jint _remaining;
5975     GLint *params = (GLint *) 0;
5976 
5977     if (!params_buf) {
5978         _exception = 1;
5979         _exceptionType = "java/lang/IllegalArgumentException";
5980         _exceptionMessage = "params == null";
5981         goto exit;
5982     }
5983     params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
5984     int _needed;
5985     switch (pname) {
5986 #if defined(GL_TEXTURE_ENV_MODE)
5987         case GL_TEXTURE_ENV_MODE:
5988 #endif // defined(GL_TEXTURE_ENV_MODE)
5989 #if defined(GL_COMBINE_RGB)
5990         case GL_COMBINE_RGB:
5991 #endif // defined(GL_COMBINE_RGB)
5992 #if defined(GL_COMBINE_ALPHA)
5993         case GL_COMBINE_ALPHA:
5994 #endif // defined(GL_COMBINE_ALPHA)
5995             _needed = 1;
5996             break;
5997 #if defined(GL_TEXTURE_ENV_COLOR)
5998         case GL_TEXTURE_ENV_COLOR:
5999 #endif // defined(GL_TEXTURE_ENV_COLOR)
6000             _needed = 4;
6001             break;
6002         default:
6003             _needed = 1;
6004             break;
6005     }
6006     if (_remaining < _needed) {
6007         _exception = 1;
6008         _exceptionType = "java/lang/IllegalArgumentException";
6009         _exceptionMessage = "remaining() < needed";
6010         goto exit;
6011     }
6012     if (params == NULL) {
6013         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
6014         params = (GLint *) (_paramsBase + _bufferOffset);
6015     }
6016     glGetTexEnviv(
6017         (GLenum)env,
6018         (GLenum)pname,
6019         (GLint *)params
6020     );
6021 
6022 exit:
6023     if (_array) {
6024         _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
6025     }
6026     if (_exception) {
6027         jniThrowException(_env, _exceptionType, _exceptionMessage);
6028     }
6029 }
6030 
6031 /* void glGetTexEnvxv ( GLenum env, GLenum pname, GLfixed *params ) */
6032 static void
android_glGetTexEnvxv__II_3II(JNIEnv * _env,jobject _this,jint env,jint pname,jintArray params_ref,jint offset)6033 android_glGetTexEnvxv__II_3II
6034   (JNIEnv *_env, jobject _this, jint env, jint pname, jintArray params_ref, jint offset) {
6035     jint _exception = 0;
6036     const char * _exceptionType = NULL;
6037     const char * _exceptionMessage = NULL;
6038     GLfixed *params_base = (GLfixed *) 0;
6039     jint _remaining;
6040     GLfixed *params = (GLfixed *) 0;
6041 
6042     if (!params_ref) {
6043         _exception = 1;
6044         _exceptionType = "java/lang/IllegalArgumentException";
6045         _exceptionMessage = "params == null";
6046         goto exit;
6047     }
6048     if (offset < 0) {
6049         _exception = 1;
6050         _exceptionType = "java/lang/IllegalArgumentException";
6051         _exceptionMessage = "offset < 0";
6052         goto exit;
6053     }
6054     _remaining = _env->GetArrayLength(params_ref) - offset;
6055     int _needed;
6056     switch (pname) {
6057 #if defined(GL_TEXTURE_ENV_MODE)
6058         case GL_TEXTURE_ENV_MODE:
6059 #endif // defined(GL_TEXTURE_ENV_MODE)
6060 #if defined(GL_COMBINE_RGB)
6061         case GL_COMBINE_RGB:
6062 #endif // defined(GL_COMBINE_RGB)
6063 #if defined(GL_COMBINE_ALPHA)
6064         case GL_COMBINE_ALPHA:
6065 #endif // defined(GL_COMBINE_ALPHA)
6066             _needed = 1;
6067             break;
6068 #if defined(GL_TEXTURE_ENV_COLOR)
6069         case GL_TEXTURE_ENV_COLOR:
6070 #endif // defined(GL_TEXTURE_ENV_COLOR)
6071             _needed = 4;
6072             break;
6073         default:
6074             _needed = 1;
6075             break;
6076     }
6077     if (_remaining < _needed) {
6078         _exception = 1;
6079         _exceptionType = "java/lang/IllegalArgumentException";
6080         _exceptionMessage = "length - offset < needed";
6081         goto exit;
6082     }
6083     params_base = (GLfixed *)
6084         _env->GetIntArrayElements(params_ref, (jboolean *)0);
6085     params = params_base + offset;
6086 
6087     glGetTexEnvxv(
6088         (GLenum)env,
6089         (GLenum)pname,
6090         (GLfixed *)params
6091     );
6092 
6093 exit:
6094     if (params_base) {
6095         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
6096             _exception ? JNI_ABORT: 0);
6097     }
6098     if (_exception) {
6099         jniThrowException(_env, _exceptionType, _exceptionMessage);
6100     }
6101 }
6102 
6103 /* void glGetTexEnvxv ( GLenum env, GLenum pname, GLfixed *params ) */
6104 static void
android_glGetTexEnvxv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint env,jint pname,jobject params_buf)6105 android_glGetTexEnvxv__IILjava_nio_IntBuffer_2
6106   (JNIEnv *_env, jobject _this, jint env, jint pname, jobject params_buf) {
6107     jint _exception = 0;
6108     const char * _exceptionType = NULL;
6109     const char * _exceptionMessage = NULL;
6110     jintArray _array = (jintArray) 0;
6111     jint _bufferOffset = (jint) 0;
6112     jint _remaining;
6113     GLfixed *params = (GLfixed *) 0;
6114 
6115     if (!params_buf) {
6116         _exception = 1;
6117         _exceptionType = "java/lang/IllegalArgumentException";
6118         _exceptionMessage = "params == null";
6119         goto exit;
6120     }
6121     params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
6122     int _needed;
6123     switch (pname) {
6124 #if defined(GL_TEXTURE_ENV_MODE)
6125         case GL_TEXTURE_ENV_MODE:
6126 #endif // defined(GL_TEXTURE_ENV_MODE)
6127 #if defined(GL_COMBINE_RGB)
6128         case GL_COMBINE_RGB:
6129 #endif // defined(GL_COMBINE_RGB)
6130 #if defined(GL_COMBINE_ALPHA)
6131         case GL_COMBINE_ALPHA:
6132 #endif // defined(GL_COMBINE_ALPHA)
6133             _needed = 1;
6134             break;
6135 #if defined(GL_TEXTURE_ENV_COLOR)
6136         case GL_TEXTURE_ENV_COLOR:
6137 #endif // defined(GL_TEXTURE_ENV_COLOR)
6138             _needed = 4;
6139             break;
6140         default:
6141             _needed = 1;
6142             break;
6143     }
6144     if (_remaining < _needed) {
6145         _exception = 1;
6146         _exceptionType = "java/lang/IllegalArgumentException";
6147         _exceptionMessage = "remaining() < needed";
6148         goto exit;
6149     }
6150     if (params == NULL) {
6151         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
6152         params = (GLfixed *) (_paramsBase + _bufferOffset);
6153     }
6154     glGetTexEnvxv(
6155         (GLenum)env,
6156         (GLenum)pname,
6157         (GLfixed *)params
6158     );
6159 
6160 exit:
6161     if (_array) {
6162         _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
6163     }
6164     if (_exception) {
6165         jniThrowException(_env, _exceptionType, _exceptionMessage);
6166     }
6167 }
6168 
6169 /* void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) */
6170 static void
android_glGetTexParameterfv__II_3FI(JNIEnv * _env,jobject _this,jint target,jint pname,jfloatArray params_ref,jint offset)6171 android_glGetTexParameterfv__II_3FI
6172   (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) {
6173     jint _exception = 0;
6174     const char * _exceptionType = NULL;
6175     const char * _exceptionMessage = NULL;
6176     GLfloat *params_base = (GLfloat *) 0;
6177     jint _remaining;
6178     GLfloat *params = (GLfloat *) 0;
6179 
6180     if (!params_ref) {
6181         _exception = 1;
6182         _exceptionType = "java/lang/IllegalArgumentException";
6183         _exceptionMessage = "params == null";
6184         goto exit;
6185     }
6186     if (offset < 0) {
6187         _exception = 1;
6188         _exceptionType = "java/lang/IllegalArgumentException";
6189         _exceptionMessage = "offset < 0";
6190         goto exit;
6191     }
6192     _remaining = _env->GetArrayLength(params_ref) - offset;
6193     if (_remaining < 1) {
6194         _exception = 1;
6195         _exceptionType = "java/lang/IllegalArgumentException";
6196         _exceptionMessage = "length - offset < 1 < needed";
6197         goto exit;
6198     }
6199     params_base = (GLfloat *)
6200         _env->GetFloatArrayElements(params_ref, (jboolean *)0);
6201     params = params_base + offset;
6202 
6203     glGetTexParameterfv(
6204         (GLenum)target,
6205         (GLenum)pname,
6206         (GLfloat *)params
6207     );
6208 
6209 exit:
6210     if (params_base) {
6211         _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
6212             _exception ? JNI_ABORT: 0);
6213     }
6214     if (_exception) {
6215         jniThrowException(_env, _exceptionType, _exceptionMessage);
6216     }
6217 }
6218 
6219 /* void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) */
6220 static void
android_glGetTexParameterfv__IILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)6221 android_glGetTexParameterfv__IILjava_nio_FloatBuffer_2
6222   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
6223     jint _exception = 0;
6224     const char * _exceptionType = NULL;
6225     const char * _exceptionMessage = NULL;
6226     jfloatArray _array = (jfloatArray) 0;
6227     jint _bufferOffset = (jint) 0;
6228     jint _remaining;
6229     GLfloat *params = (GLfloat *) 0;
6230 
6231     if (!params_buf) {
6232         _exception = 1;
6233         _exceptionType = "java/lang/IllegalArgumentException";
6234         _exceptionMessage = "params == null";
6235         goto exit;
6236     }
6237     params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
6238     if (_remaining < 1) {
6239         _exception = 1;
6240         _exceptionType = "java/lang/IllegalArgumentException";
6241         _exceptionMessage = "remaining() < 1 < needed";
6242         goto exit;
6243     }
6244     if (params == NULL) {
6245         char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
6246         params = (GLfloat *) (_paramsBase + _bufferOffset);
6247     }
6248     glGetTexParameterfv(
6249         (GLenum)target,
6250         (GLenum)pname,
6251         (GLfloat *)params
6252     );
6253 
6254 exit:
6255     if (_array) {
6256         _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0);
6257     }
6258     if (_exception) {
6259         jniThrowException(_env, _exceptionType, _exceptionMessage);
6260     }
6261 }
6262 
6263 /* void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) */
6264 static void
android_glGetTexParameteriv__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)6265 android_glGetTexParameteriv__II_3II
6266   (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
6267     jint _exception = 0;
6268     const char * _exceptionType = NULL;
6269     const char * _exceptionMessage = NULL;
6270     GLint *params_base = (GLint *) 0;
6271     jint _remaining;
6272     GLint *params = (GLint *) 0;
6273 
6274     if (!params_ref) {
6275         _exception = 1;
6276         _exceptionType = "java/lang/IllegalArgumentException";
6277         _exceptionMessage = "params == null";
6278         goto exit;
6279     }
6280     if (offset < 0) {
6281         _exception = 1;
6282         _exceptionType = "java/lang/IllegalArgumentException";
6283         _exceptionMessage = "offset < 0";
6284         goto exit;
6285     }
6286     _remaining = _env->GetArrayLength(params_ref) - offset;
6287     if (_remaining < 1) {
6288         _exception = 1;
6289         _exceptionType = "java/lang/IllegalArgumentException";
6290         _exceptionMessage = "length - offset < 1 < needed";
6291         goto exit;
6292     }
6293     params_base = (GLint *)
6294         _env->GetIntArrayElements(params_ref, (jboolean *)0);
6295     params = params_base + offset;
6296 
6297     glGetTexParameteriv(
6298         (GLenum)target,
6299         (GLenum)pname,
6300         (GLint *)params
6301     );
6302 
6303 exit:
6304     if (params_base) {
6305         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
6306             _exception ? JNI_ABORT: 0);
6307     }
6308     if (_exception) {
6309         jniThrowException(_env, _exceptionType, _exceptionMessage);
6310     }
6311 }
6312 
6313 /* void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) */
6314 static void
android_glGetTexParameteriv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)6315 android_glGetTexParameteriv__IILjava_nio_IntBuffer_2
6316   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
6317     jint _exception = 0;
6318     const char * _exceptionType = NULL;
6319     const char * _exceptionMessage = NULL;
6320     jintArray _array = (jintArray) 0;
6321     jint _bufferOffset = (jint) 0;
6322     jint _remaining;
6323     GLint *params = (GLint *) 0;
6324 
6325     if (!params_buf) {
6326         _exception = 1;
6327         _exceptionType = "java/lang/IllegalArgumentException";
6328         _exceptionMessage = "params == null";
6329         goto exit;
6330     }
6331     params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
6332     if (_remaining < 1) {
6333         _exception = 1;
6334         _exceptionType = "java/lang/IllegalArgumentException";
6335         _exceptionMessage = "remaining() < 1 < needed";
6336         goto exit;
6337     }
6338     if (params == NULL) {
6339         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
6340         params = (GLint *) (_paramsBase + _bufferOffset);
6341     }
6342     glGetTexParameteriv(
6343         (GLenum)target,
6344         (GLenum)pname,
6345         (GLint *)params
6346     );
6347 
6348 exit:
6349     if (_array) {
6350         _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
6351     }
6352     if (_exception) {
6353         jniThrowException(_env, _exceptionType, _exceptionMessage);
6354     }
6355 }
6356 
6357 /* void glGetTexParameterxv ( GLenum target, GLenum pname, GLfixed *params ) */
6358 static void
android_glGetTexParameterxv__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)6359 android_glGetTexParameterxv__II_3II
6360   (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
6361     jint _exception = 0;
6362     const char * _exceptionType = NULL;
6363     const char * _exceptionMessage = NULL;
6364     GLfixed *params_base = (GLfixed *) 0;
6365     jint _remaining;
6366     GLfixed *params = (GLfixed *) 0;
6367 
6368     if (!params_ref) {
6369         _exception = 1;
6370         _exceptionType = "java/lang/IllegalArgumentException";
6371         _exceptionMessage = "params == null";
6372         goto exit;
6373     }
6374     if (offset < 0) {
6375         _exception = 1;
6376         _exceptionType = "java/lang/IllegalArgumentException";
6377         _exceptionMessage = "offset < 0";
6378         goto exit;
6379     }
6380     _remaining = _env->GetArrayLength(params_ref) - offset;
6381     if (_remaining < 1) {
6382         _exception = 1;
6383         _exceptionType = "java/lang/IllegalArgumentException";
6384         _exceptionMessage = "length - offset < 1 < needed";
6385         goto exit;
6386     }
6387     params_base = (GLfixed *)
6388         _env->GetIntArrayElements(params_ref, (jboolean *)0);
6389     params = params_base + offset;
6390 
6391     glGetTexParameterxv(
6392         (GLenum)target,
6393         (GLenum)pname,
6394         (GLfixed *)params
6395     );
6396 
6397 exit:
6398     if (params_base) {
6399         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
6400             _exception ? JNI_ABORT: 0);
6401     }
6402     if (_exception) {
6403         jniThrowException(_env, _exceptionType, _exceptionMessage);
6404     }
6405 }
6406 
6407 /* void glGetTexParameterxv ( GLenum target, GLenum pname, GLfixed *params ) */
6408 static void
android_glGetTexParameterxv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)6409 android_glGetTexParameterxv__IILjava_nio_IntBuffer_2
6410   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
6411     jint _exception = 0;
6412     const char * _exceptionType = NULL;
6413     const char * _exceptionMessage = NULL;
6414     jintArray _array = (jintArray) 0;
6415     jint _bufferOffset = (jint) 0;
6416     jint _remaining;
6417     GLfixed *params = (GLfixed *) 0;
6418 
6419     if (!params_buf) {
6420         _exception = 1;
6421         _exceptionType = "java/lang/IllegalArgumentException";
6422         _exceptionMessage = "params == null";
6423         goto exit;
6424     }
6425     params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
6426     if (_remaining < 1) {
6427         _exception = 1;
6428         _exceptionType = "java/lang/IllegalArgumentException";
6429         _exceptionMessage = "remaining() < 1 < needed";
6430         goto exit;
6431     }
6432     if (params == NULL) {
6433         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
6434         params = (GLfixed *) (_paramsBase + _bufferOffset);
6435     }
6436     glGetTexParameterxv(
6437         (GLenum)target,
6438         (GLenum)pname,
6439         (GLfixed *)params
6440     );
6441 
6442 exit:
6443     if (_array) {
6444         _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
6445     }
6446     if (_exception) {
6447         jniThrowException(_env, _exceptionType, _exceptionMessage);
6448     }
6449 }
6450 
6451 /* GLboolean glIsBuffer ( GLuint buffer ) */
6452 static jboolean
android_glIsBuffer__I(JNIEnv * _env,jobject _this,jint buffer)6453 android_glIsBuffer__I
6454   (JNIEnv *_env, jobject _this, jint buffer) {
6455     GLboolean _returnValue;
6456     _returnValue = glIsBuffer(
6457         (GLuint)buffer
6458     );
6459     return (jboolean)_returnValue;
6460 }
6461 
6462 /* GLboolean glIsEnabled ( GLenum cap ) */
6463 static jboolean
android_glIsEnabled__I(JNIEnv * _env,jobject _this,jint cap)6464 android_glIsEnabled__I
6465   (JNIEnv *_env, jobject _this, jint cap) {
6466     GLboolean _returnValue;
6467     _returnValue = glIsEnabled(
6468         (GLenum)cap
6469     );
6470     return (jboolean)_returnValue;
6471 }
6472 
6473 /* GLboolean glIsTexture ( GLuint texture ) */
6474 static jboolean
android_glIsTexture__I(JNIEnv * _env,jobject _this,jint texture)6475 android_glIsTexture__I
6476   (JNIEnv *_env, jobject _this, jint texture) {
6477     GLboolean _returnValue;
6478     _returnValue = glIsTexture(
6479         (GLuint)texture
6480     );
6481     return (jboolean)_returnValue;
6482 }
6483 
6484 /* void glNormalPointer ( GLenum type, GLsizei stride, GLint offset ) */
6485 static void
android_glNormalPointer__III(JNIEnv * _env,jobject _this,jint type,jint stride,jint offset)6486 android_glNormalPointer__III
6487   (JNIEnv *_env, jobject _this, jint type, jint stride, jint offset) {
6488     glNormalPointer(
6489         (GLenum)type,
6490         (GLsizei)stride,
6491         reinterpret_cast<GLvoid *>(offset)
6492     );
6493 }
6494 
6495 /* void glPointParameterf ( GLenum pname, GLfloat param ) */
6496 static void
android_glPointParameterf__IF(JNIEnv * _env,jobject _this,jint pname,jfloat param)6497 android_glPointParameterf__IF
6498   (JNIEnv *_env, jobject _this, jint pname, jfloat param) {
6499     glPointParameterf(
6500         (GLenum)pname,
6501         (GLfloat)param
6502     );
6503 }
6504 
6505 /* void glPointParameterfv ( GLenum pname, const GLfloat *params ) */
6506 static void
android_glPointParameterfv__I_3FI(JNIEnv * _env,jobject _this,jint pname,jfloatArray params_ref,jint offset)6507 android_glPointParameterfv__I_3FI
6508   (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) {
6509     jint _exception = 0;
6510     const char * _exceptionType = NULL;
6511     const char * _exceptionMessage = NULL;
6512     GLfloat *params_base = (GLfloat *) 0;
6513     jint _remaining;
6514     GLfloat *params = (GLfloat *) 0;
6515 
6516     if (!params_ref) {
6517         _exception = 1;
6518         _exceptionType = "java/lang/IllegalArgumentException";
6519         _exceptionMessage = "params == null";
6520         goto exit;
6521     }
6522     if (offset < 0) {
6523         _exception = 1;
6524         _exceptionType = "java/lang/IllegalArgumentException";
6525         _exceptionMessage = "offset < 0";
6526         goto exit;
6527     }
6528     _remaining = _env->GetArrayLength(params_ref) - offset;
6529     if (_remaining < 1) {
6530         _exception = 1;
6531         _exceptionType = "java/lang/IllegalArgumentException";
6532         _exceptionMessage = "length - offset < 1 < needed";
6533         goto exit;
6534     }
6535     params_base = (GLfloat *)
6536         _env->GetFloatArrayElements(params_ref, (jboolean *)0);
6537     params = params_base + offset;
6538 
6539     glPointParameterfv(
6540         (GLenum)pname,
6541         (GLfloat *)params
6542     );
6543 
6544 exit:
6545     if (params_base) {
6546         _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
6547             JNI_ABORT);
6548     }
6549     if (_exception) {
6550         jniThrowException(_env, _exceptionType, _exceptionMessage);
6551     }
6552 }
6553 
6554 /* void glPointParameterfv ( GLenum pname, const GLfloat *params ) */
6555 static void
android_glPointParameterfv__ILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)6556 android_glPointParameterfv__ILjava_nio_FloatBuffer_2
6557   (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
6558     jint _exception = 0;
6559     const char * _exceptionType = NULL;
6560     const char * _exceptionMessage = NULL;
6561     jfloatArray _array = (jfloatArray) 0;
6562     jint _bufferOffset = (jint) 0;
6563     jint _remaining;
6564     GLfloat *params = (GLfloat *) 0;
6565 
6566     if (!params_buf) {
6567         _exception = 1;
6568         _exceptionType = "java/lang/IllegalArgumentException";
6569         _exceptionMessage = "params == null";
6570         goto exit;
6571     }
6572     params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
6573     if (_remaining < 1) {
6574         _exception = 1;
6575         _exceptionType = "java/lang/IllegalArgumentException";
6576         _exceptionMessage = "remaining() < 1 < needed";
6577         goto exit;
6578     }
6579     if (params == NULL) {
6580         char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
6581         params = (GLfloat *) (_paramsBase + _bufferOffset);
6582     }
6583     glPointParameterfv(
6584         (GLenum)pname,
6585         (GLfloat *)params
6586     );
6587 
6588 exit:
6589     if (_array) {
6590         _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT);
6591     }
6592     if (_exception) {
6593         jniThrowException(_env, _exceptionType, _exceptionMessage);
6594     }
6595 }
6596 
6597 /* void glPointParameterx ( GLenum pname, GLfixed param ) */
6598 static void
android_glPointParameterx__II(JNIEnv * _env,jobject _this,jint pname,jint param)6599 android_glPointParameterx__II
6600   (JNIEnv *_env, jobject _this, jint pname, jint param) {
6601     glPointParameterx(
6602         (GLenum)pname,
6603         (GLfixed)param
6604     );
6605 }
6606 
6607 /* void glPointParameterxv ( GLenum pname, const GLfixed *params ) */
6608 static void
android_glPointParameterxv__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray params_ref,jint offset)6609 android_glPointParameterxv__I_3II
6610   (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
6611     jint _exception = 0;
6612     const char * _exceptionType = NULL;
6613     const char * _exceptionMessage = NULL;
6614     GLfixed *params_base = (GLfixed *) 0;
6615     jint _remaining;
6616     GLfixed *params = (GLfixed *) 0;
6617 
6618     if (!params_ref) {
6619         _exception = 1;
6620         _exceptionType = "java/lang/IllegalArgumentException";
6621         _exceptionMessage = "params == null";
6622         goto exit;
6623     }
6624     if (offset < 0) {
6625         _exception = 1;
6626         _exceptionType = "java/lang/IllegalArgumentException";
6627         _exceptionMessage = "offset < 0";
6628         goto exit;
6629     }
6630     _remaining = _env->GetArrayLength(params_ref) - offset;
6631     if (_remaining < 1) {
6632         _exception = 1;
6633         _exceptionType = "java/lang/IllegalArgumentException";
6634         _exceptionMessage = "length - offset < 1 < needed";
6635         goto exit;
6636     }
6637     params_base = (GLfixed *)
6638         _env->GetIntArrayElements(params_ref, (jboolean *)0);
6639     params = params_base + offset;
6640 
6641     glPointParameterxv(
6642         (GLenum)pname,
6643         (GLfixed *)params
6644     );
6645 
6646 exit:
6647     if (params_base) {
6648         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
6649             JNI_ABORT);
6650     }
6651     if (_exception) {
6652         jniThrowException(_env, _exceptionType, _exceptionMessage);
6653     }
6654 }
6655 
6656 /* void glPointParameterxv ( GLenum pname, const GLfixed *params ) */
6657 static void
android_glPointParameterxv__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)6658 android_glPointParameterxv__ILjava_nio_IntBuffer_2
6659   (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
6660     jint _exception = 0;
6661     const char * _exceptionType = NULL;
6662     const char * _exceptionMessage = NULL;
6663     jintArray _array = (jintArray) 0;
6664     jint _bufferOffset = (jint) 0;
6665     jint _remaining;
6666     GLfixed *params = (GLfixed *) 0;
6667 
6668     if (!params_buf) {
6669         _exception = 1;
6670         _exceptionType = "java/lang/IllegalArgumentException";
6671         _exceptionMessage = "params == null";
6672         goto exit;
6673     }
6674     params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
6675     if (_remaining < 1) {
6676         _exception = 1;
6677         _exceptionType = "java/lang/IllegalArgumentException";
6678         _exceptionMessage = "remaining() < 1 < needed";
6679         goto exit;
6680     }
6681     if (params == NULL) {
6682         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
6683         params = (GLfixed *) (_paramsBase + _bufferOffset);
6684     }
6685     glPointParameterxv(
6686         (GLenum)pname,
6687         (GLfixed *)params
6688     );
6689 
6690 exit:
6691     if (_array) {
6692         _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT);
6693     }
6694     if (_exception) {
6695         jniThrowException(_env, _exceptionType, _exceptionMessage);
6696     }
6697 }
6698 
6699 /* void glPointSizePointerOES ( GLenum type, GLsizei stride, const GLvoid *pointer ) */
6700 static void
android_glPointSizePointerOESBounds__IILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint type,jint stride,jobject pointer_buf,jint remaining)6701 android_glPointSizePointerOESBounds__IILjava_nio_Buffer_2I
6702   (JNIEnv *_env, jobject _this, jint type, jint stride, jobject pointer_buf, jint remaining) {
6703     jint _exception = 0;
6704     const char * _exceptionType = NULL;
6705     const char * _exceptionMessage = NULL;
6706     jarray _array = (jarray) 0;
6707     jint _bufferOffset = (jint) 0;
6708     jint _remaining;
6709     GLvoid *pointer = (GLvoid *) 0;
6710 
6711     if (pointer_buf) {
6712         pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
6713         if ( ! pointer ) {
6714             return;
6715         }
6716     }
6717     glPointSizePointerOESBounds(
6718         (GLenum)type,
6719         (GLsizei)stride,
6720         (GLvoid *)pointer,
6721         (GLsizei)remaining
6722     );
6723     if (_exception) {
6724         jniThrowException(_env, _exceptionType, _exceptionMessage);
6725     }
6726 }
6727 
6728 /* void glTexCoordPointer ( GLint size, GLenum type, GLsizei stride, GLint offset ) */
6729 static void
android_glTexCoordPointer__IIII(JNIEnv * _env,jobject _this,jint size,jint type,jint stride,jint offset)6730 android_glTexCoordPointer__IIII
6731   (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jint offset) {
6732     glTexCoordPointer(
6733         (GLint)size,
6734         (GLenum)type,
6735         (GLsizei)stride,
6736         reinterpret_cast<GLvoid *>(offset)
6737     );
6738 }
6739 
6740 /* void glTexEnvi ( GLenum target, GLenum pname, GLint param ) */
6741 static void
android_glTexEnvi__III(JNIEnv * _env,jobject _this,jint target,jint pname,jint param)6742 android_glTexEnvi__III
6743   (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) {
6744     glTexEnvi(
6745         (GLenum)target,
6746         (GLenum)pname,
6747         (GLint)param
6748     );
6749 }
6750 
6751 /* void glTexEnviv ( GLenum target, GLenum pname, const GLint *params ) */
6752 static void
android_glTexEnviv__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)6753 android_glTexEnviv__II_3II
6754   (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
6755     jint _exception = 0;
6756     const char * _exceptionType = NULL;
6757     const char * _exceptionMessage = NULL;
6758     GLint *params_base = (GLint *) 0;
6759     jint _remaining;
6760     GLint *params = (GLint *) 0;
6761 
6762     if (!params_ref) {
6763         _exception = 1;
6764         _exceptionType = "java/lang/IllegalArgumentException";
6765         _exceptionMessage = "params == null";
6766         goto exit;
6767     }
6768     if (offset < 0) {
6769         _exception = 1;
6770         _exceptionType = "java/lang/IllegalArgumentException";
6771         _exceptionMessage = "offset < 0";
6772         goto exit;
6773     }
6774     _remaining = _env->GetArrayLength(params_ref) - offset;
6775     int _needed;
6776     switch (pname) {
6777 #if defined(GL_TEXTURE_ENV_MODE)
6778         case GL_TEXTURE_ENV_MODE:
6779 #endif // defined(GL_TEXTURE_ENV_MODE)
6780 #if defined(GL_COMBINE_RGB)
6781         case GL_COMBINE_RGB:
6782 #endif // defined(GL_COMBINE_RGB)
6783 #if defined(GL_COMBINE_ALPHA)
6784         case GL_COMBINE_ALPHA:
6785 #endif // defined(GL_COMBINE_ALPHA)
6786             _needed = 1;
6787             break;
6788 #if defined(GL_TEXTURE_ENV_COLOR)
6789         case GL_TEXTURE_ENV_COLOR:
6790 #endif // defined(GL_TEXTURE_ENV_COLOR)
6791             _needed = 4;
6792             break;
6793         default:
6794             _needed = 1;
6795             break;
6796     }
6797     if (_remaining < _needed) {
6798         _exception = 1;
6799         _exceptionType = "java/lang/IllegalArgumentException";
6800         _exceptionMessage = "length - offset < needed";
6801         goto exit;
6802     }
6803     params_base = (GLint *)
6804         _env->GetIntArrayElements(params_ref, (jboolean *)0);
6805     params = params_base + offset;
6806 
6807     glTexEnviv(
6808         (GLenum)target,
6809         (GLenum)pname,
6810         (GLint *)params
6811     );
6812 
6813 exit:
6814     if (params_base) {
6815         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
6816             JNI_ABORT);
6817     }
6818     if (_exception) {
6819         jniThrowException(_env, _exceptionType, _exceptionMessage);
6820     }
6821 }
6822 
6823 /* void glTexEnviv ( GLenum target, GLenum pname, const GLint *params ) */
6824 static void
android_glTexEnviv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)6825 android_glTexEnviv__IILjava_nio_IntBuffer_2
6826   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
6827     jint _exception = 0;
6828     const char * _exceptionType = NULL;
6829     const char * _exceptionMessage = NULL;
6830     jintArray _array = (jintArray) 0;
6831     jint _bufferOffset = (jint) 0;
6832     jint _remaining;
6833     GLint *params = (GLint *) 0;
6834 
6835     if (!params_buf) {
6836         _exception = 1;
6837         _exceptionType = "java/lang/IllegalArgumentException";
6838         _exceptionMessage = "params == null";
6839         goto exit;
6840     }
6841     params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
6842     int _needed;
6843     switch (pname) {
6844 #if defined(GL_TEXTURE_ENV_MODE)
6845         case GL_TEXTURE_ENV_MODE:
6846 #endif // defined(GL_TEXTURE_ENV_MODE)
6847 #if defined(GL_COMBINE_RGB)
6848         case GL_COMBINE_RGB:
6849 #endif // defined(GL_COMBINE_RGB)
6850 #if defined(GL_COMBINE_ALPHA)
6851         case GL_COMBINE_ALPHA:
6852 #endif // defined(GL_COMBINE_ALPHA)
6853             _needed = 1;
6854             break;
6855 #if defined(GL_TEXTURE_ENV_COLOR)
6856         case GL_TEXTURE_ENV_COLOR:
6857 #endif // defined(GL_TEXTURE_ENV_COLOR)
6858             _needed = 4;
6859             break;
6860         default:
6861             _needed = 1;
6862             break;
6863     }
6864     if (_remaining < _needed) {
6865         _exception = 1;
6866         _exceptionType = "java/lang/IllegalArgumentException";
6867         _exceptionMessage = "remaining() < needed";
6868         goto exit;
6869     }
6870     if (params == NULL) {
6871         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
6872         params = (GLint *) (_paramsBase + _bufferOffset);
6873     }
6874     glTexEnviv(
6875         (GLenum)target,
6876         (GLenum)pname,
6877         (GLint *)params
6878     );
6879 
6880 exit:
6881     if (_array) {
6882         _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT);
6883     }
6884     if (_exception) {
6885         jniThrowException(_env, _exceptionType, _exceptionMessage);
6886     }
6887 }
6888 
6889 /* void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params ) */
6890 static void
android_glTexParameterfv__II_3FI(JNIEnv * _env,jobject _this,jint target,jint pname,jfloatArray params_ref,jint offset)6891 android_glTexParameterfv__II_3FI
6892   (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) {
6893     jint _exception = 0;
6894     const char * _exceptionType = NULL;
6895     const char * _exceptionMessage = NULL;
6896     GLfloat *params_base = (GLfloat *) 0;
6897     jint _remaining;
6898     GLfloat *params = (GLfloat *) 0;
6899 
6900     if (!params_ref) {
6901         _exception = 1;
6902         _exceptionType = "java/lang/IllegalArgumentException";
6903         _exceptionMessage = "params == null";
6904         goto exit;
6905     }
6906     if (offset < 0) {
6907         _exception = 1;
6908         _exceptionType = "java/lang/IllegalArgumentException";
6909         _exceptionMessage = "offset < 0";
6910         goto exit;
6911     }
6912     _remaining = _env->GetArrayLength(params_ref) - offset;
6913     if (_remaining < 1) {
6914         _exception = 1;
6915         _exceptionType = "java/lang/IllegalArgumentException";
6916         _exceptionMessage = "length - offset < 1 < needed";
6917         goto exit;
6918     }
6919     params_base = (GLfloat *)
6920         _env->GetFloatArrayElements(params_ref, (jboolean *)0);
6921     params = params_base + offset;
6922 
6923     glTexParameterfv(
6924         (GLenum)target,
6925         (GLenum)pname,
6926         (GLfloat *)params
6927     );
6928 
6929 exit:
6930     if (params_base) {
6931         _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
6932             JNI_ABORT);
6933     }
6934     if (_exception) {
6935         jniThrowException(_env, _exceptionType, _exceptionMessage);
6936     }
6937 }
6938 
6939 /* void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params ) */
6940 static void
android_glTexParameterfv__IILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)6941 android_glTexParameterfv__IILjava_nio_FloatBuffer_2
6942   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
6943     jint _exception = 0;
6944     const char * _exceptionType = NULL;
6945     const char * _exceptionMessage = NULL;
6946     jfloatArray _array = (jfloatArray) 0;
6947     jint _bufferOffset = (jint) 0;
6948     jint _remaining;
6949     GLfloat *params = (GLfloat *) 0;
6950 
6951     if (!params_buf) {
6952         _exception = 1;
6953         _exceptionType = "java/lang/IllegalArgumentException";
6954         _exceptionMessage = "params == null";
6955         goto exit;
6956     }
6957     params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
6958     if (_remaining < 1) {
6959         _exception = 1;
6960         _exceptionType = "java/lang/IllegalArgumentException";
6961         _exceptionMessage = "remaining() < 1 < needed";
6962         goto exit;
6963     }
6964     if (params == NULL) {
6965         char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
6966         params = (GLfloat *) (_paramsBase + _bufferOffset);
6967     }
6968     glTexParameterfv(
6969         (GLenum)target,
6970         (GLenum)pname,
6971         (GLfloat *)params
6972     );
6973 
6974 exit:
6975     if (_array) {
6976         _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT);
6977     }
6978     if (_exception) {
6979         jniThrowException(_env, _exceptionType, _exceptionMessage);
6980     }
6981 }
6982 
6983 /* void glTexParameteri ( GLenum target, GLenum pname, GLint param ) */
6984 static void
android_glTexParameteri__III(JNIEnv * _env,jobject _this,jint target,jint pname,jint param)6985 android_glTexParameteri__III
6986   (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) {
6987     glTexParameteri(
6988         (GLenum)target,
6989         (GLenum)pname,
6990         (GLint)param
6991     );
6992 }
6993 
6994 /* void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params ) */
6995 static void
android_glTexParameteriv__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)6996 android_glTexParameteriv__II_3II
6997   (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
6998     jint _exception = 0;
6999     const char * _exceptionType = NULL;
7000     const char * _exceptionMessage = NULL;
7001     GLint *params_base = (GLint *) 0;
7002     jint _remaining;
7003     GLint *params = (GLint *) 0;
7004 
7005     if (!params_ref) {
7006         _exception = 1;
7007         _exceptionType = "java/lang/IllegalArgumentException";
7008         _exceptionMessage = "params == null";
7009         goto exit;
7010     }
7011     if (offset < 0) {
7012         _exception = 1;
7013         _exceptionType = "java/lang/IllegalArgumentException";
7014         _exceptionMessage = "offset < 0";
7015         goto exit;
7016     }
7017     _remaining = _env->GetArrayLength(params_ref) - offset;
7018     if (_remaining < 1) {
7019         _exception = 1;
7020         _exceptionType = "java/lang/IllegalArgumentException";
7021         _exceptionMessage = "length - offset < 1 < needed";
7022         goto exit;
7023     }
7024     params_base = (GLint *)
7025         _env->GetIntArrayElements(params_ref, (jboolean *)0);
7026     params = params_base + offset;
7027 
7028     glTexParameteriv(
7029         (GLenum)target,
7030         (GLenum)pname,
7031         (GLint *)params
7032     );
7033 
7034 exit:
7035     if (params_base) {
7036         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
7037             JNI_ABORT);
7038     }
7039     if (_exception) {
7040         jniThrowException(_env, _exceptionType, _exceptionMessage);
7041     }
7042 }
7043 
7044 /* void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params ) */
7045 static void
android_glTexParameteriv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)7046 android_glTexParameteriv__IILjava_nio_IntBuffer_2
7047   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
7048     jint _exception = 0;
7049     const char * _exceptionType = NULL;
7050     const char * _exceptionMessage = NULL;
7051     jintArray _array = (jintArray) 0;
7052     jint _bufferOffset = (jint) 0;
7053     jint _remaining;
7054     GLint *params = (GLint *) 0;
7055 
7056     if (!params_buf) {
7057         _exception = 1;
7058         _exceptionType = "java/lang/IllegalArgumentException";
7059         _exceptionMessage = "params == null";
7060         goto exit;
7061     }
7062     params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
7063     if (_remaining < 1) {
7064         _exception = 1;
7065         _exceptionType = "java/lang/IllegalArgumentException";
7066         _exceptionMessage = "remaining() < 1 < needed";
7067         goto exit;
7068     }
7069     if (params == NULL) {
7070         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
7071         params = (GLint *) (_paramsBase + _bufferOffset);
7072     }
7073     glTexParameteriv(
7074         (GLenum)target,
7075         (GLenum)pname,
7076         (GLint *)params
7077     );
7078 
7079 exit:
7080     if (_array) {
7081         _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT);
7082     }
7083     if (_exception) {
7084         jniThrowException(_env, _exceptionType, _exceptionMessage);
7085     }
7086 }
7087 
7088 /* void glTexParameterxv ( GLenum target, GLenum pname, const GLfixed *params ) */
7089 static void
android_glTexParameterxv__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)7090 android_glTexParameterxv__II_3II
7091   (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
7092     jint _exception = 0;
7093     const char * _exceptionType = NULL;
7094     const char * _exceptionMessage = NULL;
7095     GLfixed *params_base = (GLfixed *) 0;
7096     jint _remaining;
7097     GLfixed *params = (GLfixed *) 0;
7098 
7099     if (!params_ref) {
7100         _exception = 1;
7101         _exceptionType = "java/lang/IllegalArgumentException";
7102         _exceptionMessage = "params == null";
7103         goto exit;
7104     }
7105     if (offset < 0) {
7106         _exception = 1;
7107         _exceptionType = "java/lang/IllegalArgumentException";
7108         _exceptionMessage = "offset < 0";
7109         goto exit;
7110     }
7111     _remaining = _env->GetArrayLength(params_ref) - offset;
7112     if (_remaining < 1) {
7113         _exception = 1;
7114         _exceptionType = "java/lang/IllegalArgumentException";
7115         _exceptionMessage = "length - offset < 1 < needed";
7116         goto exit;
7117     }
7118     params_base = (GLfixed *)
7119         _env->GetIntArrayElements(params_ref, (jboolean *)0);
7120     params = params_base + offset;
7121 
7122     glTexParameterxv(
7123         (GLenum)target,
7124         (GLenum)pname,
7125         (GLfixed *)params
7126     );
7127 
7128 exit:
7129     if (params_base) {
7130         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
7131             JNI_ABORT);
7132     }
7133     if (_exception) {
7134         jniThrowException(_env, _exceptionType, _exceptionMessage);
7135     }
7136 }
7137 
7138 /* void glTexParameterxv ( GLenum target, GLenum pname, const GLfixed *params ) */
7139 static void
android_glTexParameterxv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)7140 android_glTexParameterxv__IILjava_nio_IntBuffer_2
7141   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
7142     jint _exception = 0;
7143     const char * _exceptionType = NULL;
7144     const char * _exceptionMessage = NULL;
7145     jintArray _array = (jintArray) 0;
7146     jint _bufferOffset = (jint) 0;
7147     jint _remaining;
7148     GLfixed *params = (GLfixed *) 0;
7149 
7150     if (!params_buf) {
7151         _exception = 1;
7152         _exceptionType = "java/lang/IllegalArgumentException";
7153         _exceptionMessage = "params == null";
7154         goto exit;
7155     }
7156     params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
7157     if (_remaining < 1) {
7158         _exception = 1;
7159         _exceptionType = "java/lang/IllegalArgumentException";
7160         _exceptionMessage = "remaining() < 1 < needed";
7161         goto exit;
7162     }
7163     if (params == NULL) {
7164         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
7165         params = (GLfixed *) (_paramsBase + _bufferOffset);
7166     }
7167     glTexParameterxv(
7168         (GLenum)target,
7169         (GLenum)pname,
7170         (GLfixed *)params
7171     );
7172 
7173 exit:
7174     if (_array) {
7175         _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT);
7176     }
7177     if (_exception) {
7178         jniThrowException(_env, _exceptionType, _exceptionMessage);
7179     }
7180 }
7181 
7182 /* void glVertexPointer ( GLint size, GLenum type, GLsizei stride, GLint offset ) */
7183 static void
android_glVertexPointer__IIII(JNIEnv * _env,jobject _this,jint size,jint type,jint stride,jint offset)7184 android_glVertexPointer__IIII
7185   (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jint offset) {
7186     glVertexPointer(
7187         (GLint)size,
7188         (GLenum)type,
7189         (GLsizei)stride,
7190         reinterpret_cast<GLvoid *>(offset)
7191     );
7192 }
7193 
7194 /* void glCurrentPaletteMatrixOES ( GLuint matrixpaletteindex ) */
7195 static void
android_glCurrentPaletteMatrixOES__I(JNIEnv * _env,jobject _this,jint matrixpaletteindex)7196 android_glCurrentPaletteMatrixOES__I
7197   (JNIEnv *_env, jobject _this, jint matrixpaletteindex) {
7198     glCurrentPaletteMatrixOES(
7199         (GLuint)matrixpaletteindex
7200     );
7201 }
7202 
7203 /* void glDrawTexfOES ( GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height ) */
7204 static void
android_glDrawTexfOES__FFFFF(JNIEnv * _env,jobject _this,jfloat x,jfloat y,jfloat z,jfloat width,jfloat height)7205 android_glDrawTexfOES__FFFFF
7206   (JNIEnv *_env, jobject _this, jfloat x, jfloat y, jfloat z, jfloat width, jfloat height) {
7207     glDrawTexfOES(
7208         (GLfloat)x,
7209         (GLfloat)y,
7210         (GLfloat)z,
7211         (GLfloat)width,
7212         (GLfloat)height
7213     );
7214 }
7215 
7216 /* void glDrawTexfvOES ( const GLfloat *coords ) */
7217 static void
android_glDrawTexfvOES___3FI(JNIEnv * _env,jobject _this,jfloatArray coords_ref,jint offset)7218 android_glDrawTexfvOES___3FI
7219   (JNIEnv *_env, jobject _this, jfloatArray coords_ref, jint offset) {
7220     jint _exception = 0;
7221     const char * _exceptionType = NULL;
7222     const char * _exceptionMessage = NULL;
7223     GLfloat *coords_base = (GLfloat *) 0;
7224     jint _remaining;
7225     GLfloat *coords = (GLfloat *) 0;
7226 
7227     if (!coords_ref) {
7228         _exception = 1;
7229         _exceptionType = "java/lang/IllegalArgumentException";
7230         _exceptionMessage = "coords == null";
7231         goto exit;
7232     }
7233     if (offset < 0) {
7234         _exception = 1;
7235         _exceptionType = "java/lang/IllegalArgumentException";
7236         _exceptionMessage = "offset < 0";
7237         goto exit;
7238     }
7239     _remaining = _env->GetArrayLength(coords_ref) - offset;
7240     if (_remaining < 5) {
7241         _exception = 1;
7242         _exceptionType = "java/lang/IllegalArgumentException";
7243         _exceptionMessage = "length - offset < 5 < needed";
7244         goto exit;
7245     }
7246     coords_base = (GLfloat *)
7247         _env->GetFloatArrayElements(coords_ref, (jboolean *)0);
7248     coords = coords_base + offset;
7249 
7250     glDrawTexfvOES(
7251         (GLfloat *)coords
7252     );
7253 
7254 exit:
7255     if (coords_base) {
7256         _env->ReleaseFloatArrayElements(coords_ref, (jfloat*)coords_base,
7257             JNI_ABORT);
7258     }
7259     if (_exception) {
7260         jniThrowException(_env, _exceptionType, _exceptionMessage);
7261     }
7262 }
7263 
7264 /* void glDrawTexfvOES ( const GLfloat *coords ) */
7265 static void
android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jobject coords_buf)7266 android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2
7267   (JNIEnv *_env, jobject _this, jobject coords_buf) {
7268     jint _exception = 0;
7269     const char * _exceptionType = NULL;
7270     const char * _exceptionMessage = NULL;
7271     jfloatArray _array = (jfloatArray) 0;
7272     jint _bufferOffset = (jint) 0;
7273     jint _remaining;
7274     GLfloat *coords = (GLfloat *) 0;
7275 
7276     if (!coords_buf) {
7277         _exception = 1;
7278         _exceptionType = "java/lang/IllegalArgumentException";
7279         _exceptionMessage = "coords == null";
7280         goto exit;
7281     }
7282     coords = (GLfloat *)getPointer(_env, coords_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
7283     if (_remaining < 5) {
7284         _exception = 1;
7285         _exceptionType = "java/lang/IllegalArgumentException";
7286         _exceptionMessage = "remaining() < 5 < needed";
7287         goto exit;
7288     }
7289     if (coords == NULL) {
7290         char * _coordsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
7291         coords = (GLfloat *) (_coordsBase + _bufferOffset);
7292     }
7293     glDrawTexfvOES(
7294         (GLfloat *)coords
7295     );
7296 
7297 exit:
7298     if (_array) {
7299         _env->ReleaseFloatArrayElements(_array, (jfloat*)coords, JNI_ABORT);
7300     }
7301     if (_exception) {
7302         jniThrowException(_env, _exceptionType, _exceptionMessage);
7303     }
7304 }
7305 
7306 /* void glDrawTexiOES ( GLint x, GLint y, GLint z, GLint width, GLint height ) */
7307 static void
android_glDrawTexiOES__IIIII(JNIEnv * _env,jobject _this,jint x,jint y,jint z,jint width,jint height)7308 android_glDrawTexiOES__IIIII
7309   (JNIEnv *_env, jobject _this, jint x, jint y, jint z, jint width, jint height) {
7310     glDrawTexiOES(
7311         (GLint)x,
7312         (GLint)y,
7313         (GLint)z,
7314         (GLint)width,
7315         (GLint)height
7316     );
7317 }
7318 
7319 /* void glDrawTexivOES ( const GLint *coords ) */
7320 static void
android_glDrawTexivOES___3II(JNIEnv * _env,jobject _this,jintArray coords_ref,jint offset)7321 android_glDrawTexivOES___3II
7322   (JNIEnv *_env, jobject _this, jintArray coords_ref, jint offset) {
7323     jint _exception = 0;
7324     const char * _exceptionType = NULL;
7325     const char * _exceptionMessage = NULL;
7326     GLint *coords_base = (GLint *) 0;
7327     jint _remaining;
7328     GLint *coords = (GLint *) 0;
7329 
7330     if (!coords_ref) {
7331         _exception = 1;
7332         _exceptionType = "java/lang/IllegalArgumentException";
7333         _exceptionMessage = "coords == null";
7334         goto exit;
7335     }
7336     if (offset < 0) {
7337         _exception = 1;
7338         _exceptionType = "java/lang/IllegalArgumentException";
7339         _exceptionMessage = "offset < 0";
7340         goto exit;
7341     }
7342     _remaining = _env->GetArrayLength(coords_ref) - offset;
7343     if (_remaining < 5) {
7344         _exception = 1;
7345         _exceptionType = "java/lang/IllegalArgumentException";
7346         _exceptionMessage = "length - offset < 5 < needed";
7347         goto exit;
7348     }
7349     coords_base = (GLint *)
7350         _env->GetIntArrayElements(coords_ref, (jboolean *)0);
7351     coords = coords_base + offset;
7352 
7353     glDrawTexivOES(
7354         (GLint *)coords
7355     );
7356 
7357 exit:
7358     if (coords_base) {
7359         _env->ReleaseIntArrayElements(coords_ref, (jint*)coords_base,
7360             JNI_ABORT);
7361     }
7362     if (_exception) {
7363         jniThrowException(_env, _exceptionType, _exceptionMessage);
7364     }
7365 }
7366 
7367 /* void glDrawTexivOES ( const GLint *coords ) */
7368 static void
android_glDrawTexivOES__Ljava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jobject coords_buf)7369 android_glDrawTexivOES__Ljava_nio_IntBuffer_2
7370   (JNIEnv *_env, jobject _this, jobject coords_buf) {
7371     jint _exception = 0;
7372     const char * _exceptionType = NULL;
7373     const char * _exceptionMessage = NULL;
7374     jintArray _array = (jintArray) 0;
7375     jint _bufferOffset = (jint) 0;
7376     jint _remaining;
7377     GLint *coords = (GLint *) 0;
7378 
7379     if (!coords_buf) {
7380         _exception = 1;
7381         _exceptionType = "java/lang/IllegalArgumentException";
7382         _exceptionMessage = "coords == null";
7383         goto exit;
7384     }
7385     coords = (GLint *)getPointer(_env, coords_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
7386     if (_remaining < 5) {
7387         _exception = 1;
7388         _exceptionType = "java/lang/IllegalArgumentException";
7389         _exceptionMessage = "remaining() < 5 < needed";
7390         goto exit;
7391     }
7392     if (coords == NULL) {
7393         char * _coordsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
7394         coords = (GLint *) (_coordsBase + _bufferOffset);
7395     }
7396     glDrawTexivOES(
7397         (GLint *)coords
7398     );
7399 
7400 exit:
7401     if (_array) {
7402         _env->ReleaseIntArrayElements(_array, (jint*)coords, JNI_ABORT);
7403     }
7404     if (_exception) {
7405         jniThrowException(_env, _exceptionType, _exceptionMessage);
7406     }
7407 }
7408 
7409 /* void glDrawTexsOES ( GLshort x, GLshort y, GLshort z, GLshort width, GLshort height ) */
7410 static void
android_glDrawTexsOES__SSSSS(JNIEnv * _env,jobject _this,jshort x,jshort y,jshort z,jshort width,jshort height)7411 android_glDrawTexsOES__SSSSS
7412   (JNIEnv *_env, jobject _this, jshort x, jshort y, jshort z, jshort width, jshort height) {
7413     glDrawTexsOES(
7414         (GLshort)x,
7415         (GLshort)y,
7416         (GLshort)z,
7417         (GLshort)width,
7418         (GLshort)height
7419     );
7420 }
7421 
7422 /* void glDrawTexsvOES ( const GLshort *coords ) */
7423 static void
android_glDrawTexsvOES___3SI(JNIEnv * _env,jobject _this,jshortArray coords_ref,jint offset)7424 android_glDrawTexsvOES___3SI
7425   (JNIEnv *_env, jobject _this, jshortArray coords_ref, jint offset) {
7426     jint _exception = 0;
7427     const char * _exceptionType = NULL;
7428     const char * _exceptionMessage = NULL;
7429     GLshort *coords_base = (GLshort *) 0;
7430     jint _remaining;
7431     GLshort *coords = (GLshort *) 0;
7432 
7433     if (!coords_ref) {
7434         _exception = 1;
7435         _exceptionType = "java/lang/IllegalArgumentException";
7436         _exceptionMessage = "coords == null";
7437         goto exit;
7438     }
7439     if (offset < 0) {
7440         _exception = 1;
7441         _exceptionType = "java/lang/IllegalArgumentException";
7442         _exceptionMessage = "offset < 0";
7443         goto exit;
7444     }
7445     _remaining = _env->GetArrayLength(coords_ref) - offset;
7446     if (_remaining < 5) {
7447         _exception = 1;
7448         _exceptionType = "java/lang/IllegalArgumentException";
7449         _exceptionMessage = "length - offset < 5 < needed";
7450         goto exit;
7451     }
7452     coords_base = (GLshort *)
7453         _env->GetShortArrayElements(coords_ref, (jboolean *)0);
7454     coords = coords_base + offset;
7455 
7456     glDrawTexsvOES(
7457         (GLshort *)coords
7458     );
7459 
7460 exit:
7461     if (coords_base) {
7462         _env->ReleaseShortArrayElements(coords_ref, (jshort*)coords_base,
7463             JNI_ABORT);
7464     }
7465     if (_exception) {
7466         jniThrowException(_env, _exceptionType, _exceptionMessage);
7467     }
7468 }
7469 
7470 /* void glDrawTexsvOES ( const GLshort *coords ) */
7471 static void
android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2(JNIEnv * _env,jobject _this,jobject coords_buf)7472 android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2
7473   (JNIEnv *_env, jobject _this, jobject coords_buf) {
7474     jint _exception = 0;
7475     const char * _exceptionType = NULL;
7476     const char * _exceptionMessage = NULL;
7477     jshortArray _array = (jshortArray) 0;
7478     jint _bufferOffset = (jint) 0;
7479     jint _remaining;
7480     GLshort *coords = (GLshort *) 0;
7481 
7482     if (!coords_buf) {
7483         _exception = 1;
7484         _exceptionType = "java/lang/IllegalArgumentException";
7485         _exceptionMessage = "coords == null";
7486         goto exit;
7487     }
7488     coords = (GLshort *)getPointer(_env, coords_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
7489     if (_remaining < 5) {
7490         _exception = 1;
7491         _exceptionType = "java/lang/IllegalArgumentException";
7492         _exceptionMessage = "remaining() < 5 < needed";
7493         goto exit;
7494     }
7495     if (coords == NULL) {
7496         char * _coordsBase = (char *)_env->GetShortArrayElements(_array, (jboolean *) 0);
7497         coords = (GLshort *) (_coordsBase + _bufferOffset);
7498     }
7499     glDrawTexsvOES(
7500         (GLshort *)coords
7501     );
7502 
7503 exit:
7504     if (_array) {
7505         _env->ReleaseShortArrayElements(_array, (jshort*)coords, JNI_ABORT);
7506     }
7507     if (_exception) {
7508         jniThrowException(_env, _exceptionType, _exceptionMessage);
7509     }
7510 }
7511 
7512 /* void glDrawTexxOES ( GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height ) */
7513 static void
android_glDrawTexxOES__IIIII(JNIEnv * _env,jobject _this,jint x,jint y,jint z,jint width,jint height)7514 android_glDrawTexxOES__IIIII
7515   (JNIEnv *_env, jobject _this, jint x, jint y, jint z, jint width, jint height) {
7516     glDrawTexxOES(
7517         (GLfixed)x,
7518         (GLfixed)y,
7519         (GLfixed)z,
7520         (GLfixed)width,
7521         (GLfixed)height
7522     );
7523 }
7524 
7525 /* void glDrawTexxvOES ( const GLfixed *coords ) */
7526 static void
android_glDrawTexxvOES___3II(JNIEnv * _env,jobject _this,jintArray coords_ref,jint offset)7527 android_glDrawTexxvOES___3II
7528   (JNIEnv *_env, jobject _this, jintArray coords_ref, jint offset) {
7529     jint _exception = 0;
7530     const char * _exceptionType = NULL;
7531     const char * _exceptionMessage = NULL;
7532     GLfixed *coords_base = (GLfixed *) 0;
7533     jint _remaining;
7534     GLfixed *coords = (GLfixed *) 0;
7535 
7536     if (!coords_ref) {
7537         _exception = 1;
7538         _exceptionType = "java/lang/IllegalArgumentException";
7539         _exceptionMessage = "coords == null";
7540         goto exit;
7541     }
7542     if (offset < 0) {
7543         _exception = 1;
7544         _exceptionType = "java/lang/IllegalArgumentException";
7545         _exceptionMessage = "offset < 0";
7546         goto exit;
7547     }
7548     _remaining = _env->GetArrayLength(coords_ref) - offset;
7549     if (_remaining < 5) {
7550         _exception = 1;
7551         _exceptionType = "java/lang/IllegalArgumentException";
7552         _exceptionMessage = "length - offset < 5 < needed";
7553         goto exit;
7554     }
7555     coords_base = (GLfixed *)
7556         _env->GetIntArrayElements(coords_ref, (jboolean *)0);
7557     coords = coords_base + offset;
7558 
7559     glDrawTexxvOES(
7560         (GLfixed *)coords
7561     );
7562 
7563 exit:
7564     if (coords_base) {
7565         _env->ReleaseIntArrayElements(coords_ref, (jint*)coords_base,
7566             JNI_ABORT);
7567     }
7568     if (_exception) {
7569         jniThrowException(_env, _exceptionType, _exceptionMessage);
7570     }
7571 }
7572 
7573 /* void glDrawTexxvOES ( const GLfixed *coords ) */
7574 static void
android_glDrawTexxvOES__Ljava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jobject coords_buf)7575 android_glDrawTexxvOES__Ljava_nio_IntBuffer_2
7576   (JNIEnv *_env, jobject _this, jobject coords_buf) {
7577     jint _exception = 0;
7578     const char * _exceptionType = NULL;
7579     const char * _exceptionMessage = NULL;
7580     jintArray _array = (jintArray) 0;
7581     jint _bufferOffset = (jint) 0;
7582     jint _remaining;
7583     GLfixed *coords = (GLfixed *) 0;
7584 
7585     if (!coords_buf) {
7586         _exception = 1;
7587         _exceptionType = "java/lang/IllegalArgumentException";
7588         _exceptionMessage = "coords == null";
7589         goto exit;
7590     }
7591     coords = (GLfixed *)getPointer(_env, coords_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
7592     if (_remaining < 5) {
7593         _exception = 1;
7594         _exceptionType = "java/lang/IllegalArgumentException";
7595         _exceptionMessage = "remaining() < 5 < needed";
7596         goto exit;
7597     }
7598     if (coords == NULL) {
7599         char * _coordsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
7600         coords = (GLfixed *) (_coordsBase + _bufferOffset);
7601     }
7602     glDrawTexxvOES(
7603         (GLfixed *)coords
7604     );
7605 
7606 exit:
7607     if (_array) {
7608         _env->ReleaseIntArrayElements(_array, (jint*)coords, JNI_ABORT);
7609     }
7610     if (_exception) {
7611         jniThrowException(_env, _exceptionType, _exceptionMessage);
7612     }
7613 }
7614 
7615 /* void glLoadPaletteFromModelViewMatrixOES ( void ) */
7616 static void
android_glLoadPaletteFromModelViewMatrixOES__(JNIEnv * _env,jobject _this)7617 android_glLoadPaletteFromModelViewMatrixOES__
7618   (JNIEnv *_env, jobject _this) {
7619     glLoadPaletteFromModelViewMatrixOES();
7620 }
7621 
7622 /* void glMatrixIndexPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
7623 static void
android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint size,jint type,jint stride,jobject pointer_buf,jint remaining)7624 android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I
7625   (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
7626     jint _exception = 0;
7627     const char * _exceptionType = NULL;
7628     const char * _exceptionMessage = NULL;
7629     jarray _array = (jarray) 0;
7630     jint _bufferOffset = (jint) 0;
7631     jint _remaining;
7632     GLvoid *pointer = (GLvoid *) 0;
7633 
7634     if (pointer_buf) {
7635         pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
7636         if ( ! pointer ) {
7637             return;
7638         }
7639     }
7640     glMatrixIndexPointerOESBounds(
7641         (GLint)size,
7642         (GLenum)type,
7643         (GLsizei)stride,
7644         (GLvoid *)pointer,
7645         (GLsizei)remaining
7646     );
7647     if (_exception) {
7648         jniThrowException(_env, _exceptionType, _exceptionMessage);
7649     }
7650 }
7651 
7652 /* void glMatrixIndexPointerOES ( GLint size, GLenum type, GLsizei stride, GLint offset ) */
7653 static void
android_glMatrixIndexPointerOES__IIII(JNIEnv * _env,jobject _this,jint size,jint type,jint stride,jint offset)7654 android_glMatrixIndexPointerOES__IIII
7655   (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jint offset) {
7656     glMatrixIndexPointerOES(
7657         (GLint)size,
7658         (GLenum)type,
7659         (GLsizei)stride,
7660         reinterpret_cast<GLvoid *>(offset)
7661     );
7662 }
7663 
7664 /* void glWeightPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
7665 static void
android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint size,jint type,jint stride,jobject pointer_buf,jint remaining)7666 android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I
7667   (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
7668     jint _exception = 0;
7669     const char * _exceptionType = NULL;
7670     const char * _exceptionMessage = NULL;
7671     jarray _array = (jarray) 0;
7672     jint _bufferOffset = (jint) 0;
7673     jint _remaining;
7674     GLvoid *pointer = (GLvoid *) 0;
7675 
7676     if (pointer_buf) {
7677         pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
7678         if ( ! pointer ) {
7679             return;
7680         }
7681     }
7682     glWeightPointerOESBounds(
7683         (GLint)size,
7684         (GLenum)type,
7685         (GLsizei)stride,
7686         (GLvoid *)pointer,
7687         (GLsizei)remaining
7688     );
7689     if (_exception) {
7690         jniThrowException(_env, _exceptionType, _exceptionMessage);
7691     }
7692 }
7693 
7694 /* void glWeightPointerOES ( GLint size, GLenum type, GLsizei stride, GLint offset ) */
7695 static void
android_glWeightPointerOES__IIII(JNIEnv * _env,jobject _this,jint size,jint type,jint stride,jint offset)7696 android_glWeightPointerOES__IIII
7697   (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jint offset) {
7698     glWeightPointerOES(
7699         (GLint)size,
7700         (GLenum)type,
7701         (GLsizei)stride,
7702         reinterpret_cast<GLvoid *>(offset)
7703     );
7704 }
7705 
7706 /* void glBindFramebufferOES ( GLint target, GLint framebuffer ) */
7707 static void
android_glBindFramebufferOES__II(JNIEnv * _env,jobject _this,jint target,jint framebuffer)7708 android_glBindFramebufferOES__II
7709   (JNIEnv *_env, jobject _this, jint target, jint framebuffer) {
7710     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
7711         jniThrowException(_env, "java/lang/UnsupportedOperationException",
7712             "glBindFramebufferOES");
7713             return;
7714     }
7715     glBindFramebufferOES(
7716         (GLint)target,
7717         (GLint)framebuffer
7718     );
7719 }
7720 
7721 /* void glBindRenderbufferOES ( GLint target, GLint renderbuffer ) */
7722 static void
android_glBindRenderbufferOES__II(JNIEnv * _env,jobject _this,jint target,jint renderbuffer)7723 android_glBindRenderbufferOES__II
7724   (JNIEnv *_env, jobject _this, jint target, jint renderbuffer) {
7725     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
7726         jniThrowException(_env, "java/lang/UnsupportedOperationException",
7727             "glBindRenderbufferOES");
7728             return;
7729     }
7730     glBindRenderbufferOES(
7731         (GLint)target,
7732         (GLint)renderbuffer
7733     );
7734 }
7735 
7736 /* void glBlendEquation ( GLint mode ) */
7737 static void
android_glBlendEquation__I(JNIEnv * _env,jobject _this,jint mode)7738 android_glBlendEquation__I
7739   (JNIEnv *_env, jobject _this, jint mode) {
7740     if (! supportsExtension(_env, _this, have_OES_blend_subtractID)) {
7741         jniThrowException(_env, "java/lang/UnsupportedOperationException",
7742             "glBlendEquation");
7743             return;
7744     }
7745     glBlendEquation(
7746         (GLint)mode
7747     );
7748 }
7749 
7750 /* void glBlendEquationSeparate ( GLint modeRGB, GLint modeAlpha ) */
7751 static void
android_glBlendEquationSeparate__II(JNIEnv * _env,jobject _this,jint modeRGB,jint modeAlpha)7752 android_glBlendEquationSeparate__II
7753   (JNIEnv *_env, jobject _this, jint modeRGB, jint modeAlpha) {
7754     if (! supportsExtension(_env, _this, have_OES_blend_equation_separateID)) {
7755         jniThrowException(_env, "java/lang/UnsupportedOperationException",
7756             "glBlendEquationSeparate");
7757             return;
7758     }
7759     glBlendEquationSeparate(
7760         (GLint)modeRGB,
7761         (GLint)modeAlpha
7762     );
7763 }
7764 
7765 /* void glBlendFuncSeparate ( GLint srcRGB, GLint dstRGB, GLint srcAlpha, GLint dstAlpha ) */
7766 static void
android_glBlendFuncSeparate__IIII(JNIEnv * _env,jobject _this,jint srcRGB,jint dstRGB,jint srcAlpha,jint dstAlpha)7767 android_glBlendFuncSeparate__IIII
7768   (JNIEnv *_env, jobject _this, jint srcRGB, jint dstRGB, jint srcAlpha, jint dstAlpha) {
7769     if (! supportsExtension(_env, _this, have_OES_blend_equation_separateID)) {
7770         jniThrowException(_env, "java/lang/UnsupportedOperationException",
7771             "glBlendFuncSeparate");
7772             return;
7773     }
7774     glBlendFuncSeparate(
7775         (GLint)srcRGB,
7776         (GLint)dstRGB,
7777         (GLint)srcAlpha,
7778         (GLint)dstAlpha
7779     );
7780 }
7781 
7782 /* GLint glCheckFramebufferStatusOES ( GLint target ) */
7783 static jint
android_glCheckFramebufferStatusOES__I(JNIEnv * _env,jobject _this,jint target)7784 android_glCheckFramebufferStatusOES__I
7785   (JNIEnv *_env, jobject _this, jint target) {
7786     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
7787         jniThrowException(_env, "java/lang/UnsupportedOperationException",
7788             "glCheckFramebufferStatusOES");
7789     return 0;
7790     }
7791     GLint _returnValue = 0;
7792     _returnValue = glCheckFramebufferStatusOES(
7793         (GLint)target
7794     );
7795     return (jint)_returnValue;
7796 }
7797 
7798 /* void glDeleteFramebuffersOES ( GLint n, GLuint *framebuffers ) */
7799 static void
android_glDeleteFramebuffersOES__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray framebuffers_ref,jint offset)7800 android_glDeleteFramebuffersOES__I_3II
7801   (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) {
7802     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
7803         jniThrowException(_env, "java/lang/UnsupportedOperationException",
7804             "glDeleteFramebuffersOES");
7805             return;
7806     }
7807     jint _exception = 0;
7808     const char * _exceptionType = NULL;
7809     const char * _exceptionMessage = NULL;
7810     GLuint *framebuffers_base = (GLuint *) 0;
7811     jint _remaining;
7812     GLuint *framebuffers = (GLuint *) 0;
7813 
7814     if (!framebuffers_ref) {
7815         _exception = 1;
7816         _exceptionType = "java/lang/IllegalArgumentException";
7817         _exceptionMessage = "framebuffers == null";
7818         goto exit;
7819     }
7820     if (offset < 0) {
7821         _exception = 1;
7822         _exceptionType = "java/lang/IllegalArgumentException";
7823         _exceptionMessage = "offset < 0";
7824         goto exit;
7825     }
7826     _remaining = _env->GetArrayLength(framebuffers_ref) - offset;
7827     if (_remaining < n) {
7828         _exception = 1;
7829         _exceptionType = "java/lang/IllegalArgumentException";
7830         _exceptionMessage = "length - offset < n < needed";
7831         goto exit;
7832     }
7833     framebuffers_base = (GLuint *)
7834         _env->GetIntArrayElements(framebuffers_ref, (jboolean *)0);
7835     framebuffers = framebuffers_base + offset;
7836 
7837     glDeleteFramebuffersOES(
7838         (GLint)n,
7839         (GLuint *)framebuffers
7840     );
7841 
7842 exit:
7843     if (framebuffers_base) {
7844         _env->ReleaseIntArrayElements(framebuffers_ref, (jint*)framebuffers_base,
7845             _exception ? JNI_ABORT: 0);
7846     }
7847     if (_exception) {
7848         jniThrowException(_env, _exceptionType, _exceptionMessage);
7849     }
7850 }
7851 
7852 /* void glDeleteFramebuffersOES ( GLint n, GLuint *framebuffers ) */
7853 static void
android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject framebuffers_buf)7854 android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2
7855   (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) {
7856     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
7857         jniThrowException(_env, "java/lang/UnsupportedOperationException",
7858             "glDeleteFramebuffersOES");
7859             return;
7860     }
7861     jint _exception = 0;
7862     const char * _exceptionType = NULL;
7863     const char * _exceptionMessage = NULL;
7864     jintArray _array = (jintArray) 0;
7865     jint _bufferOffset = (jint) 0;
7866     jint _remaining;
7867     GLuint *framebuffers = (GLuint *) 0;
7868 
7869     if (!framebuffers_buf) {
7870         _exception = 1;
7871         _exceptionType = "java/lang/IllegalArgumentException";
7872         _exceptionMessage = "framebuffers == null";
7873         goto exit;
7874     }
7875     framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
7876     if (_remaining < n) {
7877         _exception = 1;
7878         _exceptionType = "java/lang/IllegalArgumentException";
7879         _exceptionMessage = "remaining() < n < needed";
7880         goto exit;
7881     }
7882     if (framebuffers == NULL) {
7883         char * _framebuffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
7884         framebuffers = (GLuint *) (_framebuffersBase + _bufferOffset);
7885     }
7886     glDeleteFramebuffersOES(
7887         (GLint)n,
7888         (GLuint *)framebuffers
7889     );
7890 
7891 exit:
7892     if (_array) {
7893         _env->ReleaseIntArrayElements(_array, (jint*)framebuffers, _exception ? JNI_ABORT : 0);
7894     }
7895     if (_exception) {
7896         jniThrowException(_env, _exceptionType, _exceptionMessage);
7897     }
7898 }
7899 
7900 /* void glDeleteRenderbuffersOES ( GLint n, GLuint *renderbuffers ) */
7901 static void
android_glDeleteRenderbuffersOES__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray renderbuffers_ref,jint offset)7902 android_glDeleteRenderbuffersOES__I_3II
7903   (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) {
7904     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
7905         jniThrowException(_env, "java/lang/UnsupportedOperationException",
7906             "glDeleteRenderbuffersOES");
7907             return;
7908     }
7909     jint _exception = 0;
7910     const char * _exceptionType = NULL;
7911     const char * _exceptionMessage = NULL;
7912     GLuint *renderbuffers_base = (GLuint *) 0;
7913     jint _remaining;
7914     GLuint *renderbuffers = (GLuint *) 0;
7915 
7916     if (!renderbuffers_ref) {
7917         _exception = 1;
7918         _exceptionType = "java/lang/IllegalArgumentException";
7919         _exceptionMessage = "renderbuffers == null";
7920         goto exit;
7921     }
7922     if (offset < 0) {
7923         _exception = 1;
7924         _exceptionType = "java/lang/IllegalArgumentException";
7925         _exceptionMessage = "offset < 0";
7926         goto exit;
7927     }
7928     _remaining = _env->GetArrayLength(renderbuffers_ref) - offset;
7929     if (_remaining < n) {
7930         _exception = 1;
7931         _exceptionType = "java/lang/IllegalArgumentException";
7932         _exceptionMessage = "length - offset < n < needed";
7933         goto exit;
7934     }
7935     renderbuffers_base = (GLuint *)
7936         _env->GetIntArrayElements(renderbuffers_ref, (jboolean *)0);
7937     renderbuffers = renderbuffers_base + offset;
7938 
7939     glDeleteRenderbuffersOES(
7940         (GLint)n,
7941         (GLuint *)renderbuffers
7942     );
7943 
7944 exit:
7945     if (renderbuffers_base) {
7946         _env->ReleaseIntArrayElements(renderbuffers_ref, (jint*)renderbuffers_base,
7947             _exception ? JNI_ABORT: 0);
7948     }
7949     if (_exception) {
7950         jniThrowException(_env, _exceptionType, _exceptionMessage);
7951     }
7952 }
7953 
7954 /* void glDeleteRenderbuffersOES ( GLint n, GLuint *renderbuffers ) */
7955 static void
android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject renderbuffers_buf)7956 android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2
7957   (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) {
7958     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
7959         jniThrowException(_env, "java/lang/UnsupportedOperationException",
7960             "glDeleteRenderbuffersOES");
7961             return;
7962     }
7963     jint _exception = 0;
7964     const char * _exceptionType = NULL;
7965     const char * _exceptionMessage = NULL;
7966     jintArray _array = (jintArray) 0;
7967     jint _bufferOffset = (jint) 0;
7968     jint _remaining;
7969     GLuint *renderbuffers = (GLuint *) 0;
7970 
7971     if (!renderbuffers_buf) {
7972         _exception = 1;
7973         _exceptionType = "java/lang/IllegalArgumentException";
7974         _exceptionMessage = "renderbuffers == null";
7975         goto exit;
7976     }
7977     renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
7978     if (_remaining < n) {
7979         _exception = 1;
7980         _exceptionType = "java/lang/IllegalArgumentException";
7981         _exceptionMessage = "remaining() < n < needed";
7982         goto exit;
7983     }
7984     if (renderbuffers == NULL) {
7985         char * _renderbuffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
7986         renderbuffers = (GLuint *) (_renderbuffersBase + _bufferOffset);
7987     }
7988     glDeleteRenderbuffersOES(
7989         (GLint)n,
7990         (GLuint *)renderbuffers
7991     );
7992 
7993 exit:
7994     if (_array) {
7995         _env->ReleaseIntArrayElements(_array, (jint*)renderbuffers, _exception ? JNI_ABORT : 0);
7996     }
7997     if (_exception) {
7998         jniThrowException(_env, _exceptionType, _exceptionMessage);
7999     }
8000 }
8001 
8002 /* void glFramebufferRenderbufferOES ( GLint target, GLint attachment, GLint renderbuffertarget, GLint renderbuffer ) */
8003 static void
android_glFramebufferRenderbufferOES__IIII(JNIEnv * _env,jobject _this,jint target,jint attachment,jint renderbuffertarget,jint renderbuffer)8004 android_glFramebufferRenderbufferOES__IIII
8005   (JNIEnv *_env, jobject _this, jint target, jint attachment, jint renderbuffertarget, jint renderbuffer) {
8006     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
8007         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8008             "glFramebufferRenderbufferOES");
8009             return;
8010     }
8011     glFramebufferRenderbufferOES(
8012         (GLint)target,
8013         (GLint)attachment,
8014         (GLint)renderbuffertarget,
8015         (GLint)renderbuffer
8016     );
8017 }
8018 
8019 /* void glFramebufferTexture2DOES ( GLint target, GLint attachment, GLint textarget, GLint texture, GLint level ) */
8020 static void
android_glFramebufferTexture2DOES__IIIII(JNIEnv * _env,jobject _this,jint target,jint attachment,jint textarget,jint texture,jint level)8021 android_glFramebufferTexture2DOES__IIIII
8022   (JNIEnv *_env, jobject _this, jint target, jint attachment, jint textarget, jint texture, jint level) {
8023     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
8024         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8025             "glFramebufferTexture2DOES");
8026             return;
8027     }
8028     glFramebufferTexture2DOES(
8029         (GLint)target,
8030         (GLint)attachment,
8031         (GLint)textarget,
8032         (GLint)texture,
8033         (GLint)level
8034     );
8035 }
8036 
8037 /* void glGenerateMipmapOES ( GLint target ) */
8038 static void
android_glGenerateMipmapOES__I(JNIEnv * _env,jobject _this,jint target)8039 android_glGenerateMipmapOES__I
8040   (JNIEnv *_env, jobject _this, jint target) {
8041     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
8042         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8043             "glGenerateMipmapOES");
8044             return;
8045     }
8046     glGenerateMipmapOES(
8047         (GLint)target
8048     );
8049 }
8050 
8051 /* void glGenFramebuffersOES ( GLint n, GLuint *framebuffers ) */
8052 static void
android_glGenFramebuffersOES__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray framebuffers_ref,jint offset)8053 android_glGenFramebuffersOES__I_3II
8054   (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) {
8055     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
8056         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8057             "glGenFramebuffersOES");
8058             return;
8059     }
8060     jint _exception = 0;
8061     const char * _exceptionType = NULL;
8062     const char * _exceptionMessage = NULL;
8063     GLuint *framebuffers_base = (GLuint *) 0;
8064     jint _remaining;
8065     GLuint *framebuffers = (GLuint *) 0;
8066 
8067     if (!framebuffers_ref) {
8068         _exception = 1;
8069         _exceptionType = "java/lang/IllegalArgumentException";
8070         _exceptionMessage = "framebuffers == null";
8071         goto exit;
8072     }
8073     if (offset < 0) {
8074         _exception = 1;
8075         _exceptionType = "java/lang/IllegalArgumentException";
8076         _exceptionMessage = "offset < 0";
8077         goto exit;
8078     }
8079     _remaining = _env->GetArrayLength(framebuffers_ref) - offset;
8080     if (_remaining < n) {
8081         _exception = 1;
8082         _exceptionType = "java/lang/IllegalArgumentException";
8083         _exceptionMessage = "length - offset < n < needed";
8084         goto exit;
8085     }
8086     framebuffers_base = (GLuint *)
8087         _env->GetIntArrayElements(framebuffers_ref, (jboolean *)0);
8088     framebuffers = framebuffers_base + offset;
8089 
8090     glGenFramebuffersOES(
8091         (GLint)n,
8092         (GLuint *)framebuffers
8093     );
8094 
8095 exit:
8096     if (framebuffers_base) {
8097         _env->ReleaseIntArrayElements(framebuffers_ref, (jint*)framebuffers_base,
8098             _exception ? JNI_ABORT: 0);
8099     }
8100     if (_exception) {
8101         jniThrowException(_env, _exceptionType, _exceptionMessage);
8102     }
8103 }
8104 
8105 /* void glGenFramebuffersOES ( GLint n, GLuint *framebuffers ) */
8106 static void
android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject framebuffers_buf)8107 android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2
8108   (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) {
8109     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
8110         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8111             "glGenFramebuffersOES");
8112             return;
8113     }
8114     jint _exception = 0;
8115     const char * _exceptionType = NULL;
8116     const char * _exceptionMessage = NULL;
8117     jintArray _array = (jintArray) 0;
8118     jint _bufferOffset = (jint) 0;
8119     jint _remaining;
8120     GLuint *framebuffers = (GLuint *) 0;
8121 
8122     if (!framebuffers_buf) {
8123         _exception = 1;
8124         _exceptionType = "java/lang/IllegalArgumentException";
8125         _exceptionMessage = "framebuffers == null";
8126         goto exit;
8127     }
8128     framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
8129     if (_remaining < n) {
8130         _exception = 1;
8131         _exceptionType = "java/lang/IllegalArgumentException";
8132         _exceptionMessage = "remaining() < n < needed";
8133         goto exit;
8134     }
8135     if (framebuffers == NULL) {
8136         char * _framebuffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
8137         framebuffers = (GLuint *) (_framebuffersBase + _bufferOffset);
8138     }
8139     glGenFramebuffersOES(
8140         (GLint)n,
8141         (GLuint *)framebuffers
8142     );
8143 
8144 exit:
8145     if (_array) {
8146         _env->ReleaseIntArrayElements(_array, (jint*)framebuffers, _exception ? JNI_ABORT : 0);
8147     }
8148     if (_exception) {
8149         jniThrowException(_env, _exceptionType, _exceptionMessage);
8150     }
8151 }
8152 
8153 /* void glGenRenderbuffersOES ( GLint n, GLuint *renderbuffers ) */
8154 static void
android_glGenRenderbuffersOES__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray renderbuffers_ref,jint offset)8155 android_glGenRenderbuffersOES__I_3II
8156   (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) {
8157     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
8158         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8159             "glGenRenderbuffersOES");
8160             return;
8161     }
8162     jint _exception = 0;
8163     const char * _exceptionType = NULL;
8164     const char * _exceptionMessage = NULL;
8165     GLuint *renderbuffers_base = (GLuint *) 0;
8166     jint _remaining;
8167     GLuint *renderbuffers = (GLuint *) 0;
8168 
8169     if (!renderbuffers_ref) {
8170         _exception = 1;
8171         _exceptionType = "java/lang/IllegalArgumentException";
8172         _exceptionMessage = "renderbuffers == null";
8173         goto exit;
8174     }
8175     if (offset < 0) {
8176         _exception = 1;
8177         _exceptionType = "java/lang/IllegalArgumentException";
8178         _exceptionMessage = "offset < 0";
8179         goto exit;
8180     }
8181     _remaining = _env->GetArrayLength(renderbuffers_ref) - offset;
8182     if (_remaining < n) {
8183         _exception = 1;
8184         _exceptionType = "java/lang/IllegalArgumentException";
8185         _exceptionMessage = "length - offset < n < needed";
8186         goto exit;
8187     }
8188     renderbuffers_base = (GLuint *)
8189         _env->GetIntArrayElements(renderbuffers_ref, (jboolean *)0);
8190     renderbuffers = renderbuffers_base + offset;
8191 
8192     glGenRenderbuffersOES(
8193         (GLint)n,
8194         (GLuint *)renderbuffers
8195     );
8196 
8197 exit:
8198     if (renderbuffers_base) {
8199         _env->ReleaseIntArrayElements(renderbuffers_ref, (jint*)renderbuffers_base,
8200             _exception ? JNI_ABORT: 0);
8201     }
8202     if (_exception) {
8203         jniThrowException(_env, _exceptionType, _exceptionMessage);
8204     }
8205 }
8206 
8207 /* void glGenRenderbuffersOES ( GLint n, GLuint *renderbuffers ) */
8208 static void
android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject renderbuffers_buf)8209 android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2
8210   (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) {
8211     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
8212         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8213             "glGenRenderbuffersOES");
8214             return;
8215     }
8216     jint _exception = 0;
8217     const char * _exceptionType = NULL;
8218     const char * _exceptionMessage = NULL;
8219     jintArray _array = (jintArray) 0;
8220     jint _bufferOffset = (jint) 0;
8221     jint _remaining;
8222     GLuint *renderbuffers = (GLuint *) 0;
8223 
8224     if (!renderbuffers_buf) {
8225         _exception = 1;
8226         _exceptionType = "java/lang/IllegalArgumentException";
8227         _exceptionMessage = "renderbuffers == null";
8228         goto exit;
8229     }
8230     renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
8231     if (_remaining < n) {
8232         _exception = 1;
8233         _exceptionType = "java/lang/IllegalArgumentException";
8234         _exceptionMessage = "remaining() < n < needed";
8235         goto exit;
8236     }
8237     if (renderbuffers == NULL) {
8238         char * _renderbuffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
8239         renderbuffers = (GLuint *) (_renderbuffersBase + _bufferOffset);
8240     }
8241     glGenRenderbuffersOES(
8242         (GLint)n,
8243         (GLuint *)renderbuffers
8244     );
8245 
8246 exit:
8247     if (_array) {
8248         _env->ReleaseIntArrayElements(_array, (jint*)renderbuffers, _exception ? JNI_ABORT : 0);
8249     }
8250     if (_exception) {
8251         jniThrowException(_env, _exceptionType, _exceptionMessage);
8252     }
8253 }
8254 
8255 /* void glGetFramebufferAttachmentParameterivOES ( GLint target, GLint attachment, GLint pname, GLint *params ) */
8256 static void
android_glGetFramebufferAttachmentParameterivOES__III_3II(JNIEnv * _env,jobject _this,jint target,jint attachment,jint pname,jintArray params_ref,jint offset)8257 android_glGetFramebufferAttachmentParameterivOES__III_3II
8258   (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jintArray params_ref, jint offset) {
8259     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
8260         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8261             "glGetFramebufferAttachmentParameterivOES");
8262             return;
8263     }
8264     jint _exception = 0;
8265     const char * _exceptionType = NULL;
8266     const char * _exceptionMessage = NULL;
8267     GLint *params_base = (GLint *) 0;
8268     jint _remaining;
8269     GLint *params = (GLint *) 0;
8270 
8271     if (!params_ref) {
8272         _exception = 1;
8273         _exceptionType = "java/lang/IllegalArgumentException";
8274         _exceptionMessage = "params == null";
8275         goto exit;
8276     }
8277     if (offset < 0) {
8278         _exception = 1;
8279         _exceptionType = "java/lang/IllegalArgumentException";
8280         _exceptionMessage = "offset < 0";
8281         goto exit;
8282     }
8283     _remaining = _env->GetArrayLength(params_ref) - offset;
8284     params_base = (GLint *)
8285         _env->GetIntArrayElements(params_ref, (jboolean *)0);
8286     params = params_base + offset;
8287 
8288     glGetFramebufferAttachmentParameterivOES(
8289         (GLint)target,
8290         (GLint)attachment,
8291         (GLint)pname,
8292         (GLint *)params
8293     );
8294 
8295 exit:
8296     if (params_base) {
8297         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
8298             _exception ? JNI_ABORT: 0);
8299     }
8300     if (_exception) {
8301         jniThrowException(_env, _exceptionType, _exceptionMessage);
8302     }
8303 }
8304 
8305 /* void glGetFramebufferAttachmentParameterivOES ( GLint target, GLint attachment, GLint pname, GLint *params ) */
8306 static void
android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint attachment,jint pname,jobject params_buf)8307 android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2
8308   (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jobject params_buf) {
8309     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
8310         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8311             "glGetFramebufferAttachmentParameterivOES");
8312             return;
8313     }
8314     jint _exception = 0;
8315     const char * _exceptionType = NULL;
8316     const char * _exceptionMessage = NULL;
8317     jintArray _array = (jintArray) 0;
8318     jint _bufferOffset = (jint) 0;
8319     jint _remaining;
8320     GLint *params = (GLint *) 0;
8321 
8322     if (!params_buf) {
8323         _exception = 1;
8324         _exceptionType = "java/lang/IllegalArgumentException";
8325         _exceptionMessage = "params == null";
8326         goto exit;
8327     }
8328     params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
8329     if (params == NULL) {
8330         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
8331         params = (GLint *) (_paramsBase + _bufferOffset);
8332     }
8333     glGetFramebufferAttachmentParameterivOES(
8334         (GLint)target,
8335         (GLint)attachment,
8336         (GLint)pname,
8337         (GLint *)params
8338     );
8339 
8340 exit:
8341     if (_array) {
8342         _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
8343     }
8344     if (_exception) {
8345         jniThrowException(_env, _exceptionType, _exceptionMessage);
8346     }
8347 }
8348 
8349 /* void glGetRenderbufferParameterivOES ( GLint target, GLint pname, GLint *params ) */
8350 static void
android_glGetRenderbufferParameterivOES__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)8351 android_glGetRenderbufferParameterivOES__II_3II
8352   (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
8353     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
8354         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8355             "glGetRenderbufferParameterivOES");
8356             return;
8357     }
8358     jint _exception = 0;
8359     const char * _exceptionType = NULL;
8360     const char * _exceptionMessage = NULL;
8361     GLint *params_base = (GLint *) 0;
8362     jint _remaining;
8363     GLint *params = (GLint *) 0;
8364 
8365     if (!params_ref) {
8366         _exception = 1;
8367         _exceptionType = "java/lang/IllegalArgumentException";
8368         _exceptionMessage = "params == null";
8369         goto exit;
8370     }
8371     if (offset < 0) {
8372         _exception = 1;
8373         _exceptionType = "java/lang/IllegalArgumentException";
8374         _exceptionMessage = "offset < 0";
8375         goto exit;
8376     }
8377     _remaining = _env->GetArrayLength(params_ref) - offset;
8378     params_base = (GLint *)
8379         _env->GetIntArrayElements(params_ref, (jboolean *)0);
8380     params = params_base + offset;
8381 
8382     glGetRenderbufferParameterivOES(
8383         (GLint)target,
8384         (GLint)pname,
8385         (GLint *)params
8386     );
8387 
8388 exit:
8389     if (params_base) {
8390         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
8391             _exception ? JNI_ABORT: 0);
8392     }
8393     if (_exception) {
8394         jniThrowException(_env, _exceptionType, _exceptionMessage);
8395     }
8396 }
8397 
8398 /* void glGetRenderbufferParameterivOES ( GLint target, GLint pname, GLint *params ) */
8399 static void
android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)8400 android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2
8401   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
8402     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
8403         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8404             "glGetRenderbufferParameterivOES");
8405             return;
8406     }
8407     jint _exception = 0;
8408     const char * _exceptionType = NULL;
8409     const char * _exceptionMessage = NULL;
8410     jintArray _array = (jintArray) 0;
8411     jint _bufferOffset = (jint) 0;
8412     jint _remaining;
8413     GLint *params = (GLint *) 0;
8414 
8415     if (!params_buf) {
8416         _exception = 1;
8417         _exceptionType = "java/lang/IllegalArgumentException";
8418         _exceptionMessage = "params == null";
8419         goto exit;
8420     }
8421     params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
8422     if (params == NULL) {
8423         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
8424         params = (GLint *) (_paramsBase + _bufferOffset);
8425     }
8426     glGetRenderbufferParameterivOES(
8427         (GLint)target,
8428         (GLint)pname,
8429         (GLint *)params
8430     );
8431 
8432 exit:
8433     if (_array) {
8434         _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
8435     }
8436     if (_exception) {
8437         jniThrowException(_env, _exceptionType, _exceptionMessage);
8438     }
8439 }
8440 
8441 /* void glGetTexGenfv ( GLint coord, GLint pname, GLfloat *params ) */
8442 static void
android_glGetTexGenfv__II_3FI(JNIEnv * _env,jobject _this,jint coord,jint pname,jfloatArray params_ref,jint offset)8443 android_glGetTexGenfv__II_3FI
8444   (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) {
8445     if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) {
8446         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8447             "glGetTexGenfv");
8448             return;
8449     }
8450     jint _exception = 0;
8451     const char * _exceptionType = NULL;
8452     const char * _exceptionMessage = NULL;
8453     GLfloat *params_base = (GLfloat *) 0;
8454     jint _remaining;
8455     GLfloat *params = (GLfloat *) 0;
8456 
8457     if (!params_ref) {
8458         _exception = 1;
8459         _exceptionType = "java/lang/IllegalArgumentException";
8460         _exceptionMessage = "params == null";
8461         goto exit;
8462     }
8463     if (offset < 0) {
8464         _exception = 1;
8465         _exceptionType = "java/lang/IllegalArgumentException";
8466         _exceptionMessage = "offset < 0";
8467         goto exit;
8468     }
8469     _remaining = _env->GetArrayLength(params_ref) - offset;
8470     params_base = (GLfloat *)
8471         _env->GetFloatArrayElements(params_ref, (jboolean *)0);
8472     params = params_base + offset;
8473 
8474     glGetTexGenfv(
8475         (GLint)coord,
8476         (GLint)pname,
8477         (GLfloat *)params
8478     );
8479 
8480 exit:
8481     if (params_base) {
8482         _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
8483             _exception ? JNI_ABORT: 0);
8484     }
8485     if (_exception) {
8486         jniThrowException(_env, _exceptionType, _exceptionMessage);
8487     }
8488 }
8489 
8490 /* void glGetTexGenfv ( GLint coord, GLint pname, GLfloat *params ) */
8491 static void
android_glGetTexGenfv__IILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)8492 android_glGetTexGenfv__IILjava_nio_FloatBuffer_2
8493   (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
8494     if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) {
8495         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8496             "glGetTexGenfv");
8497             return;
8498     }
8499     jint _exception = 0;
8500     const char * _exceptionType = NULL;
8501     const char * _exceptionMessage = NULL;
8502     jfloatArray _array = (jfloatArray) 0;
8503     jint _bufferOffset = (jint) 0;
8504     jint _remaining;
8505     GLfloat *params = (GLfloat *) 0;
8506 
8507     if (!params_buf) {
8508         _exception = 1;
8509         _exceptionType = "java/lang/IllegalArgumentException";
8510         _exceptionMessage = "params == null";
8511         goto exit;
8512     }
8513     params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
8514     if (params == NULL) {
8515         char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
8516         params = (GLfloat *) (_paramsBase + _bufferOffset);
8517     }
8518     glGetTexGenfv(
8519         (GLint)coord,
8520         (GLint)pname,
8521         (GLfloat *)params
8522     );
8523 
8524 exit:
8525     if (_array) {
8526         _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0);
8527     }
8528     if (_exception) {
8529         jniThrowException(_env, _exceptionType, _exceptionMessage);
8530     }
8531 }
8532 
8533 /* void glGetTexGeniv ( GLint coord, GLint pname, GLint *params ) */
8534 static void
android_glGetTexGeniv__II_3II(JNIEnv * _env,jobject _this,jint coord,jint pname,jintArray params_ref,jint offset)8535 android_glGetTexGeniv__II_3II
8536   (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
8537     if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) {
8538         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8539             "glGetTexGeniv");
8540             return;
8541     }
8542     jint _exception = 0;
8543     const char * _exceptionType = NULL;
8544     const char * _exceptionMessage = NULL;
8545     GLint *params_base = (GLint *) 0;
8546     jint _remaining;
8547     GLint *params = (GLint *) 0;
8548 
8549     if (!params_ref) {
8550         _exception = 1;
8551         _exceptionType = "java/lang/IllegalArgumentException";
8552         _exceptionMessage = "params == null";
8553         goto exit;
8554     }
8555     if (offset < 0) {
8556         _exception = 1;
8557         _exceptionType = "java/lang/IllegalArgumentException";
8558         _exceptionMessage = "offset < 0";
8559         goto exit;
8560     }
8561     _remaining = _env->GetArrayLength(params_ref) - offset;
8562     params_base = (GLint *)
8563         _env->GetIntArrayElements(params_ref, (jboolean *)0);
8564     params = params_base + offset;
8565 
8566     glGetTexGeniv(
8567         (GLint)coord,
8568         (GLint)pname,
8569         (GLint *)params
8570     );
8571 
8572 exit:
8573     if (params_base) {
8574         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
8575             _exception ? JNI_ABORT: 0);
8576     }
8577     if (_exception) {
8578         jniThrowException(_env, _exceptionType, _exceptionMessage);
8579     }
8580 }
8581 
8582 /* void glGetTexGeniv ( GLint coord, GLint pname, GLint *params ) */
8583 static void
android_glGetTexGeniv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)8584 android_glGetTexGeniv__IILjava_nio_IntBuffer_2
8585   (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
8586     if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) {
8587         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8588             "glGetTexGeniv");
8589             return;
8590     }
8591     jint _exception = 0;
8592     const char * _exceptionType = NULL;
8593     const char * _exceptionMessage = NULL;
8594     jintArray _array = (jintArray) 0;
8595     jint _bufferOffset = (jint) 0;
8596     jint _remaining;
8597     GLint *params = (GLint *) 0;
8598 
8599     if (!params_buf) {
8600         _exception = 1;
8601         _exceptionType = "java/lang/IllegalArgumentException";
8602         _exceptionMessage = "params == null";
8603         goto exit;
8604     }
8605     params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
8606     if (params == NULL) {
8607         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
8608         params = (GLint *) (_paramsBase + _bufferOffset);
8609     }
8610     glGetTexGeniv(
8611         (GLint)coord,
8612         (GLint)pname,
8613         (GLint *)params
8614     );
8615 
8616 exit:
8617     if (_array) {
8618         _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
8619     }
8620     if (_exception) {
8621         jniThrowException(_env, _exceptionType, _exceptionMessage);
8622     }
8623 }
8624 
8625 /* void glGetTexGenxv ( GLint coord, GLint pname, GLint *params ) */
8626 static void
android_glGetTexGenxv__II_3II(JNIEnv * _env,jobject _this,jint coord,jint pname,jintArray params_ref,jint offset)8627 android_glGetTexGenxv__II_3II
8628   (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
8629     if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) {
8630         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8631             "glGetTexGenxv");
8632             return;
8633     }
8634     jint _exception = 0;
8635     const char * _exceptionType = NULL;
8636     const char * _exceptionMessage = NULL;
8637     GLint *params_base = (GLint *) 0;
8638     jint _remaining;
8639     GLint *params = (GLint *) 0;
8640 
8641     if (!params_ref) {
8642         _exception = 1;
8643         _exceptionType = "java/lang/IllegalArgumentException";
8644         _exceptionMessage = "params == null";
8645         goto exit;
8646     }
8647     if (offset < 0) {
8648         _exception = 1;
8649         _exceptionType = "java/lang/IllegalArgumentException";
8650         _exceptionMessage = "offset < 0";
8651         goto exit;
8652     }
8653     _remaining = _env->GetArrayLength(params_ref) - offset;
8654     params_base = (GLint *)
8655         _env->GetIntArrayElements(params_ref, (jboolean *)0);
8656     params = params_base + offset;
8657 
8658     glGetTexGenxv(
8659         (GLint)coord,
8660         (GLint)pname,
8661         (GLint *)params
8662     );
8663 
8664 exit:
8665     if (params_base) {
8666         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
8667             _exception ? JNI_ABORT: 0);
8668     }
8669     if (_exception) {
8670         jniThrowException(_env, _exceptionType, _exceptionMessage);
8671     }
8672 }
8673 
8674 /* void glGetTexGenxv ( GLint coord, GLint pname, GLint *params ) */
8675 static void
android_glGetTexGenxv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)8676 android_glGetTexGenxv__IILjava_nio_IntBuffer_2
8677   (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
8678     if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) {
8679         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8680             "glGetTexGenxv");
8681             return;
8682     }
8683     jint _exception = 0;
8684     const char * _exceptionType = NULL;
8685     const char * _exceptionMessage = NULL;
8686     jintArray _array = (jintArray) 0;
8687     jint _bufferOffset = (jint) 0;
8688     jint _remaining;
8689     GLint *params = (GLint *) 0;
8690 
8691     if (!params_buf) {
8692         _exception = 1;
8693         _exceptionType = "java/lang/IllegalArgumentException";
8694         _exceptionMessage = "params == null";
8695         goto exit;
8696     }
8697     params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
8698     if (params == NULL) {
8699         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
8700         params = (GLint *) (_paramsBase + _bufferOffset);
8701     }
8702     glGetTexGenxv(
8703         (GLint)coord,
8704         (GLint)pname,
8705         (GLint *)params
8706     );
8707 
8708 exit:
8709     if (_array) {
8710         _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
8711     }
8712     if (_exception) {
8713         jniThrowException(_env, _exceptionType, _exceptionMessage);
8714     }
8715 }
8716 
8717 /* GLboolean glIsFramebufferOES ( GLint framebuffer ) */
8718 static jboolean
android_glIsFramebufferOES__I(JNIEnv * _env,jobject _this,jint framebuffer)8719 android_glIsFramebufferOES__I
8720   (JNIEnv *_env, jobject _this, jint framebuffer) {
8721     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
8722         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8723             "glIsFramebufferOES");
8724     return JNI_FALSE;
8725     }
8726     GLboolean _returnValue = JNI_FALSE;
8727     _returnValue = glIsFramebufferOES(
8728         (GLint)framebuffer
8729     );
8730     return (jboolean)_returnValue;
8731 }
8732 
8733 /* GLboolean glIsRenderbufferOES ( GLint renderbuffer ) */
8734 static jboolean
android_glIsRenderbufferOES__I(JNIEnv * _env,jobject _this,jint renderbuffer)8735 android_glIsRenderbufferOES__I
8736   (JNIEnv *_env, jobject _this, jint renderbuffer) {
8737     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
8738         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8739             "glIsRenderbufferOES");
8740     return JNI_FALSE;
8741     }
8742     GLboolean _returnValue = JNI_FALSE;
8743     _returnValue = glIsRenderbufferOES(
8744         (GLint)renderbuffer
8745     );
8746     return (jboolean)_returnValue;
8747 }
8748 
8749 /* void glRenderbufferStorageOES ( GLint target, GLint internalformat, GLint width, GLint height ) */
8750 static void
android_glRenderbufferStorageOES__IIII(JNIEnv * _env,jobject _this,jint target,jint internalformat,jint width,jint height)8751 android_glRenderbufferStorageOES__IIII
8752   (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint width, jint height) {
8753     if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) {
8754         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8755             "glRenderbufferStorageOES");
8756             return;
8757     }
8758     glRenderbufferStorageOES(
8759         (GLint)target,
8760         (GLint)internalformat,
8761         (GLint)width,
8762         (GLint)height
8763     );
8764 }
8765 
8766 /* void glTexGenf ( GLint coord, GLint pname, GLfloat param ) */
8767 static void
android_glTexGenf__IIF(JNIEnv * _env,jobject _this,jint coord,jint pname,jfloat param)8768 android_glTexGenf__IIF
8769   (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloat param) {
8770     if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) {
8771         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8772             "glTexGenf");
8773             return;
8774     }
8775     glTexGenf(
8776         (GLint)coord,
8777         (GLint)pname,
8778         (GLfloat)param
8779     );
8780 }
8781 
8782 /* void glTexGenfv ( GLint coord, GLint pname, GLfloat *params ) */
8783 static void
android_glTexGenfv__II_3FI(JNIEnv * _env,jobject _this,jint coord,jint pname,jfloatArray params_ref,jint offset)8784 android_glTexGenfv__II_3FI
8785   (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) {
8786     if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) {
8787         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8788             "glTexGenfv");
8789             return;
8790     }
8791     jint _exception = 0;
8792     const char * _exceptionType = NULL;
8793     const char * _exceptionMessage = NULL;
8794     GLfloat *params_base = (GLfloat *) 0;
8795     jint _remaining;
8796     GLfloat *params = (GLfloat *) 0;
8797 
8798     if (!params_ref) {
8799         _exception = 1;
8800         _exceptionType = "java/lang/IllegalArgumentException";
8801         _exceptionMessage = "params == null";
8802         goto exit;
8803     }
8804     if (offset < 0) {
8805         _exception = 1;
8806         _exceptionType = "java/lang/IllegalArgumentException";
8807         _exceptionMessage = "offset < 0";
8808         goto exit;
8809     }
8810     _remaining = _env->GetArrayLength(params_ref) - offset;
8811     params_base = (GLfloat *)
8812         _env->GetFloatArrayElements(params_ref, (jboolean *)0);
8813     params = params_base + offset;
8814 
8815     glTexGenfv(
8816         (GLint)coord,
8817         (GLint)pname,
8818         (GLfloat *)params
8819     );
8820 
8821 exit:
8822     if (params_base) {
8823         _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
8824             _exception ? JNI_ABORT: 0);
8825     }
8826     if (_exception) {
8827         jniThrowException(_env, _exceptionType, _exceptionMessage);
8828     }
8829 }
8830 
8831 /* void glTexGenfv ( GLint coord, GLint pname, GLfloat *params ) */
8832 static void
android_glTexGenfv__IILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)8833 android_glTexGenfv__IILjava_nio_FloatBuffer_2
8834   (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
8835     if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) {
8836         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8837             "glTexGenfv");
8838             return;
8839     }
8840     jint _exception = 0;
8841     const char * _exceptionType = NULL;
8842     const char * _exceptionMessage = NULL;
8843     jfloatArray _array = (jfloatArray) 0;
8844     jint _bufferOffset = (jint) 0;
8845     jint _remaining;
8846     GLfloat *params = (GLfloat *) 0;
8847 
8848     if (!params_buf) {
8849         _exception = 1;
8850         _exceptionType = "java/lang/IllegalArgumentException";
8851         _exceptionMessage = "params == null";
8852         goto exit;
8853     }
8854     params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
8855     if (params == NULL) {
8856         char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
8857         params = (GLfloat *) (_paramsBase + _bufferOffset);
8858     }
8859     glTexGenfv(
8860         (GLint)coord,
8861         (GLint)pname,
8862         (GLfloat *)params
8863     );
8864 
8865 exit:
8866     if (_array) {
8867         _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0);
8868     }
8869     if (_exception) {
8870         jniThrowException(_env, _exceptionType, _exceptionMessage);
8871     }
8872 }
8873 
8874 /* void glTexGeni ( GLint coord, GLint pname, GLint param ) */
8875 static void
android_glTexGeni__III(JNIEnv * _env,jobject _this,jint coord,jint pname,jint param)8876 android_glTexGeni__III
8877   (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) {
8878     if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) {
8879         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8880             "glTexGeni");
8881             return;
8882     }
8883     glTexGeni(
8884         (GLint)coord,
8885         (GLint)pname,
8886         (GLint)param
8887     );
8888 }
8889 
8890 /* void glTexGeniv ( GLint coord, GLint pname, GLint *params ) */
8891 static void
android_glTexGeniv__II_3II(JNIEnv * _env,jobject _this,jint coord,jint pname,jintArray params_ref,jint offset)8892 android_glTexGeniv__II_3II
8893   (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
8894     if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) {
8895         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8896             "glTexGeniv");
8897             return;
8898     }
8899     jint _exception = 0;
8900     const char * _exceptionType = NULL;
8901     const char * _exceptionMessage = NULL;
8902     GLint *params_base = (GLint *) 0;
8903     jint _remaining;
8904     GLint *params = (GLint *) 0;
8905 
8906     if (!params_ref) {
8907         _exception = 1;
8908         _exceptionType = "java/lang/IllegalArgumentException";
8909         _exceptionMessage = "params == null";
8910         goto exit;
8911     }
8912     if (offset < 0) {
8913         _exception = 1;
8914         _exceptionType = "java/lang/IllegalArgumentException";
8915         _exceptionMessage = "offset < 0";
8916         goto exit;
8917     }
8918     _remaining = _env->GetArrayLength(params_ref) - offset;
8919     params_base = (GLint *)
8920         _env->GetIntArrayElements(params_ref, (jboolean *)0);
8921     params = params_base + offset;
8922 
8923     glTexGeniv(
8924         (GLint)coord,
8925         (GLint)pname,
8926         (GLint *)params
8927     );
8928 
8929 exit:
8930     if (params_base) {
8931         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
8932             _exception ? JNI_ABORT: 0);
8933     }
8934     if (_exception) {
8935         jniThrowException(_env, _exceptionType, _exceptionMessage);
8936     }
8937 }
8938 
8939 /* void glTexGeniv ( GLint coord, GLint pname, GLint *params ) */
8940 static void
android_glTexGeniv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)8941 android_glTexGeniv__IILjava_nio_IntBuffer_2
8942   (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
8943     if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) {
8944         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8945             "glTexGeniv");
8946             return;
8947     }
8948     jint _exception = 0;
8949     const char * _exceptionType = NULL;
8950     const char * _exceptionMessage = NULL;
8951     jintArray _array = (jintArray) 0;
8952     jint _bufferOffset = (jint) 0;
8953     jint _remaining;
8954     GLint *params = (GLint *) 0;
8955 
8956     if (!params_buf) {
8957         _exception = 1;
8958         _exceptionType = "java/lang/IllegalArgumentException";
8959         _exceptionMessage = "params == null";
8960         goto exit;
8961     }
8962     params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
8963     if (params == NULL) {
8964         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
8965         params = (GLint *) (_paramsBase + _bufferOffset);
8966     }
8967     glTexGeniv(
8968         (GLint)coord,
8969         (GLint)pname,
8970         (GLint *)params
8971     );
8972 
8973 exit:
8974     if (_array) {
8975         _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
8976     }
8977     if (_exception) {
8978         jniThrowException(_env, _exceptionType, _exceptionMessage);
8979     }
8980 }
8981 
8982 /* void glTexGenx ( GLint coord, GLint pname, GLint param ) */
8983 static void
android_glTexGenx__III(JNIEnv * _env,jobject _this,jint coord,jint pname,jint param)8984 android_glTexGenx__III
8985   (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) {
8986     if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) {
8987         jniThrowException(_env, "java/lang/UnsupportedOperationException",
8988             "glTexGenx");
8989             return;
8990     }
8991     glTexGenx(
8992         (GLint)coord,
8993         (GLint)pname,
8994         (GLint)param
8995     );
8996 }
8997 
8998 /* void glTexGenxv ( GLint coord, GLint pname, GLint *params ) */
8999 static void
android_glTexGenxv__II_3II(JNIEnv * _env,jobject _this,jint coord,jint pname,jintArray params_ref,jint offset)9000 android_glTexGenxv__II_3II
9001   (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
9002     if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) {
9003         jniThrowException(_env, "java/lang/UnsupportedOperationException",
9004             "glTexGenxv");
9005             return;
9006     }
9007     jint _exception = 0;
9008     const char * _exceptionType = NULL;
9009     const char * _exceptionMessage = NULL;
9010     GLint *params_base = (GLint *) 0;
9011     jint _remaining;
9012     GLint *params = (GLint *) 0;
9013 
9014     if (!params_ref) {
9015         _exception = 1;
9016         _exceptionType = "java/lang/IllegalArgumentException";
9017         _exceptionMessage = "params == null";
9018         goto exit;
9019     }
9020     if (offset < 0) {
9021         _exception = 1;
9022         _exceptionType = "java/lang/IllegalArgumentException";
9023         _exceptionMessage = "offset < 0";
9024         goto exit;
9025     }
9026     _remaining = _env->GetArrayLength(params_ref) - offset;
9027     params_base = (GLint *)
9028         _env->GetIntArrayElements(params_ref, (jboolean *)0);
9029     params = params_base + offset;
9030 
9031     glTexGenxv(
9032         (GLint)coord,
9033         (GLint)pname,
9034         (GLint *)params
9035     );
9036 
9037 exit:
9038     if (params_base) {
9039         _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
9040             _exception ? JNI_ABORT: 0);
9041     }
9042     if (_exception) {
9043         jniThrowException(_env, _exceptionType, _exceptionMessage);
9044     }
9045 }
9046 
9047 /* void glTexGenxv ( GLint coord, GLint pname, GLint *params ) */
9048 static void
android_glTexGenxv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)9049 android_glTexGenxv__IILjava_nio_IntBuffer_2
9050   (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
9051     if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) {
9052         jniThrowException(_env, "java/lang/UnsupportedOperationException",
9053             "glTexGenxv");
9054             return;
9055     }
9056     jint _exception = 0;
9057     const char * _exceptionType = NULL;
9058     const char * _exceptionMessage = NULL;
9059     jintArray _array = (jintArray) 0;
9060     jint _bufferOffset = (jint) 0;
9061     jint _remaining;
9062     GLint *params = (GLint *) 0;
9063 
9064     if (!params_buf) {
9065         _exception = 1;
9066         _exceptionType = "java/lang/IllegalArgumentException";
9067         _exceptionMessage = "params == null";
9068         goto exit;
9069     }
9070     params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
9071     if (params == NULL) {
9072         char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
9073         params = (GLint *) (_paramsBase + _bufferOffset);
9074     }
9075     glTexGenxv(
9076         (GLint)coord,
9077         (GLint)pname,
9078         (GLint *)params
9079     );
9080 
9081 exit:
9082     if (_array) {
9083         _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
9084     }
9085     if (_exception) {
9086         jniThrowException(_env, _exceptionType, _exceptionMessage);
9087     }
9088 }
9089 
9090 static const char *classPathName = "com/google/android/gles_jni/GLImpl";
9091 
9092 static const JNINativeMethod methods[] = {
9093 {"_nativeClassInit", "()V", (void*)nativeClassInit },
9094 {"glActiveTexture", "(I)V", (void *) android_glActiveTexture__I },
9095 {"glAlphaFunc", "(IF)V", (void *) android_glAlphaFunc__IF },
9096 {"glAlphaFuncx", "(II)V", (void *) android_glAlphaFuncx__II },
9097 {"glBindTexture", "(II)V", (void *) android_glBindTexture__II },
9098 {"glBlendFunc", "(II)V", (void *) android_glBlendFunc__II },
9099 {"glClear", "(I)V", (void *) android_glClear__I },
9100 {"glClearColor", "(FFFF)V", (void *) android_glClearColor__FFFF },
9101 {"glClearColorx", "(IIII)V", (void *) android_glClearColorx__IIII },
9102 {"glClearDepthf", "(F)V", (void *) android_glClearDepthf__F },
9103 {"glClearDepthx", "(I)V", (void *) android_glClearDepthx__I },
9104 {"glClearStencil", "(I)V", (void *) android_glClearStencil__I },
9105 {"glClientActiveTexture", "(I)V", (void *) android_glClientActiveTexture__I },
9106 {"glColor4f", "(FFFF)V", (void *) android_glColor4f__FFFF },
9107 {"glColor4x", "(IIII)V", (void *) android_glColor4x__IIII },
9108 {"glColorMask", "(ZZZZ)V", (void *) android_glColorMask__ZZZZ },
9109 {"glColorPointerBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glColorPointerBounds__IIILjava_nio_Buffer_2I },
9110 {"glCompressedTexImage2D", "(IIIIIIILjava/nio/Buffer;)V", (void *) android_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2 },
9111 {"glCompressedTexSubImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 },
9112 {"glCopyTexImage2D", "(IIIIIIII)V", (void *) android_glCopyTexImage2D__IIIIIIII },
9113 {"glCopyTexSubImage2D", "(IIIIIIII)V", (void *) android_glCopyTexSubImage2D__IIIIIIII },
9114 {"glCullFace", "(I)V", (void *) android_glCullFace__I },
9115 {"glDeleteTextures", "(I[II)V", (void *) android_glDeleteTextures__I_3II },
9116 {"glDeleteTextures", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteTextures__ILjava_nio_IntBuffer_2 },
9117 {"glDepthFunc", "(I)V", (void *) android_glDepthFunc__I },
9118 {"glDepthMask", "(Z)V", (void *) android_glDepthMask__Z },
9119 {"glDepthRangef", "(FF)V", (void *) android_glDepthRangef__FF },
9120 {"glDepthRangex", "(II)V", (void *) android_glDepthRangex__II },
9121 {"glDisable", "(I)V", (void *) android_glDisable__I },
9122 {"glDisableClientState", "(I)V", (void *) android_glDisableClientState__I },
9123 {"glDrawArrays", "(III)V", (void *) android_glDrawArrays__III },
9124 {"glDrawElements", "(IIILjava/nio/Buffer;)V", (void *) android_glDrawElements__IIILjava_nio_Buffer_2 },
9125 {"glEnable", "(I)V", (void *) android_glEnable__I },
9126 {"glEnableClientState", "(I)V", (void *) android_glEnableClientState__I },
9127 {"glFinish", "()V", (void *) android_glFinish__ },
9128 {"glFlush", "()V", (void *) android_glFlush__ },
9129 {"glFogf", "(IF)V", (void *) android_glFogf__IF },
9130 {"glFogfv", "(I[FI)V", (void *) android_glFogfv__I_3FI },
9131 {"glFogfv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glFogfv__ILjava_nio_FloatBuffer_2 },
9132 {"glFogx", "(II)V", (void *) android_glFogx__II },
9133 {"glFogxv", "(I[II)V", (void *) android_glFogxv__I_3II },
9134 {"glFogxv", "(ILjava/nio/IntBuffer;)V", (void *) android_glFogxv__ILjava_nio_IntBuffer_2 },
9135 {"glFrontFace", "(I)V", (void *) android_glFrontFace__I },
9136 {"glFrustumf", "(FFFFFF)V", (void *) android_glFrustumf__FFFFFF },
9137 {"glFrustumx", "(IIIIII)V", (void *) android_glFrustumx__IIIIII },
9138 {"glGenTextures", "(I[II)V", (void *) android_glGenTextures__I_3II },
9139 {"glGenTextures", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenTextures__ILjava_nio_IntBuffer_2 },
9140 {"glGetError", "()I", (void *) android_glGetError__ },
9141 {"glGetIntegerv", "(I[II)V", (void *) android_glGetIntegerv__I_3II },
9142 {"glGetIntegerv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetIntegerv__ILjava_nio_IntBuffer_2 },
9143 {"_glGetString", "(I)Ljava/lang/String;", (void *) android_glGetString },
9144 {"glHint", "(II)V", (void *) android_glHint__II },
9145 {"glLightModelf", "(IF)V", (void *) android_glLightModelf__IF },
9146 {"glLightModelfv", "(I[FI)V", (void *) android_glLightModelfv__I_3FI },
9147 {"glLightModelfv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glLightModelfv__ILjava_nio_FloatBuffer_2 },
9148 {"glLightModelx", "(II)V", (void *) android_glLightModelx__II },
9149 {"glLightModelxv", "(I[II)V", (void *) android_glLightModelxv__I_3II },
9150 {"glLightModelxv", "(ILjava/nio/IntBuffer;)V", (void *) android_glLightModelxv__ILjava_nio_IntBuffer_2 },
9151 {"glLightf", "(IIF)V", (void *) android_glLightf__IIF },
9152 {"glLightfv", "(II[FI)V", (void *) android_glLightfv__II_3FI },
9153 {"glLightfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glLightfv__IILjava_nio_FloatBuffer_2 },
9154 {"glLightx", "(III)V", (void *) android_glLightx__III },
9155 {"glLightxv", "(II[II)V", (void *) android_glLightxv__II_3II },
9156 {"glLightxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glLightxv__IILjava_nio_IntBuffer_2 },
9157 {"glLineWidth", "(F)V", (void *) android_glLineWidth__F },
9158 {"glLineWidthx", "(I)V", (void *) android_glLineWidthx__I },
9159 {"glLoadIdentity", "()V", (void *) android_glLoadIdentity__ },
9160 {"glLoadMatrixf", "([FI)V", (void *) android_glLoadMatrixf___3FI },
9161 {"glLoadMatrixf", "(Ljava/nio/FloatBuffer;)V", (void *) android_glLoadMatrixf__Ljava_nio_FloatBuffer_2 },
9162 {"glLoadMatrixx", "([II)V", (void *) android_glLoadMatrixx___3II },
9163 {"glLoadMatrixx", "(Ljava/nio/IntBuffer;)V", (void *) android_glLoadMatrixx__Ljava_nio_IntBuffer_2 },
9164 {"glLogicOp", "(I)V", (void *) android_glLogicOp__I },
9165 {"glMaterialf", "(IIF)V", (void *) android_glMaterialf__IIF },
9166 {"glMaterialfv", "(II[FI)V", (void *) android_glMaterialfv__II_3FI },
9167 {"glMaterialfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glMaterialfv__IILjava_nio_FloatBuffer_2 },
9168 {"glMaterialx", "(III)V", (void *) android_glMaterialx__III },
9169 {"glMaterialxv", "(II[II)V", (void *) android_glMaterialxv__II_3II },
9170 {"glMaterialxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glMaterialxv__IILjava_nio_IntBuffer_2 },
9171 {"glMatrixMode", "(I)V", (void *) android_glMatrixMode__I },
9172 {"glMultMatrixf", "([FI)V", (void *) android_glMultMatrixf___3FI },
9173 {"glMultMatrixf", "(Ljava/nio/FloatBuffer;)V", (void *) android_glMultMatrixf__Ljava_nio_FloatBuffer_2 },
9174 {"glMultMatrixx", "([II)V", (void *) android_glMultMatrixx___3II },
9175 {"glMultMatrixx", "(Ljava/nio/IntBuffer;)V", (void *) android_glMultMatrixx__Ljava_nio_IntBuffer_2 },
9176 {"glMultiTexCoord4f", "(IFFFF)V", (void *) android_glMultiTexCoord4f__IFFFF },
9177 {"glMultiTexCoord4x", "(IIIII)V", (void *) android_glMultiTexCoord4x__IIIII },
9178 {"glNormal3f", "(FFF)V", (void *) android_glNormal3f__FFF },
9179 {"glNormal3x", "(III)V", (void *) android_glNormal3x__III },
9180 {"glNormalPointerBounds", "(IILjava/nio/Buffer;I)V", (void *) android_glNormalPointerBounds__IILjava_nio_Buffer_2I },
9181 {"glOrthof", "(FFFFFF)V", (void *) android_glOrthof__FFFFFF },
9182 {"glOrthox", "(IIIIII)V", (void *) android_glOrthox__IIIIII },
9183 {"glPixelStorei", "(II)V", (void *) android_glPixelStorei__II },
9184 {"glPointSize", "(F)V", (void *) android_glPointSize__F },
9185 {"glPointSizex", "(I)V", (void *) android_glPointSizex__I },
9186 {"glPolygonOffset", "(FF)V", (void *) android_glPolygonOffset__FF },
9187 {"glPolygonOffsetx", "(II)V", (void *) android_glPolygonOffsetx__II },
9188 {"glPopMatrix", "()V", (void *) android_glPopMatrix__ },
9189 {"glPushMatrix", "()V", (void *) android_glPushMatrix__ },
9190 {"glReadPixels", "(IIIIIILjava/nio/Buffer;)V", (void *) android_glReadPixels__IIIIIILjava_nio_Buffer_2 },
9191 {"glRotatef", "(FFFF)V", (void *) android_glRotatef__FFFF },
9192 {"glRotatex", "(IIII)V", (void *) android_glRotatex__IIII },
9193 {"glSampleCoverage", "(FZ)V", (void *) android_glSampleCoverage__FZ },
9194 {"glSampleCoveragex", "(IZ)V", (void *) android_glSampleCoveragex__IZ },
9195 {"glScalef", "(FFF)V", (void *) android_glScalef__FFF },
9196 {"glScalex", "(III)V", (void *) android_glScalex__III },
9197 {"glScissor", "(IIII)V", (void *) android_glScissor__IIII },
9198 {"glShadeModel", "(I)V", (void *) android_glShadeModel__I },
9199 {"glStencilFunc", "(III)V", (void *) android_glStencilFunc__III },
9200 {"glStencilMask", "(I)V", (void *) android_glStencilMask__I },
9201 {"glStencilOp", "(III)V", (void *) android_glStencilOp__III },
9202 {"glTexCoordPointerBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glTexCoordPointerBounds__IIILjava_nio_Buffer_2I },
9203 {"glTexEnvf", "(IIF)V", (void *) android_glTexEnvf__IIF },
9204 {"glTexEnvfv", "(II[FI)V", (void *) android_glTexEnvfv__II_3FI },
9205 {"glTexEnvfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexEnvfv__IILjava_nio_FloatBuffer_2 },
9206 {"glTexEnvx", "(III)V", (void *) android_glTexEnvx__III },
9207 {"glTexEnvxv", "(II[II)V", (void *) android_glTexEnvxv__II_3II },
9208 {"glTexEnvxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexEnvxv__IILjava_nio_IntBuffer_2 },
9209 {"glTexImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2 },
9210 {"glTexParameterf", "(IIF)V", (void *) android_glTexParameterf__IIF },
9211 {"glTexParameterx", "(III)V", (void *) android_glTexParameterx__III },
9212 {"glTexSubImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 },
9213 {"glTranslatef", "(FFF)V", (void *) android_glTranslatef__FFF },
9214 {"glTranslatex", "(III)V", (void *) android_glTranslatex__III },
9215 {"glVertexPointerBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glVertexPointerBounds__IIILjava_nio_Buffer_2I },
9216 {"glViewport", "(IIII)V", (void *) android_glViewport__IIII },
9217 {"glQueryMatrixxOES", "([II[II)I", (void *) android_glQueryMatrixxOES___3II_3II },
9218 {"glQueryMatrixxOES", "(Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;)I", (void *) android_glQueryMatrixxOES__Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 },
9219 {"glBindBuffer", "(II)V", (void *) android_glBindBuffer__II },
9220 {"glBufferData", "(IILjava/nio/Buffer;I)V", (void *) android_glBufferData__IILjava_nio_Buffer_2I },
9221 {"glBufferSubData", "(IIILjava/nio/Buffer;)V", (void *) android_glBufferSubData__IIILjava_nio_Buffer_2 },
9222 {"glClipPlanef", "(I[FI)V", (void *) android_glClipPlanef__I_3FI },
9223 {"glClipPlanef", "(ILjava/nio/FloatBuffer;)V", (void *) android_glClipPlanef__ILjava_nio_FloatBuffer_2 },
9224 {"glClipPlanex", "(I[II)V", (void *) android_glClipPlanex__I_3II },
9225 {"glClipPlanex", "(ILjava/nio/IntBuffer;)V", (void *) android_glClipPlanex__ILjava_nio_IntBuffer_2 },
9226 {"glColor4ub", "(BBBB)V", (void *) android_glColor4ub__BBBB },
9227 {"glColorPointer", "(IIII)V", (void *) android_glColorPointer__IIII },
9228 {"glDeleteBuffers", "(I[II)V", (void *) android_glDeleteBuffers__I_3II },
9229 {"glDeleteBuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteBuffers__ILjava_nio_IntBuffer_2 },
9230 {"glDrawElements", "(IIII)V", (void *) android_glDrawElements__IIII },
9231 {"glGenBuffers", "(I[II)V", (void *) android_glGenBuffers__I_3II },
9232 {"glGenBuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenBuffers__ILjava_nio_IntBuffer_2 },
9233 {"glGetBooleanv", "(I[ZI)V", (void *) android_glGetBooleanv__I_3ZI },
9234 {"glGetBooleanv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetBooleanv__ILjava_nio_IntBuffer_2 },
9235 {"glGetBufferParameteriv", "(II[II)V", (void *) android_glGetBufferParameteriv__II_3II },
9236 {"glGetBufferParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetBufferParameteriv__IILjava_nio_IntBuffer_2 },
9237 {"glGetClipPlanef", "(I[FI)V", (void *) android_glGetClipPlanef__I_3FI },
9238 {"glGetClipPlanef", "(ILjava/nio/FloatBuffer;)V", (void *) android_glGetClipPlanef__ILjava_nio_FloatBuffer_2 },
9239 {"glGetClipPlanex", "(I[II)V", (void *) android_glGetClipPlanex__I_3II },
9240 {"glGetClipPlanex", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetClipPlanex__ILjava_nio_IntBuffer_2 },
9241 {"glGetFixedv", "(I[II)V", (void *) android_glGetFixedv__I_3II },
9242 {"glGetFixedv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetFixedv__ILjava_nio_IntBuffer_2 },
9243 {"glGetFloatv", "(I[FI)V", (void *) android_glGetFloatv__I_3FI },
9244 {"glGetFloatv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glGetFloatv__ILjava_nio_FloatBuffer_2 },
9245 {"glGetLightfv", "(II[FI)V", (void *) android_glGetLightfv__II_3FI },
9246 {"glGetLightfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetLightfv__IILjava_nio_FloatBuffer_2 },
9247 {"glGetLightxv", "(II[II)V", (void *) android_glGetLightxv__II_3II },
9248 {"glGetLightxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetLightxv__IILjava_nio_IntBuffer_2 },
9249 {"glGetMaterialfv", "(II[FI)V", (void *) android_glGetMaterialfv__II_3FI },
9250 {"glGetMaterialfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetMaterialfv__IILjava_nio_FloatBuffer_2 },
9251 {"glGetMaterialxv", "(II[II)V", (void *) android_glGetMaterialxv__II_3II },
9252 {"glGetMaterialxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetMaterialxv__IILjava_nio_IntBuffer_2 },
9253 {"glGetTexEnviv", "(II[II)V", (void *) android_glGetTexEnviv__II_3II },
9254 {"glGetTexEnviv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexEnviv__IILjava_nio_IntBuffer_2 },
9255 {"glGetTexEnvxv", "(II[II)V", (void *) android_glGetTexEnvxv__II_3II },
9256 {"glGetTexEnvxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexEnvxv__IILjava_nio_IntBuffer_2 },
9257 {"glGetTexParameterfv", "(II[FI)V", (void *) android_glGetTexParameterfv__II_3FI },
9258 {"glGetTexParameterfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetTexParameterfv__IILjava_nio_FloatBuffer_2 },
9259 {"glGetTexParameteriv", "(II[II)V", (void *) android_glGetTexParameteriv__II_3II },
9260 {"glGetTexParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameteriv__IILjava_nio_IntBuffer_2 },
9261 {"glGetTexParameterxv", "(II[II)V", (void *) android_glGetTexParameterxv__II_3II },
9262 {"glGetTexParameterxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameterxv__IILjava_nio_IntBuffer_2 },
9263 {"glIsBuffer", "(I)Z", (void *) android_glIsBuffer__I },
9264 {"glIsEnabled", "(I)Z", (void *) android_glIsEnabled__I },
9265 {"glIsTexture", "(I)Z", (void *) android_glIsTexture__I },
9266 {"glNormalPointer", "(III)V", (void *) android_glNormalPointer__III },
9267 {"glPointParameterf", "(IF)V", (void *) android_glPointParameterf__IF },
9268 {"glPointParameterfv", "(I[FI)V", (void *) android_glPointParameterfv__I_3FI },
9269 {"glPointParameterfv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glPointParameterfv__ILjava_nio_FloatBuffer_2 },
9270 {"glPointParameterx", "(II)V", (void *) android_glPointParameterx__II },
9271 {"glPointParameterxv", "(I[II)V", (void *) android_glPointParameterxv__I_3II },
9272 {"glPointParameterxv", "(ILjava/nio/IntBuffer;)V", (void *) android_glPointParameterxv__ILjava_nio_IntBuffer_2 },
9273 {"glPointSizePointerOESBounds", "(IILjava/nio/Buffer;I)V", (void *) android_glPointSizePointerOESBounds__IILjava_nio_Buffer_2I },
9274 {"glTexCoordPointer", "(IIII)V", (void *) android_glTexCoordPointer__IIII },
9275 {"glTexEnvi", "(III)V", (void *) android_glTexEnvi__III },
9276 {"glTexEnviv", "(II[II)V", (void *) android_glTexEnviv__II_3II },
9277 {"glTexEnviv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexEnviv__IILjava_nio_IntBuffer_2 },
9278 {"glTexParameterfv", "(II[FI)V", (void *) android_glTexParameterfv__II_3FI },
9279 {"glTexParameterfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexParameterfv__IILjava_nio_FloatBuffer_2 },
9280 {"glTexParameteri", "(III)V", (void *) android_glTexParameteri__III },
9281 {"glTexParameteriv", "(II[II)V", (void *) android_glTexParameteriv__II_3II },
9282 {"glTexParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameteriv__IILjava_nio_IntBuffer_2 },
9283 {"glTexParameterxv", "(II[II)V", (void *) android_glTexParameterxv__II_3II },
9284 {"glTexParameterxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameterxv__IILjava_nio_IntBuffer_2 },
9285 {"glVertexPointer", "(IIII)V", (void *) android_glVertexPointer__IIII },
9286 {"glCurrentPaletteMatrixOES", "(I)V", (void *) android_glCurrentPaletteMatrixOES__I },
9287 {"glDrawTexfOES", "(FFFFF)V", (void *) android_glDrawTexfOES__FFFFF },
9288 {"glDrawTexfvOES", "([FI)V", (void *) android_glDrawTexfvOES___3FI },
9289 {"glDrawTexfvOES", "(Ljava/nio/FloatBuffer;)V", (void *) android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2 },
9290 {"glDrawTexiOES", "(IIIII)V", (void *) android_glDrawTexiOES__IIIII },
9291 {"glDrawTexivOES", "([II)V", (void *) android_glDrawTexivOES___3II },
9292 {"glDrawTexivOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexivOES__Ljava_nio_IntBuffer_2 },
9293 {"glDrawTexsOES", "(SSSSS)V", (void *) android_glDrawTexsOES__SSSSS },
9294 {"glDrawTexsvOES", "([SI)V", (void *) android_glDrawTexsvOES___3SI },
9295 {"glDrawTexsvOES", "(Ljava/nio/ShortBuffer;)V", (void *) android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2 },
9296 {"glDrawTexxOES", "(IIIII)V", (void *) android_glDrawTexxOES__IIIII },
9297 {"glDrawTexxvOES", "([II)V", (void *) android_glDrawTexxvOES___3II },
9298 {"glDrawTexxvOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexxvOES__Ljava_nio_IntBuffer_2 },
9299 {"glLoadPaletteFromModelViewMatrixOES", "()V", (void *) android_glLoadPaletteFromModelViewMatrixOES__ },
9300 {"glMatrixIndexPointerOESBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I },
9301 {"glMatrixIndexPointerOES", "(IIII)V", (void *) android_glMatrixIndexPointerOES__IIII },
9302 {"glWeightPointerOESBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I },
9303 {"glWeightPointerOES", "(IIII)V", (void *) android_glWeightPointerOES__IIII },
9304 {"glBindFramebufferOES", "(II)V", (void *) android_glBindFramebufferOES__II },
9305 {"glBindRenderbufferOES", "(II)V", (void *) android_glBindRenderbufferOES__II },
9306 {"glBlendEquation", "(I)V", (void *) android_glBlendEquation__I },
9307 {"glBlendEquationSeparate", "(II)V", (void *) android_glBlendEquationSeparate__II },
9308 {"glBlendFuncSeparate", "(IIII)V", (void *) android_glBlendFuncSeparate__IIII },
9309 {"glCheckFramebufferStatusOES", "(I)I", (void *) android_glCheckFramebufferStatusOES__I },
9310 {"glDeleteFramebuffersOES", "(I[II)V", (void *) android_glDeleteFramebuffersOES__I_3II },
9311 {"glDeleteFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2 },
9312 {"glDeleteRenderbuffersOES", "(I[II)V", (void *) android_glDeleteRenderbuffersOES__I_3II },
9313 {"glDeleteRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2 },
9314 {"glFramebufferRenderbufferOES", "(IIII)V", (void *) android_glFramebufferRenderbufferOES__IIII },
9315 {"glFramebufferTexture2DOES", "(IIIII)V", (void *) android_glFramebufferTexture2DOES__IIIII },
9316 {"glGenerateMipmapOES", "(I)V", (void *) android_glGenerateMipmapOES__I },
9317 {"glGenFramebuffersOES", "(I[II)V", (void *) android_glGenFramebuffersOES__I_3II },
9318 {"glGenFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2 },
9319 {"glGenRenderbuffersOES", "(I[II)V", (void *) android_glGenRenderbuffersOES__I_3II },
9320 {"glGenRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2 },
9321 {"glGetFramebufferAttachmentParameterivOES", "(III[II)V", (void *) android_glGetFramebufferAttachmentParameterivOES__III_3II },
9322 {"glGetFramebufferAttachmentParameterivOES", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2 },
9323 {"glGetRenderbufferParameterivOES", "(II[II)V", (void *) android_glGetRenderbufferParameterivOES__II_3II },
9324 {"glGetRenderbufferParameterivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2 },
9325 {"glGetTexGenfv", "(II[FI)V", (void *) android_glGetTexGenfv__II_3FI },
9326 {"glGetTexGenfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetTexGenfv__IILjava_nio_FloatBuffer_2 },
9327 {"glGetTexGeniv", "(II[II)V", (void *) android_glGetTexGeniv__II_3II },
9328 {"glGetTexGeniv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGeniv__IILjava_nio_IntBuffer_2 },
9329 {"glGetTexGenxv", "(II[II)V", (void *) android_glGetTexGenxv__II_3II },
9330 {"glGetTexGenxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGenxv__IILjava_nio_IntBuffer_2 },
9331 {"glIsFramebufferOES", "(I)Z", (void *) android_glIsFramebufferOES__I },
9332 {"glIsRenderbufferOES", "(I)Z", (void *) android_glIsRenderbufferOES__I },
9333 {"glRenderbufferStorageOES", "(IIII)V", (void *) android_glRenderbufferStorageOES__IIII },
9334 {"glTexGenf", "(IIF)V", (void *) android_glTexGenf__IIF },
9335 {"glTexGenfv", "(II[FI)V", (void *) android_glTexGenfv__II_3FI },
9336 {"glTexGenfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexGenfv__IILjava_nio_FloatBuffer_2 },
9337 {"glTexGeni", "(III)V", (void *) android_glTexGeni__III },
9338 {"glTexGeniv", "(II[II)V", (void *) android_glTexGeniv__II_3II },
9339 {"glTexGeniv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGeniv__IILjava_nio_IntBuffer_2 },
9340 {"glTexGenx", "(III)V", (void *) android_glTexGenx__III },
9341 {"glTexGenxv", "(II[II)V", (void *) android_glTexGenxv__II_3II },
9342 {"glTexGenxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGenxv__IILjava_nio_IntBuffer_2 },
9343 };
9344 
register_com_google_android_gles_jni_GLImpl(JNIEnv * _env)9345 int register_com_google_android_gles_jni_GLImpl(JNIEnv *_env)
9346 {
9347     int err;
9348     err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));
9349     return err;
9350 }
9351