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