1 /*
2 **
3 ** Copyright 2009, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 ** http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17
18 // This source file is automatically generated
19
20 #include <GLES/gl.h>
21 #include <GLES/glext.h>
22
23 #include <jni.h>
24 #include <JNIHelp.h>
25 #include <android_runtime/AndroidRuntime.h>
26 #include <utils/misc.h>
27 #include <assert.h>
28
29 static int initialized = 0;
30
31 static jclass nioAccessClass;
32 static jclass bufferClass;
33 static jmethodID getBasePointerID;
34 static jmethodID getBaseArrayID;
35 static jmethodID getBaseArrayOffsetID;
36 static jfieldID positionID;
37 static jfieldID limitID;
38 static jfieldID elementSizeShiftID;
39
40
41 /* special calls implemented in Android's GLES wrapper used to more
42 * efficiently bound-check passed arrays */
43 extern "C" {
44 #ifdef GL_VERSION_ES_CM_1_1
45 GL_API void GL_APIENTRY glColorPointerBounds(GLint size, GLenum type, GLsizei stride,
46 const GLvoid *ptr, GLsizei count);
47 GL_API void GL_APIENTRY glNormalPointerBounds(GLenum type, GLsizei stride,
48 const GLvoid *pointer, GLsizei count);
49 GL_API void GL_APIENTRY glTexCoordPointerBounds(GLint size, GLenum type,
50 GLsizei stride, const GLvoid *pointer, GLsizei count);
51 GL_API void GL_APIENTRY glVertexPointerBounds(GLint size, GLenum type,
52 GLsizei stride, const GLvoid *pointer, GLsizei count);
53 GL_API void GL_APIENTRY glPointSizePointerOESBounds(GLenum type,
54 GLsizei stride, const GLvoid *pointer, GLsizei count);
55 GL_API void GL_APIENTRY glMatrixIndexPointerOESBounds(GLint size, GLenum type,
56 GLsizei stride, const GLvoid *pointer, GLsizei count);
57 GL_API void GL_APIENTRY glWeightPointerOESBounds(GLint size, GLenum type,
58 GLsizei stride, const GLvoid *pointer, GLsizei count);
59 #endif
60 #ifdef GL_ES_VERSION_2_0
glVertexAttribPointerBounds(GLuint indx,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const GLvoid * pointer,GLsizei count)61 static void glVertexAttribPointerBounds(GLuint indx, GLint size, GLenum type,
62 GLboolean normalized, GLsizei stride, const GLvoid *pointer, GLsizei count) {
63 glVertexAttribPointer(indx, size, type, normalized, stride, pointer);
64 }
65 #endif
66 #ifdef GL_ES_VERSION_3_0
glVertexAttribIPointerBounds(GLuint indx,GLint size,GLenum type,GLsizei stride,const GLvoid * pointer,GLsizei count)67 static void glVertexAttribIPointerBounds(GLuint indx, GLint size, GLenum type,
68 GLsizei stride, const GLvoid *pointer, GLsizei count) {
69 glVertexAttribIPointer(indx, size, type, stride, pointer);
70 }
71 #endif
72 }
73
74 /* Cache method IDs each time the class is loaded. */
75
76 static void
nativeClassInit(JNIEnv * _env,jclass glImplClass)77 nativeClassInit(JNIEnv *_env, jclass glImplClass)
78 {
79 jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess");
80 nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal);
81
82 jclass bufferClassLocal = _env->FindClass("java/nio/Buffer");
83 bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal);
84
85 getBasePointerID = _env->GetStaticMethodID(nioAccessClass,
86 "getBasePointer", "(Ljava/nio/Buffer;)J");
87 getBaseArrayID = _env->GetStaticMethodID(nioAccessClass,
88 "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;");
89 getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass,
90 "getBaseArrayOffset", "(Ljava/nio/Buffer;)I");
91
92 positionID = _env->GetFieldID(bufferClass, "position", "I");
93 limitID = _env->GetFieldID(bufferClass, "limit", "I");
94 elementSizeShiftID =
95 _env->GetFieldID(bufferClass, "_elementSizeShift", "I");
96 }
97
98 static void *
getPointer(JNIEnv * _env,jobject buffer,jarray * array,jint * remaining,jint * offset)99 getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining, jint *offset)
100 {
101 jint position;
102 jint limit;
103 jint elementSizeShift;
104 jlong pointer;
105
106 position = _env->GetIntField(buffer, positionID);
107 limit = _env->GetIntField(buffer, limitID);
108 elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
109 *remaining = (limit - position) << elementSizeShift;
110 pointer = _env->CallStaticLongMethod(nioAccessClass,
111 getBasePointerID, buffer);
112 if (pointer != 0L) {
113 *array = NULL;
114 return reinterpret_cast<void*>(pointer);
115 }
116
117 *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass,
118 getBaseArrayID, buffer);
119 *offset = _env->CallStaticIntMethod(nioAccessClass,
120 getBaseArrayOffsetID, buffer);
121
122 return NULL;
123 }
124
125 static void
releasePointer(JNIEnv * _env,jarray array,void * data,jboolean commit)126 releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit)
127 {
128 _env->ReleasePrimitiveArrayCritical(array, data,
129 commit ? 0 : JNI_ABORT);
130 }
131
132 static void *
getDirectBufferPointer(JNIEnv * _env,jobject buffer)133 getDirectBufferPointer(JNIEnv *_env, jobject buffer) {
134 char* buf = (char*) _env->GetDirectBufferAddress(buffer);
135 if (buf) {
136 jint position = _env->GetIntField(buffer, positionID);
137 jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
138 buf += position << elementSizeShift;
139 } else {
140 jniThrowException(_env, "java/lang/IllegalArgumentException",
141 "Must use a native order direct Buffer");
142 }
143 return (void*) buf;
144 }
145
146 // --------------------------------------------------------------------------
147
148 /*
149 * returns the number of values glGet returns for a given pname.
150 *
151 * The code below is written such that pnames requiring only one values
152 * are the default (and are not explicitely tested for). This makes the
153 * checking code much shorter/readable/efficient.
154 *
155 * This means that unknown pnames (e.g.: extensions) will default to 1. If
156 * that unknown pname needs more than 1 value, then the validation check
157 * is incomplete and the app may crash if it passed the wrong number params.
158 */
getNeededCount(GLint pname)159 static int getNeededCount(GLint pname) {
160 int needed = 1;
161 #ifdef GL_ES_VERSION_2_0
162 // GLES 2.x pnames
163 switch (pname) {
164 case GL_ALIASED_LINE_WIDTH_RANGE:
165 case GL_ALIASED_POINT_SIZE_RANGE:
166 needed = 2;
167 break;
168
169 case GL_BLEND_COLOR:
170 case GL_COLOR_CLEAR_VALUE:
171 case GL_COLOR_WRITEMASK:
172 case GL_SCISSOR_BOX:
173 case GL_VIEWPORT:
174 needed = 4;
175 break;
176
177 case GL_COMPRESSED_TEXTURE_FORMATS:
178 glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed);
179 break;
180
181 case GL_SHADER_BINARY_FORMATS:
182 glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &needed);
183 break;
184 }
185 #endif
186
187 #ifdef GL_VERSION_ES_CM_1_1
188 // GLES 1.x pnames
189 switch (pname) {
190 case GL_ALIASED_LINE_WIDTH_RANGE:
191 case GL_ALIASED_POINT_SIZE_RANGE:
192 case GL_DEPTH_RANGE:
193 case GL_SMOOTH_LINE_WIDTH_RANGE:
194 case GL_SMOOTH_POINT_SIZE_RANGE:
195 needed = 2;
196 break;
197
198 case GL_CURRENT_NORMAL:
199 case GL_POINT_DISTANCE_ATTENUATION:
200 needed = 3;
201 break;
202
203 case GL_COLOR_CLEAR_VALUE:
204 case GL_COLOR_WRITEMASK:
205 case GL_CURRENT_COLOR:
206 case GL_CURRENT_TEXTURE_COORDS:
207 case GL_FOG_COLOR:
208 case GL_LIGHT_MODEL_AMBIENT:
209 case GL_SCISSOR_BOX:
210 case GL_VIEWPORT:
211 needed = 4;
212 break;
213
214 case GL_MODELVIEW_MATRIX:
215 case GL_PROJECTION_MATRIX:
216 case GL_TEXTURE_MATRIX:
217 needed = 16;
218 break;
219
220 case GL_COMPRESSED_TEXTURE_FORMATS:
221 glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed);
222 break;
223 }
224 #endif
225 return needed;
226 }
227
228 template <typename JTYPEARRAY, typename CTYPE, void GET(GLenum, CTYPE*)>
229 static void
get(JNIEnv * _env,jobject _this,jint pname,JTYPEARRAY params_ref,jint offset)230 get
231 (JNIEnv *_env, jobject _this, jint pname, JTYPEARRAY params_ref, jint offset) {
232 jint _exception = 0;
233 const char * _exceptionType;
234 const char * _exceptionMessage;
235 CTYPE *params_base = (CTYPE *) 0;
236 jint _remaining;
237 CTYPE *params = (CTYPE *) 0;
238 int _needed = 0;
239
240 if (!params_ref) {
241 _exception = 1;
242 _exceptionType = "java/lang/IllegalArgumentException";
243 _exceptionMessage = "params == null";
244 goto exit;
245 }
246 if (offset < 0) {
247 _exception = 1;
248 _exceptionType = "java/lang/IllegalArgumentException";
249 _exceptionMessage = "offset < 0";
250 goto exit;
251 }
252 _remaining = _env->GetArrayLength(params_ref) - offset;
253 _needed = getNeededCount(pname);
254 // if we didn't find this pname, we just assume the user passed
255 // an array of the right size -- this might happen with extensions
256 // or if we forget an enum here.
257 if (_remaining < _needed) {
258 _exception = 1;
259 _exceptionType = "java/lang/IllegalArgumentException";
260 _exceptionMessage = "length - offset < needed";
261 goto exit;
262 }
263 params_base = (CTYPE *)
264 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
265 params = params_base + offset;
266
267 GET(
268 (GLenum)pname,
269 (CTYPE *)params
270 );
271
272 exit:
273 if (params_base) {
274 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
275 _exception ? JNI_ABORT: 0);
276 }
277 if (_exception) {
278 jniThrowException(_env, _exceptionType, _exceptionMessage);
279 }
280 }
281
282
283 template <typename CTYPE, void GET(GLenum, CTYPE*)>
284 static void
getarray(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)285 getarray
286 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
287 jint _exception = 0;
288 const char * _exceptionType;
289 const char * _exceptionMessage;
290 jarray _array = (jarray) 0;
291 jint _bufferOffset = (jint) 0;
292 jint _remaining;
293 CTYPE *params = (CTYPE *) 0;
294 int _needed = 0;
295
296 params = (CTYPE *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
297 _remaining /= sizeof(CTYPE); // convert from bytes to item count
298 _needed = getNeededCount(pname);
299 // if we didn't find this pname, we just assume the user passed
300 // an array of the right size -- this might happen with extensions
301 // or if we forget an enum here.
302 if (_needed>0 && _remaining < _needed) {
303 _exception = 1;
304 _exceptionType = "java/lang/IllegalArgumentException";
305 _exceptionMessage = "remaining() < needed";
306 goto exit;
307 }
308 if (params == NULL) {
309 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
310 params = (CTYPE *) (_paramsBase + _bufferOffset);
311 }
312 GET(
313 (GLenum)pname,
314 (CTYPE *)params
315 );
316
317 exit:
318 if (_array) {
319 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
320 }
321 if (_exception) {
322 jniThrowException(_env, _exceptionType, _exceptionMessage);
323 }
324 }
325
326 // --------------------------------------------------------------------------
327 /* void glBlendEquationSeparateOES ( GLenum modeRGB, GLenum modeAlpha ) */
328 static void
android_glBlendEquationSeparateOES__II(JNIEnv * _env,jobject _this,jint modeRGB,jint modeAlpha)329 android_glBlendEquationSeparateOES__II
330 (JNIEnv *_env, jobject _this, jint modeRGB, jint modeAlpha) {
331 glBlendEquationSeparateOES(
332 (GLenum)modeRGB,
333 (GLenum)modeAlpha
334 );
335 }
336
337 /* void glBlendFuncSeparateOES ( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) */
338 static void
android_glBlendFuncSeparateOES__IIII(JNIEnv * _env,jobject _this,jint srcRGB,jint dstRGB,jint srcAlpha,jint dstAlpha)339 android_glBlendFuncSeparateOES__IIII
340 (JNIEnv *_env, jobject _this, jint srcRGB, jint dstRGB, jint srcAlpha, jint dstAlpha) {
341 glBlendFuncSeparateOES(
342 (GLenum)srcRGB,
343 (GLenum)dstRGB,
344 (GLenum)srcAlpha,
345 (GLenum)dstAlpha
346 );
347 }
348
349 /* void glBlendEquationOES ( GLenum mode ) */
350 static void
android_glBlendEquationOES__I(JNIEnv * _env,jobject _this,jint mode)351 android_glBlendEquationOES__I
352 (JNIEnv *_env, jobject _this, jint mode) {
353 glBlendEquationOES(
354 (GLenum)mode
355 );
356 }
357
358 /* void glDrawTexsOES ( GLshort x, GLshort y, GLshort z, GLshort width, GLshort height ) */
359 static void
android_glDrawTexsOES__SSSSS(JNIEnv * _env,jobject _this,jshort x,jshort y,jshort z,jshort width,jshort height)360 android_glDrawTexsOES__SSSSS
361 (JNIEnv *_env, jobject _this, jshort x, jshort y, jshort z, jshort width, jshort height) {
362 glDrawTexsOES(
363 (GLshort)x,
364 (GLshort)y,
365 (GLshort)z,
366 (GLshort)width,
367 (GLshort)height
368 );
369 }
370
371 /* void glDrawTexiOES ( GLint x, GLint y, GLint z, GLint width, GLint height ) */
372 static void
android_glDrawTexiOES__IIIII(JNIEnv * _env,jobject _this,jint x,jint y,jint z,jint width,jint height)373 android_glDrawTexiOES__IIIII
374 (JNIEnv *_env, jobject _this, jint x, jint y, jint z, jint width, jint height) {
375 glDrawTexiOES(
376 (GLint)x,
377 (GLint)y,
378 (GLint)z,
379 (GLint)width,
380 (GLint)height
381 );
382 }
383
384 /* void glDrawTexxOES ( GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height ) */
385 static void
android_glDrawTexxOES__IIIII(JNIEnv * _env,jobject _this,jint x,jint y,jint z,jint width,jint height)386 android_glDrawTexxOES__IIIII
387 (JNIEnv *_env, jobject _this, jint x, jint y, jint z, jint width, jint height) {
388 glDrawTexxOES(
389 (GLfixed)x,
390 (GLfixed)y,
391 (GLfixed)z,
392 (GLfixed)width,
393 (GLfixed)height
394 );
395 }
396
397 /* void glDrawTexsvOES ( const GLshort *coords ) */
398 static void
android_glDrawTexsvOES___3SI(JNIEnv * _env,jobject _this,jshortArray coords_ref,jint offset)399 android_glDrawTexsvOES___3SI
400 (JNIEnv *_env, jobject _this, jshortArray coords_ref, jint offset) {
401 jint _exception = 0;
402 const char * _exceptionType = NULL;
403 const char * _exceptionMessage = NULL;
404 GLshort *coords_base = (GLshort *) 0;
405 jint _remaining;
406 GLshort *coords = (GLshort *) 0;
407
408 if (!coords_ref) {
409 _exception = 1;
410 _exceptionType = "java/lang/IllegalArgumentException";
411 _exceptionMessage = "coords == null";
412 goto exit;
413 }
414 if (offset < 0) {
415 _exception = 1;
416 _exceptionType = "java/lang/IllegalArgumentException";
417 _exceptionMessage = "offset < 0";
418 goto exit;
419 }
420 _remaining = _env->GetArrayLength(coords_ref) - offset;
421 if (_remaining < 5) {
422 _exception = 1;
423 _exceptionType = "java/lang/IllegalArgumentException";
424 _exceptionMessage = "length - offset < 5 < needed";
425 goto exit;
426 }
427 coords_base = (GLshort *)
428 _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0);
429 coords = coords_base + offset;
430
431 glDrawTexsvOES(
432 (GLshort *)coords
433 );
434
435 exit:
436 if (coords_base) {
437 _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base,
438 JNI_ABORT);
439 }
440 if (_exception) {
441 jniThrowException(_env, _exceptionType, _exceptionMessage);
442 }
443 }
444
445 /* void glDrawTexsvOES ( const GLshort *coords ) */
446 static void
android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2(JNIEnv * _env,jobject _this,jobject coords_buf)447 android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2
448 (JNIEnv *_env, jobject _this, jobject coords_buf) {
449 jint _exception = 0;
450 const char * _exceptionType = NULL;
451 const char * _exceptionMessage = NULL;
452 jarray _array = (jarray) 0;
453 jint _bufferOffset = (jint) 0;
454 jint _remaining;
455 GLshort *coords = (GLshort *) 0;
456
457 coords = (GLshort *)getPointer(_env, coords_buf, &_array, &_remaining, &_bufferOffset);
458 if (_remaining < 5) {
459 _exception = 1;
460 _exceptionType = "java/lang/IllegalArgumentException";
461 _exceptionMessage = "remaining() < 5 < needed";
462 goto exit;
463 }
464 if (coords == NULL) {
465 char * _coordsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
466 coords = (GLshort *) (_coordsBase + _bufferOffset);
467 }
468 glDrawTexsvOES(
469 (GLshort *)coords
470 );
471
472 exit:
473 if (_array) {
474 releasePointer(_env, _array, coords, JNI_FALSE);
475 }
476 if (_exception) {
477 jniThrowException(_env, _exceptionType, _exceptionMessage);
478 }
479 }
480
481 /* void glDrawTexivOES ( const GLint *coords ) */
482 static void
android_glDrawTexivOES___3II(JNIEnv * _env,jobject _this,jintArray coords_ref,jint offset)483 android_glDrawTexivOES___3II
484 (JNIEnv *_env, jobject _this, jintArray coords_ref, jint offset) {
485 jint _exception = 0;
486 const char * _exceptionType = NULL;
487 const char * _exceptionMessage = NULL;
488 GLint *coords_base = (GLint *) 0;
489 jint _remaining;
490 GLint *coords = (GLint *) 0;
491
492 if (!coords_ref) {
493 _exception = 1;
494 _exceptionType = "java/lang/IllegalArgumentException";
495 _exceptionMessage = "coords == null";
496 goto exit;
497 }
498 if (offset < 0) {
499 _exception = 1;
500 _exceptionType = "java/lang/IllegalArgumentException";
501 _exceptionMessage = "offset < 0";
502 goto exit;
503 }
504 _remaining = _env->GetArrayLength(coords_ref) - offset;
505 if (_remaining < 5) {
506 _exception = 1;
507 _exceptionType = "java/lang/IllegalArgumentException";
508 _exceptionMessage = "length - offset < 5 < needed";
509 goto exit;
510 }
511 coords_base = (GLint *)
512 _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0);
513 coords = coords_base + offset;
514
515 glDrawTexivOES(
516 (GLint *)coords
517 );
518
519 exit:
520 if (coords_base) {
521 _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base,
522 JNI_ABORT);
523 }
524 if (_exception) {
525 jniThrowException(_env, _exceptionType, _exceptionMessage);
526 }
527 }
528
529 /* void glDrawTexivOES ( const GLint *coords ) */
530 static void
android_glDrawTexivOES__Ljava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jobject coords_buf)531 android_glDrawTexivOES__Ljava_nio_IntBuffer_2
532 (JNIEnv *_env, jobject _this, jobject coords_buf) {
533 jint _exception = 0;
534 const char * _exceptionType = NULL;
535 const char * _exceptionMessage = NULL;
536 jarray _array = (jarray) 0;
537 jint _bufferOffset = (jint) 0;
538 jint _remaining;
539 GLint *coords = (GLint *) 0;
540
541 coords = (GLint *)getPointer(_env, coords_buf, &_array, &_remaining, &_bufferOffset);
542 if (_remaining < 5) {
543 _exception = 1;
544 _exceptionType = "java/lang/IllegalArgumentException";
545 _exceptionMessage = "remaining() < 5 < needed";
546 goto exit;
547 }
548 if (coords == NULL) {
549 char * _coordsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
550 coords = (GLint *) (_coordsBase + _bufferOffset);
551 }
552 glDrawTexivOES(
553 (GLint *)coords
554 );
555
556 exit:
557 if (_array) {
558 releasePointer(_env, _array, coords, JNI_FALSE);
559 }
560 if (_exception) {
561 jniThrowException(_env, _exceptionType, _exceptionMessage);
562 }
563 }
564
565 /* void glDrawTexxvOES ( const GLfixed *coords ) */
566 static void
android_glDrawTexxvOES___3II(JNIEnv * _env,jobject _this,jintArray coords_ref,jint offset)567 android_glDrawTexxvOES___3II
568 (JNIEnv *_env, jobject _this, jintArray coords_ref, jint offset) {
569 jint _exception = 0;
570 const char * _exceptionType = NULL;
571 const char * _exceptionMessage = NULL;
572 GLfixed *coords_base = (GLfixed *) 0;
573 jint _remaining;
574 GLfixed *coords = (GLfixed *) 0;
575
576 if (!coords_ref) {
577 _exception = 1;
578 _exceptionType = "java/lang/IllegalArgumentException";
579 _exceptionMessage = "coords == null";
580 goto exit;
581 }
582 if (offset < 0) {
583 _exception = 1;
584 _exceptionType = "java/lang/IllegalArgumentException";
585 _exceptionMessage = "offset < 0";
586 goto exit;
587 }
588 _remaining = _env->GetArrayLength(coords_ref) - offset;
589 if (_remaining < 5) {
590 _exception = 1;
591 _exceptionType = "java/lang/IllegalArgumentException";
592 _exceptionMessage = "length - offset < 5 < needed";
593 goto exit;
594 }
595 coords_base = (GLfixed *)
596 _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0);
597 coords = coords_base + offset;
598
599 glDrawTexxvOES(
600 (GLfixed *)coords
601 );
602
603 exit:
604 if (coords_base) {
605 _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base,
606 JNI_ABORT);
607 }
608 if (_exception) {
609 jniThrowException(_env, _exceptionType, _exceptionMessage);
610 }
611 }
612
613 /* void glDrawTexxvOES ( const GLfixed *coords ) */
614 static void
android_glDrawTexxvOES__Ljava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jobject coords_buf)615 android_glDrawTexxvOES__Ljava_nio_IntBuffer_2
616 (JNIEnv *_env, jobject _this, jobject coords_buf) {
617 jint _exception = 0;
618 const char * _exceptionType = NULL;
619 const char * _exceptionMessage = NULL;
620 jarray _array = (jarray) 0;
621 jint _bufferOffset = (jint) 0;
622 jint _remaining;
623 GLfixed *coords = (GLfixed *) 0;
624
625 coords = (GLfixed *)getPointer(_env, coords_buf, &_array, &_remaining, &_bufferOffset);
626 if (_remaining < 5) {
627 _exception = 1;
628 _exceptionType = "java/lang/IllegalArgumentException";
629 _exceptionMessage = "remaining() < 5 < needed";
630 goto exit;
631 }
632 if (coords == NULL) {
633 char * _coordsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
634 coords = (GLfixed *) (_coordsBase + _bufferOffset);
635 }
636 glDrawTexxvOES(
637 (GLfixed *)coords
638 );
639
640 exit:
641 if (_array) {
642 releasePointer(_env, _array, coords, JNI_FALSE);
643 }
644 if (_exception) {
645 jniThrowException(_env, _exceptionType, _exceptionMessage);
646 }
647 }
648
649 /* void glDrawTexfOES ( GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height ) */
650 static void
android_glDrawTexfOES__FFFFF(JNIEnv * _env,jobject _this,jfloat x,jfloat y,jfloat z,jfloat width,jfloat height)651 android_glDrawTexfOES__FFFFF
652 (JNIEnv *_env, jobject _this, jfloat x, jfloat y, jfloat z, jfloat width, jfloat height) {
653 glDrawTexfOES(
654 (GLfloat)x,
655 (GLfloat)y,
656 (GLfloat)z,
657 (GLfloat)width,
658 (GLfloat)height
659 );
660 }
661
662 /* void glDrawTexfvOES ( const GLfloat *coords ) */
663 static void
android_glDrawTexfvOES___3FI(JNIEnv * _env,jobject _this,jfloatArray coords_ref,jint offset)664 android_glDrawTexfvOES___3FI
665 (JNIEnv *_env, jobject _this, jfloatArray coords_ref, jint offset) {
666 jint _exception = 0;
667 const char * _exceptionType = NULL;
668 const char * _exceptionMessage = NULL;
669 GLfloat *coords_base = (GLfloat *) 0;
670 jint _remaining;
671 GLfloat *coords = (GLfloat *) 0;
672
673 if (!coords_ref) {
674 _exception = 1;
675 _exceptionType = "java/lang/IllegalArgumentException";
676 _exceptionMessage = "coords == null";
677 goto exit;
678 }
679 if (offset < 0) {
680 _exception = 1;
681 _exceptionType = "java/lang/IllegalArgumentException";
682 _exceptionMessage = "offset < 0";
683 goto exit;
684 }
685 _remaining = _env->GetArrayLength(coords_ref) - offset;
686 if (_remaining < 5) {
687 _exception = 1;
688 _exceptionType = "java/lang/IllegalArgumentException";
689 _exceptionMessage = "length - offset < 5 < needed";
690 goto exit;
691 }
692 coords_base = (GLfloat *)
693 _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0);
694 coords = coords_base + offset;
695
696 glDrawTexfvOES(
697 (GLfloat *)coords
698 );
699
700 exit:
701 if (coords_base) {
702 _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base,
703 JNI_ABORT);
704 }
705 if (_exception) {
706 jniThrowException(_env, _exceptionType, _exceptionMessage);
707 }
708 }
709
710 /* void glDrawTexfvOES ( const GLfloat *coords ) */
711 static void
android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jobject coords_buf)712 android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2
713 (JNIEnv *_env, jobject _this, jobject coords_buf) {
714 jint _exception = 0;
715 const char * _exceptionType = NULL;
716 const char * _exceptionMessage = NULL;
717 jarray _array = (jarray) 0;
718 jint _bufferOffset = (jint) 0;
719 jint _remaining;
720 GLfloat *coords = (GLfloat *) 0;
721
722 coords = (GLfloat *)getPointer(_env, coords_buf, &_array, &_remaining, &_bufferOffset);
723 if (_remaining < 5) {
724 _exception = 1;
725 _exceptionType = "java/lang/IllegalArgumentException";
726 _exceptionMessage = "remaining() < 5 < needed";
727 goto exit;
728 }
729 if (coords == NULL) {
730 char * _coordsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
731 coords = (GLfloat *) (_coordsBase + _bufferOffset);
732 }
733 glDrawTexfvOES(
734 (GLfloat *)coords
735 );
736
737 exit:
738 if (_array) {
739 releasePointer(_env, _array, coords, JNI_FALSE);
740 }
741 if (_exception) {
742 jniThrowException(_env, _exceptionType, _exceptionMessage);
743 }
744 }
745
746 /* void glEGLImageTargetTexture2DOES ( GLenum target, GLeglImageOES image ) */
747 static void
android_glEGLImageTargetTexture2DOES__ILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint target,jobject image_buf)748 android_glEGLImageTargetTexture2DOES__ILjava_nio_Buffer_2
749 (JNIEnv *_env, jobject _this, jint target, jobject image_buf) {
750 jarray _array = (jarray) 0;
751 jint _bufferOffset = (jint) 0;
752 jint _remaining;
753 GLeglImageOES image = (GLeglImageOES) 0;
754
755 image = (GLeglImageOES)getPointer(_env, image_buf, &_array, &_remaining, &_bufferOffset);
756 if (image == NULL) {
757 char * _imageBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
758 image = (GLeglImageOES) (_imageBase + _bufferOffset);
759 }
760 glEGLImageTargetTexture2DOES(
761 (GLenum)target,
762 (GLeglImageOES)image
763 );
764 if (_array) {
765 releasePointer(_env, _array, image, JNI_TRUE);
766 }
767 }
768
769 /* void glEGLImageTargetRenderbufferStorageOES ( GLenum target, GLeglImageOES image ) */
770 static void
android_glEGLImageTargetRenderbufferStorageOES__ILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint target,jobject image_buf)771 android_glEGLImageTargetRenderbufferStorageOES__ILjava_nio_Buffer_2
772 (JNIEnv *_env, jobject _this, jint target, jobject image_buf) {
773 jarray _array = (jarray) 0;
774 jint _bufferOffset = (jint) 0;
775 jint _remaining;
776 GLeglImageOES image = (GLeglImageOES) 0;
777
778 image = (GLeglImageOES)getPointer(_env, image_buf, &_array, &_remaining, &_bufferOffset);
779 if (image == NULL) {
780 char * _imageBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
781 image = (GLeglImageOES) (_imageBase + _bufferOffset);
782 }
783 glEGLImageTargetRenderbufferStorageOES(
784 (GLenum)target,
785 (GLeglImageOES)image
786 );
787 if (_array) {
788 releasePointer(_env, _array, image, JNI_TRUE);
789 }
790 }
791
792 /* void glAlphaFuncxOES ( GLenum func, GLclampx ref ) */
793 static void
android_glAlphaFuncxOES__II(JNIEnv * _env,jobject _this,jint func,jint ref)794 android_glAlphaFuncxOES__II
795 (JNIEnv *_env, jobject _this, jint func, jint ref) {
796 glAlphaFuncxOES(
797 (GLenum)func,
798 (GLclampx)ref
799 );
800 }
801
802 /* void glClearColorxOES ( GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha ) */
803 static void
android_glClearColorxOES__IIII(JNIEnv * _env,jobject _this,jint red,jint green,jint blue,jint alpha)804 android_glClearColorxOES__IIII
805 (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) {
806 glClearColorxOES(
807 (GLclampx)red,
808 (GLclampx)green,
809 (GLclampx)blue,
810 (GLclampx)alpha
811 );
812 }
813
814 /* void glClearDepthxOES ( GLclampx depth ) */
815 static void
android_glClearDepthxOES__I(JNIEnv * _env,jobject _this,jint depth)816 android_glClearDepthxOES__I
817 (JNIEnv *_env, jobject _this, jint depth) {
818 glClearDepthxOES(
819 (GLclampx)depth
820 );
821 }
822
823 /* void glClipPlanexOES ( GLenum plane, const GLfixed *equation ) */
824 static void
android_glClipPlanexOES__I_3II(JNIEnv * _env,jobject _this,jint plane,jintArray equation_ref,jint offset)825 android_glClipPlanexOES__I_3II
826 (JNIEnv *_env, jobject _this, jint plane, jintArray equation_ref, jint offset) {
827 jint _exception = 0;
828 const char * _exceptionType = NULL;
829 const char * _exceptionMessage = NULL;
830 GLfixed *equation_base = (GLfixed *) 0;
831 jint _remaining;
832 GLfixed *equation = (GLfixed *) 0;
833
834 if (!equation_ref) {
835 _exception = 1;
836 _exceptionType = "java/lang/IllegalArgumentException";
837 _exceptionMessage = "equation == null";
838 goto exit;
839 }
840 if (offset < 0) {
841 _exception = 1;
842 _exceptionType = "java/lang/IllegalArgumentException";
843 _exceptionMessage = "offset < 0";
844 goto exit;
845 }
846 _remaining = _env->GetArrayLength(equation_ref) - offset;
847 equation_base = (GLfixed *)
848 _env->GetPrimitiveArrayCritical(equation_ref, (jboolean *)0);
849 equation = equation_base + offset;
850
851 glClipPlanexOES(
852 (GLenum)plane,
853 (GLfixed *)equation
854 );
855
856 exit:
857 if (equation_base) {
858 _env->ReleasePrimitiveArrayCritical(equation_ref, equation_base,
859 JNI_ABORT);
860 }
861 if (_exception) {
862 jniThrowException(_env, _exceptionType, _exceptionMessage);
863 }
864 }
865
866 /* void glClipPlanexOES ( GLenum plane, const GLfixed *equation ) */
867 static void
android_glClipPlanexOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint plane,jobject equation_buf)868 android_glClipPlanexOES__ILjava_nio_IntBuffer_2
869 (JNIEnv *_env, jobject _this, jint plane, jobject equation_buf) {
870 jarray _array = (jarray) 0;
871 jint _bufferOffset = (jint) 0;
872 jint _remaining;
873 GLfixed *equation = (GLfixed *) 0;
874
875 equation = (GLfixed *)getPointer(_env, equation_buf, &_array, &_remaining, &_bufferOffset);
876 if (equation == NULL) {
877 char * _equationBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
878 equation = (GLfixed *) (_equationBase + _bufferOffset);
879 }
880 glClipPlanexOES(
881 (GLenum)plane,
882 (GLfixed *)equation
883 );
884 if (_array) {
885 releasePointer(_env, _array, equation, JNI_FALSE);
886 }
887 }
888
889 /* void glColor4xOES ( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) */
890 static void
android_glColor4xOES__IIII(JNIEnv * _env,jobject _this,jint red,jint green,jint blue,jint alpha)891 android_glColor4xOES__IIII
892 (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) {
893 glColor4xOES(
894 (GLfixed)red,
895 (GLfixed)green,
896 (GLfixed)blue,
897 (GLfixed)alpha
898 );
899 }
900
901 /* void glDepthRangexOES ( GLclampx zNear, GLclampx zFar ) */
902 static void
android_glDepthRangexOES__II(JNIEnv * _env,jobject _this,jint zNear,jint zFar)903 android_glDepthRangexOES__II
904 (JNIEnv *_env, jobject _this, jint zNear, jint zFar) {
905 glDepthRangexOES(
906 (GLclampx)zNear,
907 (GLclampx)zFar
908 );
909 }
910
911 /* void glFogxOES ( GLenum pname, GLfixed param ) */
912 static void
android_glFogxOES__II(JNIEnv * _env,jobject _this,jint pname,jint param)913 android_glFogxOES__II
914 (JNIEnv *_env, jobject _this, jint pname, jint param) {
915 glFogxOES(
916 (GLenum)pname,
917 (GLfixed)param
918 );
919 }
920
921 /* void glFogxvOES ( GLenum pname, const GLfixed *params ) */
922 static void
android_glFogxvOES__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray params_ref,jint offset)923 android_glFogxvOES__I_3II
924 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
925 jint _exception = 0;
926 const char * _exceptionType = NULL;
927 const char * _exceptionMessage = NULL;
928 GLfixed *params_base = (GLfixed *) 0;
929 jint _remaining;
930 GLfixed *params = (GLfixed *) 0;
931
932 if (!params_ref) {
933 _exception = 1;
934 _exceptionType = "java/lang/IllegalArgumentException";
935 _exceptionMessage = "params == null";
936 goto exit;
937 }
938 if (offset < 0) {
939 _exception = 1;
940 _exceptionType = "java/lang/IllegalArgumentException";
941 _exceptionMessage = "offset < 0";
942 goto exit;
943 }
944 _remaining = _env->GetArrayLength(params_ref) - offset;
945 params_base = (GLfixed *)
946 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
947 params = params_base + offset;
948
949 glFogxvOES(
950 (GLenum)pname,
951 (GLfixed *)params
952 );
953
954 exit:
955 if (params_base) {
956 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
957 JNI_ABORT);
958 }
959 if (_exception) {
960 jniThrowException(_env, _exceptionType, _exceptionMessage);
961 }
962 }
963
964 /* void glFogxvOES ( GLenum pname, const GLfixed *params ) */
965 static void
android_glFogxvOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)966 android_glFogxvOES__ILjava_nio_IntBuffer_2
967 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
968 jarray _array = (jarray) 0;
969 jint _bufferOffset = (jint) 0;
970 jint _remaining;
971 GLfixed *params = (GLfixed *) 0;
972
973 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
974 if (params == NULL) {
975 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
976 params = (GLfixed *) (_paramsBase + _bufferOffset);
977 }
978 glFogxvOES(
979 (GLenum)pname,
980 (GLfixed *)params
981 );
982 if (_array) {
983 releasePointer(_env, _array, params, JNI_FALSE);
984 }
985 }
986
987 /* void glFrustumxOES ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */
988 static void
android_glFrustumxOES__IIIIII(JNIEnv * _env,jobject _this,jint left,jint right,jint bottom,jint top,jint zNear,jint zFar)989 android_glFrustumxOES__IIIIII
990 (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) {
991 glFrustumxOES(
992 (GLfixed)left,
993 (GLfixed)right,
994 (GLfixed)bottom,
995 (GLfixed)top,
996 (GLfixed)zNear,
997 (GLfixed)zFar
998 );
999 }
1000
1001 /* void glGetClipPlanexOES ( GLenum pname, GLfixed *eqn ) */
1002 static void
android_glGetClipPlanexOES__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray eqn_ref,jint offset)1003 android_glGetClipPlanexOES__I_3II
1004 (JNIEnv *_env, jobject _this, jint pname, jintArray eqn_ref, jint offset) {
1005 jint _exception = 0;
1006 const char * _exceptionType = NULL;
1007 const char * _exceptionMessage = NULL;
1008 GLfixed *eqn_base = (GLfixed *) 0;
1009 jint _remaining;
1010 GLfixed *eqn = (GLfixed *) 0;
1011
1012 if (!eqn_ref) {
1013 _exception = 1;
1014 _exceptionType = "java/lang/IllegalArgumentException";
1015 _exceptionMessage = "eqn == null";
1016 goto exit;
1017 }
1018 if (offset < 0) {
1019 _exception = 1;
1020 _exceptionType = "java/lang/IllegalArgumentException";
1021 _exceptionMessage = "offset < 0";
1022 goto exit;
1023 }
1024 _remaining = _env->GetArrayLength(eqn_ref) - offset;
1025 if (_remaining < 4) {
1026 _exception = 1;
1027 _exceptionType = "java/lang/IllegalArgumentException";
1028 _exceptionMessage = "length - offset < 4 < needed";
1029 goto exit;
1030 }
1031 eqn_base = (GLfixed *)
1032 _env->GetPrimitiveArrayCritical(eqn_ref, (jboolean *)0);
1033 eqn = eqn_base + offset;
1034
1035 glGetClipPlanexOES(
1036 (GLenum)pname,
1037 (GLfixed *)eqn
1038 );
1039
1040 exit:
1041 if (eqn_base) {
1042 _env->ReleasePrimitiveArrayCritical(eqn_ref, eqn_base,
1043 _exception ? JNI_ABORT: 0);
1044 }
1045 if (_exception) {
1046 jniThrowException(_env, _exceptionType, _exceptionMessage);
1047 }
1048 }
1049
1050 /* void glGetClipPlanexOES ( GLenum pname, GLfixed *eqn ) */
1051 static void
android_glGetClipPlanexOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject eqn_buf)1052 android_glGetClipPlanexOES__ILjava_nio_IntBuffer_2
1053 (JNIEnv *_env, jobject _this, jint pname, jobject eqn_buf) {
1054 jint _exception = 0;
1055 const char * _exceptionType = NULL;
1056 const char * _exceptionMessage = NULL;
1057 jarray _array = (jarray) 0;
1058 jint _bufferOffset = (jint) 0;
1059 jint _remaining;
1060 GLfixed *eqn = (GLfixed *) 0;
1061
1062 eqn = (GLfixed *)getPointer(_env, eqn_buf, &_array, &_remaining, &_bufferOffset);
1063 if (_remaining < 4) {
1064 _exception = 1;
1065 _exceptionType = "java/lang/IllegalArgumentException";
1066 _exceptionMessage = "remaining() < 4 < needed";
1067 goto exit;
1068 }
1069 if (eqn == NULL) {
1070 char * _eqnBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1071 eqn = (GLfixed *) (_eqnBase + _bufferOffset);
1072 }
1073 glGetClipPlanexOES(
1074 (GLenum)pname,
1075 (GLfixed *)eqn
1076 );
1077
1078 exit:
1079 if (_array) {
1080 releasePointer(_env, _array, eqn, _exception ? JNI_FALSE : JNI_TRUE);
1081 }
1082 if (_exception) {
1083 jniThrowException(_env, _exceptionType, _exceptionMessage);
1084 }
1085 }
1086
1087 /* void glGetFixedvOES ( GLenum pname, GLfixed *params ) */
1088 static void
android_glGetFixedvOES__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray params_ref,jint offset)1089 android_glGetFixedvOES__I_3II
1090 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
1091 jint _exception = 0;
1092 const char * _exceptionType = NULL;
1093 const char * _exceptionMessage = NULL;
1094 GLfixed *params_base = (GLfixed *) 0;
1095 jint _remaining;
1096 GLfixed *params = (GLfixed *) 0;
1097
1098 if (!params_ref) {
1099 _exception = 1;
1100 _exceptionType = "java/lang/IllegalArgumentException";
1101 _exceptionMessage = "params == null";
1102 goto exit;
1103 }
1104 if (offset < 0) {
1105 _exception = 1;
1106 _exceptionType = "java/lang/IllegalArgumentException";
1107 _exceptionMessage = "offset < 0";
1108 goto exit;
1109 }
1110 _remaining = _env->GetArrayLength(params_ref) - offset;
1111 params_base = (GLfixed *)
1112 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1113 params = params_base + offset;
1114
1115 glGetFixedvOES(
1116 (GLenum)pname,
1117 (GLfixed *)params
1118 );
1119
1120 exit:
1121 if (params_base) {
1122 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1123 _exception ? JNI_ABORT: 0);
1124 }
1125 if (_exception) {
1126 jniThrowException(_env, _exceptionType, _exceptionMessage);
1127 }
1128 }
1129
1130 /* void glGetFixedvOES ( GLenum pname, GLfixed *params ) */
1131 static void
android_glGetFixedvOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)1132 android_glGetFixedvOES__ILjava_nio_IntBuffer_2
1133 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
1134 jarray _array = (jarray) 0;
1135 jint _bufferOffset = (jint) 0;
1136 jint _remaining;
1137 GLfixed *params = (GLfixed *) 0;
1138
1139 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
1140 if (params == NULL) {
1141 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1142 params = (GLfixed *) (_paramsBase + _bufferOffset);
1143 }
1144 glGetFixedvOES(
1145 (GLenum)pname,
1146 (GLfixed *)params
1147 );
1148 if (_array) {
1149 releasePointer(_env, _array, params, JNI_TRUE);
1150 }
1151 }
1152
1153 /* void glGetLightxvOES ( GLenum light, GLenum pname, GLfixed *params ) */
1154 static void
android_glGetLightxvOES__II_3II(JNIEnv * _env,jobject _this,jint light,jint pname,jintArray params_ref,jint offset)1155 android_glGetLightxvOES__II_3II
1156 (JNIEnv *_env, jobject _this, jint light, jint pname, jintArray params_ref, jint offset) {
1157 jint _exception = 0;
1158 const char * _exceptionType = NULL;
1159 const char * _exceptionMessage = NULL;
1160 GLfixed *params_base = (GLfixed *) 0;
1161 jint _remaining;
1162 GLfixed *params = (GLfixed *) 0;
1163
1164 if (!params_ref) {
1165 _exception = 1;
1166 _exceptionType = "java/lang/IllegalArgumentException";
1167 _exceptionMessage = "params == null";
1168 goto exit;
1169 }
1170 if (offset < 0) {
1171 _exception = 1;
1172 _exceptionType = "java/lang/IllegalArgumentException";
1173 _exceptionMessage = "offset < 0";
1174 goto exit;
1175 }
1176 _remaining = _env->GetArrayLength(params_ref) - offset;
1177 params_base = (GLfixed *)
1178 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1179 params = params_base + offset;
1180
1181 glGetLightxvOES(
1182 (GLenum)light,
1183 (GLenum)pname,
1184 (GLfixed *)params
1185 );
1186
1187 exit:
1188 if (params_base) {
1189 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1190 _exception ? JNI_ABORT: 0);
1191 }
1192 if (_exception) {
1193 jniThrowException(_env, _exceptionType, _exceptionMessage);
1194 }
1195 }
1196
1197 /* void glGetLightxvOES ( GLenum light, GLenum pname, GLfixed *params ) */
1198 static void
android_glGetLightxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint light,jint pname,jobject params_buf)1199 android_glGetLightxvOES__IILjava_nio_IntBuffer_2
1200 (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) {
1201 jarray _array = (jarray) 0;
1202 jint _bufferOffset = (jint) 0;
1203 jint _remaining;
1204 GLfixed *params = (GLfixed *) 0;
1205
1206 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
1207 if (params == NULL) {
1208 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1209 params = (GLfixed *) (_paramsBase + _bufferOffset);
1210 }
1211 glGetLightxvOES(
1212 (GLenum)light,
1213 (GLenum)pname,
1214 (GLfixed *)params
1215 );
1216 if (_array) {
1217 releasePointer(_env, _array, params, JNI_TRUE);
1218 }
1219 }
1220
1221 /* void glGetMaterialxvOES ( GLenum face, GLenum pname, GLfixed *params ) */
1222 static void
android_glGetMaterialxvOES__II_3II(JNIEnv * _env,jobject _this,jint face,jint pname,jintArray params_ref,jint offset)1223 android_glGetMaterialxvOES__II_3II
1224 (JNIEnv *_env, jobject _this, jint face, jint pname, jintArray params_ref, jint offset) {
1225 jint _exception = 0;
1226 const char * _exceptionType = NULL;
1227 const char * _exceptionMessage = NULL;
1228 GLfixed *params_base = (GLfixed *) 0;
1229 jint _remaining;
1230 GLfixed *params = (GLfixed *) 0;
1231
1232 if (!params_ref) {
1233 _exception = 1;
1234 _exceptionType = "java/lang/IllegalArgumentException";
1235 _exceptionMessage = "params == null";
1236 goto exit;
1237 }
1238 if (offset < 0) {
1239 _exception = 1;
1240 _exceptionType = "java/lang/IllegalArgumentException";
1241 _exceptionMessage = "offset < 0";
1242 goto exit;
1243 }
1244 _remaining = _env->GetArrayLength(params_ref) - offset;
1245 params_base = (GLfixed *)
1246 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1247 params = params_base + offset;
1248
1249 glGetMaterialxvOES(
1250 (GLenum)face,
1251 (GLenum)pname,
1252 (GLfixed *)params
1253 );
1254
1255 exit:
1256 if (params_base) {
1257 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1258 _exception ? JNI_ABORT: 0);
1259 }
1260 if (_exception) {
1261 jniThrowException(_env, _exceptionType, _exceptionMessage);
1262 }
1263 }
1264
1265 /* void glGetMaterialxvOES ( GLenum face, GLenum pname, GLfixed *params ) */
1266 static void
android_glGetMaterialxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint face,jint pname,jobject params_buf)1267 android_glGetMaterialxvOES__IILjava_nio_IntBuffer_2
1268 (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) {
1269 jarray _array = (jarray) 0;
1270 jint _bufferOffset = (jint) 0;
1271 jint _remaining;
1272 GLfixed *params = (GLfixed *) 0;
1273
1274 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
1275 if (params == NULL) {
1276 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1277 params = (GLfixed *) (_paramsBase + _bufferOffset);
1278 }
1279 glGetMaterialxvOES(
1280 (GLenum)face,
1281 (GLenum)pname,
1282 (GLfixed *)params
1283 );
1284 if (_array) {
1285 releasePointer(_env, _array, params, JNI_TRUE);
1286 }
1287 }
1288
1289 /* void glGetTexEnvxvOES ( GLenum env, GLenum pname, GLfixed *params ) */
1290 static void
android_glGetTexEnvxvOES__II_3II(JNIEnv * _env,jobject _this,jint env,jint pname,jintArray params_ref,jint offset)1291 android_glGetTexEnvxvOES__II_3II
1292 (JNIEnv *_env, jobject _this, jint env, jint pname, jintArray params_ref, jint offset) {
1293 jint _exception = 0;
1294 const char * _exceptionType = NULL;
1295 const char * _exceptionMessage = NULL;
1296 GLfixed *params_base = (GLfixed *) 0;
1297 jint _remaining;
1298 GLfixed *params = (GLfixed *) 0;
1299
1300 if (!params_ref) {
1301 _exception = 1;
1302 _exceptionType = "java/lang/IllegalArgumentException";
1303 _exceptionMessage = "params == null";
1304 goto exit;
1305 }
1306 if (offset < 0) {
1307 _exception = 1;
1308 _exceptionType = "java/lang/IllegalArgumentException";
1309 _exceptionMessage = "offset < 0";
1310 goto exit;
1311 }
1312 _remaining = _env->GetArrayLength(params_ref) - offset;
1313 params_base = (GLfixed *)
1314 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1315 params = params_base + offset;
1316
1317 glGetTexEnvxvOES(
1318 (GLenum)env,
1319 (GLenum)pname,
1320 (GLfixed *)params
1321 );
1322
1323 exit:
1324 if (params_base) {
1325 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1326 _exception ? JNI_ABORT: 0);
1327 }
1328 if (_exception) {
1329 jniThrowException(_env, _exceptionType, _exceptionMessage);
1330 }
1331 }
1332
1333 /* void glGetTexEnvxvOES ( GLenum env, GLenum pname, GLfixed *params ) */
1334 static void
android_glGetTexEnvxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint env,jint pname,jobject params_buf)1335 android_glGetTexEnvxvOES__IILjava_nio_IntBuffer_2
1336 (JNIEnv *_env, jobject _this, jint env, jint pname, jobject params_buf) {
1337 jarray _array = (jarray) 0;
1338 jint _bufferOffset = (jint) 0;
1339 jint _remaining;
1340 GLfixed *params = (GLfixed *) 0;
1341
1342 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
1343 if (params == NULL) {
1344 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1345 params = (GLfixed *) (_paramsBase + _bufferOffset);
1346 }
1347 glGetTexEnvxvOES(
1348 (GLenum)env,
1349 (GLenum)pname,
1350 (GLfixed *)params
1351 );
1352 if (_array) {
1353 releasePointer(_env, _array, params, JNI_TRUE);
1354 }
1355 }
1356
1357 /* void glGetTexParameterxvOES ( GLenum target, GLenum pname, GLfixed *params ) */
1358 static void
android_glGetTexParameterxvOES__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)1359 android_glGetTexParameterxvOES__II_3II
1360 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
1361 jint _exception = 0;
1362 const char * _exceptionType = NULL;
1363 const char * _exceptionMessage = NULL;
1364 GLfixed *params_base = (GLfixed *) 0;
1365 jint _remaining;
1366 GLfixed *params = (GLfixed *) 0;
1367
1368 if (!params_ref) {
1369 _exception = 1;
1370 _exceptionType = "java/lang/IllegalArgumentException";
1371 _exceptionMessage = "params == null";
1372 goto exit;
1373 }
1374 if (offset < 0) {
1375 _exception = 1;
1376 _exceptionType = "java/lang/IllegalArgumentException";
1377 _exceptionMessage = "offset < 0";
1378 goto exit;
1379 }
1380 _remaining = _env->GetArrayLength(params_ref) - offset;
1381 params_base = (GLfixed *)
1382 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1383 params = params_base + offset;
1384
1385 glGetTexParameterxvOES(
1386 (GLenum)target,
1387 (GLenum)pname,
1388 (GLfixed *)params
1389 );
1390
1391 exit:
1392 if (params_base) {
1393 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1394 _exception ? JNI_ABORT: 0);
1395 }
1396 if (_exception) {
1397 jniThrowException(_env, _exceptionType, _exceptionMessage);
1398 }
1399 }
1400
1401 /* void glGetTexParameterxvOES ( GLenum target, GLenum pname, GLfixed *params ) */
1402 static void
android_glGetTexParameterxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)1403 android_glGetTexParameterxvOES__IILjava_nio_IntBuffer_2
1404 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
1405 jarray _array = (jarray) 0;
1406 jint _bufferOffset = (jint) 0;
1407 jint _remaining;
1408 GLfixed *params = (GLfixed *) 0;
1409
1410 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
1411 if (params == NULL) {
1412 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1413 params = (GLfixed *) (_paramsBase + _bufferOffset);
1414 }
1415 glGetTexParameterxvOES(
1416 (GLenum)target,
1417 (GLenum)pname,
1418 (GLfixed *)params
1419 );
1420 if (_array) {
1421 releasePointer(_env, _array, params, JNI_TRUE);
1422 }
1423 }
1424
1425 /* void glLightModelxOES ( GLenum pname, GLfixed param ) */
1426 static void
android_glLightModelxOES__II(JNIEnv * _env,jobject _this,jint pname,jint param)1427 android_glLightModelxOES__II
1428 (JNIEnv *_env, jobject _this, jint pname, jint param) {
1429 glLightModelxOES(
1430 (GLenum)pname,
1431 (GLfixed)param
1432 );
1433 }
1434
1435 /* void glLightModelxvOES ( GLenum pname, const GLfixed *params ) */
1436 static void
android_glLightModelxvOES__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray params_ref,jint offset)1437 android_glLightModelxvOES__I_3II
1438 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
1439 jint _exception = 0;
1440 const char * _exceptionType = NULL;
1441 const char * _exceptionMessage = NULL;
1442 GLfixed *params_base = (GLfixed *) 0;
1443 jint _remaining;
1444 GLfixed *params = (GLfixed *) 0;
1445
1446 if (!params_ref) {
1447 _exception = 1;
1448 _exceptionType = "java/lang/IllegalArgumentException";
1449 _exceptionMessage = "params == null";
1450 goto exit;
1451 }
1452 if (offset < 0) {
1453 _exception = 1;
1454 _exceptionType = "java/lang/IllegalArgumentException";
1455 _exceptionMessage = "offset < 0";
1456 goto exit;
1457 }
1458 _remaining = _env->GetArrayLength(params_ref) - offset;
1459 params_base = (GLfixed *)
1460 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1461 params = params_base + offset;
1462
1463 glLightModelxvOES(
1464 (GLenum)pname,
1465 (GLfixed *)params
1466 );
1467
1468 exit:
1469 if (params_base) {
1470 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1471 JNI_ABORT);
1472 }
1473 if (_exception) {
1474 jniThrowException(_env, _exceptionType, _exceptionMessage);
1475 }
1476 }
1477
1478 /* void glLightModelxvOES ( GLenum pname, const GLfixed *params ) */
1479 static void
android_glLightModelxvOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)1480 android_glLightModelxvOES__ILjava_nio_IntBuffer_2
1481 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
1482 jarray _array = (jarray) 0;
1483 jint _bufferOffset = (jint) 0;
1484 jint _remaining;
1485 GLfixed *params = (GLfixed *) 0;
1486
1487 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
1488 if (params == NULL) {
1489 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1490 params = (GLfixed *) (_paramsBase + _bufferOffset);
1491 }
1492 glLightModelxvOES(
1493 (GLenum)pname,
1494 (GLfixed *)params
1495 );
1496 if (_array) {
1497 releasePointer(_env, _array, params, JNI_FALSE);
1498 }
1499 }
1500
1501 /* void glLightxOES ( GLenum light, GLenum pname, GLfixed param ) */
1502 static void
android_glLightxOES__III(JNIEnv * _env,jobject _this,jint light,jint pname,jint param)1503 android_glLightxOES__III
1504 (JNIEnv *_env, jobject _this, jint light, jint pname, jint param) {
1505 glLightxOES(
1506 (GLenum)light,
1507 (GLenum)pname,
1508 (GLfixed)param
1509 );
1510 }
1511
1512 /* void glLightxvOES ( GLenum light, GLenum pname, const GLfixed *params ) */
1513 static void
android_glLightxvOES__II_3II(JNIEnv * _env,jobject _this,jint light,jint pname,jintArray params_ref,jint offset)1514 android_glLightxvOES__II_3II
1515 (JNIEnv *_env, jobject _this, jint light, jint pname, jintArray params_ref, jint offset) {
1516 jint _exception = 0;
1517 const char * _exceptionType = NULL;
1518 const char * _exceptionMessage = NULL;
1519 GLfixed *params_base = (GLfixed *) 0;
1520 jint _remaining;
1521 GLfixed *params = (GLfixed *) 0;
1522
1523 if (!params_ref) {
1524 _exception = 1;
1525 _exceptionType = "java/lang/IllegalArgumentException";
1526 _exceptionMessage = "params == null";
1527 goto exit;
1528 }
1529 if (offset < 0) {
1530 _exception = 1;
1531 _exceptionType = "java/lang/IllegalArgumentException";
1532 _exceptionMessage = "offset < 0";
1533 goto exit;
1534 }
1535 _remaining = _env->GetArrayLength(params_ref) - offset;
1536 params_base = (GLfixed *)
1537 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1538 params = params_base + offset;
1539
1540 glLightxvOES(
1541 (GLenum)light,
1542 (GLenum)pname,
1543 (GLfixed *)params
1544 );
1545
1546 exit:
1547 if (params_base) {
1548 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1549 JNI_ABORT);
1550 }
1551 if (_exception) {
1552 jniThrowException(_env, _exceptionType, _exceptionMessage);
1553 }
1554 }
1555
1556 /* void glLightxvOES ( GLenum light, GLenum pname, const GLfixed *params ) */
1557 static void
android_glLightxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint light,jint pname,jobject params_buf)1558 android_glLightxvOES__IILjava_nio_IntBuffer_2
1559 (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) {
1560 jarray _array = (jarray) 0;
1561 jint _bufferOffset = (jint) 0;
1562 jint _remaining;
1563 GLfixed *params = (GLfixed *) 0;
1564
1565 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
1566 if (params == NULL) {
1567 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1568 params = (GLfixed *) (_paramsBase + _bufferOffset);
1569 }
1570 glLightxvOES(
1571 (GLenum)light,
1572 (GLenum)pname,
1573 (GLfixed *)params
1574 );
1575 if (_array) {
1576 releasePointer(_env, _array, params, JNI_FALSE);
1577 }
1578 }
1579
1580 /* void glLineWidthxOES ( GLfixed width ) */
1581 static void
android_glLineWidthxOES__I(JNIEnv * _env,jobject _this,jint width)1582 android_glLineWidthxOES__I
1583 (JNIEnv *_env, jobject _this, jint width) {
1584 glLineWidthxOES(
1585 (GLfixed)width
1586 );
1587 }
1588
1589 /* void glLoadMatrixxOES ( const GLfixed *m ) */
1590 static void
android_glLoadMatrixxOES___3II(JNIEnv * _env,jobject _this,jintArray m_ref,jint offset)1591 android_glLoadMatrixxOES___3II
1592 (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) {
1593 jint _exception = 0;
1594 const char * _exceptionType = NULL;
1595 const char * _exceptionMessage = NULL;
1596 GLfixed *m_base = (GLfixed *) 0;
1597 jint _remaining;
1598 GLfixed *m = (GLfixed *) 0;
1599
1600 if (!m_ref) {
1601 _exception = 1;
1602 _exceptionType = "java/lang/IllegalArgumentException";
1603 _exceptionMessage = "m == null";
1604 goto exit;
1605 }
1606 if (offset < 0) {
1607 _exception = 1;
1608 _exceptionType = "java/lang/IllegalArgumentException";
1609 _exceptionMessage = "offset < 0";
1610 goto exit;
1611 }
1612 _remaining = _env->GetArrayLength(m_ref) - offset;
1613 m_base = (GLfixed *)
1614 _env->GetPrimitiveArrayCritical(m_ref, (jboolean *)0);
1615 m = m_base + offset;
1616
1617 glLoadMatrixxOES(
1618 (GLfixed *)m
1619 );
1620
1621 exit:
1622 if (m_base) {
1623 _env->ReleasePrimitiveArrayCritical(m_ref, m_base,
1624 JNI_ABORT);
1625 }
1626 if (_exception) {
1627 jniThrowException(_env, _exceptionType, _exceptionMessage);
1628 }
1629 }
1630
1631 /* void glLoadMatrixxOES ( const GLfixed *m ) */
1632 static void
android_glLoadMatrixxOES__Ljava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jobject m_buf)1633 android_glLoadMatrixxOES__Ljava_nio_IntBuffer_2
1634 (JNIEnv *_env, jobject _this, jobject m_buf) {
1635 jarray _array = (jarray) 0;
1636 jint _bufferOffset = (jint) 0;
1637 jint _remaining;
1638 GLfixed *m = (GLfixed *) 0;
1639
1640 m = (GLfixed *)getPointer(_env, m_buf, &_array, &_remaining, &_bufferOffset);
1641 if (m == NULL) {
1642 char * _mBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1643 m = (GLfixed *) (_mBase + _bufferOffset);
1644 }
1645 glLoadMatrixxOES(
1646 (GLfixed *)m
1647 );
1648 if (_array) {
1649 releasePointer(_env, _array, m, JNI_FALSE);
1650 }
1651 }
1652
1653 /* void glMaterialxOES ( GLenum face, GLenum pname, GLfixed param ) */
1654 static void
android_glMaterialxOES__III(JNIEnv * _env,jobject _this,jint face,jint pname,jint param)1655 android_glMaterialxOES__III
1656 (JNIEnv *_env, jobject _this, jint face, jint pname, jint param) {
1657 glMaterialxOES(
1658 (GLenum)face,
1659 (GLenum)pname,
1660 (GLfixed)param
1661 );
1662 }
1663
1664 /* void glMaterialxvOES ( GLenum face, GLenum pname, const GLfixed *params ) */
1665 static void
android_glMaterialxvOES__II_3II(JNIEnv * _env,jobject _this,jint face,jint pname,jintArray params_ref,jint offset)1666 android_glMaterialxvOES__II_3II
1667 (JNIEnv *_env, jobject _this, jint face, jint pname, jintArray params_ref, jint offset) {
1668 jint _exception = 0;
1669 const char * _exceptionType = NULL;
1670 const char * _exceptionMessage = NULL;
1671 GLfixed *params_base = (GLfixed *) 0;
1672 jint _remaining;
1673 GLfixed *params = (GLfixed *) 0;
1674
1675 if (!params_ref) {
1676 _exception = 1;
1677 _exceptionType = "java/lang/IllegalArgumentException";
1678 _exceptionMessage = "params == null";
1679 goto exit;
1680 }
1681 if (offset < 0) {
1682 _exception = 1;
1683 _exceptionType = "java/lang/IllegalArgumentException";
1684 _exceptionMessage = "offset < 0";
1685 goto exit;
1686 }
1687 _remaining = _env->GetArrayLength(params_ref) - offset;
1688 params_base = (GLfixed *)
1689 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1690 params = params_base + offset;
1691
1692 glMaterialxvOES(
1693 (GLenum)face,
1694 (GLenum)pname,
1695 (GLfixed *)params
1696 );
1697
1698 exit:
1699 if (params_base) {
1700 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1701 JNI_ABORT);
1702 }
1703 if (_exception) {
1704 jniThrowException(_env, _exceptionType, _exceptionMessage);
1705 }
1706 }
1707
1708 /* void glMaterialxvOES ( GLenum face, GLenum pname, const GLfixed *params ) */
1709 static void
android_glMaterialxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint face,jint pname,jobject params_buf)1710 android_glMaterialxvOES__IILjava_nio_IntBuffer_2
1711 (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) {
1712 jarray _array = (jarray) 0;
1713 jint _bufferOffset = (jint) 0;
1714 jint _remaining;
1715 GLfixed *params = (GLfixed *) 0;
1716
1717 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
1718 if (params == NULL) {
1719 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1720 params = (GLfixed *) (_paramsBase + _bufferOffset);
1721 }
1722 glMaterialxvOES(
1723 (GLenum)face,
1724 (GLenum)pname,
1725 (GLfixed *)params
1726 );
1727 if (_array) {
1728 releasePointer(_env, _array, params, JNI_FALSE);
1729 }
1730 }
1731
1732 /* void glMultMatrixxOES ( const GLfixed *m ) */
1733 static void
android_glMultMatrixxOES___3II(JNIEnv * _env,jobject _this,jintArray m_ref,jint offset)1734 android_glMultMatrixxOES___3II
1735 (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) {
1736 jint _exception = 0;
1737 const char * _exceptionType = NULL;
1738 const char * _exceptionMessage = NULL;
1739 GLfixed *m_base = (GLfixed *) 0;
1740 jint _remaining;
1741 GLfixed *m = (GLfixed *) 0;
1742
1743 if (!m_ref) {
1744 _exception = 1;
1745 _exceptionType = "java/lang/IllegalArgumentException";
1746 _exceptionMessage = "m == null";
1747 goto exit;
1748 }
1749 if (offset < 0) {
1750 _exception = 1;
1751 _exceptionType = "java/lang/IllegalArgumentException";
1752 _exceptionMessage = "offset < 0";
1753 goto exit;
1754 }
1755 _remaining = _env->GetArrayLength(m_ref) - offset;
1756 m_base = (GLfixed *)
1757 _env->GetPrimitiveArrayCritical(m_ref, (jboolean *)0);
1758 m = m_base + offset;
1759
1760 glMultMatrixxOES(
1761 (GLfixed *)m
1762 );
1763
1764 exit:
1765 if (m_base) {
1766 _env->ReleasePrimitiveArrayCritical(m_ref, m_base,
1767 JNI_ABORT);
1768 }
1769 if (_exception) {
1770 jniThrowException(_env, _exceptionType, _exceptionMessage);
1771 }
1772 }
1773
1774 /* void glMultMatrixxOES ( const GLfixed *m ) */
1775 static void
android_glMultMatrixxOES__Ljava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jobject m_buf)1776 android_glMultMatrixxOES__Ljava_nio_IntBuffer_2
1777 (JNIEnv *_env, jobject _this, jobject m_buf) {
1778 jarray _array = (jarray) 0;
1779 jint _bufferOffset = (jint) 0;
1780 jint _remaining;
1781 GLfixed *m = (GLfixed *) 0;
1782
1783 m = (GLfixed *)getPointer(_env, m_buf, &_array, &_remaining, &_bufferOffset);
1784 if (m == NULL) {
1785 char * _mBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1786 m = (GLfixed *) (_mBase + _bufferOffset);
1787 }
1788 glMultMatrixxOES(
1789 (GLfixed *)m
1790 );
1791 if (_array) {
1792 releasePointer(_env, _array, m, JNI_FALSE);
1793 }
1794 }
1795
1796 /* void glMultiTexCoord4xOES ( GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q ) */
1797 static void
android_glMultiTexCoord4xOES__IIIII(JNIEnv * _env,jobject _this,jint target,jint s,jint t,jint r,jint q)1798 android_glMultiTexCoord4xOES__IIIII
1799 (JNIEnv *_env, jobject _this, jint target, jint s, jint t, jint r, jint q) {
1800 glMultiTexCoord4xOES(
1801 (GLenum)target,
1802 (GLfixed)s,
1803 (GLfixed)t,
1804 (GLfixed)r,
1805 (GLfixed)q
1806 );
1807 }
1808
1809 /* void glNormal3xOES ( GLfixed nx, GLfixed ny, GLfixed nz ) */
1810 static void
android_glNormal3xOES__III(JNIEnv * _env,jobject _this,jint nx,jint ny,jint nz)1811 android_glNormal3xOES__III
1812 (JNIEnv *_env, jobject _this, jint nx, jint ny, jint nz) {
1813 glNormal3xOES(
1814 (GLfixed)nx,
1815 (GLfixed)ny,
1816 (GLfixed)nz
1817 );
1818 }
1819
1820 /* void glOrthoxOES ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */
1821 static void
android_glOrthoxOES__IIIIII(JNIEnv * _env,jobject _this,jint left,jint right,jint bottom,jint top,jint zNear,jint zFar)1822 android_glOrthoxOES__IIIIII
1823 (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) {
1824 glOrthoxOES(
1825 (GLfixed)left,
1826 (GLfixed)right,
1827 (GLfixed)bottom,
1828 (GLfixed)top,
1829 (GLfixed)zNear,
1830 (GLfixed)zFar
1831 );
1832 }
1833
1834 /* void glPointParameterxOES ( GLenum pname, GLfixed param ) */
1835 static void
android_glPointParameterxOES__II(JNIEnv * _env,jobject _this,jint pname,jint param)1836 android_glPointParameterxOES__II
1837 (JNIEnv *_env, jobject _this, jint pname, jint param) {
1838 glPointParameterxOES(
1839 (GLenum)pname,
1840 (GLfixed)param
1841 );
1842 }
1843
1844 /* void glPointParameterxvOES ( GLenum pname, const GLfixed *params ) */
1845 static void
android_glPointParameterxvOES__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray params_ref,jint offset)1846 android_glPointParameterxvOES__I_3II
1847 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
1848 jint _exception = 0;
1849 const char * _exceptionType = NULL;
1850 const char * _exceptionMessage = NULL;
1851 GLfixed *params_base = (GLfixed *) 0;
1852 jint _remaining;
1853 GLfixed *params = (GLfixed *) 0;
1854
1855 if (!params_ref) {
1856 _exception = 1;
1857 _exceptionType = "java/lang/IllegalArgumentException";
1858 _exceptionMessage = "params == null";
1859 goto exit;
1860 }
1861 if (offset < 0) {
1862 _exception = 1;
1863 _exceptionType = "java/lang/IllegalArgumentException";
1864 _exceptionMessage = "offset < 0";
1865 goto exit;
1866 }
1867 _remaining = _env->GetArrayLength(params_ref) - offset;
1868 params_base = (GLfixed *)
1869 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1870 params = params_base + offset;
1871
1872 glPointParameterxvOES(
1873 (GLenum)pname,
1874 (GLfixed *)params
1875 );
1876
1877 exit:
1878 if (params_base) {
1879 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1880 JNI_ABORT);
1881 }
1882 if (_exception) {
1883 jniThrowException(_env, _exceptionType, _exceptionMessage);
1884 }
1885 }
1886
1887 /* void glPointParameterxvOES ( GLenum pname, const GLfixed *params ) */
1888 static void
android_glPointParameterxvOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)1889 android_glPointParameterxvOES__ILjava_nio_IntBuffer_2
1890 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
1891 jarray _array = (jarray) 0;
1892 jint _bufferOffset = (jint) 0;
1893 jint _remaining;
1894 GLfixed *params = (GLfixed *) 0;
1895
1896 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
1897 if (params == NULL) {
1898 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1899 params = (GLfixed *) (_paramsBase + _bufferOffset);
1900 }
1901 glPointParameterxvOES(
1902 (GLenum)pname,
1903 (GLfixed *)params
1904 );
1905 if (_array) {
1906 releasePointer(_env, _array, params, JNI_FALSE);
1907 }
1908 }
1909
1910 /* void glPointSizexOES ( GLfixed size ) */
1911 static void
android_glPointSizexOES__I(JNIEnv * _env,jobject _this,jint size)1912 android_glPointSizexOES__I
1913 (JNIEnv *_env, jobject _this, jint size) {
1914 glPointSizexOES(
1915 (GLfixed)size
1916 );
1917 }
1918
1919 /* void glPolygonOffsetxOES ( GLfixed factor, GLfixed units ) */
1920 static void
android_glPolygonOffsetxOES__II(JNIEnv * _env,jobject _this,jint factor,jint units)1921 android_glPolygonOffsetxOES__II
1922 (JNIEnv *_env, jobject _this, jint factor, jint units) {
1923 glPolygonOffsetxOES(
1924 (GLfixed)factor,
1925 (GLfixed)units
1926 );
1927 }
1928
1929 /* void glRotatexOES ( GLfixed angle, GLfixed x, GLfixed y, GLfixed z ) */
1930 static void
android_glRotatexOES__IIII(JNIEnv * _env,jobject _this,jint angle,jint x,jint y,jint z)1931 android_glRotatexOES__IIII
1932 (JNIEnv *_env, jobject _this, jint angle, jint x, jint y, jint z) {
1933 glRotatexOES(
1934 (GLfixed)angle,
1935 (GLfixed)x,
1936 (GLfixed)y,
1937 (GLfixed)z
1938 );
1939 }
1940
1941 /* void glSampleCoveragexOES ( GLclampx value, GLboolean invert ) */
1942 static void
android_glSampleCoveragexOES__IZ(JNIEnv * _env,jobject _this,jint value,jboolean invert)1943 android_glSampleCoveragexOES__IZ
1944 (JNIEnv *_env, jobject _this, jint value, jboolean invert) {
1945 glSampleCoveragexOES(
1946 (GLclampx)value,
1947 (GLboolean)invert
1948 );
1949 }
1950
1951 /* void glScalexOES ( GLfixed x, GLfixed y, GLfixed z ) */
1952 static void
android_glScalexOES__III(JNIEnv * _env,jobject _this,jint x,jint y,jint z)1953 android_glScalexOES__III
1954 (JNIEnv *_env, jobject _this, jint x, jint y, jint z) {
1955 glScalexOES(
1956 (GLfixed)x,
1957 (GLfixed)y,
1958 (GLfixed)z
1959 );
1960 }
1961
1962 /* void glTexEnvxOES ( GLenum target, GLenum pname, GLfixed param ) */
1963 static void
android_glTexEnvxOES__III(JNIEnv * _env,jobject _this,jint target,jint pname,jint param)1964 android_glTexEnvxOES__III
1965 (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) {
1966 glTexEnvxOES(
1967 (GLenum)target,
1968 (GLenum)pname,
1969 (GLfixed)param
1970 );
1971 }
1972
1973 /* void glTexEnvxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */
1974 static void
android_glTexEnvxvOES__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)1975 android_glTexEnvxvOES__II_3II
1976 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
1977 jint _exception = 0;
1978 const char * _exceptionType = NULL;
1979 const char * _exceptionMessage = NULL;
1980 GLfixed *params_base = (GLfixed *) 0;
1981 jint _remaining;
1982 GLfixed *params = (GLfixed *) 0;
1983
1984 if (!params_ref) {
1985 _exception = 1;
1986 _exceptionType = "java/lang/IllegalArgumentException";
1987 _exceptionMessage = "params == null";
1988 goto exit;
1989 }
1990 if (offset < 0) {
1991 _exception = 1;
1992 _exceptionType = "java/lang/IllegalArgumentException";
1993 _exceptionMessage = "offset < 0";
1994 goto exit;
1995 }
1996 _remaining = _env->GetArrayLength(params_ref) - offset;
1997 params_base = (GLfixed *)
1998 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1999 params = params_base + offset;
2000
2001 glTexEnvxvOES(
2002 (GLenum)target,
2003 (GLenum)pname,
2004 (GLfixed *)params
2005 );
2006
2007 exit:
2008 if (params_base) {
2009 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2010 JNI_ABORT);
2011 }
2012 if (_exception) {
2013 jniThrowException(_env, _exceptionType, _exceptionMessage);
2014 }
2015 }
2016
2017 /* void glTexEnvxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */
2018 static void
android_glTexEnvxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)2019 android_glTexEnvxvOES__IILjava_nio_IntBuffer_2
2020 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
2021 jarray _array = (jarray) 0;
2022 jint _bufferOffset = (jint) 0;
2023 jint _remaining;
2024 GLfixed *params = (GLfixed *) 0;
2025
2026 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
2027 if (params == NULL) {
2028 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
2029 params = (GLfixed *) (_paramsBase + _bufferOffset);
2030 }
2031 glTexEnvxvOES(
2032 (GLenum)target,
2033 (GLenum)pname,
2034 (GLfixed *)params
2035 );
2036 if (_array) {
2037 releasePointer(_env, _array, params, JNI_FALSE);
2038 }
2039 }
2040
2041 /* void glTexParameterxOES ( GLenum target, GLenum pname, GLfixed param ) */
2042 static void
android_glTexParameterxOES__III(JNIEnv * _env,jobject _this,jint target,jint pname,jint param)2043 android_glTexParameterxOES__III
2044 (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) {
2045 glTexParameterxOES(
2046 (GLenum)target,
2047 (GLenum)pname,
2048 (GLfixed)param
2049 );
2050 }
2051
2052 /* void glTexParameterxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */
2053 static void
android_glTexParameterxvOES__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)2054 android_glTexParameterxvOES__II_3II
2055 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
2056 jint _exception = 0;
2057 const char * _exceptionType = NULL;
2058 const char * _exceptionMessage = NULL;
2059 GLfixed *params_base = (GLfixed *) 0;
2060 jint _remaining;
2061 GLfixed *params = (GLfixed *) 0;
2062
2063 if (!params_ref) {
2064 _exception = 1;
2065 _exceptionType = "java/lang/IllegalArgumentException";
2066 _exceptionMessage = "params == null";
2067 goto exit;
2068 }
2069 if (offset < 0) {
2070 _exception = 1;
2071 _exceptionType = "java/lang/IllegalArgumentException";
2072 _exceptionMessage = "offset < 0";
2073 goto exit;
2074 }
2075 _remaining = _env->GetArrayLength(params_ref) - offset;
2076 params_base = (GLfixed *)
2077 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2078 params = params_base + offset;
2079
2080 glTexParameterxvOES(
2081 (GLenum)target,
2082 (GLenum)pname,
2083 (GLfixed *)params
2084 );
2085
2086 exit:
2087 if (params_base) {
2088 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2089 JNI_ABORT);
2090 }
2091 if (_exception) {
2092 jniThrowException(_env, _exceptionType, _exceptionMessage);
2093 }
2094 }
2095
2096 /* void glTexParameterxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */
2097 static void
android_glTexParameterxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)2098 android_glTexParameterxvOES__IILjava_nio_IntBuffer_2
2099 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
2100 jarray _array = (jarray) 0;
2101 jint _bufferOffset = (jint) 0;
2102 jint _remaining;
2103 GLfixed *params = (GLfixed *) 0;
2104
2105 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
2106 if (params == NULL) {
2107 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
2108 params = (GLfixed *) (_paramsBase + _bufferOffset);
2109 }
2110 glTexParameterxvOES(
2111 (GLenum)target,
2112 (GLenum)pname,
2113 (GLfixed *)params
2114 );
2115 if (_array) {
2116 releasePointer(_env, _array, params, JNI_FALSE);
2117 }
2118 }
2119
2120 /* void glTranslatexOES ( GLfixed x, GLfixed y, GLfixed z ) */
2121 static void
android_glTranslatexOES__III(JNIEnv * _env,jobject _this,jint x,jint y,jint z)2122 android_glTranslatexOES__III
2123 (JNIEnv *_env, jobject _this, jint x, jint y, jint z) {
2124 glTranslatexOES(
2125 (GLfixed)x,
2126 (GLfixed)y,
2127 (GLfixed)z
2128 );
2129 }
2130
2131 /* GLboolean glIsRenderbufferOES ( GLuint renderbuffer ) */
2132 static jboolean
android_glIsRenderbufferOES__I(JNIEnv * _env,jobject _this,jint renderbuffer)2133 android_glIsRenderbufferOES__I
2134 (JNIEnv *_env, jobject _this, jint renderbuffer) {
2135 GLboolean _returnValue;
2136 _returnValue = glIsRenderbufferOES(
2137 (GLuint)renderbuffer
2138 );
2139 return (jboolean)_returnValue;
2140 }
2141
2142 /* void glBindRenderbufferOES ( GLenum target, GLuint renderbuffer ) */
2143 static void
android_glBindRenderbufferOES__II(JNIEnv * _env,jobject _this,jint target,jint renderbuffer)2144 android_glBindRenderbufferOES__II
2145 (JNIEnv *_env, jobject _this, jint target, jint renderbuffer) {
2146 glBindRenderbufferOES(
2147 (GLenum)target,
2148 (GLuint)renderbuffer
2149 );
2150 }
2151
2152 /* void glDeleteRenderbuffersOES ( GLsizei n, const GLuint *renderbuffers ) */
2153 static void
android_glDeleteRenderbuffersOES__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray renderbuffers_ref,jint offset)2154 android_glDeleteRenderbuffersOES__I_3II
2155 (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) {
2156 jint _exception = 0;
2157 const char * _exceptionType = NULL;
2158 const char * _exceptionMessage = NULL;
2159 GLuint *renderbuffers_base = (GLuint *) 0;
2160 jint _remaining;
2161 GLuint *renderbuffers = (GLuint *) 0;
2162
2163 if (!renderbuffers_ref) {
2164 _exception = 1;
2165 _exceptionType = "java/lang/IllegalArgumentException";
2166 _exceptionMessage = "renderbuffers == null";
2167 goto exit;
2168 }
2169 if (offset < 0) {
2170 _exception = 1;
2171 _exceptionType = "java/lang/IllegalArgumentException";
2172 _exceptionMessage = "offset < 0";
2173 goto exit;
2174 }
2175 _remaining = _env->GetArrayLength(renderbuffers_ref) - offset;
2176 if (_remaining < n) {
2177 _exception = 1;
2178 _exceptionType = "java/lang/IllegalArgumentException";
2179 _exceptionMessage = "length - offset < n < needed";
2180 goto exit;
2181 }
2182 renderbuffers_base = (GLuint *)
2183 _env->GetPrimitiveArrayCritical(renderbuffers_ref, (jboolean *)0);
2184 renderbuffers = renderbuffers_base + offset;
2185
2186 glDeleteRenderbuffersOES(
2187 (GLsizei)n,
2188 (GLuint *)renderbuffers
2189 );
2190
2191 exit:
2192 if (renderbuffers_base) {
2193 _env->ReleasePrimitiveArrayCritical(renderbuffers_ref, renderbuffers_base,
2194 JNI_ABORT);
2195 }
2196 if (_exception) {
2197 jniThrowException(_env, _exceptionType, _exceptionMessage);
2198 }
2199 }
2200
2201 /* void glDeleteRenderbuffersOES ( GLsizei n, const GLuint *renderbuffers ) */
2202 static void
android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject renderbuffers_buf)2203 android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2
2204 (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) {
2205 jint _exception = 0;
2206 const char * _exceptionType = NULL;
2207 const char * _exceptionMessage = NULL;
2208 jarray _array = (jarray) 0;
2209 jint _bufferOffset = (jint) 0;
2210 jint _remaining;
2211 GLuint *renderbuffers = (GLuint *) 0;
2212
2213 renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, &_array, &_remaining, &_bufferOffset);
2214 if (_remaining < n) {
2215 _exception = 1;
2216 _exceptionType = "java/lang/IllegalArgumentException";
2217 _exceptionMessage = "remaining() < n < needed";
2218 goto exit;
2219 }
2220 if (renderbuffers == NULL) {
2221 char * _renderbuffersBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
2222 renderbuffers = (GLuint *) (_renderbuffersBase + _bufferOffset);
2223 }
2224 glDeleteRenderbuffersOES(
2225 (GLsizei)n,
2226 (GLuint *)renderbuffers
2227 );
2228
2229 exit:
2230 if (_array) {
2231 releasePointer(_env, _array, renderbuffers, JNI_FALSE);
2232 }
2233 if (_exception) {
2234 jniThrowException(_env, _exceptionType, _exceptionMessage);
2235 }
2236 }
2237
2238 /* void glGenRenderbuffersOES ( GLsizei n, GLuint *renderbuffers ) */
2239 static void
android_glGenRenderbuffersOES__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray renderbuffers_ref,jint offset)2240 android_glGenRenderbuffersOES__I_3II
2241 (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) {
2242 jint _exception = 0;
2243 const char * _exceptionType = NULL;
2244 const char * _exceptionMessage = NULL;
2245 GLuint *renderbuffers_base = (GLuint *) 0;
2246 jint _remaining;
2247 GLuint *renderbuffers = (GLuint *) 0;
2248
2249 if (!renderbuffers_ref) {
2250 _exception = 1;
2251 _exceptionType = "java/lang/IllegalArgumentException";
2252 _exceptionMessage = "renderbuffers == null";
2253 goto exit;
2254 }
2255 if (offset < 0) {
2256 _exception = 1;
2257 _exceptionType = "java/lang/IllegalArgumentException";
2258 _exceptionMessage = "offset < 0";
2259 goto exit;
2260 }
2261 _remaining = _env->GetArrayLength(renderbuffers_ref) - offset;
2262 if (_remaining < n) {
2263 _exception = 1;
2264 _exceptionType = "java/lang/IllegalArgumentException";
2265 _exceptionMessage = "length - offset < n < needed";
2266 goto exit;
2267 }
2268 renderbuffers_base = (GLuint *)
2269 _env->GetPrimitiveArrayCritical(renderbuffers_ref, (jboolean *)0);
2270 renderbuffers = renderbuffers_base + offset;
2271
2272 glGenRenderbuffersOES(
2273 (GLsizei)n,
2274 (GLuint *)renderbuffers
2275 );
2276
2277 exit:
2278 if (renderbuffers_base) {
2279 _env->ReleasePrimitiveArrayCritical(renderbuffers_ref, renderbuffers_base,
2280 _exception ? JNI_ABORT: 0);
2281 }
2282 if (_exception) {
2283 jniThrowException(_env, _exceptionType, _exceptionMessage);
2284 }
2285 }
2286
2287 /* void glGenRenderbuffersOES ( GLsizei n, GLuint *renderbuffers ) */
2288 static void
android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject renderbuffers_buf)2289 android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2
2290 (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) {
2291 jint _exception = 0;
2292 const char * _exceptionType = NULL;
2293 const char * _exceptionMessage = NULL;
2294 jarray _array = (jarray) 0;
2295 jint _bufferOffset = (jint) 0;
2296 jint _remaining;
2297 GLuint *renderbuffers = (GLuint *) 0;
2298
2299 renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, &_array, &_remaining, &_bufferOffset);
2300 if (_remaining < n) {
2301 _exception = 1;
2302 _exceptionType = "java/lang/IllegalArgumentException";
2303 _exceptionMessage = "remaining() < n < needed";
2304 goto exit;
2305 }
2306 if (renderbuffers == NULL) {
2307 char * _renderbuffersBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
2308 renderbuffers = (GLuint *) (_renderbuffersBase + _bufferOffset);
2309 }
2310 glGenRenderbuffersOES(
2311 (GLsizei)n,
2312 (GLuint *)renderbuffers
2313 );
2314
2315 exit:
2316 if (_array) {
2317 releasePointer(_env, _array, renderbuffers, _exception ? JNI_FALSE : JNI_TRUE);
2318 }
2319 if (_exception) {
2320 jniThrowException(_env, _exceptionType, _exceptionMessage);
2321 }
2322 }
2323
2324 /* void glRenderbufferStorageOES ( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) */
2325 static void
android_glRenderbufferStorageOES__IIII(JNIEnv * _env,jobject _this,jint target,jint internalformat,jint width,jint height)2326 android_glRenderbufferStorageOES__IIII
2327 (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint width, jint height) {
2328 glRenderbufferStorageOES(
2329 (GLenum)target,
2330 (GLenum)internalformat,
2331 (GLsizei)width,
2332 (GLsizei)height
2333 );
2334 }
2335
2336 /* void glGetRenderbufferParameterivOES ( GLenum target, GLenum pname, GLint *params ) */
2337 static void
android_glGetRenderbufferParameterivOES__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)2338 android_glGetRenderbufferParameterivOES__II_3II
2339 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
2340 jint _exception = 0;
2341 const char * _exceptionType = NULL;
2342 const char * _exceptionMessage = NULL;
2343 GLint *params_base = (GLint *) 0;
2344 jint _remaining;
2345 GLint *params = (GLint *) 0;
2346
2347 if (!params_ref) {
2348 _exception = 1;
2349 _exceptionType = "java/lang/IllegalArgumentException";
2350 _exceptionMessage = "params == null";
2351 goto exit;
2352 }
2353 if (offset < 0) {
2354 _exception = 1;
2355 _exceptionType = "java/lang/IllegalArgumentException";
2356 _exceptionMessage = "offset < 0";
2357 goto exit;
2358 }
2359 _remaining = _env->GetArrayLength(params_ref) - offset;
2360 if (_remaining < 1) {
2361 _exception = 1;
2362 _exceptionType = "java/lang/IllegalArgumentException";
2363 _exceptionMessage = "length - offset < 1 < needed";
2364 goto exit;
2365 }
2366 params_base = (GLint *)
2367 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2368 params = params_base + offset;
2369
2370 glGetRenderbufferParameterivOES(
2371 (GLenum)target,
2372 (GLenum)pname,
2373 (GLint *)params
2374 );
2375
2376 exit:
2377 if (params_base) {
2378 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2379 _exception ? JNI_ABORT: 0);
2380 }
2381 if (_exception) {
2382 jniThrowException(_env, _exceptionType, _exceptionMessage);
2383 }
2384 }
2385
2386 /* void glGetRenderbufferParameterivOES ( GLenum target, GLenum pname, GLint *params ) */
2387 static void
android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)2388 android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2
2389 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
2390 jint _exception = 0;
2391 const char * _exceptionType = NULL;
2392 const char * _exceptionMessage = NULL;
2393 jarray _array = (jarray) 0;
2394 jint _bufferOffset = (jint) 0;
2395 jint _remaining;
2396 GLint *params = (GLint *) 0;
2397
2398 params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
2399 if (_remaining < 1) {
2400 _exception = 1;
2401 _exceptionType = "java/lang/IllegalArgumentException";
2402 _exceptionMessage = "remaining() < 1 < needed";
2403 goto exit;
2404 }
2405 if (params == NULL) {
2406 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
2407 params = (GLint *) (_paramsBase + _bufferOffset);
2408 }
2409 glGetRenderbufferParameterivOES(
2410 (GLenum)target,
2411 (GLenum)pname,
2412 (GLint *)params
2413 );
2414
2415 exit:
2416 if (_array) {
2417 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
2418 }
2419 if (_exception) {
2420 jniThrowException(_env, _exceptionType, _exceptionMessage);
2421 }
2422 }
2423
2424 /* GLboolean glIsFramebufferOES ( GLuint framebuffer ) */
2425 static jboolean
android_glIsFramebufferOES__I(JNIEnv * _env,jobject _this,jint framebuffer)2426 android_glIsFramebufferOES__I
2427 (JNIEnv *_env, jobject _this, jint framebuffer) {
2428 GLboolean _returnValue;
2429 _returnValue = glIsFramebufferOES(
2430 (GLuint)framebuffer
2431 );
2432 return (jboolean)_returnValue;
2433 }
2434
2435 /* void glBindFramebufferOES ( GLenum target, GLuint framebuffer ) */
2436 static void
android_glBindFramebufferOES__II(JNIEnv * _env,jobject _this,jint target,jint framebuffer)2437 android_glBindFramebufferOES__II
2438 (JNIEnv *_env, jobject _this, jint target, jint framebuffer) {
2439 glBindFramebufferOES(
2440 (GLenum)target,
2441 (GLuint)framebuffer
2442 );
2443 }
2444
2445 /* void glDeleteFramebuffersOES ( GLsizei n, const GLuint *framebuffers ) */
2446 static void
android_glDeleteFramebuffersOES__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray framebuffers_ref,jint offset)2447 android_glDeleteFramebuffersOES__I_3II
2448 (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) {
2449 jint _exception = 0;
2450 const char * _exceptionType = NULL;
2451 const char * _exceptionMessage = NULL;
2452 GLuint *framebuffers_base = (GLuint *) 0;
2453 jint _remaining;
2454 GLuint *framebuffers = (GLuint *) 0;
2455
2456 if (!framebuffers_ref) {
2457 _exception = 1;
2458 _exceptionType = "java/lang/IllegalArgumentException";
2459 _exceptionMessage = "framebuffers == null";
2460 goto exit;
2461 }
2462 if (offset < 0) {
2463 _exception = 1;
2464 _exceptionType = "java/lang/IllegalArgumentException";
2465 _exceptionMessage = "offset < 0";
2466 goto exit;
2467 }
2468 _remaining = _env->GetArrayLength(framebuffers_ref) - offset;
2469 if (_remaining < n) {
2470 _exception = 1;
2471 _exceptionType = "java/lang/IllegalArgumentException";
2472 _exceptionMessage = "length - offset < n < needed";
2473 goto exit;
2474 }
2475 framebuffers_base = (GLuint *)
2476 _env->GetPrimitiveArrayCritical(framebuffers_ref, (jboolean *)0);
2477 framebuffers = framebuffers_base + offset;
2478
2479 glDeleteFramebuffersOES(
2480 (GLsizei)n,
2481 (GLuint *)framebuffers
2482 );
2483
2484 exit:
2485 if (framebuffers_base) {
2486 _env->ReleasePrimitiveArrayCritical(framebuffers_ref, framebuffers_base,
2487 JNI_ABORT);
2488 }
2489 if (_exception) {
2490 jniThrowException(_env, _exceptionType, _exceptionMessage);
2491 }
2492 }
2493
2494 /* void glDeleteFramebuffersOES ( GLsizei n, const GLuint *framebuffers ) */
2495 static void
android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject framebuffers_buf)2496 android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2
2497 (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) {
2498 jint _exception = 0;
2499 const char * _exceptionType = NULL;
2500 const char * _exceptionMessage = NULL;
2501 jarray _array = (jarray) 0;
2502 jint _bufferOffset = (jint) 0;
2503 jint _remaining;
2504 GLuint *framebuffers = (GLuint *) 0;
2505
2506 framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, &_array, &_remaining, &_bufferOffset);
2507 if (_remaining < n) {
2508 _exception = 1;
2509 _exceptionType = "java/lang/IllegalArgumentException";
2510 _exceptionMessage = "remaining() < n < needed";
2511 goto exit;
2512 }
2513 if (framebuffers == NULL) {
2514 char * _framebuffersBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
2515 framebuffers = (GLuint *) (_framebuffersBase + _bufferOffset);
2516 }
2517 glDeleteFramebuffersOES(
2518 (GLsizei)n,
2519 (GLuint *)framebuffers
2520 );
2521
2522 exit:
2523 if (_array) {
2524 releasePointer(_env, _array, framebuffers, JNI_FALSE);
2525 }
2526 if (_exception) {
2527 jniThrowException(_env, _exceptionType, _exceptionMessage);
2528 }
2529 }
2530
2531 /* void glGenFramebuffersOES ( GLsizei n, GLuint *framebuffers ) */
2532 static void
android_glGenFramebuffersOES__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray framebuffers_ref,jint offset)2533 android_glGenFramebuffersOES__I_3II
2534 (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) {
2535 jint _exception = 0;
2536 const char * _exceptionType = NULL;
2537 const char * _exceptionMessage = NULL;
2538 GLuint *framebuffers_base = (GLuint *) 0;
2539 jint _remaining;
2540 GLuint *framebuffers = (GLuint *) 0;
2541
2542 if (!framebuffers_ref) {
2543 _exception = 1;
2544 _exceptionType = "java/lang/IllegalArgumentException";
2545 _exceptionMessage = "framebuffers == null";
2546 goto exit;
2547 }
2548 if (offset < 0) {
2549 _exception = 1;
2550 _exceptionType = "java/lang/IllegalArgumentException";
2551 _exceptionMessage = "offset < 0";
2552 goto exit;
2553 }
2554 _remaining = _env->GetArrayLength(framebuffers_ref) - offset;
2555 if (_remaining < n) {
2556 _exception = 1;
2557 _exceptionType = "java/lang/IllegalArgumentException";
2558 _exceptionMessage = "length - offset < n < needed";
2559 goto exit;
2560 }
2561 framebuffers_base = (GLuint *)
2562 _env->GetPrimitiveArrayCritical(framebuffers_ref, (jboolean *)0);
2563 framebuffers = framebuffers_base + offset;
2564
2565 glGenFramebuffersOES(
2566 (GLsizei)n,
2567 (GLuint *)framebuffers
2568 );
2569
2570 exit:
2571 if (framebuffers_base) {
2572 _env->ReleasePrimitiveArrayCritical(framebuffers_ref, framebuffers_base,
2573 _exception ? JNI_ABORT: 0);
2574 }
2575 if (_exception) {
2576 jniThrowException(_env, _exceptionType, _exceptionMessage);
2577 }
2578 }
2579
2580 /* void glGenFramebuffersOES ( GLsizei n, GLuint *framebuffers ) */
2581 static void
android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject framebuffers_buf)2582 android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2
2583 (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) {
2584 jint _exception = 0;
2585 const char * _exceptionType = NULL;
2586 const char * _exceptionMessage = NULL;
2587 jarray _array = (jarray) 0;
2588 jint _bufferOffset = (jint) 0;
2589 jint _remaining;
2590 GLuint *framebuffers = (GLuint *) 0;
2591
2592 framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, &_array, &_remaining, &_bufferOffset);
2593 if (_remaining < n) {
2594 _exception = 1;
2595 _exceptionType = "java/lang/IllegalArgumentException";
2596 _exceptionMessage = "remaining() < n < needed";
2597 goto exit;
2598 }
2599 if (framebuffers == NULL) {
2600 char * _framebuffersBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
2601 framebuffers = (GLuint *) (_framebuffersBase + _bufferOffset);
2602 }
2603 glGenFramebuffersOES(
2604 (GLsizei)n,
2605 (GLuint *)framebuffers
2606 );
2607
2608 exit:
2609 if (_array) {
2610 releasePointer(_env, _array, framebuffers, _exception ? JNI_FALSE : JNI_TRUE);
2611 }
2612 if (_exception) {
2613 jniThrowException(_env, _exceptionType, _exceptionMessage);
2614 }
2615 }
2616
2617 /* GLenum glCheckFramebufferStatusOES ( GLenum target ) */
2618 static jint
android_glCheckFramebufferStatusOES__I(JNIEnv * _env,jobject _this,jint target)2619 android_glCheckFramebufferStatusOES__I
2620 (JNIEnv *_env, jobject _this, jint target) {
2621 GLenum _returnValue;
2622 _returnValue = glCheckFramebufferStatusOES(
2623 (GLenum)target
2624 );
2625 return (jint)_returnValue;
2626 }
2627
2628 /* void glFramebufferRenderbufferOES ( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) */
2629 static void
android_glFramebufferRenderbufferOES__IIII(JNIEnv * _env,jobject _this,jint target,jint attachment,jint renderbuffertarget,jint renderbuffer)2630 android_glFramebufferRenderbufferOES__IIII
2631 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint renderbuffertarget, jint renderbuffer) {
2632 glFramebufferRenderbufferOES(
2633 (GLenum)target,
2634 (GLenum)attachment,
2635 (GLenum)renderbuffertarget,
2636 (GLuint)renderbuffer
2637 );
2638 }
2639
2640 /* void glFramebufferTexture2DOES ( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) */
2641 static void
android_glFramebufferTexture2DOES__IIIII(JNIEnv * _env,jobject _this,jint target,jint attachment,jint textarget,jint texture,jint level)2642 android_glFramebufferTexture2DOES__IIIII
2643 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint textarget, jint texture, jint level) {
2644 glFramebufferTexture2DOES(
2645 (GLenum)target,
2646 (GLenum)attachment,
2647 (GLenum)textarget,
2648 (GLuint)texture,
2649 (GLint)level
2650 );
2651 }
2652
2653 /* void glGetFramebufferAttachmentParameterivOES ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */
2654 static void
android_glGetFramebufferAttachmentParameterivOES__III_3II(JNIEnv * _env,jobject _this,jint target,jint attachment,jint pname,jintArray params_ref,jint offset)2655 android_glGetFramebufferAttachmentParameterivOES__III_3II
2656 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jintArray params_ref, jint offset) {
2657 jint _exception = 0;
2658 const char * _exceptionType = NULL;
2659 const char * _exceptionMessage = NULL;
2660 GLint *params_base = (GLint *) 0;
2661 jint _remaining;
2662 GLint *params = (GLint *) 0;
2663
2664 if (!params_ref) {
2665 _exception = 1;
2666 _exceptionType = "java/lang/IllegalArgumentException";
2667 _exceptionMessage = "params == null";
2668 goto exit;
2669 }
2670 if (offset < 0) {
2671 _exception = 1;
2672 _exceptionType = "java/lang/IllegalArgumentException";
2673 _exceptionMessage = "offset < 0";
2674 goto exit;
2675 }
2676 _remaining = _env->GetArrayLength(params_ref) - offset;
2677 if (_remaining < 1) {
2678 _exception = 1;
2679 _exceptionType = "java/lang/IllegalArgumentException";
2680 _exceptionMessage = "length - offset < 1 < needed";
2681 goto exit;
2682 }
2683 params_base = (GLint *)
2684 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2685 params = params_base + offset;
2686
2687 glGetFramebufferAttachmentParameterivOES(
2688 (GLenum)target,
2689 (GLenum)attachment,
2690 (GLenum)pname,
2691 (GLint *)params
2692 );
2693
2694 exit:
2695 if (params_base) {
2696 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2697 _exception ? JNI_ABORT: 0);
2698 }
2699 if (_exception) {
2700 jniThrowException(_env, _exceptionType, _exceptionMessage);
2701 }
2702 }
2703
2704 /* void glGetFramebufferAttachmentParameterivOES ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */
2705 static void
android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint attachment,jint pname,jobject params_buf)2706 android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2
2707 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jobject params_buf) {
2708 jint _exception = 0;
2709 const char * _exceptionType = NULL;
2710 const char * _exceptionMessage = NULL;
2711 jarray _array = (jarray) 0;
2712 jint _bufferOffset = (jint) 0;
2713 jint _remaining;
2714 GLint *params = (GLint *) 0;
2715
2716 params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
2717 if (_remaining < 1) {
2718 _exception = 1;
2719 _exceptionType = "java/lang/IllegalArgumentException";
2720 _exceptionMessage = "remaining() < 1 < needed";
2721 goto exit;
2722 }
2723 if (params == NULL) {
2724 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
2725 params = (GLint *) (_paramsBase + _bufferOffset);
2726 }
2727 glGetFramebufferAttachmentParameterivOES(
2728 (GLenum)target,
2729 (GLenum)attachment,
2730 (GLenum)pname,
2731 (GLint *)params
2732 );
2733
2734 exit:
2735 if (_array) {
2736 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
2737 }
2738 if (_exception) {
2739 jniThrowException(_env, _exceptionType, _exceptionMessage);
2740 }
2741 }
2742
2743 /* void glGenerateMipmapOES ( GLenum target ) */
2744 static void
android_glGenerateMipmapOES__I(JNIEnv * _env,jobject _this,jint target)2745 android_glGenerateMipmapOES__I
2746 (JNIEnv *_env, jobject _this, jint target) {
2747 glGenerateMipmapOES(
2748 (GLenum)target
2749 );
2750 }
2751
2752 /* void glCurrentPaletteMatrixOES ( GLuint matrixpaletteindex ) */
2753 static void
android_glCurrentPaletteMatrixOES__I(JNIEnv * _env,jobject _this,jint matrixpaletteindex)2754 android_glCurrentPaletteMatrixOES__I
2755 (JNIEnv *_env, jobject _this, jint matrixpaletteindex) {
2756 glCurrentPaletteMatrixOES(
2757 (GLuint)matrixpaletteindex
2758 );
2759 }
2760
2761 /* void glLoadPaletteFromModelViewMatrixOES ( void ) */
2762 static void
android_glLoadPaletteFromModelViewMatrixOES__(JNIEnv * _env,jobject _this)2763 android_glLoadPaletteFromModelViewMatrixOES__
2764 (JNIEnv *_env, jobject _this) {
2765 glLoadPaletteFromModelViewMatrixOES();
2766 }
2767
2768 /* void glMatrixIndexPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
2769 static void
android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint size,jint type,jint stride,jobject pointer_buf,jint remaining)2770 android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I
2771 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
2772 jarray _array = (jarray) 0;
2773 jint _bufferOffset = (jint) 0;
2774 jint _remaining;
2775 GLvoid *pointer = (GLvoid *) 0;
2776
2777 if (pointer_buf) {
2778 pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
2779 if ( ! pointer ) {
2780 return;
2781 }
2782 }
2783 glMatrixIndexPointerOESBounds(
2784 (GLint)size,
2785 (GLenum)type,
2786 (GLsizei)stride,
2787 (GLvoid *)pointer,
2788 (GLsizei)remaining
2789 );
2790 }
2791
2792 /* void glWeightPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
2793 static void
android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint size,jint type,jint stride,jobject pointer_buf,jint remaining)2794 android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I
2795 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
2796 jarray _array = (jarray) 0;
2797 jint _bufferOffset = (jint) 0;
2798 jint _remaining;
2799 GLvoid *pointer = (GLvoid *) 0;
2800
2801 if (pointer_buf) {
2802 pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
2803 if ( ! pointer ) {
2804 return;
2805 }
2806 }
2807 glWeightPointerOESBounds(
2808 (GLint)size,
2809 (GLenum)type,
2810 (GLsizei)stride,
2811 (GLvoid *)pointer,
2812 (GLsizei)remaining
2813 );
2814 }
2815
2816 /* void glDepthRangefOES ( GLclampf zNear, GLclampf zFar ) */
2817 static void
android_glDepthRangefOES__FF(JNIEnv * _env,jobject _this,jfloat zNear,jfloat zFar)2818 android_glDepthRangefOES__FF
2819 (JNIEnv *_env, jobject _this, jfloat zNear, jfloat zFar) {
2820 glDepthRangefOES(
2821 (GLclampf)zNear,
2822 (GLclampf)zFar
2823 );
2824 }
2825
2826 /* void glFrustumfOES ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */
2827 static void
android_glFrustumfOES__FFFFFF(JNIEnv * _env,jobject _this,jfloat left,jfloat right,jfloat bottom,jfloat top,jfloat zNear,jfloat zFar)2828 android_glFrustumfOES__FFFFFF
2829 (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) {
2830 glFrustumfOES(
2831 (GLfloat)left,
2832 (GLfloat)right,
2833 (GLfloat)bottom,
2834 (GLfloat)top,
2835 (GLfloat)zNear,
2836 (GLfloat)zFar
2837 );
2838 }
2839
2840 /* void glOrthofOES ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */
2841 static void
android_glOrthofOES__FFFFFF(JNIEnv * _env,jobject _this,jfloat left,jfloat right,jfloat bottom,jfloat top,jfloat zNear,jfloat zFar)2842 android_glOrthofOES__FFFFFF
2843 (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) {
2844 glOrthofOES(
2845 (GLfloat)left,
2846 (GLfloat)right,
2847 (GLfloat)bottom,
2848 (GLfloat)top,
2849 (GLfloat)zNear,
2850 (GLfloat)zFar
2851 );
2852 }
2853
2854 /* void glClipPlanefOES ( GLenum plane, const GLfloat *equation ) */
2855 static void
android_glClipPlanefOES__I_3FI(JNIEnv * _env,jobject _this,jint plane,jfloatArray equation_ref,jint offset)2856 android_glClipPlanefOES__I_3FI
2857 (JNIEnv *_env, jobject _this, jint plane, jfloatArray equation_ref, jint offset) {
2858 jint _exception = 0;
2859 const char * _exceptionType = NULL;
2860 const char * _exceptionMessage = NULL;
2861 GLfloat *equation_base = (GLfloat *) 0;
2862 jint _remaining;
2863 GLfloat *equation = (GLfloat *) 0;
2864
2865 if (!equation_ref) {
2866 _exception = 1;
2867 _exceptionType = "java/lang/IllegalArgumentException";
2868 _exceptionMessage = "equation == null";
2869 goto exit;
2870 }
2871 if (offset < 0) {
2872 _exception = 1;
2873 _exceptionType = "java/lang/IllegalArgumentException";
2874 _exceptionMessage = "offset < 0";
2875 goto exit;
2876 }
2877 _remaining = _env->GetArrayLength(equation_ref) - offset;
2878 equation_base = (GLfloat *)
2879 _env->GetPrimitiveArrayCritical(equation_ref, (jboolean *)0);
2880 equation = equation_base + offset;
2881
2882 glClipPlanefOES(
2883 (GLenum)plane,
2884 (GLfloat *)equation
2885 );
2886
2887 exit:
2888 if (equation_base) {
2889 _env->ReleasePrimitiveArrayCritical(equation_ref, equation_base,
2890 JNI_ABORT);
2891 }
2892 if (_exception) {
2893 jniThrowException(_env, _exceptionType, _exceptionMessage);
2894 }
2895 }
2896
2897 /* void glClipPlanefOES ( GLenum plane, const GLfloat *equation ) */
2898 static void
android_glClipPlanefOES__ILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint plane,jobject equation_buf)2899 android_glClipPlanefOES__ILjava_nio_FloatBuffer_2
2900 (JNIEnv *_env, jobject _this, jint plane, jobject equation_buf) {
2901 jarray _array = (jarray) 0;
2902 jint _bufferOffset = (jint) 0;
2903 jint _remaining;
2904 GLfloat *equation = (GLfloat *) 0;
2905
2906 equation = (GLfloat *)getPointer(_env, equation_buf, &_array, &_remaining, &_bufferOffset);
2907 if (equation == NULL) {
2908 char * _equationBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
2909 equation = (GLfloat *) (_equationBase + _bufferOffset);
2910 }
2911 glClipPlanefOES(
2912 (GLenum)plane,
2913 (GLfloat *)equation
2914 );
2915 if (_array) {
2916 releasePointer(_env, _array, equation, JNI_FALSE);
2917 }
2918 }
2919
2920 /* void glGetClipPlanefOES ( GLenum pname, GLfloat *eqn ) */
2921 static void
android_glGetClipPlanefOES__I_3FI(JNIEnv * _env,jobject _this,jint pname,jfloatArray eqn_ref,jint offset)2922 android_glGetClipPlanefOES__I_3FI
2923 (JNIEnv *_env, jobject _this, jint pname, jfloatArray eqn_ref, jint offset) {
2924 jint _exception = 0;
2925 const char * _exceptionType = NULL;
2926 const char * _exceptionMessage = NULL;
2927 GLfloat *eqn_base = (GLfloat *) 0;
2928 jint _remaining;
2929 GLfloat *eqn = (GLfloat *) 0;
2930
2931 if (!eqn_ref) {
2932 _exception = 1;
2933 _exceptionType = "java/lang/IllegalArgumentException";
2934 _exceptionMessage = "eqn == null";
2935 goto exit;
2936 }
2937 if (offset < 0) {
2938 _exception = 1;
2939 _exceptionType = "java/lang/IllegalArgumentException";
2940 _exceptionMessage = "offset < 0";
2941 goto exit;
2942 }
2943 _remaining = _env->GetArrayLength(eqn_ref) - offset;
2944 if (_remaining < 4) {
2945 _exception = 1;
2946 _exceptionType = "java/lang/IllegalArgumentException";
2947 _exceptionMessage = "length - offset < 4 < needed";
2948 goto exit;
2949 }
2950 eqn_base = (GLfloat *)
2951 _env->GetPrimitiveArrayCritical(eqn_ref, (jboolean *)0);
2952 eqn = eqn_base + offset;
2953
2954 glGetClipPlanefOES(
2955 (GLenum)pname,
2956 (GLfloat *)eqn
2957 );
2958
2959 exit:
2960 if (eqn_base) {
2961 _env->ReleasePrimitiveArrayCritical(eqn_ref, eqn_base,
2962 _exception ? JNI_ABORT: 0);
2963 }
2964 if (_exception) {
2965 jniThrowException(_env, _exceptionType, _exceptionMessage);
2966 }
2967 }
2968
2969 /* void glGetClipPlanefOES ( GLenum pname, GLfloat *eqn ) */
2970 static void
android_glGetClipPlanefOES__ILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject eqn_buf)2971 android_glGetClipPlanefOES__ILjava_nio_FloatBuffer_2
2972 (JNIEnv *_env, jobject _this, jint pname, jobject eqn_buf) {
2973 jint _exception = 0;
2974 const char * _exceptionType = NULL;
2975 const char * _exceptionMessage = NULL;
2976 jarray _array = (jarray) 0;
2977 jint _bufferOffset = (jint) 0;
2978 jint _remaining;
2979 GLfloat *eqn = (GLfloat *) 0;
2980
2981 eqn = (GLfloat *)getPointer(_env, eqn_buf, &_array, &_remaining, &_bufferOffset);
2982 if (_remaining < 4) {
2983 _exception = 1;
2984 _exceptionType = "java/lang/IllegalArgumentException";
2985 _exceptionMessage = "remaining() < 4 < needed";
2986 goto exit;
2987 }
2988 if (eqn == NULL) {
2989 char * _eqnBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
2990 eqn = (GLfloat *) (_eqnBase + _bufferOffset);
2991 }
2992 glGetClipPlanefOES(
2993 (GLenum)pname,
2994 (GLfloat *)eqn
2995 );
2996
2997 exit:
2998 if (_array) {
2999 releasePointer(_env, _array, eqn, _exception ? JNI_FALSE : JNI_TRUE);
3000 }
3001 if (_exception) {
3002 jniThrowException(_env, _exceptionType, _exceptionMessage);
3003 }
3004 }
3005
3006 /* void glClearDepthfOES ( GLclampf depth ) */
3007 static void
android_glClearDepthfOES__F(JNIEnv * _env,jobject _this,jfloat depth)3008 android_glClearDepthfOES__F
3009 (JNIEnv *_env, jobject _this, jfloat depth) {
3010 glClearDepthfOES(
3011 (GLclampf)depth
3012 );
3013 }
3014
3015 /* void glTexGenfOES ( GLenum coord, GLenum pname, GLfloat param ) */
3016 static void
android_glTexGenfOES__IIF(JNIEnv * _env,jobject _this,jint coord,jint pname,jfloat param)3017 android_glTexGenfOES__IIF
3018 (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloat param) {
3019 glTexGenfOES(
3020 (GLenum)coord,
3021 (GLenum)pname,
3022 (GLfloat)param
3023 );
3024 }
3025
3026 /* void glTexGenfvOES ( GLenum coord, GLenum pname, const GLfloat *params ) */
3027 static void
android_glTexGenfvOES__II_3FI(JNIEnv * _env,jobject _this,jint coord,jint pname,jfloatArray params_ref,jint offset)3028 android_glTexGenfvOES__II_3FI
3029 (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) {
3030 jint _exception = 0;
3031 const char * _exceptionType = NULL;
3032 const char * _exceptionMessage = NULL;
3033 GLfloat *params_base = (GLfloat *) 0;
3034 jint _remaining;
3035 GLfloat *params = (GLfloat *) 0;
3036
3037 if (!params_ref) {
3038 _exception = 1;
3039 _exceptionType = "java/lang/IllegalArgumentException";
3040 _exceptionMessage = "params == null";
3041 goto exit;
3042 }
3043 if (offset < 0) {
3044 _exception = 1;
3045 _exceptionType = "java/lang/IllegalArgumentException";
3046 _exceptionMessage = "offset < 0";
3047 goto exit;
3048 }
3049 _remaining = _env->GetArrayLength(params_ref) - offset;
3050 params_base = (GLfloat *)
3051 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
3052 params = params_base + offset;
3053
3054 glTexGenfvOES(
3055 (GLenum)coord,
3056 (GLenum)pname,
3057 (GLfloat *)params
3058 );
3059
3060 exit:
3061 if (params_base) {
3062 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
3063 JNI_ABORT);
3064 }
3065 if (_exception) {
3066 jniThrowException(_env, _exceptionType, _exceptionMessage);
3067 }
3068 }
3069
3070 /* void glTexGenfvOES ( GLenum coord, GLenum pname, const GLfloat *params ) */
3071 static void
android_glTexGenfvOES__IILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)3072 android_glTexGenfvOES__IILjava_nio_FloatBuffer_2
3073 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
3074 jarray _array = (jarray) 0;
3075 jint _bufferOffset = (jint) 0;
3076 jint _remaining;
3077 GLfloat *params = (GLfloat *) 0;
3078
3079 params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
3080 if (params == NULL) {
3081 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3082 params = (GLfloat *) (_paramsBase + _bufferOffset);
3083 }
3084 glTexGenfvOES(
3085 (GLenum)coord,
3086 (GLenum)pname,
3087 (GLfloat *)params
3088 );
3089 if (_array) {
3090 releasePointer(_env, _array, params, JNI_FALSE);
3091 }
3092 }
3093
3094 /* void glTexGeniOES ( GLenum coord, GLenum pname, GLint param ) */
3095 static void
android_glTexGeniOES__III(JNIEnv * _env,jobject _this,jint coord,jint pname,jint param)3096 android_glTexGeniOES__III
3097 (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) {
3098 glTexGeniOES(
3099 (GLenum)coord,
3100 (GLenum)pname,
3101 (GLint)param
3102 );
3103 }
3104
3105 /* void glTexGenivOES ( GLenum coord, GLenum pname, const GLint *params ) */
3106 static void
android_glTexGenivOES__II_3II(JNIEnv * _env,jobject _this,jint coord,jint pname,jintArray params_ref,jint offset)3107 android_glTexGenivOES__II_3II
3108 (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
3109 jint _exception = 0;
3110 const char * _exceptionType = NULL;
3111 const char * _exceptionMessage = NULL;
3112 GLint *params_base = (GLint *) 0;
3113 jint _remaining;
3114 GLint *params = (GLint *) 0;
3115
3116 if (!params_ref) {
3117 _exception = 1;
3118 _exceptionType = "java/lang/IllegalArgumentException";
3119 _exceptionMessage = "params == null";
3120 goto exit;
3121 }
3122 if (offset < 0) {
3123 _exception = 1;
3124 _exceptionType = "java/lang/IllegalArgumentException";
3125 _exceptionMessage = "offset < 0";
3126 goto exit;
3127 }
3128 _remaining = _env->GetArrayLength(params_ref) - offset;
3129 params_base = (GLint *)
3130 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
3131 params = params_base + offset;
3132
3133 glTexGenivOES(
3134 (GLenum)coord,
3135 (GLenum)pname,
3136 (GLint *)params
3137 );
3138
3139 exit:
3140 if (params_base) {
3141 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
3142 JNI_ABORT);
3143 }
3144 if (_exception) {
3145 jniThrowException(_env, _exceptionType, _exceptionMessage);
3146 }
3147 }
3148
3149 /* void glTexGenivOES ( GLenum coord, GLenum pname, const GLint *params ) */
3150 static void
android_glTexGenivOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)3151 android_glTexGenivOES__IILjava_nio_IntBuffer_2
3152 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
3153 jarray _array = (jarray) 0;
3154 jint _bufferOffset = (jint) 0;
3155 jint _remaining;
3156 GLint *params = (GLint *) 0;
3157
3158 params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
3159 if (params == NULL) {
3160 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3161 params = (GLint *) (_paramsBase + _bufferOffset);
3162 }
3163 glTexGenivOES(
3164 (GLenum)coord,
3165 (GLenum)pname,
3166 (GLint *)params
3167 );
3168 if (_array) {
3169 releasePointer(_env, _array, params, JNI_FALSE);
3170 }
3171 }
3172
3173 /* void glTexGenxOES ( GLenum coord, GLenum pname, GLfixed param ) */
3174 static void
android_glTexGenxOES__III(JNIEnv * _env,jobject _this,jint coord,jint pname,jint param)3175 android_glTexGenxOES__III
3176 (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) {
3177 glTexGenxOES(
3178 (GLenum)coord,
3179 (GLenum)pname,
3180 (GLfixed)param
3181 );
3182 }
3183
3184 /* void glTexGenxvOES ( GLenum coord, GLenum pname, const GLfixed *params ) */
3185 static void
android_glTexGenxvOES__II_3II(JNIEnv * _env,jobject _this,jint coord,jint pname,jintArray params_ref,jint offset)3186 android_glTexGenxvOES__II_3II
3187 (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
3188 jint _exception = 0;
3189 const char * _exceptionType = NULL;
3190 const char * _exceptionMessage = NULL;
3191 GLfixed *params_base = (GLfixed *) 0;
3192 jint _remaining;
3193 GLfixed *params = (GLfixed *) 0;
3194
3195 if (!params_ref) {
3196 _exception = 1;
3197 _exceptionType = "java/lang/IllegalArgumentException";
3198 _exceptionMessage = "params == null";
3199 goto exit;
3200 }
3201 if (offset < 0) {
3202 _exception = 1;
3203 _exceptionType = "java/lang/IllegalArgumentException";
3204 _exceptionMessage = "offset < 0";
3205 goto exit;
3206 }
3207 _remaining = _env->GetArrayLength(params_ref) - offset;
3208 params_base = (GLfixed *)
3209 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
3210 params = params_base + offset;
3211
3212 glTexGenxvOES(
3213 (GLenum)coord,
3214 (GLenum)pname,
3215 (GLfixed *)params
3216 );
3217
3218 exit:
3219 if (params_base) {
3220 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
3221 JNI_ABORT);
3222 }
3223 if (_exception) {
3224 jniThrowException(_env, _exceptionType, _exceptionMessage);
3225 }
3226 }
3227
3228 /* void glTexGenxvOES ( GLenum coord, GLenum pname, const GLfixed *params ) */
3229 static void
android_glTexGenxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)3230 android_glTexGenxvOES__IILjava_nio_IntBuffer_2
3231 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
3232 jarray _array = (jarray) 0;
3233 jint _bufferOffset = (jint) 0;
3234 jint _remaining;
3235 GLfixed *params = (GLfixed *) 0;
3236
3237 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
3238 if (params == NULL) {
3239 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3240 params = (GLfixed *) (_paramsBase + _bufferOffset);
3241 }
3242 glTexGenxvOES(
3243 (GLenum)coord,
3244 (GLenum)pname,
3245 (GLfixed *)params
3246 );
3247 if (_array) {
3248 releasePointer(_env, _array, params, JNI_FALSE);
3249 }
3250 }
3251
3252 /* void glGetTexGenfvOES ( GLenum coord, GLenum pname, GLfloat *params ) */
3253 static void
android_glGetTexGenfvOES__II_3FI(JNIEnv * _env,jobject _this,jint coord,jint pname,jfloatArray params_ref,jint offset)3254 android_glGetTexGenfvOES__II_3FI
3255 (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) {
3256 jint _exception = 0;
3257 const char * _exceptionType = NULL;
3258 const char * _exceptionMessage = NULL;
3259 GLfloat *params_base = (GLfloat *) 0;
3260 jint _remaining;
3261 GLfloat *params = (GLfloat *) 0;
3262
3263 if (!params_ref) {
3264 _exception = 1;
3265 _exceptionType = "java/lang/IllegalArgumentException";
3266 _exceptionMessage = "params == null";
3267 goto exit;
3268 }
3269 if (offset < 0) {
3270 _exception = 1;
3271 _exceptionType = "java/lang/IllegalArgumentException";
3272 _exceptionMessage = "offset < 0";
3273 goto exit;
3274 }
3275 _remaining = _env->GetArrayLength(params_ref) - offset;
3276 params_base = (GLfloat *)
3277 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
3278 params = params_base + offset;
3279
3280 glGetTexGenfvOES(
3281 (GLenum)coord,
3282 (GLenum)pname,
3283 (GLfloat *)params
3284 );
3285
3286 exit:
3287 if (params_base) {
3288 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
3289 _exception ? JNI_ABORT: 0);
3290 }
3291 if (_exception) {
3292 jniThrowException(_env, _exceptionType, _exceptionMessage);
3293 }
3294 }
3295
3296 /* void glGetTexGenfvOES ( GLenum coord, GLenum pname, GLfloat *params ) */
3297 static void
android_glGetTexGenfvOES__IILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)3298 android_glGetTexGenfvOES__IILjava_nio_FloatBuffer_2
3299 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
3300 jarray _array = (jarray) 0;
3301 jint _bufferOffset = (jint) 0;
3302 jint _remaining;
3303 GLfloat *params = (GLfloat *) 0;
3304
3305 params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
3306 if (params == NULL) {
3307 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3308 params = (GLfloat *) (_paramsBase + _bufferOffset);
3309 }
3310 glGetTexGenfvOES(
3311 (GLenum)coord,
3312 (GLenum)pname,
3313 (GLfloat *)params
3314 );
3315 if (_array) {
3316 releasePointer(_env, _array, params, JNI_TRUE);
3317 }
3318 }
3319
3320 /* void glGetTexGenivOES ( GLenum coord, GLenum pname, GLint *params ) */
3321 static void
android_glGetTexGenivOES__II_3II(JNIEnv * _env,jobject _this,jint coord,jint pname,jintArray params_ref,jint offset)3322 android_glGetTexGenivOES__II_3II
3323 (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
3324 jint _exception = 0;
3325 const char * _exceptionType = NULL;
3326 const char * _exceptionMessage = NULL;
3327 GLint *params_base = (GLint *) 0;
3328 jint _remaining;
3329 GLint *params = (GLint *) 0;
3330
3331 if (!params_ref) {
3332 _exception = 1;
3333 _exceptionType = "java/lang/IllegalArgumentException";
3334 _exceptionMessage = "params == null";
3335 goto exit;
3336 }
3337 if (offset < 0) {
3338 _exception = 1;
3339 _exceptionType = "java/lang/IllegalArgumentException";
3340 _exceptionMessage = "offset < 0";
3341 goto exit;
3342 }
3343 _remaining = _env->GetArrayLength(params_ref) - offset;
3344 params_base = (GLint *)
3345 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
3346 params = params_base + offset;
3347
3348 glGetTexGenivOES(
3349 (GLenum)coord,
3350 (GLenum)pname,
3351 (GLint *)params
3352 );
3353
3354 exit:
3355 if (params_base) {
3356 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
3357 _exception ? JNI_ABORT: 0);
3358 }
3359 if (_exception) {
3360 jniThrowException(_env, _exceptionType, _exceptionMessage);
3361 }
3362 }
3363
3364 /* void glGetTexGenivOES ( GLenum coord, GLenum pname, GLint *params ) */
3365 static void
android_glGetTexGenivOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)3366 android_glGetTexGenivOES__IILjava_nio_IntBuffer_2
3367 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
3368 jarray _array = (jarray) 0;
3369 jint _bufferOffset = (jint) 0;
3370 jint _remaining;
3371 GLint *params = (GLint *) 0;
3372
3373 params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
3374 if (params == NULL) {
3375 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3376 params = (GLint *) (_paramsBase + _bufferOffset);
3377 }
3378 glGetTexGenivOES(
3379 (GLenum)coord,
3380 (GLenum)pname,
3381 (GLint *)params
3382 );
3383 if (_array) {
3384 releasePointer(_env, _array, params, JNI_TRUE);
3385 }
3386 }
3387
3388 /* void glGetTexGenxvOES ( GLenum coord, GLenum pname, GLfixed *params ) */
3389 static void
android_glGetTexGenxvOES__II_3II(JNIEnv * _env,jobject _this,jint coord,jint pname,jintArray params_ref,jint offset)3390 android_glGetTexGenxvOES__II_3II
3391 (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
3392 jint _exception = 0;
3393 const char * _exceptionType = NULL;
3394 const char * _exceptionMessage = NULL;
3395 GLfixed *params_base = (GLfixed *) 0;
3396 jint _remaining;
3397 GLfixed *params = (GLfixed *) 0;
3398
3399 if (!params_ref) {
3400 _exception = 1;
3401 _exceptionType = "java/lang/IllegalArgumentException";
3402 _exceptionMessage = "params == null";
3403 goto exit;
3404 }
3405 if (offset < 0) {
3406 _exception = 1;
3407 _exceptionType = "java/lang/IllegalArgumentException";
3408 _exceptionMessage = "offset < 0";
3409 goto exit;
3410 }
3411 _remaining = _env->GetArrayLength(params_ref) - offset;
3412 params_base = (GLfixed *)
3413 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
3414 params = params_base + offset;
3415
3416 glGetTexGenxvOES(
3417 (GLenum)coord,
3418 (GLenum)pname,
3419 (GLfixed *)params
3420 );
3421
3422 exit:
3423 if (params_base) {
3424 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
3425 _exception ? JNI_ABORT: 0);
3426 }
3427 if (_exception) {
3428 jniThrowException(_env, _exceptionType, _exceptionMessage);
3429 }
3430 }
3431
3432 /* void glGetTexGenxvOES ( GLenum coord, GLenum pname, GLfixed *params ) */
3433 static void
android_glGetTexGenxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)3434 android_glGetTexGenxvOES__IILjava_nio_IntBuffer_2
3435 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
3436 jarray _array = (jarray) 0;
3437 jint _bufferOffset = (jint) 0;
3438 jint _remaining;
3439 GLfixed *params = (GLfixed *) 0;
3440
3441 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
3442 if (params == NULL) {
3443 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3444 params = (GLfixed *) (_paramsBase + _bufferOffset);
3445 }
3446 glGetTexGenxvOES(
3447 (GLenum)coord,
3448 (GLenum)pname,
3449 (GLfixed *)params
3450 );
3451 if (_array) {
3452 releasePointer(_env, _array, params, JNI_TRUE);
3453 }
3454 }
3455
3456 static const char *classPathName = "android/opengl/GLES11Ext";
3457
3458 static JNINativeMethod methods[] = {
3459 {"_nativeClassInit", "()V", (void*)nativeClassInit },
3460 {"glBlendEquationSeparateOES", "(II)V", (void *) android_glBlendEquationSeparateOES__II },
3461 {"glBlendFuncSeparateOES", "(IIII)V", (void *) android_glBlendFuncSeparateOES__IIII },
3462 {"glBlendEquationOES", "(I)V", (void *) android_glBlendEquationOES__I },
3463 {"glDrawTexsOES", "(SSSSS)V", (void *) android_glDrawTexsOES__SSSSS },
3464 {"glDrawTexiOES", "(IIIII)V", (void *) android_glDrawTexiOES__IIIII },
3465 {"glDrawTexxOES", "(IIIII)V", (void *) android_glDrawTexxOES__IIIII },
3466 {"glDrawTexsvOES", "([SI)V", (void *) android_glDrawTexsvOES___3SI },
3467 {"glDrawTexsvOES", "(Ljava/nio/ShortBuffer;)V", (void *) android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2 },
3468 {"glDrawTexivOES", "([II)V", (void *) android_glDrawTexivOES___3II },
3469 {"glDrawTexivOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexivOES__Ljava_nio_IntBuffer_2 },
3470 {"glDrawTexxvOES", "([II)V", (void *) android_glDrawTexxvOES___3II },
3471 {"glDrawTexxvOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexxvOES__Ljava_nio_IntBuffer_2 },
3472 {"glDrawTexfOES", "(FFFFF)V", (void *) android_glDrawTexfOES__FFFFF },
3473 {"glDrawTexfvOES", "([FI)V", (void *) android_glDrawTexfvOES___3FI },
3474 {"glDrawTexfvOES", "(Ljava/nio/FloatBuffer;)V", (void *) android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2 },
3475 {"glEGLImageTargetTexture2DOES", "(ILjava/nio/Buffer;)V", (void *) android_glEGLImageTargetTexture2DOES__ILjava_nio_Buffer_2 },
3476 {"glEGLImageTargetRenderbufferStorageOES", "(ILjava/nio/Buffer;)V", (void *) android_glEGLImageTargetRenderbufferStorageOES__ILjava_nio_Buffer_2 },
3477 {"glAlphaFuncxOES", "(II)V", (void *) android_glAlphaFuncxOES__II },
3478 {"glClearColorxOES", "(IIII)V", (void *) android_glClearColorxOES__IIII },
3479 {"glClearDepthxOES", "(I)V", (void *) android_glClearDepthxOES__I },
3480 {"glClipPlanexOES", "(I[II)V", (void *) android_glClipPlanexOES__I_3II },
3481 {"glClipPlanexOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glClipPlanexOES__ILjava_nio_IntBuffer_2 },
3482 {"glColor4xOES", "(IIII)V", (void *) android_glColor4xOES__IIII },
3483 {"glDepthRangexOES", "(II)V", (void *) android_glDepthRangexOES__II },
3484 {"glFogxOES", "(II)V", (void *) android_glFogxOES__II },
3485 {"glFogxvOES", "(I[II)V", (void *) android_glFogxvOES__I_3II },
3486 {"glFogxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glFogxvOES__ILjava_nio_IntBuffer_2 },
3487 {"glFrustumxOES", "(IIIIII)V", (void *) android_glFrustumxOES__IIIIII },
3488 {"glGetClipPlanexOES", "(I[II)V", (void *) android_glGetClipPlanexOES__I_3II },
3489 {"glGetClipPlanexOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetClipPlanexOES__ILjava_nio_IntBuffer_2 },
3490 {"glGetFixedvOES", "(I[II)V", (void *) android_glGetFixedvOES__I_3II },
3491 {"glGetFixedvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetFixedvOES__ILjava_nio_IntBuffer_2 },
3492 {"glGetLightxvOES", "(II[II)V", (void *) android_glGetLightxvOES__II_3II },
3493 {"glGetLightxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetLightxvOES__IILjava_nio_IntBuffer_2 },
3494 {"glGetMaterialxvOES", "(II[II)V", (void *) android_glGetMaterialxvOES__II_3II },
3495 {"glGetMaterialxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetMaterialxvOES__IILjava_nio_IntBuffer_2 },
3496 {"glGetTexEnvxvOES", "(II[II)V", (void *) android_glGetTexEnvxvOES__II_3II },
3497 {"glGetTexEnvxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexEnvxvOES__IILjava_nio_IntBuffer_2 },
3498 {"glGetTexParameterxvOES", "(II[II)V", (void *) android_glGetTexParameterxvOES__II_3II },
3499 {"glGetTexParameterxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameterxvOES__IILjava_nio_IntBuffer_2 },
3500 {"glLightModelxOES", "(II)V", (void *) android_glLightModelxOES__II },
3501 {"glLightModelxvOES", "(I[II)V", (void *) android_glLightModelxvOES__I_3II },
3502 {"glLightModelxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glLightModelxvOES__ILjava_nio_IntBuffer_2 },
3503 {"glLightxOES", "(III)V", (void *) android_glLightxOES__III },
3504 {"glLightxvOES", "(II[II)V", (void *) android_glLightxvOES__II_3II },
3505 {"glLightxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glLightxvOES__IILjava_nio_IntBuffer_2 },
3506 {"glLineWidthxOES", "(I)V", (void *) android_glLineWidthxOES__I },
3507 {"glLoadMatrixxOES", "([II)V", (void *) android_glLoadMatrixxOES___3II },
3508 {"glLoadMatrixxOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glLoadMatrixxOES__Ljava_nio_IntBuffer_2 },
3509 {"glMaterialxOES", "(III)V", (void *) android_glMaterialxOES__III },
3510 {"glMaterialxvOES", "(II[II)V", (void *) android_glMaterialxvOES__II_3II },
3511 {"glMaterialxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glMaterialxvOES__IILjava_nio_IntBuffer_2 },
3512 {"glMultMatrixxOES", "([II)V", (void *) android_glMultMatrixxOES___3II },
3513 {"glMultMatrixxOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glMultMatrixxOES__Ljava_nio_IntBuffer_2 },
3514 {"glMultiTexCoord4xOES", "(IIIII)V", (void *) android_glMultiTexCoord4xOES__IIIII },
3515 {"glNormal3xOES", "(III)V", (void *) android_glNormal3xOES__III },
3516 {"glOrthoxOES", "(IIIIII)V", (void *) android_glOrthoxOES__IIIIII },
3517 {"glPointParameterxOES", "(II)V", (void *) android_glPointParameterxOES__II },
3518 {"glPointParameterxvOES", "(I[II)V", (void *) android_glPointParameterxvOES__I_3II },
3519 {"glPointParameterxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glPointParameterxvOES__ILjava_nio_IntBuffer_2 },
3520 {"glPointSizexOES", "(I)V", (void *) android_glPointSizexOES__I },
3521 {"glPolygonOffsetxOES", "(II)V", (void *) android_glPolygonOffsetxOES__II },
3522 {"glRotatexOES", "(IIII)V", (void *) android_glRotatexOES__IIII },
3523 {"glSampleCoveragexOES", "(IZ)V", (void *) android_glSampleCoveragexOES__IZ },
3524 {"glScalexOES", "(III)V", (void *) android_glScalexOES__III },
3525 {"glTexEnvxOES", "(III)V", (void *) android_glTexEnvxOES__III },
3526 {"glTexEnvxvOES", "(II[II)V", (void *) android_glTexEnvxvOES__II_3II },
3527 {"glTexEnvxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexEnvxvOES__IILjava_nio_IntBuffer_2 },
3528 {"glTexParameterxOES", "(III)V", (void *) android_glTexParameterxOES__III },
3529 {"glTexParameterxvOES", "(II[II)V", (void *) android_glTexParameterxvOES__II_3II },
3530 {"glTexParameterxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameterxvOES__IILjava_nio_IntBuffer_2 },
3531 {"glTranslatexOES", "(III)V", (void *) android_glTranslatexOES__III },
3532 {"glIsRenderbufferOES", "(I)Z", (void *) android_glIsRenderbufferOES__I },
3533 {"glBindRenderbufferOES", "(II)V", (void *) android_glBindRenderbufferOES__II },
3534 {"glDeleteRenderbuffersOES", "(I[II)V", (void *) android_glDeleteRenderbuffersOES__I_3II },
3535 {"glDeleteRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2 },
3536 {"glGenRenderbuffersOES", "(I[II)V", (void *) android_glGenRenderbuffersOES__I_3II },
3537 {"glGenRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2 },
3538 {"glRenderbufferStorageOES", "(IIII)V", (void *) android_glRenderbufferStorageOES__IIII },
3539 {"glGetRenderbufferParameterivOES", "(II[II)V", (void *) android_glGetRenderbufferParameterivOES__II_3II },
3540 {"glGetRenderbufferParameterivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2 },
3541 {"glIsFramebufferOES", "(I)Z", (void *) android_glIsFramebufferOES__I },
3542 {"glBindFramebufferOES", "(II)V", (void *) android_glBindFramebufferOES__II },
3543 {"glDeleteFramebuffersOES", "(I[II)V", (void *) android_glDeleteFramebuffersOES__I_3II },
3544 {"glDeleteFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2 },
3545 {"glGenFramebuffersOES", "(I[II)V", (void *) android_glGenFramebuffersOES__I_3II },
3546 {"glGenFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2 },
3547 {"glCheckFramebufferStatusOES", "(I)I", (void *) android_glCheckFramebufferStatusOES__I },
3548 {"glFramebufferRenderbufferOES", "(IIII)V", (void *) android_glFramebufferRenderbufferOES__IIII },
3549 {"glFramebufferTexture2DOES", "(IIIII)V", (void *) android_glFramebufferTexture2DOES__IIIII },
3550 {"glGetFramebufferAttachmentParameterivOES", "(III[II)V", (void *) android_glGetFramebufferAttachmentParameterivOES__III_3II },
3551 {"glGetFramebufferAttachmentParameterivOES", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2 },
3552 {"glGenerateMipmapOES", "(I)V", (void *) android_glGenerateMipmapOES__I },
3553 {"glCurrentPaletteMatrixOES", "(I)V", (void *) android_glCurrentPaletteMatrixOES__I },
3554 {"glLoadPaletteFromModelViewMatrixOES", "()V", (void *) android_glLoadPaletteFromModelViewMatrixOES__ },
3555 {"glMatrixIndexPointerOESBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I },
3556 {"glWeightPointerOESBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I },
3557 {"glDepthRangefOES", "(FF)V", (void *) android_glDepthRangefOES__FF },
3558 {"glFrustumfOES", "(FFFFFF)V", (void *) android_glFrustumfOES__FFFFFF },
3559 {"glOrthofOES", "(FFFFFF)V", (void *) android_glOrthofOES__FFFFFF },
3560 {"glClipPlanefOES", "(I[FI)V", (void *) android_glClipPlanefOES__I_3FI },
3561 {"glClipPlanefOES", "(ILjava/nio/FloatBuffer;)V", (void *) android_glClipPlanefOES__ILjava_nio_FloatBuffer_2 },
3562 {"glGetClipPlanefOES", "(I[FI)V", (void *) android_glGetClipPlanefOES__I_3FI },
3563 {"glGetClipPlanefOES", "(ILjava/nio/FloatBuffer;)V", (void *) android_glGetClipPlanefOES__ILjava_nio_FloatBuffer_2 },
3564 {"glClearDepthfOES", "(F)V", (void *) android_glClearDepthfOES__F },
3565 {"glTexGenfOES", "(IIF)V", (void *) android_glTexGenfOES__IIF },
3566 {"glTexGenfvOES", "(II[FI)V", (void *) android_glTexGenfvOES__II_3FI },
3567 {"glTexGenfvOES", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexGenfvOES__IILjava_nio_FloatBuffer_2 },
3568 {"glTexGeniOES", "(III)V", (void *) android_glTexGeniOES__III },
3569 {"glTexGenivOES", "(II[II)V", (void *) android_glTexGenivOES__II_3II },
3570 {"glTexGenivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGenivOES__IILjava_nio_IntBuffer_2 },
3571 {"glTexGenxOES", "(III)V", (void *) android_glTexGenxOES__III },
3572 {"glTexGenxvOES", "(II[II)V", (void *) android_glTexGenxvOES__II_3II },
3573 {"glTexGenxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGenxvOES__IILjava_nio_IntBuffer_2 },
3574 {"glGetTexGenfvOES", "(II[FI)V", (void *) android_glGetTexGenfvOES__II_3FI },
3575 {"glGetTexGenfvOES", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetTexGenfvOES__IILjava_nio_FloatBuffer_2 },
3576 {"glGetTexGenivOES", "(II[II)V", (void *) android_glGetTexGenivOES__II_3II },
3577 {"glGetTexGenivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGenivOES__IILjava_nio_IntBuffer_2 },
3578 {"glGetTexGenxvOES", "(II[II)V", (void *) android_glGetTexGenxvOES__II_3II },
3579 {"glGetTexGenxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGenxvOES__IILjava_nio_IntBuffer_2 },
3580 };
3581
register_android_opengl_jni_GLES11Ext(JNIEnv * _env)3582 int register_android_opengl_jni_GLES11Ext(JNIEnv *_env)
3583 {
3584 int err;
3585 err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));
3586 return err;
3587 }
3588