1 /*
2 * Copyright 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 // This source file is automatically generated
18
19 #pragma GCC diagnostic ignored "-Wunused-variable"
20 #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
21 #pragma GCC diagnostic ignored "-Wunused-function"
22
23 #include <stdint.h>
24 #include <GLES3/gl32.h>
25 #include <jni.h>
26 #include <nativehelper/JNIHelp.h>
27 #include <android_runtime/AndroidRuntime.h>
28 #include <utils/misc.h>
29 #include <assert.h>
30
31 static int initialized = 0;
32
33 static jclass nioAccessClass;
34 static jclass bufferClass;
35 static jmethodID getBasePointerID;
36 static jmethodID getBaseArrayID;
37 static jmethodID getBaseArrayOffsetID;
38 static jfieldID positionID;
39 static jfieldID limitID;
40 static jfieldID elementSizeShiftID;
41
42
43 /* special calls implemented in Android's GLES wrapper used to more
44 * efficiently bound-check passed arrays */
45 extern "C" {
46 #ifdef GL_VERSION_ES_CM_1_1
47 GL_API void GL_APIENTRY glColorPointerBounds(GLint size, GLenum type, GLsizei stride,
48 const GLvoid *ptr, GLsizei count);
49 GL_API void GL_APIENTRY glNormalPointerBounds(GLenum type, GLsizei stride,
50 const GLvoid *pointer, GLsizei count);
51 GL_API void GL_APIENTRY glTexCoordPointerBounds(GLint size, GLenum type,
52 GLsizei stride, const GLvoid *pointer, GLsizei count);
53 GL_API void GL_APIENTRY glVertexPointerBounds(GLint size, GLenum type,
54 GLsizei stride, const GLvoid *pointer, GLsizei count);
55 GL_API void GL_APIENTRY glPointSizePointerOESBounds(GLenum type,
56 GLsizei stride, const GLvoid *pointer, GLsizei count);
57 GL_API void GL_APIENTRY glMatrixIndexPointerOESBounds(GLint size, GLenum type,
58 GLsizei stride, const GLvoid *pointer, GLsizei count);
59 GL_API void GL_APIENTRY glWeightPointerOESBounds(GLint size, GLenum type,
60 GLsizei stride, const GLvoid *pointer, GLsizei count);
61 #endif
62 #ifdef GL_ES_VERSION_2_0
glVertexAttribPointerBounds(GLuint indx,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const GLvoid * pointer,GLsizei count)63 static void glVertexAttribPointerBounds(GLuint indx, GLint size, GLenum type,
64 GLboolean normalized, GLsizei stride, const GLvoid *pointer, GLsizei count) {
65 glVertexAttribPointer(indx, size, type, normalized, stride, pointer);
66 }
67 #endif
68 #ifdef GL_ES_VERSION_3_0
glVertexAttribIPointerBounds(GLuint indx,GLint size,GLenum type,GLsizei stride,const GLvoid * pointer,GLsizei count)69 static void glVertexAttribIPointerBounds(GLuint indx, GLint size, GLenum type,
70 GLsizei stride, const GLvoid *pointer, GLsizei count) {
71 glVertexAttribIPointer(indx, size, type, stride, pointer);
72 }
73 #endif
74 }
75
76 /* Cache method IDs each time the class is loaded. */
77
78 static void
nativeClassInit(JNIEnv * _env,jclass glImplClass)79 nativeClassInit(JNIEnv *_env, jclass glImplClass)
80 {
81 jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess");
82 nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal);
83
84 jclass bufferClassLocal = _env->FindClass("java/nio/Buffer");
85 bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal);
86
87 getBasePointerID = _env->GetStaticMethodID(nioAccessClass,
88 "getBasePointer", "(Ljava/nio/Buffer;)J");
89 getBaseArrayID = _env->GetStaticMethodID(nioAccessClass,
90 "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;");
91 getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass,
92 "getBaseArrayOffset", "(Ljava/nio/Buffer;)I");
93
94 positionID = _env->GetFieldID(bufferClass, "position", "I");
95 limitID = _env->GetFieldID(bufferClass, "limit", "I");
96 elementSizeShiftID =
97 _env->GetFieldID(bufferClass, "_elementSizeShift", "I");
98 }
99
100 static void *
getPointer(JNIEnv * _env,jobject buffer,jarray * array,jint * remaining,jint * offset)101 getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining, jint *offset)
102 {
103 jint position;
104 jint limit;
105 jint elementSizeShift;
106 jlong pointer;
107
108 position = _env->GetIntField(buffer, positionID);
109 limit = _env->GetIntField(buffer, limitID);
110 elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
111 *remaining = (limit - position) << elementSizeShift;
112 pointer = _env->CallStaticLongMethod(nioAccessClass,
113 getBasePointerID, buffer);
114 if (pointer != 0L) {
115 *array = NULL;
116 return reinterpret_cast<void*>(pointer);
117 }
118
119 *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass,
120 getBaseArrayID, buffer);
121 *offset = _env->CallStaticIntMethod(nioAccessClass,
122 getBaseArrayOffsetID, buffer);
123
124 return NULL;
125 }
126
127 class ByteArrayGetter {
128 public:
Get(JNIEnv * _env,jbyteArray array,jboolean * is_copy)129 static void* Get(JNIEnv* _env, jbyteArray array, jboolean* is_copy) {
130 return _env->GetByteArrayElements(array, is_copy);
131 }
132 };
133 class BooleanArrayGetter {
134 public:
Get(JNIEnv * _env,jbooleanArray array,jboolean * is_copy)135 static void* Get(JNIEnv* _env, jbooleanArray array, jboolean* is_copy) {
136 return _env->GetBooleanArrayElements(array, is_copy);
137 }
138 };
139 class CharArrayGetter {
140 public:
Get(JNIEnv * _env,jcharArray array,jboolean * is_copy)141 static void* Get(JNIEnv* _env, jcharArray array, jboolean* is_copy) {
142 return _env->GetCharArrayElements(array, is_copy);
143 }
144 };
145 class ShortArrayGetter {
146 public:
Get(JNIEnv * _env,jshortArray array,jboolean * is_copy)147 static void* Get(JNIEnv* _env, jshortArray array, jboolean* is_copy) {
148 return _env->GetShortArrayElements(array, is_copy);
149 }
150 };
151 class IntArrayGetter {
152 public:
Get(JNIEnv * _env,jintArray array,jboolean * is_copy)153 static void* Get(JNIEnv* _env, jintArray array, jboolean* is_copy) {
154 return _env->GetIntArrayElements(array, is_copy);
155 }
156 };
157 class LongArrayGetter {
158 public:
Get(JNIEnv * _env,jlongArray array,jboolean * is_copy)159 static void* Get(JNIEnv* _env, jlongArray array, jboolean* is_copy) {
160 return _env->GetLongArrayElements(array, is_copy);
161 }
162 };
163 class FloatArrayGetter {
164 public:
Get(JNIEnv * _env,jfloatArray array,jboolean * is_copy)165 static void* Get(JNIEnv* _env, jfloatArray array, jboolean* is_copy) {
166 return _env->GetFloatArrayElements(array, is_copy);
167 }
168 };
169 class DoubleArrayGetter {
170 public:
Get(JNIEnv * _env,jdoubleArray array,jboolean * is_copy)171 static void* Get(JNIEnv* _env, jdoubleArray array, jboolean* is_copy) {
172 return _env->GetDoubleArrayElements(array, is_copy);
173 }
174 };
175
176 template<typename JTYPEARRAY, typename ARRAYGETTER>
177 static void*
getArrayPointer(JNIEnv * _env,JTYPEARRAY array,jboolean * is_copy)178 getArrayPointer(JNIEnv *_env, JTYPEARRAY array, jboolean* is_copy) {
179 return ARRAYGETTER::Get(_env, array, is_copy);
180 }
181
182 class ByteArrayReleaser {
183 public:
Release(JNIEnv * _env,jbyteArray array,jbyte * data,jboolean commit)184 static void Release(JNIEnv* _env, jbyteArray array, jbyte* data, jboolean commit) {
185 _env->ReleaseByteArrayElements(array, data, commit ? 0 : JNI_ABORT);
186 }
187 };
188 class BooleanArrayReleaser {
189 public:
Release(JNIEnv * _env,jbooleanArray array,jboolean * data,jboolean commit)190 static void Release(JNIEnv* _env, jbooleanArray array, jboolean* data, jboolean commit) {
191 _env->ReleaseBooleanArrayElements(array, data, commit ? 0 : JNI_ABORT);
192 }
193 };
194 class CharArrayReleaser {
195 public:
Release(JNIEnv * _env,jcharArray array,jchar * data,jboolean commit)196 static void Release(JNIEnv* _env, jcharArray array, jchar* data, jboolean commit) {
197 _env->ReleaseCharArrayElements(array, data, commit ? 0 : JNI_ABORT);
198 }
199 };
200 class ShortArrayReleaser {
201 public:
Release(JNIEnv * _env,jshortArray array,jshort * data,jboolean commit)202 static void Release(JNIEnv* _env, jshortArray array, jshort* data, jboolean commit) {
203 _env->ReleaseShortArrayElements(array, data, commit ? 0 : JNI_ABORT);
204 }
205 };
206 class IntArrayReleaser {
207 public:
Release(JNIEnv * _env,jintArray array,jint * data,jboolean commit)208 static void Release(JNIEnv* _env, jintArray array, jint* data, jboolean commit) {
209 _env->ReleaseIntArrayElements(array, data, commit ? 0 : JNI_ABORT);
210 }
211 };
212 class LongArrayReleaser {
213 public:
Release(JNIEnv * _env,jlongArray array,jlong * data,jboolean commit)214 static void Release(JNIEnv* _env, jlongArray array, jlong* data, jboolean commit) {
215 _env->ReleaseLongArrayElements(array, data, commit ? 0 : JNI_ABORT);
216 }
217 };
218 class FloatArrayReleaser {
219 public:
Release(JNIEnv * _env,jfloatArray array,jfloat * data,jboolean commit)220 static void Release(JNIEnv* _env, jfloatArray array, jfloat* data, jboolean commit) {
221 _env->ReleaseFloatArrayElements(array, data, commit ? 0 : JNI_ABORT);
222 }
223 };
224 class DoubleArrayReleaser {
225 public:
Release(JNIEnv * _env,jdoubleArray array,jdouble * data,jboolean commit)226 static void Release(JNIEnv* _env, jdoubleArray array, jdouble* data, jboolean commit) {
227 _env->ReleaseDoubleArrayElements(array, data, commit ? 0 : JNI_ABORT);
228 }
229 };
230
231 template<typename JTYPEARRAY, typename NTYPEARRAY, typename ARRAYRELEASER>
232 static void
releaseArrayPointer(JNIEnv * _env,JTYPEARRAY array,NTYPEARRAY data,jboolean commit)233 releaseArrayPointer(JNIEnv *_env, JTYPEARRAY array, NTYPEARRAY data, jboolean commit) {
234 ARRAYRELEASER::Release(_env, array, data, commit);
235 }
236
237 static void
releasePointer(JNIEnv * _env,jarray array,void * data,jboolean commit)238 releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit)
239 {
240 _env->ReleasePrimitiveArrayCritical(array, data,
241 commit ? 0 : JNI_ABORT);
242 }
243
244 static void *
getDirectBufferPointer(JNIEnv * _env,jobject buffer)245 getDirectBufferPointer(JNIEnv *_env, jobject buffer) {
246 char* buf = (char*) _env->GetDirectBufferAddress(buffer);
247 if (buf) {
248 jint position = _env->GetIntField(buffer, positionID);
249 jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
250 buf += position << elementSizeShift;
251 } else {
252 jniThrowException(_env, "java/lang/IllegalArgumentException",
253 "Must use a native order direct Buffer");
254 }
255 return (void*) buf;
256 }
257
258 // --------------------------------------------------------------------------
259
260 /*
261 * returns the number of values glGet returns for a given pname.
262 *
263 * The code below is written such that pnames requiring only one values
264 * are the default (and are not explicitely tested for). This makes the
265 * checking code much shorter/readable/efficient.
266 *
267 * This means that unknown pnames (e.g.: extensions) will default to 1. If
268 * that unknown pname needs more than 1 value, then the validation check
269 * is incomplete and the app may crash if it passed the wrong number params.
270 */
getNeededCount(GLint pname)271 static int getNeededCount(GLint pname) {
272 int needed = 1;
273 #ifdef GL_ES_VERSION_3_0
274 // GLES 3.x pnames
275 switch (pname) {
276 case GL_MAX_VIEWPORT_DIMS:
277 needed = 2;
278 break;
279
280 case GL_PROGRAM_BINARY_FORMATS:
281 glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &needed);
282 break;
283 }
284 #endif
285
286 #ifdef GL_ES_VERSION_2_0
287 // GLES 2.x pnames
288 switch (pname) {
289 case GL_ALIASED_LINE_WIDTH_RANGE:
290 case GL_ALIASED_POINT_SIZE_RANGE:
291 needed = 2;
292 break;
293
294 case GL_BLEND_COLOR:
295 case GL_COLOR_CLEAR_VALUE:
296 case GL_COLOR_WRITEMASK:
297 case GL_SCISSOR_BOX:
298 case GL_VIEWPORT:
299 needed = 4;
300 break;
301
302 case GL_COMPRESSED_TEXTURE_FORMATS:
303 glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed);
304 break;
305
306 case GL_SHADER_BINARY_FORMATS:
307 glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &needed);
308 break;
309 }
310 #endif
311
312 #ifdef GL_VERSION_ES_CM_1_1
313 // GLES 1.x pnames
314 switch (pname) {
315 case GL_ALIASED_LINE_WIDTH_RANGE:
316 case GL_ALIASED_POINT_SIZE_RANGE:
317 case GL_DEPTH_RANGE:
318 case GL_SMOOTH_LINE_WIDTH_RANGE:
319 case GL_SMOOTH_POINT_SIZE_RANGE:
320 needed = 2;
321 break;
322
323 case GL_CURRENT_NORMAL:
324 case GL_POINT_DISTANCE_ATTENUATION:
325 needed = 3;
326 break;
327
328 case GL_COLOR_CLEAR_VALUE:
329 case GL_COLOR_WRITEMASK:
330 case GL_CURRENT_COLOR:
331 case GL_CURRENT_TEXTURE_COORDS:
332 case GL_FOG_COLOR:
333 case GL_LIGHT_MODEL_AMBIENT:
334 case GL_SCISSOR_BOX:
335 case GL_VIEWPORT:
336 needed = 4;
337 break;
338
339 case GL_MODELVIEW_MATRIX:
340 case GL_PROJECTION_MATRIX:
341 case GL_TEXTURE_MATRIX:
342 needed = 16;
343 break;
344
345 case GL_COMPRESSED_TEXTURE_FORMATS:
346 glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed);
347 break;
348 }
349 #endif
350 return needed;
351 }
352
353 template <typename JTYPEARRAY, typename ARRAYGETTER, typename NTYPEARRAY,
354 typename ARRAYRELEASER, typename CTYPE, void GET(GLenum, CTYPE*)>
355 static void
get(JNIEnv * _env,jobject _this,jint pname,JTYPEARRAY params_ref,jint offset)356 get
357 (JNIEnv *_env, jobject _this, jint pname, JTYPEARRAY params_ref, jint offset) {
358 jint _exception = 0;
359 const char * _exceptionType;
360 const char * _exceptionMessage;
361 CTYPE *params_base = (CTYPE *) 0;
362 jint _remaining;
363 CTYPE *params = (CTYPE *) 0;
364 int _needed = 0;
365
366 if (!params_ref) {
367 _exception = 1;
368 _exceptionType = "java/lang/IllegalArgumentException";
369 _exceptionMessage = "params == null";
370 goto exit;
371 }
372 if (offset < 0) {
373 _exception = 1;
374 _exceptionType = "java/lang/IllegalArgumentException";
375 _exceptionMessage = "offset < 0";
376 goto exit;
377 }
378 _remaining = _env->GetArrayLength(params_ref) - offset;
379 _needed = getNeededCount(pname);
380 // if we didn't find this pname, we just assume the user passed
381 // an array of the right size -- this might happen with extensions
382 // or if we forget an enum here.
383 if (_remaining < _needed) {
384 _exception = 1;
385 _exceptionType = "java/lang/IllegalArgumentException";
386 _exceptionMessage = "length - offset < needed";
387 goto exit;
388 }
389 params_base = (CTYPE *) getArrayPointer<JTYPEARRAY, ARRAYGETTER>(
390 _env, params_ref, (jboolean *)0);
391 params = params_base + offset;
392
393 GET(
394 (GLenum)pname,
395 (CTYPE *)params
396 );
397
398 exit:
399 if (params_base) {
400 releaseArrayPointer<JTYPEARRAY, NTYPEARRAY, ARRAYRELEASER>(
401 _env, params_ref, params_base, !_exception);
402 }
403 if (_exception) {
404 jniThrowException(_env, _exceptionType, _exceptionMessage);
405 }
406 }
407
408
409 template <typename CTYPE, typename JTYPEARRAY, typename ARRAYGETTER, typename NTYPEARRAY,
410 typename ARRAYRELEASER, void GET(GLenum, CTYPE*)>
411 static void
getarray(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)412 getarray
413 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
414 jint _exception = 0;
415 const char * _exceptionType;
416 const char * _exceptionMessage;
417 JTYPEARRAY _array = (JTYPEARRAY) 0;
418 jint _bufferOffset = (jint) 0;
419 jint _remaining;
420 CTYPE *params = (CTYPE *) 0;
421 int _needed = 0;
422
423 params = (CTYPE *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
424 _remaining /= sizeof(CTYPE); // convert from bytes to item count
425 _needed = getNeededCount(pname);
426 // if we didn't find this pname, we just assume the user passed
427 // an array of the right size -- this might happen with extensions
428 // or if we forget an enum here.
429 if (_needed>0 && _remaining < _needed) {
430 _exception = 1;
431 _exceptionType = "java/lang/IllegalArgumentException";
432 _exceptionMessage = "remaining() < needed";
433 goto exit;
434 }
435 if (params == NULL) {
436 char * _paramsBase = (char *) getArrayPointer<JTYPEARRAY, ARRAYGETTER>(
437 _env, _array, (jboolean *) 0);
438 params = (CTYPE *) (_paramsBase + _bufferOffset);
439 }
440 GET(
441 (GLenum)pname,
442 (CTYPE *)params
443 );
444
445 exit:
446 if (_array) {
447 releaseArrayPointer<JTYPEARRAY, NTYPEARRAY, ARRAYRELEASER>(
448 _env, _array, (NTYPEARRAY)params, _exception ? JNI_FALSE : JNI_TRUE);
449 }
450 if (_exception) {
451 jniThrowException(_env, _exceptionType, _exceptionMessage);
452 }
453 }
454
455 // --------------------------------------------------------------------------
456 /* void glBlendBarrier ( void ) */
457 static void
android_glBlendBarrier__(JNIEnv * _env,jobject _this)458 android_glBlendBarrier__
459 (JNIEnv *_env, jobject _this) {
460 glBlendBarrier();
461 }
462
463 /* void glCopyImageSubData ( GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth ) */
464 static void
android_glCopyImageSubData__IIIIIIIIIIIIIII(JNIEnv * _env,jobject _this,jint srcName,jint srcTarget,jint srcLevel,jint srcX,jint srcY,jint srcZ,jint dstName,jint dstTarget,jint dstLevel,jint dstX,jint dstY,jint dstZ,jint srcWidth,jint srcHeight,jint srcDepth)465 android_glCopyImageSubData__IIIIIIIIIIIIIII
466 (JNIEnv *_env, jobject _this, jint srcName, jint srcTarget, jint srcLevel, jint srcX, jint srcY, jint srcZ, jint dstName, jint dstTarget, jint dstLevel, jint dstX, jint dstY, jint dstZ, jint srcWidth, jint srcHeight, jint srcDepth) {
467 glCopyImageSubData(
468 (GLuint)srcName,
469 (GLenum)srcTarget,
470 (GLint)srcLevel,
471 (GLint)srcX,
472 (GLint)srcY,
473 (GLint)srcZ,
474 (GLuint)dstName,
475 (GLenum)dstTarget,
476 (GLint)dstLevel,
477 (GLint)dstX,
478 (GLint)dstY,
479 (GLint)dstZ,
480 (GLsizei)srcWidth,
481 (GLsizei)srcHeight,
482 (GLsizei)srcDepth
483 );
484 }
485
486 /* void glDebugMessageControl ( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled ) */
487 static void
android_glDebugMessageControl__IIII_3IIZ(JNIEnv * _env,jobject _this,jint source,jint type,jint severity,jint count,jintArray ids_ref,jint offset,jboolean enabled)488 android_glDebugMessageControl__IIII_3IIZ
489 (JNIEnv *_env, jobject _this, jint source, jint type, jint severity, jint count, jintArray ids_ref, jint offset, jboolean enabled) {
490 jint _exception = 0;
491 const char * _exceptionType = NULL;
492 const char * _exceptionMessage = NULL;
493 GLuint *ids_base = (GLuint *) 0;
494 jint _remaining;
495 GLuint *ids = (GLuint *) 0;
496
497 if (!ids_ref) {
498 _exception = 1;
499 _exceptionType = "java/lang/IllegalArgumentException";
500 _exceptionMessage = "ids == null";
501 goto exit;
502 }
503 if (offset < 0) {
504 _exception = 1;
505 _exceptionType = "java/lang/IllegalArgumentException";
506 _exceptionMessage = "offset < 0";
507 goto exit;
508 }
509 _remaining = _env->GetArrayLength(ids_ref) - offset;
510 if (_remaining < count) {
511 _exception = 1;
512 _exceptionType = "java/lang/IllegalArgumentException";
513 _exceptionMessage = "length - offset < count < needed";
514 goto exit;
515 }
516 ids_base = (GLuint *)
517 _env->GetIntArrayElements(ids_ref, (jboolean *)0);
518 ids = ids_base + offset;
519
520 glDebugMessageControl(
521 (GLenum)source,
522 (GLenum)type,
523 (GLenum)severity,
524 (GLsizei)count,
525 (GLuint *)ids,
526 (GLboolean)enabled
527 );
528
529 exit:
530 if (ids_base) {
531 _env->ReleaseIntArrayElements(ids_ref, (jint*)ids_base,
532 JNI_ABORT);
533 }
534 if (_exception) {
535 jniThrowException(_env, _exceptionType, _exceptionMessage);
536 }
537 }
538
539 /* void glDebugMessageControl ( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled ) */
540 static void
android_glDebugMessageControl__IIIILjava_nio_IntBuffer_2Z(JNIEnv * _env,jobject _this,jint source,jint type,jint severity,jint count,jobject ids_buf,jboolean enabled)541 android_glDebugMessageControl__IIIILjava_nio_IntBuffer_2Z
542 (JNIEnv *_env, jobject _this, jint source, jint type, jint severity, jint count, jobject ids_buf, jboolean enabled) {
543 jint _exception = 0;
544 const char * _exceptionType = NULL;
545 const char * _exceptionMessage = NULL;
546 jintArray _array = (jintArray) 0;
547 jint _bufferOffset = (jint) 0;
548 jint _remaining;
549 GLuint *ids = (GLuint *) 0;
550
551 if (!ids_buf) {
552 _exception = 1;
553 _exceptionType = "java/lang/IllegalArgumentException";
554 _exceptionMessage = "ids == null";
555 goto exit;
556 }
557 ids = (GLuint *)getPointer(_env, ids_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
558 if (_remaining < count) {
559 _exception = 1;
560 _exceptionType = "java/lang/IllegalArgumentException";
561 _exceptionMessage = "remaining() < count < needed";
562 goto exit;
563 }
564 if (ids == NULL) {
565 char * _idsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
566 ids = (GLuint *) (_idsBase + _bufferOffset);
567 }
568 glDebugMessageControl(
569 (GLenum)source,
570 (GLenum)type,
571 (GLenum)severity,
572 (GLsizei)count,
573 (GLuint *)ids,
574 (GLboolean)enabled
575 );
576
577 exit:
578 if (_array) {
579 _env->ReleaseIntArrayElements(_array, (jint*)ids, JNI_ABORT);
580 }
581 if (_exception) {
582 jniThrowException(_env, _exceptionType, _exceptionMessage);
583 }
584 }
585
586 /* void glDebugMessageInsert ( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf ) */
587 static void
android_glDebugMessageInsert__IIIIILjava_lang_String_2(JNIEnv * _env,jobject _this,jint source,jint type,jint id,jint severity,jint length,jstring buf)588 android_glDebugMessageInsert__IIIIILjava_lang_String_2
589 (JNIEnv *_env, jobject _this, jint source, jint type, jint id, jint severity, jint length, jstring buf) {
590 jint _exception = 0;
591 const char * _exceptionType = NULL;
592 const char * _exceptionMessage = NULL;
593 const char* _nativebuf = 0;
594
595 if (!buf) {
596 _exception = 1;
597 _exceptionType = "java/lang/IllegalArgumentException";
598 _exceptionMessage = "buf == null";
599 goto exit;
600 }
601 _nativebuf = _env->GetStringUTFChars(buf, 0);
602
603 glDebugMessageInsert(
604 (GLenum)source,
605 (GLenum)type,
606 (GLuint)id,
607 (GLenum)severity,
608 (GLsizei)length,
609 (GLchar *)_nativebuf
610 );
611
612 exit:
613 if (_nativebuf) {
614 _env->ReleaseStringUTFChars(buf, _nativebuf);
615 }
616
617 if (_exception) {
618 jniThrowException(_env, _exceptionType, _exceptionMessage);
619 }
620 }
621
622 /* void glDebugMessageCallback ( GLDEBUGPROC callback, const void *userParam ) */
623 static void
android_glDebugMessageCallback(JNIEnv * _env,jobject _this,jobject callback)624 android_glDebugMessageCallback(JNIEnv *_env, jobject _this, jobject callback) {
625 jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
626 }
627 /* GLuint glGetDebugMessageLog ( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) */
628 static jint
android_glGetDebugMessageLog__II_3II_3II_3II_3II_3II_3BI(JNIEnv * _env,jobject _this,jint count,jint bufSize,jintArray sources_ref,jint sourcesOffset,jintArray types_ref,jint typesOffset,jintArray ids_ref,jint idsOffset,jintArray severities_ref,jint severitiesOffset,jintArray lengths_ref,jint lengthsOffset,jbyteArray messageLog_ref,jint messageLogOffset)629 android_glGetDebugMessageLog__II_3II_3II_3II_3II_3II_3BI
630 (JNIEnv *_env, jobject _this, jint count, jint bufSize, jintArray sources_ref, jint sourcesOffset, jintArray types_ref, jint typesOffset, jintArray ids_ref, jint idsOffset, jintArray severities_ref, jint severitiesOffset, jintArray lengths_ref, jint lengthsOffset, jbyteArray messageLog_ref, jint messageLogOffset) {
631 jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
632 return 0;
633 }
634
635 /* GLuint glGetDebugMessageLog ( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) */
636 static uint
android_glGetDebugMessageLog__ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_ByteBuffer_2(JNIEnv * _env,jobject _this,jint count,jobject sources_ref,jobject types_ref,jobject ids_ref,jobject severities_ref,jobject lengths_ref,jobject messageLog_ref)637 android_glGetDebugMessageLog__ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_ByteBuffer_2
638 (JNIEnv *_env, jobject _this, jint count, jobject sources_ref, jobject types_ref, jobject ids_ref, jobject severities_ref, jobject lengths_ref, jobject messageLog_ref) {
639 jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
640 return 0;
641 }
642
643 /* GLuint glGetDebugMessageLog ( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) */
644 static jobjectArray
android_glGetDebugMessageLog__I_3II_3II_3II_3II(JNIEnv * _env,jobject _this,jint count,jintArray sources_ref,jint sourcesOffset,jintArray types_ref,jint typesOffset,jintArray ids_ref,jint idsOffset,jintArray severities_ref,jint severitiesOffset)645 android_glGetDebugMessageLog__I_3II_3II_3II_3II
646 (JNIEnv *_env, jobject _this, jint count, jintArray sources_ref, jint sourcesOffset, jintArray types_ref, jint typesOffset, jintArray ids_ref, jint idsOffset, jintArray severities_ref, jint severitiesOffset) {
647 jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
648 return 0;
649 }
650
651 /* GLuint glGetDebugMessageLog ( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) */
652 static jobjectArray
android_glGetDebugMessageLog__ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint count,jobject sources_ref,jobject types_ref,jobject ids_ref,jobject severities_ref)653 android_glGetDebugMessageLog__ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2
654 (JNIEnv *_env, jobject _this, jint count, jobject sources_ref, jobject types_ref, jobject ids_ref, jobject severities_ref) {
655 jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
656 return 0;
657 }
658 /* void glPushDebugGroup ( GLenum source, GLuint id, GLsizei length, const GLchar *message ) */
659 static void
android_glPushDebugGroup__IIILjava_lang_String_2(JNIEnv * _env,jobject _this,jint source,jint id,jint length,jstring message)660 android_glPushDebugGroup__IIILjava_lang_String_2
661 (JNIEnv *_env, jobject _this, jint source, jint id, jint length, jstring message) {
662 jint _exception = 0;
663 const char * _exceptionType = NULL;
664 const char * _exceptionMessage = NULL;
665 const char* _nativemessage = 0;
666 jsize _stringlen = 0;
667
668 if (!message) {
669 _exception = 1;
670 _exceptionType = "java/lang/IllegalArgumentException";
671 _exceptionMessage = "message == null";
672 goto exit;
673 }
674 _nativemessage = _env->GetStringUTFChars(message, 0);
675 _stringlen = _env->GetStringUTFLength(message);
676 if (length > _stringlen) {
677 _exception = 1;
678 _exceptionType = "java/lang/ArrayIndexOutOfBoundsException";
679 _exceptionMessage = "length of message is shorter than length argument";
680 goto exit;
681 }
682
683 glPushDebugGroup(
684 (GLenum)source,
685 (GLuint)id,
686 (GLsizei)length,
687 (GLchar *)_nativemessage
688 );
689
690 exit:
691 if (_nativemessage) {
692 _env->ReleaseStringUTFChars(message, _nativemessage);
693 }
694
695 if (_exception) {
696 jniThrowException(_env, _exceptionType, _exceptionMessage);
697 }
698 }
699
700 /* void glPopDebugGroup ( void ) */
701 static void
android_glPopDebugGroup__(JNIEnv * _env,jobject _this)702 android_glPopDebugGroup__
703 (JNIEnv *_env, jobject _this) {
704 glPopDebugGroup();
705 }
706
707 /* void glObjectLabel ( GLenum identifier, GLuint name, GLsizei length, const GLchar *label ) */
708 static void
android_glObjectLabel__IIILjava_lang_String_2(JNIEnv * _env,jobject _this,jint identifier,jint name,jint length,jstring label)709 android_glObjectLabel__IIILjava_lang_String_2
710 (JNIEnv *_env, jobject _this, jint identifier, jint name, jint length, jstring label) {
711 jint _exception = 0;
712 const char * _exceptionType = NULL;
713 const char * _exceptionMessage = NULL;
714 const char* _nativelabel = 0;
715 jsize _stringlen = 0;
716
717 if (label) {
718 _nativelabel = _env->GetStringUTFChars(label, 0);
719 _stringlen = _env->GetStringUTFLength(label);
720 if (length > _stringlen) {
721 _exception = 1;
722 _exceptionType = "java/lang/ArrayIndexOutOfBoundsException";
723 _exceptionMessage = "length of label is shorter than length argument";
724 goto exit;
725 }
726 }
727
728 glObjectLabel(
729 (GLenum)identifier,
730 (GLuint)name,
731 (GLsizei)length,
732 (GLchar *)_nativelabel
733 );
734
735 exit:
736 if (_nativelabel) {
737 _env->ReleaseStringUTFChars(label, _nativelabel);
738 }
739
740 if (_exception) {
741 jniThrowException(_env, _exceptionType, _exceptionMessage);
742 }
743 }
744
745 /* void glGetObjectLabel ( GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label ) */
746 static jstring
android_glGetObjectLabel(JNIEnv * _env,jobject _this,jint identifier,jint name)747 android_glGetObjectLabel(JNIEnv *_env, jobject _this, jint identifier, jint name) {
748 jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
749 return NULL;
750 }
751
752 /* void glObjectPtrLabel ( const void *ptr, GLsizei length, const GLchar *label ) */
753 static void
android_glObjectPtrLabel(JNIEnv * _env,jobject _this,jlong ptr,jstring label)754 android_glObjectPtrLabel(JNIEnv *_env, jobject _this, jlong ptr, jstring label) {
755 jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
756 }
757
758 /* void glGetObjectPtrLabel ( const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label ) */
759 static jstring
android_glGetObjectPtrLabel(JNIEnv * _env,jobject _this,jlong ptr)760 android_glGetObjectPtrLabel(JNIEnv *_env, jobject _this, jlong ptr) {
761 jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
762 return NULL;
763 }
764
765 /* void glGetPointerv ( GLenum pname, void **params ) */
766 static jlong
android_glGetPointerv(JNIEnv * _env,jobject _this,jint pname)767 android_glGetPointerv(JNIEnv *_env, jobject _this, jint pname) {
768 jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
769 return NULL;
770 }
771
772 /* void glEnablei ( GLenum target, GLuint index ) */
773 static void
android_glEnablei__II(JNIEnv * _env,jobject _this,jint target,jint index)774 android_glEnablei__II
775 (JNIEnv *_env, jobject _this, jint target, jint index) {
776 glEnablei(
777 (GLenum)target,
778 (GLuint)index
779 );
780 }
781
782 /* void glDisablei ( GLenum target, GLuint index ) */
783 static void
android_glDisablei__II(JNIEnv * _env,jobject _this,jint target,jint index)784 android_glDisablei__II
785 (JNIEnv *_env, jobject _this, jint target, jint index) {
786 glDisablei(
787 (GLenum)target,
788 (GLuint)index
789 );
790 }
791
792 /* void glBlendEquationi ( GLuint buf, GLenum mode ) */
793 static void
android_glBlendEquationi__II(JNIEnv * _env,jobject _this,jint buf,jint mode)794 android_glBlendEquationi__II
795 (JNIEnv *_env, jobject _this, jint buf, jint mode) {
796 glBlendEquationi(
797 (GLuint)buf,
798 (GLenum)mode
799 );
800 }
801
802 /* void glBlendEquationSeparatei ( GLuint buf, GLenum modeRGB, GLenum modeAlpha ) */
803 static void
android_glBlendEquationSeparatei__III(JNIEnv * _env,jobject _this,jint buf,jint modeRGB,jint modeAlpha)804 android_glBlendEquationSeparatei__III
805 (JNIEnv *_env, jobject _this, jint buf, jint modeRGB, jint modeAlpha) {
806 glBlendEquationSeparatei(
807 (GLuint)buf,
808 (GLenum)modeRGB,
809 (GLenum)modeAlpha
810 );
811 }
812
813 /* void glBlendFunci ( GLuint buf, GLenum src, GLenum dst ) */
814 static void
android_glBlendFunci__III(JNIEnv * _env,jobject _this,jint buf,jint src,jint dst)815 android_glBlendFunci__III
816 (JNIEnv *_env, jobject _this, jint buf, jint src, jint dst) {
817 glBlendFunci(
818 (GLuint)buf,
819 (GLenum)src,
820 (GLenum)dst
821 );
822 }
823
824 /* void glBlendFuncSeparatei ( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) */
825 static void
android_glBlendFuncSeparatei__IIIII(JNIEnv * _env,jobject _this,jint buf,jint srcRGB,jint dstRGB,jint srcAlpha,jint dstAlpha)826 android_glBlendFuncSeparatei__IIIII
827 (JNIEnv *_env, jobject _this, jint buf, jint srcRGB, jint dstRGB, jint srcAlpha, jint dstAlpha) {
828 glBlendFuncSeparatei(
829 (GLuint)buf,
830 (GLenum)srcRGB,
831 (GLenum)dstRGB,
832 (GLenum)srcAlpha,
833 (GLenum)dstAlpha
834 );
835 }
836
837 /* void glColorMaski ( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a ) */
838 static void
android_glColorMaski__IZZZZ(JNIEnv * _env,jobject _this,jint index,jboolean r,jboolean g,jboolean b,jboolean a)839 android_glColorMaski__IZZZZ
840 (JNIEnv *_env, jobject _this, jint index, jboolean r, jboolean g, jboolean b, jboolean a) {
841 glColorMaski(
842 (GLuint)index,
843 (GLboolean)r,
844 (GLboolean)g,
845 (GLboolean)b,
846 (GLboolean)a
847 );
848 }
849
850 /* GLboolean glIsEnabledi ( GLenum target, GLuint index ) */
851 static jboolean
android_glIsEnabledi__II(JNIEnv * _env,jobject _this,jint target,jint index)852 android_glIsEnabledi__II
853 (JNIEnv *_env, jobject _this, jint target, jint index) {
854 GLboolean _returnValue;
855 _returnValue = glIsEnabledi(
856 (GLenum)target,
857 (GLuint)index
858 );
859 return (jboolean)_returnValue;
860 }
861
862 /* void glDrawElementsBaseVertex ( GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex ) */
863 static void
android_glDrawElementsBaseVertex__IIILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint mode,jint count,jint type,jobject indices_buf,jint basevertex)864 android_glDrawElementsBaseVertex__IIILjava_nio_Buffer_2I
865 (JNIEnv *_env, jobject _this, jint mode, jint count, jint type, jobject indices_buf, jint basevertex) {
866 jint _exception = 0;
867 const char * _exceptionType = NULL;
868 const char * _exceptionMessage = NULL;
869 jarray _array = (jarray) 0;
870 jint _bufferOffset = (jint) 0;
871 jint _remaining;
872 void *indices = (void *) 0;
873
874 if (!indices_buf) {
875 _exception = 1;
876 _exceptionType = "java/lang/IllegalArgumentException";
877 _exceptionMessage = "indices == null";
878 goto exit;
879 }
880 indices = (void *)getPointer(_env, indices_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
881 if (_remaining < count-basevertex) {
882 _exception = 1;
883 _exceptionType = "java/lang/ArrayIndexOutOfBoundsException";
884 _exceptionMessage = "remaining() < count-basevertex < needed";
885 goto exit;
886 }
887 if (indices == NULL) {
888 char * _indicesBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
889 indices = (void *) (_indicesBase + _bufferOffset);
890 }
891 glDrawElementsBaseVertex(
892 (GLenum)mode,
893 (GLsizei)count,
894 (GLenum)type,
895 (void *)indices,
896 (GLint)basevertex
897 );
898
899 exit:
900 if (_array) {
901 releasePointer(_env, _array, indices, JNI_FALSE);
902 }
903 if (_exception) {
904 jniThrowException(_env, _exceptionType, _exceptionMessage);
905 }
906 }
907
908 /* void glDrawRangeElementsBaseVertex ( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex ) */
909 static void
android_glDrawRangeElementsBaseVertex__IIIIILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint mode,jint start,jint end,jint count,jint type,jobject indices_buf,jint basevertex)910 android_glDrawRangeElementsBaseVertex__IIIIILjava_nio_Buffer_2I
911 (JNIEnv *_env, jobject _this, jint mode, jint start, jint end, jint count, jint type, jobject indices_buf, jint basevertex) {
912 jint _exception = 0;
913 const char * _exceptionType = NULL;
914 const char * _exceptionMessage = NULL;
915 jarray _array = (jarray) 0;
916 jint _bufferOffset = (jint) 0;
917 jint _remaining;
918 void *indices = (void *) 0;
919
920 if (!indices_buf) {
921 _exception = 1;
922 _exceptionType = "java/lang/IllegalArgumentException";
923 _exceptionMessage = "indices == null";
924 goto exit;
925 }
926 indices = (void *)getPointer(_env, indices_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
927 if (_remaining < count-basevertex) {
928 _exception = 1;
929 _exceptionType = "java/lang/ArrayIndexOutOfBoundsException";
930 _exceptionMessage = "remaining() < count-basevertex < needed";
931 goto exit;
932 }
933 if (indices == NULL) {
934 char * _indicesBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
935 indices = (void *) (_indicesBase + _bufferOffset);
936 }
937 glDrawRangeElementsBaseVertex(
938 (GLenum)mode,
939 (GLuint)start,
940 (GLuint)end,
941 (GLsizei)count,
942 (GLenum)type,
943 (void *)indices,
944 (GLint)basevertex
945 );
946
947 exit:
948 if (_array) {
949 releasePointer(_env, _array, indices, JNI_FALSE);
950 }
951 if (_exception) {
952 jniThrowException(_env, _exceptionType, _exceptionMessage);
953 }
954 }
955
956 /* void glDrawElementsInstancedBaseVertex ( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instanceCount, GLint basevertex ) */
957 static void
android_glDrawElementsInstancedBaseVertex__IIILjava_nio_Buffer_2II(JNIEnv * _env,jobject _this,jint mode,jint count,jint type,jobject indices_buf,jint instanceCount,jint basevertex)958 android_glDrawElementsInstancedBaseVertex__IIILjava_nio_Buffer_2II
959 (JNIEnv *_env, jobject _this, jint mode, jint count, jint type, jobject indices_buf, jint instanceCount, jint basevertex) {
960 jint _exception = 0;
961 const char * _exceptionType = NULL;
962 const char * _exceptionMessage = NULL;
963 jarray _array = (jarray) 0;
964 jint _bufferOffset = (jint) 0;
965 jint _remaining;
966 void *indices = (void *) 0;
967
968 indices = (void *)getPointer(_env, indices_buf, &_array, &_remaining, &_bufferOffset);
969 if (_remaining < count-basevertex) {
970 _exception = 1;
971 _exceptionType = "java/lang/ArrayIndexOutOfBoundsException";
972 _exceptionMessage = "remaining() < count-basevertex < needed";
973 goto exit;
974 }
975 if (indices == NULL) {
976 char * _indicesBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
977 indices = (void *) (_indicesBase + _bufferOffset);
978 }
979 glDrawElementsInstancedBaseVertex(
980 (GLenum)mode,
981 (GLsizei)count,
982 (GLenum)type,
983 (void *)indices,
984 (GLsizei)instanceCount,
985 (GLint) basevertex
986 );
987
988 exit:
989 if (_array) {
990 releasePointer(_env, _array, indices, JNI_FALSE);
991 }
992 }
993
994 /* void glDrawElementsInstancedBaseVertex ( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instanceCount, GLint basevertex ) */
995 static void
android_glDrawElementsInstancedBaseVertex__IIIIII(JNIEnv * _env,jobject _this,jint mode,jint count,jint type,jint indicesOffset,jint instanceCount,jint basevertex)996 android_glDrawElementsInstancedBaseVertex__IIIIII
997 (JNIEnv *_env, jobject _this, jint mode, jint count, jint type, jint indicesOffset, jint instanceCount, jint basevertex) {
998 glDrawElementsInstancedBaseVertex(
999 (GLenum)mode,
1000 (GLsizei)count,
1001 (GLenum)type,
1002 (void *)static_cast<uintptr_t>(indicesOffset),
1003 (GLsizei)instanceCount,
1004 (GLint)basevertex
1005 );
1006 }
1007 /* void glFramebufferTexture ( GLenum target, GLenum attachment, GLuint texture, GLint level ) */
1008 static void
android_glFramebufferTexture__IIII(JNIEnv * _env,jobject _this,jint target,jint attachment,jint texture,jint level)1009 android_glFramebufferTexture__IIII
1010 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint texture, jint level) {
1011 glFramebufferTexture(
1012 (GLenum)target,
1013 (GLenum)attachment,
1014 (GLuint)texture,
1015 (GLint)level
1016 );
1017 }
1018
1019 /* void glPrimitiveBoundingBox ( GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW ) */
1020 static void
android_glPrimitiveBoundingBox__FFFFFFFF(JNIEnv * _env,jobject _this,jfloat minX,jfloat minY,jfloat minZ,jfloat minW,jfloat maxX,jfloat maxY,jfloat maxZ,jfloat maxW)1021 android_glPrimitiveBoundingBox__FFFFFFFF
1022 (JNIEnv *_env, jobject _this, jfloat minX, jfloat minY, jfloat minZ, jfloat minW, jfloat maxX, jfloat maxY, jfloat maxZ, jfloat maxW) {
1023 glPrimitiveBoundingBox(
1024 (GLfloat)minX,
1025 (GLfloat)minY,
1026 (GLfloat)minZ,
1027 (GLfloat)minW,
1028 (GLfloat)maxX,
1029 (GLfloat)maxY,
1030 (GLfloat)maxZ,
1031 (GLfloat)maxW
1032 );
1033 }
1034
1035 /* GLenum glGetGraphicsResetStatus ( void ) */
1036 static jint
android_glGetGraphicsResetStatus__(JNIEnv * _env,jobject _this)1037 android_glGetGraphicsResetStatus__
1038 (JNIEnv *_env, jobject _this) {
1039 GLenum _returnValue;
1040 _returnValue = glGetGraphicsResetStatus();
1041 return (jint)_returnValue;
1042 }
1043
1044 /* void glReadnPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data ) */
1045 static void
android_glReadnPixels__IIIIIIILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint x,jint y,jint width,jint height,jint format,jint type,jint bufSize,jobject data_buf)1046 android_glReadnPixels__IIIIIIILjava_nio_Buffer_2
1047 (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height, jint format, jint type, jint bufSize, jobject data_buf) {
1048 jint _exception = 0;
1049 const char * _exceptionType = NULL;
1050 const char * _exceptionMessage = NULL;
1051 jarray _array = (jarray) 0;
1052 jint _bufferOffset = (jint) 0;
1053 jint _remaining;
1054 void *data = (void *) 0;
1055
1056 if (!data_buf) {
1057 _exception = 1;
1058 _exceptionType = "java/lang/IllegalArgumentException";
1059 _exceptionMessage = "data == null";
1060 goto exit;
1061 }
1062 data = (void *)getPointer(_env, data_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1063 if (_remaining < bufSize) {
1064 _exception = 1;
1065 _exceptionType = "java/lang/IllegalArgumentException";
1066 _exceptionMessage = "remaining() < bufSize < needed";
1067 goto exit;
1068 }
1069 if (data == NULL) {
1070 char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1071 data = (void *) (_dataBase + _bufferOffset);
1072 }
1073 glReadnPixels(
1074 (GLint)x,
1075 (GLint)y,
1076 (GLsizei)width,
1077 (GLsizei)height,
1078 (GLenum)format,
1079 (GLenum)type,
1080 (GLsizei)bufSize,
1081 (void *)data
1082 );
1083
1084 exit:
1085 if (_array) {
1086 releasePointer(_env, _array, data, _exception ? JNI_FALSE : JNI_TRUE);
1087 }
1088 if (_exception) {
1089 jniThrowException(_env, _exceptionType, _exceptionMessage);
1090 }
1091 }
1092
1093 /* void glGetnUniformfv ( GLuint program, GLint location, GLsizei bufSize, GLfloat *params ) */
1094 static void
android_glGetnUniformfv__III_3FI(JNIEnv * _env,jobject _this,jint program,jint location,jint bufSize,jfloatArray params_ref,jint offset)1095 android_glGetnUniformfv__III_3FI
1096 (JNIEnv *_env, jobject _this, jint program, jint location, jint bufSize, jfloatArray params_ref, jint offset) {
1097 jint _exception = 0;
1098 const char * _exceptionType = NULL;
1099 const char * _exceptionMessage = NULL;
1100 GLfloat *params_base = (GLfloat *) 0;
1101 jint _remaining;
1102 GLfloat *params = (GLfloat *) 0;
1103
1104 if (!params_ref) {
1105 _exception = 1;
1106 _exceptionType = "java/lang/IllegalArgumentException";
1107 _exceptionMessage = "params == null";
1108 goto exit;
1109 }
1110 if (offset < 0) {
1111 _exception = 1;
1112 _exceptionType = "java/lang/IllegalArgumentException";
1113 _exceptionMessage = "offset < 0";
1114 goto exit;
1115 }
1116 _remaining = _env->GetArrayLength(params_ref) - offset;
1117 if (_remaining < bufSize) {
1118 _exception = 1;
1119 _exceptionType = "java/lang/IllegalArgumentException";
1120 _exceptionMessage = "length - offset < bufSize < needed";
1121 goto exit;
1122 }
1123 params_base = (GLfloat *)
1124 _env->GetFloatArrayElements(params_ref, (jboolean *)0);
1125 params = params_base + offset;
1126
1127 glGetnUniformfv(
1128 (GLuint)program,
1129 (GLint)location,
1130 (GLsizei)bufSize,
1131 (GLfloat *)params
1132 );
1133
1134 exit:
1135 if (params_base) {
1136 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
1137 _exception ? JNI_ABORT: 0);
1138 }
1139 if (_exception) {
1140 jniThrowException(_env, _exceptionType, _exceptionMessage);
1141 }
1142 }
1143
1144 /* void glGetnUniformfv ( GLuint program, GLint location, GLsizei bufSize, GLfloat *params ) */
1145 static void
android_glGetnUniformfv__IIILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint program,jint location,jint bufSize,jobject params_buf)1146 android_glGetnUniformfv__IIILjava_nio_FloatBuffer_2
1147 (JNIEnv *_env, jobject _this, jint program, jint location, jint bufSize, jobject params_buf) {
1148 jint _exception = 0;
1149 const char * _exceptionType = NULL;
1150 const char * _exceptionMessage = NULL;
1151 jfloatArray _array = (jfloatArray) 0;
1152 jint _bufferOffset = (jint) 0;
1153 jint _remaining;
1154 GLfloat *params = (GLfloat *) 0;
1155
1156 if (!params_buf) {
1157 _exception = 1;
1158 _exceptionType = "java/lang/IllegalArgumentException";
1159 _exceptionMessage = "params == null";
1160 goto exit;
1161 }
1162 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1163 if (_remaining < bufSize) {
1164 _exception = 1;
1165 _exceptionType = "java/lang/IllegalArgumentException";
1166 _exceptionMessage = "remaining() < bufSize < needed";
1167 goto exit;
1168 }
1169 if (params == NULL) {
1170 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
1171 params = (GLfloat *) (_paramsBase + _bufferOffset);
1172 }
1173 glGetnUniformfv(
1174 (GLuint)program,
1175 (GLint)location,
1176 (GLsizei)bufSize,
1177 (GLfloat *)params
1178 );
1179
1180 exit:
1181 if (_array) {
1182 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0);
1183 }
1184 if (_exception) {
1185 jniThrowException(_env, _exceptionType, _exceptionMessage);
1186 }
1187 }
1188
1189 /* void glGetnUniformiv ( GLuint program, GLint location, GLsizei bufSize, GLint *params ) */
1190 static void
android_glGetnUniformiv__III_3II(JNIEnv * _env,jobject _this,jint program,jint location,jint bufSize,jintArray params_ref,jint offset)1191 android_glGetnUniformiv__III_3II
1192 (JNIEnv *_env, jobject _this, jint program, jint location, jint bufSize, jintArray params_ref, jint offset) {
1193 jint _exception = 0;
1194 const char * _exceptionType = NULL;
1195 const char * _exceptionMessage = NULL;
1196 GLint *params_base = (GLint *) 0;
1197 jint _remaining;
1198 GLint *params = (GLint *) 0;
1199
1200 if (!params_ref) {
1201 _exception = 1;
1202 _exceptionType = "java/lang/IllegalArgumentException";
1203 _exceptionMessage = "params == null";
1204 goto exit;
1205 }
1206 if (offset < 0) {
1207 _exception = 1;
1208 _exceptionType = "java/lang/IllegalArgumentException";
1209 _exceptionMessage = "offset < 0";
1210 goto exit;
1211 }
1212 _remaining = _env->GetArrayLength(params_ref) - offset;
1213 if (_remaining < bufSize) {
1214 _exception = 1;
1215 _exceptionType = "java/lang/IllegalArgumentException";
1216 _exceptionMessage = "length - offset < bufSize < needed";
1217 goto exit;
1218 }
1219 params_base = (GLint *)
1220 _env->GetIntArrayElements(params_ref, (jboolean *)0);
1221 params = params_base + offset;
1222
1223 glGetnUniformiv(
1224 (GLuint)program,
1225 (GLint)location,
1226 (GLsizei)bufSize,
1227 (GLint *)params
1228 );
1229
1230 exit:
1231 if (params_base) {
1232 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
1233 _exception ? JNI_ABORT: 0);
1234 }
1235 if (_exception) {
1236 jniThrowException(_env, _exceptionType, _exceptionMessage);
1237 }
1238 }
1239
1240 /* void glGetnUniformiv ( GLuint program, GLint location, GLsizei bufSize, GLint *params ) */
1241 static void
android_glGetnUniformiv__IIILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint program,jint location,jint bufSize,jobject params_buf)1242 android_glGetnUniformiv__IIILjava_nio_IntBuffer_2
1243 (JNIEnv *_env, jobject _this, jint program, jint location, jint bufSize, jobject params_buf) {
1244 jint _exception = 0;
1245 const char * _exceptionType = NULL;
1246 const char * _exceptionMessage = NULL;
1247 jintArray _array = (jintArray) 0;
1248 jint _bufferOffset = (jint) 0;
1249 jint _remaining;
1250 GLint *params = (GLint *) 0;
1251
1252 if (!params_buf) {
1253 _exception = 1;
1254 _exceptionType = "java/lang/IllegalArgumentException";
1255 _exceptionMessage = "params == null";
1256 goto exit;
1257 }
1258 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1259 if (_remaining < bufSize) {
1260 _exception = 1;
1261 _exceptionType = "java/lang/IllegalArgumentException";
1262 _exceptionMessage = "remaining() < bufSize < needed";
1263 goto exit;
1264 }
1265 if (params == NULL) {
1266 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1267 params = (GLint *) (_paramsBase + _bufferOffset);
1268 }
1269 glGetnUniformiv(
1270 (GLuint)program,
1271 (GLint)location,
1272 (GLsizei)bufSize,
1273 (GLint *)params
1274 );
1275
1276 exit:
1277 if (_array) {
1278 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
1279 }
1280 if (_exception) {
1281 jniThrowException(_env, _exceptionType, _exceptionMessage);
1282 }
1283 }
1284
1285 /* void glGetnUniformuiv ( GLuint program, GLint location, GLsizei bufSize, GLuint *params ) */
1286 static void
android_glGetnUniformuiv__III_3II(JNIEnv * _env,jobject _this,jint program,jint location,jint bufSize,jintArray params_ref,jint offset)1287 android_glGetnUniformuiv__III_3II
1288 (JNIEnv *_env, jobject _this, jint program, jint location, jint bufSize, jintArray params_ref, jint offset) {
1289 jint _exception = 0;
1290 const char * _exceptionType = NULL;
1291 const char * _exceptionMessage = NULL;
1292 GLuint *params_base = (GLuint *) 0;
1293 jint _remaining;
1294 GLuint *params = (GLuint *) 0;
1295
1296 if (!params_ref) {
1297 _exception = 1;
1298 _exceptionType = "java/lang/IllegalArgumentException";
1299 _exceptionMessage = "params == null";
1300 goto exit;
1301 }
1302 if (offset < 0) {
1303 _exception = 1;
1304 _exceptionType = "java/lang/IllegalArgumentException";
1305 _exceptionMessage = "offset < 0";
1306 goto exit;
1307 }
1308 _remaining = _env->GetArrayLength(params_ref) - offset;
1309 if (_remaining < bufSize) {
1310 _exception = 1;
1311 _exceptionType = "java/lang/IllegalArgumentException";
1312 _exceptionMessage = "length - offset < bufSize < needed";
1313 goto exit;
1314 }
1315 params_base = (GLuint *)
1316 _env->GetIntArrayElements(params_ref, (jboolean *)0);
1317 params = params_base + offset;
1318
1319 glGetnUniformuiv(
1320 (GLuint)program,
1321 (GLint)location,
1322 (GLsizei)bufSize,
1323 (GLuint *)params
1324 );
1325
1326 exit:
1327 if (params_base) {
1328 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
1329 _exception ? JNI_ABORT: 0);
1330 }
1331 if (_exception) {
1332 jniThrowException(_env, _exceptionType, _exceptionMessage);
1333 }
1334 }
1335
1336 /* void glGetnUniformuiv ( GLuint program, GLint location, GLsizei bufSize, GLuint *params ) */
1337 static void
android_glGetnUniformuiv__IIILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint program,jint location,jint bufSize,jobject params_buf)1338 android_glGetnUniformuiv__IIILjava_nio_IntBuffer_2
1339 (JNIEnv *_env, jobject _this, jint program, jint location, jint bufSize, jobject params_buf) {
1340 jint _exception = 0;
1341 const char * _exceptionType = NULL;
1342 const char * _exceptionMessage = NULL;
1343 jintArray _array = (jintArray) 0;
1344 jint _bufferOffset = (jint) 0;
1345 jint _remaining;
1346 GLuint *params = (GLuint *) 0;
1347
1348 if (!params_buf) {
1349 _exception = 1;
1350 _exceptionType = "java/lang/IllegalArgumentException";
1351 _exceptionMessage = "params == null";
1352 goto exit;
1353 }
1354 params = (GLuint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1355 if (_remaining < bufSize) {
1356 _exception = 1;
1357 _exceptionType = "java/lang/IllegalArgumentException";
1358 _exceptionMessage = "remaining() < bufSize < needed";
1359 goto exit;
1360 }
1361 if (params == NULL) {
1362 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1363 params = (GLuint *) (_paramsBase + _bufferOffset);
1364 }
1365 glGetnUniformuiv(
1366 (GLuint)program,
1367 (GLint)location,
1368 (GLsizei)bufSize,
1369 (GLuint *)params
1370 );
1371
1372 exit:
1373 if (_array) {
1374 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
1375 }
1376 if (_exception) {
1377 jniThrowException(_env, _exceptionType, _exceptionMessage);
1378 }
1379 }
1380
1381 /* void glMinSampleShading ( GLfloat value ) */
1382 static void
android_glMinSampleShading__F(JNIEnv * _env,jobject _this,jfloat value)1383 android_glMinSampleShading__F
1384 (JNIEnv *_env, jobject _this, jfloat value) {
1385 glMinSampleShading(
1386 (GLfloat)value
1387 );
1388 }
1389
1390 /* void glPatchParameteri ( GLenum pname, GLint value ) */
1391 static void
android_glPatchParameteri__II(JNIEnv * _env,jobject _this,jint pname,jint value)1392 android_glPatchParameteri__II
1393 (JNIEnv *_env, jobject _this, jint pname, jint value) {
1394 glPatchParameteri(
1395 (GLenum)pname,
1396 (GLint)value
1397 );
1398 }
1399
1400 /* void glTexParameterIiv ( GLenum target, GLenum pname, const GLint *params ) */
1401 static void
android_glTexParameterIiv__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)1402 android_glTexParameterIiv__II_3II
1403 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
1404 jint _exception = 0;
1405 const char * _exceptionType = NULL;
1406 const char * _exceptionMessage = NULL;
1407 GLint *params_base = (GLint *) 0;
1408 jint _remaining;
1409 GLint *params = (GLint *) 0;
1410
1411 if (!params_ref) {
1412 _exception = 1;
1413 _exceptionType = "java/lang/IllegalArgumentException";
1414 _exceptionMessage = "params == null";
1415 goto exit;
1416 }
1417 if (offset < 0) {
1418 _exception = 1;
1419 _exceptionType = "java/lang/IllegalArgumentException";
1420 _exceptionMessage = "offset < 0";
1421 goto exit;
1422 }
1423 _remaining = _env->GetArrayLength(params_ref) - offset;
1424 params_base = (GLint *)
1425 _env->GetIntArrayElements(params_ref, (jboolean *)0);
1426 params = params_base + offset;
1427
1428 glTexParameterIiv(
1429 (GLenum)target,
1430 (GLenum)pname,
1431 (GLint *)params
1432 );
1433
1434 exit:
1435 if (params_base) {
1436 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
1437 JNI_ABORT);
1438 }
1439 if (_exception) {
1440 jniThrowException(_env, _exceptionType, _exceptionMessage);
1441 }
1442 }
1443
1444 /* void glTexParameterIiv ( GLenum target, GLenum pname, const GLint *params ) */
1445 static void
android_glTexParameterIiv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)1446 android_glTexParameterIiv__IILjava_nio_IntBuffer_2
1447 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
1448 jint _exception = 0;
1449 const char * _exceptionType = NULL;
1450 const char * _exceptionMessage = NULL;
1451 jintArray _array = (jintArray) 0;
1452 jint _bufferOffset = (jint) 0;
1453 jint _remaining;
1454 GLint *params = (GLint *) 0;
1455
1456 if (!params_buf) {
1457 _exception = 1;
1458 _exceptionType = "java/lang/IllegalArgumentException";
1459 _exceptionMessage = "params == null";
1460 goto exit;
1461 }
1462 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1463 if (params == NULL) {
1464 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1465 params = (GLint *) (_paramsBase + _bufferOffset);
1466 }
1467 glTexParameterIiv(
1468 (GLenum)target,
1469 (GLenum)pname,
1470 (GLint *)params
1471 );
1472
1473 exit:
1474 if (_array) {
1475 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT);
1476 }
1477 if (_exception) {
1478 jniThrowException(_env, _exceptionType, _exceptionMessage);
1479 }
1480 }
1481
1482 /* void glTexParameterIuiv ( GLenum target, GLenum pname, const GLuint *params ) */
1483 static void
android_glTexParameterIuiv__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)1484 android_glTexParameterIuiv__II_3II
1485 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
1486 jint _exception = 0;
1487 const char * _exceptionType = NULL;
1488 const char * _exceptionMessage = NULL;
1489 GLuint *params_base = (GLuint *) 0;
1490 jint _remaining;
1491 GLuint *params = (GLuint *) 0;
1492
1493 if (!params_ref) {
1494 _exception = 1;
1495 _exceptionType = "java/lang/IllegalArgumentException";
1496 _exceptionMessage = "params == null";
1497 goto exit;
1498 }
1499 if (offset < 0) {
1500 _exception = 1;
1501 _exceptionType = "java/lang/IllegalArgumentException";
1502 _exceptionMessage = "offset < 0";
1503 goto exit;
1504 }
1505 _remaining = _env->GetArrayLength(params_ref) - offset;
1506 params_base = (GLuint *)
1507 _env->GetIntArrayElements(params_ref, (jboolean *)0);
1508 params = params_base + offset;
1509
1510 glTexParameterIuiv(
1511 (GLenum)target,
1512 (GLenum)pname,
1513 (GLuint *)params
1514 );
1515
1516 exit:
1517 if (params_base) {
1518 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
1519 JNI_ABORT);
1520 }
1521 if (_exception) {
1522 jniThrowException(_env, _exceptionType, _exceptionMessage);
1523 }
1524 }
1525
1526 /* void glTexParameterIuiv ( GLenum target, GLenum pname, const GLuint *params ) */
1527 static void
android_glTexParameterIuiv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)1528 android_glTexParameterIuiv__IILjava_nio_IntBuffer_2
1529 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
1530 jint _exception = 0;
1531 const char * _exceptionType = NULL;
1532 const char * _exceptionMessage = NULL;
1533 jintArray _array = (jintArray) 0;
1534 jint _bufferOffset = (jint) 0;
1535 jint _remaining;
1536 GLuint *params = (GLuint *) 0;
1537
1538 if (!params_buf) {
1539 _exception = 1;
1540 _exceptionType = "java/lang/IllegalArgumentException";
1541 _exceptionMessage = "params == null";
1542 goto exit;
1543 }
1544 params = (GLuint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1545 if (params == NULL) {
1546 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1547 params = (GLuint *) (_paramsBase + _bufferOffset);
1548 }
1549 glTexParameterIuiv(
1550 (GLenum)target,
1551 (GLenum)pname,
1552 (GLuint *)params
1553 );
1554
1555 exit:
1556 if (_array) {
1557 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT);
1558 }
1559 if (_exception) {
1560 jniThrowException(_env, _exceptionType, _exceptionMessage);
1561 }
1562 }
1563
1564 /* void glGetTexParameterIiv ( GLenum target, GLenum pname, GLint *params ) */
1565 static void
android_glGetTexParameterIiv__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)1566 android_glGetTexParameterIiv__II_3II
1567 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
1568 jint _exception = 0;
1569 const char * _exceptionType = NULL;
1570 const char * _exceptionMessage = NULL;
1571 GLint *params_base = (GLint *) 0;
1572 jint _remaining;
1573 GLint *params = (GLint *) 0;
1574
1575 if (!params_ref) {
1576 _exception = 1;
1577 _exceptionType = "java/lang/IllegalArgumentException";
1578 _exceptionMessage = "params == null";
1579 goto exit;
1580 }
1581 if (offset < 0) {
1582 _exception = 1;
1583 _exceptionType = "java/lang/IllegalArgumentException";
1584 _exceptionMessage = "offset < 0";
1585 goto exit;
1586 }
1587 _remaining = _env->GetArrayLength(params_ref) - offset;
1588 params_base = (GLint *)
1589 _env->GetIntArrayElements(params_ref, (jboolean *)0);
1590 params = params_base + offset;
1591
1592 glGetTexParameterIiv(
1593 (GLenum)target,
1594 (GLenum)pname,
1595 (GLint *)params
1596 );
1597
1598 exit:
1599 if (params_base) {
1600 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
1601 _exception ? JNI_ABORT: 0);
1602 }
1603 if (_exception) {
1604 jniThrowException(_env, _exceptionType, _exceptionMessage);
1605 }
1606 }
1607
1608 /* void glGetTexParameterIiv ( GLenum target, GLenum pname, GLint *params ) */
1609 static void
android_glGetTexParameterIiv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)1610 android_glGetTexParameterIiv__IILjava_nio_IntBuffer_2
1611 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
1612 jint _exception = 0;
1613 const char * _exceptionType = NULL;
1614 const char * _exceptionMessage = NULL;
1615 jintArray _array = (jintArray) 0;
1616 jint _bufferOffset = (jint) 0;
1617 jint _remaining;
1618 GLint *params = (GLint *) 0;
1619
1620 if (!params_buf) {
1621 _exception = 1;
1622 _exceptionType = "java/lang/IllegalArgumentException";
1623 _exceptionMessage = "params == null";
1624 goto exit;
1625 }
1626 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1627 if (params == NULL) {
1628 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1629 params = (GLint *) (_paramsBase + _bufferOffset);
1630 }
1631 glGetTexParameterIiv(
1632 (GLenum)target,
1633 (GLenum)pname,
1634 (GLint *)params
1635 );
1636
1637 exit:
1638 if (_array) {
1639 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
1640 }
1641 if (_exception) {
1642 jniThrowException(_env, _exceptionType, _exceptionMessage);
1643 }
1644 }
1645
1646 /* void glGetTexParameterIuiv ( GLenum target, GLenum pname, GLuint *params ) */
1647 static void
android_glGetTexParameterIuiv__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)1648 android_glGetTexParameterIuiv__II_3II
1649 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
1650 jint _exception = 0;
1651 const char * _exceptionType = NULL;
1652 const char * _exceptionMessage = NULL;
1653 GLuint *params_base = (GLuint *) 0;
1654 jint _remaining;
1655 GLuint *params = (GLuint *) 0;
1656
1657 if (!params_ref) {
1658 _exception = 1;
1659 _exceptionType = "java/lang/IllegalArgumentException";
1660 _exceptionMessage = "params == null";
1661 goto exit;
1662 }
1663 if (offset < 0) {
1664 _exception = 1;
1665 _exceptionType = "java/lang/IllegalArgumentException";
1666 _exceptionMessage = "offset < 0";
1667 goto exit;
1668 }
1669 _remaining = _env->GetArrayLength(params_ref) - offset;
1670 params_base = (GLuint *)
1671 _env->GetIntArrayElements(params_ref, (jboolean *)0);
1672 params = params_base + offset;
1673
1674 glGetTexParameterIuiv(
1675 (GLenum)target,
1676 (GLenum)pname,
1677 (GLuint *)params
1678 );
1679
1680 exit:
1681 if (params_base) {
1682 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
1683 _exception ? JNI_ABORT: 0);
1684 }
1685 if (_exception) {
1686 jniThrowException(_env, _exceptionType, _exceptionMessage);
1687 }
1688 }
1689
1690 /* void glGetTexParameterIuiv ( GLenum target, GLenum pname, GLuint *params ) */
1691 static void
android_glGetTexParameterIuiv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)1692 android_glGetTexParameterIuiv__IILjava_nio_IntBuffer_2
1693 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
1694 jint _exception = 0;
1695 const char * _exceptionType = NULL;
1696 const char * _exceptionMessage = NULL;
1697 jintArray _array = (jintArray) 0;
1698 jint _bufferOffset = (jint) 0;
1699 jint _remaining;
1700 GLuint *params = (GLuint *) 0;
1701
1702 if (!params_buf) {
1703 _exception = 1;
1704 _exceptionType = "java/lang/IllegalArgumentException";
1705 _exceptionMessage = "params == null";
1706 goto exit;
1707 }
1708 params = (GLuint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1709 if (params == NULL) {
1710 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1711 params = (GLuint *) (_paramsBase + _bufferOffset);
1712 }
1713 glGetTexParameterIuiv(
1714 (GLenum)target,
1715 (GLenum)pname,
1716 (GLuint *)params
1717 );
1718
1719 exit:
1720 if (_array) {
1721 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
1722 }
1723 if (_exception) {
1724 jniThrowException(_env, _exceptionType, _exceptionMessage);
1725 }
1726 }
1727
1728 /* void glSamplerParameterIiv ( GLuint sampler, GLenum pname, const GLint *param ) */
1729 static void
android_glSamplerParameterIiv__II_3II(JNIEnv * _env,jobject _this,jint sampler,jint pname,jintArray param_ref,jint offset)1730 android_glSamplerParameterIiv__II_3II
1731 (JNIEnv *_env, jobject _this, jint sampler, jint pname, jintArray param_ref, jint offset) {
1732 jint _exception = 0;
1733 const char * _exceptionType = NULL;
1734 const char * _exceptionMessage = NULL;
1735 GLint *param_base = (GLint *) 0;
1736 jint _remaining;
1737 GLint *param = (GLint *) 0;
1738
1739 if (!param_ref) {
1740 _exception = 1;
1741 _exceptionType = "java/lang/IllegalArgumentException";
1742 _exceptionMessage = "param == null";
1743 goto exit;
1744 }
1745 if (offset < 0) {
1746 _exception = 1;
1747 _exceptionType = "java/lang/IllegalArgumentException";
1748 _exceptionMessage = "offset < 0";
1749 goto exit;
1750 }
1751 _remaining = _env->GetArrayLength(param_ref) - offset;
1752 param_base = (GLint *)
1753 _env->GetIntArrayElements(param_ref, (jboolean *)0);
1754 param = param_base + offset;
1755
1756 glSamplerParameterIiv(
1757 (GLuint)sampler,
1758 (GLenum)pname,
1759 (GLint *)param
1760 );
1761
1762 exit:
1763 if (param_base) {
1764 _env->ReleaseIntArrayElements(param_ref, (jint*)param_base,
1765 JNI_ABORT);
1766 }
1767 if (_exception) {
1768 jniThrowException(_env, _exceptionType, _exceptionMessage);
1769 }
1770 }
1771
1772 /* void glSamplerParameterIiv ( GLuint sampler, GLenum pname, const GLint *param ) */
1773 static void
android_glSamplerParameterIiv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint sampler,jint pname,jobject param_buf)1774 android_glSamplerParameterIiv__IILjava_nio_IntBuffer_2
1775 (JNIEnv *_env, jobject _this, jint sampler, jint pname, jobject param_buf) {
1776 jint _exception = 0;
1777 const char * _exceptionType = NULL;
1778 const char * _exceptionMessage = NULL;
1779 jintArray _array = (jintArray) 0;
1780 jint _bufferOffset = (jint) 0;
1781 jint _remaining;
1782 GLint *param = (GLint *) 0;
1783
1784 if (!param_buf) {
1785 _exception = 1;
1786 _exceptionType = "java/lang/IllegalArgumentException";
1787 _exceptionMessage = "param == null";
1788 goto exit;
1789 }
1790 param = (GLint *)getPointer(_env, param_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1791 if (param == NULL) {
1792 char * _paramBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1793 param = (GLint *) (_paramBase + _bufferOffset);
1794 }
1795 glSamplerParameterIiv(
1796 (GLuint)sampler,
1797 (GLenum)pname,
1798 (GLint *)param
1799 );
1800
1801 exit:
1802 if (_array) {
1803 _env->ReleaseIntArrayElements(_array, (jint*)param, JNI_ABORT);
1804 }
1805 if (_exception) {
1806 jniThrowException(_env, _exceptionType, _exceptionMessage);
1807 }
1808 }
1809
1810 /* void glSamplerParameterIuiv ( GLuint sampler, GLenum pname, const GLuint *param ) */
1811 static void
android_glSamplerParameterIuiv__II_3II(JNIEnv * _env,jobject _this,jint sampler,jint pname,jintArray param_ref,jint offset)1812 android_glSamplerParameterIuiv__II_3II
1813 (JNIEnv *_env, jobject _this, jint sampler, jint pname, jintArray param_ref, jint offset) {
1814 jint _exception = 0;
1815 const char * _exceptionType = NULL;
1816 const char * _exceptionMessage = NULL;
1817 GLuint *param_base = (GLuint *) 0;
1818 jint _remaining;
1819 GLuint *param = (GLuint *) 0;
1820
1821 if (!param_ref) {
1822 _exception = 1;
1823 _exceptionType = "java/lang/IllegalArgumentException";
1824 _exceptionMessage = "param == null";
1825 goto exit;
1826 }
1827 if (offset < 0) {
1828 _exception = 1;
1829 _exceptionType = "java/lang/IllegalArgumentException";
1830 _exceptionMessage = "offset < 0";
1831 goto exit;
1832 }
1833 _remaining = _env->GetArrayLength(param_ref) - offset;
1834 param_base = (GLuint *)
1835 _env->GetIntArrayElements(param_ref, (jboolean *)0);
1836 param = param_base + offset;
1837
1838 glSamplerParameterIuiv(
1839 (GLuint)sampler,
1840 (GLenum)pname,
1841 (GLuint *)param
1842 );
1843
1844 exit:
1845 if (param_base) {
1846 _env->ReleaseIntArrayElements(param_ref, (jint*)param_base,
1847 JNI_ABORT);
1848 }
1849 if (_exception) {
1850 jniThrowException(_env, _exceptionType, _exceptionMessage);
1851 }
1852 }
1853
1854 /* void glSamplerParameterIuiv ( GLuint sampler, GLenum pname, const GLuint *param ) */
1855 static void
android_glSamplerParameterIuiv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint sampler,jint pname,jobject param_buf)1856 android_glSamplerParameterIuiv__IILjava_nio_IntBuffer_2
1857 (JNIEnv *_env, jobject _this, jint sampler, jint pname, jobject param_buf) {
1858 jint _exception = 0;
1859 const char * _exceptionType = NULL;
1860 const char * _exceptionMessage = NULL;
1861 jintArray _array = (jintArray) 0;
1862 jint _bufferOffset = (jint) 0;
1863 jint _remaining;
1864 GLuint *param = (GLuint *) 0;
1865
1866 if (!param_buf) {
1867 _exception = 1;
1868 _exceptionType = "java/lang/IllegalArgumentException";
1869 _exceptionMessage = "param == null";
1870 goto exit;
1871 }
1872 param = (GLuint *)getPointer(_env, param_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1873 if (param == NULL) {
1874 char * _paramBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1875 param = (GLuint *) (_paramBase + _bufferOffset);
1876 }
1877 glSamplerParameterIuiv(
1878 (GLuint)sampler,
1879 (GLenum)pname,
1880 (GLuint *)param
1881 );
1882
1883 exit:
1884 if (_array) {
1885 _env->ReleaseIntArrayElements(_array, (jint*)param, JNI_ABORT);
1886 }
1887 if (_exception) {
1888 jniThrowException(_env, _exceptionType, _exceptionMessage);
1889 }
1890 }
1891
1892 /* void glGetSamplerParameterIiv ( GLuint sampler, GLenum pname, GLint *params ) */
1893 static void
android_glGetSamplerParameterIiv__II_3II(JNIEnv * _env,jobject _this,jint sampler,jint pname,jintArray params_ref,jint offset)1894 android_glGetSamplerParameterIiv__II_3II
1895 (JNIEnv *_env, jobject _this, jint sampler, jint pname, jintArray params_ref, jint offset) {
1896 jint _exception = 0;
1897 const char * _exceptionType = NULL;
1898 const char * _exceptionMessage = NULL;
1899 GLint *params_base = (GLint *) 0;
1900 jint _remaining;
1901 GLint *params = (GLint *) 0;
1902
1903 if (!params_ref) {
1904 _exception = 1;
1905 _exceptionType = "java/lang/IllegalArgumentException";
1906 _exceptionMessage = "params == null";
1907 goto exit;
1908 }
1909 if (offset < 0) {
1910 _exception = 1;
1911 _exceptionType = "java/lang/IllegalArgumentException";
1912 _exceptionMessage = "offset < 0";
1913 goto exit;
1914 }
1915 _remaining = _env->GetArrayLength(params_ref) - offset;
1916 params_base = (GLint *)
1917 _env->GetIntArrayElements(params_ref, (jboolean *)0);
1918 params = params_base + offset;
1919
1920 glGetSamplerParameterIiv(
1921 (GLuint)sampler,
1922 (GLenum)pname,
1923 (GLint *)params
1924 );
1925
1926 exit:
1927 if (params_base) {
1928 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
1929 _exception ? JNI_ABORT: 0);
1930 }
1931 if (_exception) {
1932 jniThrowException(_env, _exceptionType, _exceptionMessage);
1933 }
1934 }
1935
1936 /* void glGetSamplerParameterIiv ( GLuint sampler, GLenum pname, GLint *params ) */
1937 static void
android_glGetSamplerParameterIiv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint sampler,jint pname,jobject params_buf)1938 android_glGetSamplerParameterIiv__IILjava_nio_IntBuffer_2
1939 (JNIEnv *_env, jobject _this, jint sampler, jint pname, jobject params_buf) {
1940 jint _exception = 0;
1941 const char * _exceptionType = NULL;
1942 const char * _exceptionMessage = NULL;
1943 jintArray _array = (jintArray) 0;
1944 jint _bufferOffset = (jint) 0;
1945 jint _remaining;
1946 GLint *params = (GLint *) 0;
1947
1948 if (!params_buf) {
1949 _exception = 1;
1950 _exceptionType = "java/lang/IllegalArgumentException";
1951 _exceptionMessage = "params == null";
1952 goto exit;
1953 }
1954 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1955 if (params == NULL) {
1956 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1957 params = (GLint *) (_paramsBase + _bufferOffset);
1958 }
1959 glGetSamplerParameterIiv(
1960 (GLuint)sampler,
1961 (GLenum)pname,
1962 (GLint *)params
1963 );
1964
1965 exit:
1966 if (_array) {
1967 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
1968 }
1969 if (_exception) {
1970 jniThrowException(_env, _exceptionType, _exceptionMessage);
1971 }
1972 }
1973
1974 /* void glGetSamplerParameterIuiv ( GLuint sampler, GLenum pname, GLuint *params ) */
1975 static void
android_glGetSamplerParameterIuiv__II_3II(JNIEnv * _env,jobject _this,jint sampler,jint pname,jintArray params_ref,jint offset)1976 android_glGetSamplerParameterIuiv__II_3II
1977 (JNIEnv *_env, jobject _this, jint sampler, jint pname, jintArray params_ref, jint offset) {
1978 jint _exception = 0;
1979 const char * _exceptionType = NULL;
1980 const char * _exceptionMessage = NULL;
1981 GLuint *params_base = (GLuint *) 0;
1982 jint _remaining;
1983 GLuint *params = (GLuint *) 0;
1984
1985 if (!params_ref) {
1986 _exception = 1;
1987 _exceptionType = "java/lang/IllegalArgumentException";
1988 _exceptionMessage = "params == null";
1989 goto exit;
1990 }
1991 if (offset < 0) {
1992 _exception = 1;
1993 _exceptionType = "java/lang/IllegalArgumentException";
1994 _exceptionMessage = "offset < 0";
1995 goto exit;
1996 }
1997 _remaining = _env->GetArrayLength(params_ref) - offset;
1998 params_base = (GLuint *)
1999 _env->GetIntArrayElements(params_ref, (jboolean *)0);
2000 params = params_base + offset;
2001
2002 glGetSamplerParameterIuiv(
2003 (GLuint)sampler,
2004 (GLenum)pname,
2005 (GLuint *)params
2006 );
2007
2008 exit:
2009 if (params_base) {
2010 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
2011 _exception ? JNI_ABORT: 0);
2012 }
2013 if (_exception) {
2014 jniThrowException(_env, _exceptionType, _exceptionMessage);
2015 }
2016 }
2017
2018 /* void glGetSamplerParameterIuiv ( GLuint sampler, GLenum pname, GLuint *params ) */
2019 static void
android_glGetSamplerParameterIuiv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint sampler,jint pname,jobject params_buf)2020 android_glGetSamplerParameterIuiv__IILjava_nio_IntBuffer_2
2021 (JNIEnv *_env, jobject _this, jint sampler, jint pname, jobject params_buf) {
2022 jint _exception = 0;
2023 const char * _exceptionType = NULL;
2024 const char * _exceptionMessage = NULL;
2025 jintArray _array = (jintArray) 0;
2026 jint _bufferOffset = (jint) 0;
2027 jint _remaining;
2028 GLuint *params = (GLuint *) 0;
2029
2030 if (!params_buf) {
2031 _exception = 1;
2032 _exceptionType = "java/lang/IllegalArgumentException";
2033 _exceptionMessage = "params == null";
2034 goto exit;
2035 }
2036 params = (GLuint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2037 if (params == NULL) {
2038 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
2039 params = (GLuint *) (_paramsBase + _bufferOffset);
2040 }
2041 glGetSamplerParameterIuiv(
2042 (GLuint)sampler,
2043 (GLenum)pname,
2044 (GLuint *)params
2045 );
2046
2047 exit:
2048 if (_array) {
2049 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0);
2050 }
2051 if (_exception) {
2052 jniThrowException(_env, _exceptionType, _exceptionMessage);
2053 }
2054 }
2055
2056 /* void glTexBuffer ( GLenum target, GLenum internalformat, GLuint buffer ) */
2057 static void
android_glTexBuffer__III(JNIEnv * _env,jobject _this,jint target,jint internalformat,jint buffer)2058 android_glTexBuffer__III
2059 (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint buffer) {
2060 glTexBuffer(
2061 (GLenum)target,
2062 (GLenum)internalformat,
2063 (GLuint)buffer
2064 );
2065 }
2066
2067 /* void glTexBufferRange ( GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size ) */
2068 static void
android_glTexBufferRange__IIIII(JNIEnv * _env,jobject _this,jint target,jint internalformat,jint buffer,jint offset,jint size)2069 android_glTexBufferRange__IIIII
2070 (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint buffer, jint offset, jint size) {
2071 glTexBufferRange(
2072 (GLenum)target,
2073 (GLenum)internalformat,
2074 (GLuint)buffer,
2075 (GLintptr)offset,
2076 (GLsizeiptr)size
2077 );
2078 }
2079
2080 /* void glTexStorage3DMultisample ( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations ) */
2081 static void
android_glTexStorage3DMultisample__IIIIIIZ(JNIEnv * _env,jobject _this,jint target,jint samples,jint internalformat,jint width,jint height,jint depth,jboolean fixedsamplelocations)2082 android_glTexStorage3DMultisample__IIIIIIZ
2083 (JNIEnv *_env, jobject _this, jint target, jint samples, jint internalformat, jint width, jint height, jint depth, jboolean fixedsamplelocations) {
2084 glTexStorage3DMultisample(
2085 (GLenum)target,
2086 (GLsizei)samples,
2087 (GLenum)internalformat,
2088 (GLsizei)width,
2089 (GLsizei)height,
2090 (GLsizei)depth,
2091 (GLboolean)fixedsamplelocations
2092 );
2093 }
2094
2095 static const char *classPathName = "android/opengl/GLES32";
2096
2097 static const JNINativeMethod methods[] = {
2098 {"_nativeClassInit", "()V", (void*)nativeClassInit },
2099 {"glBlendBarrier", "()V", (void *) android_glBlendBarrier__ },
2100 {"glCopyImageSubData", "(IIIIIIIIIIIIIII)V", (void *) android_glCopyImageSubData__IIIIIIIIIIIIIII },
2101 {"glDebugMessageControl", "(IIII[IIZ)V", (void *) android_glDebugMessageControl__IIII_3IIZ },
2102 {"glDebugMessageControl", "(IIIILjava/nio/IntBuffer;Z)V", (void *) android_glDebugMessageControl__IIIILjava_nio_IntBuffer_2Z },
2103 {"glDebugMessageInsert", "(IIIIILjava/lang/String;)V", (void *) android_glDebugMessageInsert__IIIIILjava_lang_String_2 },
2104 {"glDebugMessageCallback", "(Landroid/opengl/GLES32$DebugProc;)V", (void *) android_glDebugMessageCallback },
2105 {"glGetDebugMessageLog", "(II[II[II[II[II[II[BI)I", (void *) android_glGetDebugMessageLog__II_3II_3II_3II_3II_3II_3BI },
2106 {"glGetDebugMessageLog", "(ILjava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/ByteBuffer;)I", (void *) android_glGetDebugMessageLog__ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_ByteBuffer_2 },
2107 {"glGetDebugMessageLog", "(I[II[II[II[II)[Ljava/lang/String;", (void *) android_glGetDebugMessageLog__I_3II_3II_3II_3II },
2108 {"glGetDebugMessageLog", "(ILjava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;)[Ljava/lang/String;", (void *) android_glGetDebugMessageLog__ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 },
2109 {"glPushDebugGroup", "(IIILjava/lang/String;)V", (void *) android_glPushDebugGroup__IIILjava_lang_String_2 },
2110 {"glPopDebugGroup", "()V", (void *) android_glPopDebugGroup__ },
2111 {"glObjectLabel", "(IIILjava/lang/String;)V", (void *) android_glObjectLabel__IIILjava_lang_String_2 },
2112 {"glGetObjectLabel", "(II)Ljava/lang/String;", (void *) android_glGetObjectLabel },
2113 {"glObjectPtrLabel", "(JLjava/lang/String;)V", (void *) android_glObjectPtrLabel },
2114 {"glGetObjectPtrLabel", "(J)Ljava/lang/String;", (void *) android_glGetObjectPtrLabel },
2115 {"glGetPointerv", "(I)J", (void *) android_glGetPointerv },
2116 {"glEnablei", "(II)V", (void *) android_glEnablei__II },
2117 {"glDisablei", "(II)V", (void *) android_glDisablei__II },
2118 {"glBlendEquationi", "(II)V", (void *) android_glBlendEquationi__II },
2119 {"glBlendEquationSeparatei", "(III)V", (void *) android_glBlendEquationSeparatei__III },
2120 {"glBlendFunci", "(III)V", (void *) android_glBlendFunci__III },
2121 {"glBlendFuncSeparatei", "(IIIII)V", (void *) android_glBlendFuncSeparatei__IIIII },
2122 {"glColorMaski", "(IZZZZ)V", (void *) android_glColorMaski__IZZZZ },
2123 {"glIsEnabledi", "(II)Z", (void *) android_glIsEnabledi__II },
2124 {"glDrawElementsBaseVertex", "(IIILjava/nio/Buffer;I)V", (void *) android_glDrawElementsBaseVertex__IIILjava_nio_Buffer_2I },
2125 {"glDrawRangeElementsBaseVertex", "(IIIIILjava/nio/Buffer;I)V", (void *) android_glDrawRangeElementsBaseVertex__IIIIILjava_nio_Buffer_2I },
2126 {"glDrawElementsInstancedBaseVertex", "(IIILjava/nio/Buffer;II)V", (void *) android_glDrawElementsInstancedBaseVertex__IIILjava_nio_Buffer_2II },
2127 {"glDrawElementsInstancedBaseVertex", "(IIIIII)V", (void *) android_glDrawElementsInstancedBaseVertex__IIIIII },
2128 {"glFramebufferTexture", "(IIII)V", (void *) android_glFramebufferTexture__IIII },
2129 {"glPrimitiveBoundingBox", "(FFFFFFFF)V", (void *) android_glPrimitiveBoundingBox__FFFFFFFF },
2130 {"glGetGraphicsResetStatus", "()I", (void *) android_glGetGraphicsResetStatus__ },
2131 {"glReadnPixels", "(IIIIIIILjava/nio/Buffer;)V", (void *) android_glReadnPixels__IIIIIIILjava_nio_Buffer_2 },
2132 {"glGetnUniformfv", "(III[FI)V", (void *) android_glGetnUniformfv__III_3FI },
2133 {"glGetnUniformfv", "(IIILjava/nio/FloatBuffer;)V", (void *) android_glGetnUniformfv__IIILjava_nio_FloatBuffer_2 },
2134 {"glGetnUniformiv", "(III[II)V", (void *) android_glGetnUniformiv__III_3II },
2135 {"glGetnUniformiv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetnUniformiv__IIILjava_nio_IntBuffer_2 },
2136 {"glGetnUniformuiv", "(III[II)V", (void *) android_glGetnUniformuiv__III_3II },
2137 {"glGetnUniformuiv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetnUniformuiv__IIILjava_nio_IntBuffer_2 },
2138 {"glMinSampleShading", "(F)V", (void *) android_glMinSampleShading__F },
2139 {"glPatchParameteri", "(II)V", (void *) android_glPatchParameteri__II },
2140 {"glTexParameterIiv", "(II[II)V", (void *) android_glTexParameterIiv__II_3II },
2141 {"glTexParameterIiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameterIiv__IILjava_nio_IntBuffer_2 },
2142 {"glTexParameterIuiv", "(II[II)V", (void *) android_glTexParameterIuiv__II_3II },
2143 {"glTexParameterIuiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameterIuiv__IILjava_nio_IntBuffer_2 },
2144 {"glGetTexParameterIiv", "(II[II)V", (void *) android_glGetTexParameterIiv__II_3II },
2145 {"glGetTexParameterIiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameterIiv__IILjava_nio_IntBuffer_2 },
2146 {"glGetTexParameterIuiv", "(II[II)V", (void *) android_glGetTexParameterIuiv__II_3II },
2147 {"glGetTexParameterIuiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameterIuiv__IILjava_nio_IntBuffer_2 },
2148 {"glSamplerParameterIiv", "(II[II)V", (void *) android_glSamplerParameterIiv__II_3II },
2149 {"glSamplerParameterIiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glSamplerParameterIiv__IILjava_nio_IntBuffer_2 },
2150 {"glSamplerParameterIuiv", "(II[II)V", (void *) android_glSamplerParameterIuiv__II_3II },
2151 {"glSamplerParameterIuiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glSamplerParameterIuiv__IILjava_nio_IntBuffer_2 },
2152 {"glGetSamplerParameterIiv", "(II[II)V", (void *) android_glGetSamplerParameterIiv__II_3II },
2153 {"glGetSamplerParameterIiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetSamplerParameterIiv__IILjava_nio_IntBuffer_2 },
2154 {"glGetSamplerParameterIuiv", "(II[II)V", (void *) android_glGetSamplerParameterIuiv__II_3II },
2155 {"glGetSamplerParameterIuiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetSamplerParameterIuiv__IILjava_nio_IntBuffer_2 },
2156 {"glTexBuffer", "(III)V", (void *) android_glTexBuffer__III },
2157 {"glTexBufferRange", "(IIIII)V", (void *) android_glTexBufferRange__IIIII },
2158 {"glTexStorage3DMultisample", "(IIIIIIZ)V", (void *) android_glTexStorage3DMultisample__IIIIIIZ },
2159 };
2160
register_android_opengl_jni_GLES32(JNIEnv * _env)2161 int register_android_opengl_jni_GLES32(JNIEnv *_env)
2162 {
2163 int err;
2164 err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));
2165 return err;
2166 }
2167