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