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