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