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