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