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 "jni.h"
21 #include "JNIHelp.h"
22 #include <android_runtime/AndroidRuntime.h>
23 #include <utils/misc.h>
24
25 #include <assert.h>
26 #include <GLES/gl.h>
27 #include <GLES/glext.h>
28
29 /* special calls implemented in Android's GLES wrapper used to more
30 * efficiently bound-check passed arrays */
31 extern "C" {
32 GL_API void GL_APIENTRY glMatrixIndexPointerOESBounds(GLint size, GLenum type, GLsizei stride,
33 const GLvoid *ptr, GLsizei count);
34 GL_API void GL_APIENTRY glWeightPointerOESBounds(GLint size, GLenum type, GLsizei stride,
35 const GLvoid *ptr, GLsizei count);
36 }
37
38 static int initialized = 0;
39
40 static jclass nioAccessClass;
41 static jclass bufferClass;
42 static jmethodID getBasePointerID;
43 static jmethodID getBaseArrayID;
44 static jmethodID getBaseArrayOffsetID;
45 static jfieldID positionID;
46 static jfieldID limitID;
47 static jfieldID elementSizeShiftID;
48
49 /* Cache method IDs each time the class is loaded. */
50
51 static void
nativeClassInit(JNIEnv * _env,jclass glImplClass)52 nativeClassInit(JNIEnv *_env, jclass glImplClass)
53 {
54 jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess");
55 nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal);
56
57 jclass bufferClassLocal = _env->FindClass("java/nio/Buffer");
58 bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal);
59
60 getBasePointerID = _env->GetStaticMethodID(nioAccessClass,
61 "getBasePointer", "(Ljava/nio/Buffer;)J");
62 getBaseArrayID = _env->GetStaticMethodID(nioAccessClass,
63 "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;");
64 getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass,
65 "getBaseArrayOffset", "(Ljava/nio/Buffer;)I");
66
67 positionID = _env->GetFieldID(bufferClass, "position", "I");
68 limitID = _env->GetFieldID(bufferClass, "limit", "I");
69 elementSizeShiftID =
70 _env->GetFieldID(bufferClass, "_elementSizeShift", "I");
71 }
72
73
74 static void *
getPointer(JNIEnv * _env,jobject buffer,jarray * array,jint * remaining)75 getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining)
76 {
77 jint position;
78 jint limit;
79 jint elementSizeShift;
80 jlong pointer;
81 jint offset;
82 void *data;
83
84 position = _env->GetIntField(buffer, positionID);
85 limit = _env->GetIntField(buffer, limitID);
86 elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
87 *remaining = (limit - position) << elementSizeShift;
88 pointer = _env->CallStaticLongMethod(nioAccessClass,
89 getBasePointerID, buffer);
90 if (pointer != 0L) {
91 *array = NULL;
92 return (void *) (jint) pointer;
93 }
94
95 *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass,
96 getBaseArrayID, buffer);
97 offset = _env->CallStaticIntMethod(nioAccessClass,
98 getBaseArrayOffsetID, buffer);
99 data = _env->GetPrimitiveArrayCritical(*array, (jboolean *) 0);
100
101 return (void *) ((char *) data + offset);
102 }
103
104
105 static void
releasePointer(JNIEnv * _env,jarray array,void * data,jboolean commit)106 releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit)
107 {
108 _env->ReleasePrimitiveArrayCritical(array, data,
109 commit ? 0 : JNI_ABORT);
110 }
111
112 static void *
getDirectBufferPointer(JNIEnv * _env,jobject buffer)113 getDirectBufferPointer(JNIEnv *_env, jobject buffer) {
114 char* buf = (char*) _env->GetDirectBufferAddress(buffer);
115 if (buf) {
116 jint position = _env->GetIntField(buffer, positionID);
117 jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
118 buf += position << elementSizeShift;
119 } else {
120 jniThrowException(_env, "java/lang/IllegalArgumentException",
121 "Must use a native order direct Buffer");
122 }
123 return (void*) buf;
124 }
125 // --------------------------------------------------------------------------
126 /* void glBlendEquationSeparateOES ( GLenum modeRGB, GLenum modeAlpha ) */
127 static void
android_glBlendEquationSeparateOES__II(JNIEnv * _env,jobject _this,jint modeRGB,jint modeAlpha)128 android_glBlendEquationSeparateOES__II
129 (JNIEnv *_env, jobject _this, jint modeRGB, jint modeAlpha) {
130 glBlendEquationSeparateOES(
131 (GLenum)modeRGB,
132 (GLenum)modeAlpha
133 );
134 }
135
136 /* void glBlendFuncSeparateOES ( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) */
137 static void
android_glBlendFuncSeparateOES__IIII(JNIEnv * _env,jobject _this,jint srcRGB,jint dstRGB,jint srcAlpha,jint dstAlpha)138 android_glBlendFuncSeparateOES__IIII
139 (JNIEnv *_env, jobject _this, jint srcRGB, jint dstRGB, jint srcAlpha, jint dstAlpha) {
140 glBlendFuncSeparateOES(
141 (GLenum)srcRGB,
142 (GLenum)dstRGB,
143 (GLenum)srcAlpha,
144 (GLenum)dstAlpha
145 );
146 }
147
148 /* void glBlendEquationOES ( GLenum mode ) */
149 static void
android_glBlendEquationOES__I(JNIEnv * _env,jobject _this,jint mode)150 android_glBlendEquationOES__I
151 (JNIEnv *_env, jobject _this, jint mode) {
152 glBlendEquationOES(
153 (GLenum)mode
154 );
155 }
156
157 /* void glDrawTexsOES ( GLshort x, GLshort y, GLshort z, GLshort width, GLshort height ) */
158 static void
android_glDrawTexsOES__SSSSS(JNIEnv * _env,jobject _this,jshort x,jshort y,jshort z,jshort width,jshort height)159 android_glDrawTexsOES__SSSSS
160 (JNIEnv *_env, jobject _this, jshort x, jshort y, jshort z, jshort width, jshort height) {
161 glDrawTexsOES(
162 (GLshort)x,
163 (GLshort)y,
164 (GLshort)z,
165 (GLshort)width,
166 (GLshort)height
167 );
168 }
169
170 /* void glDrawTexiOES ( GLint x, GLint y, GLint z, GLint width, GLint height ) */
171 static void
android_glDrawTexiOES__IIIII(JNIEnv * _env,jobject _this,jint x,jint y,jint z,jint width,jint height)172 android_glDrawTexiOES__IIIII
173 (JNIEnv *_env, jobject _this, jint x, jint y, jint z, jint width, jint height) {
174 glDrawTexiOES(
175 (GLint)x,
176 (GLint)y,
177 (GLint)z,
178 (GLint)width,
179 (GLint)height
180 );
181 }
182
183 /* void glDrawTexxOES ( GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height ) */
184 static void
android_glDrawTexxOES__IIIII(JNIEnv * _env,jobject _this,jint x,jint y,jint z,jint width,jint height)185 android_glDrawTexxOES__IIIII
186 (JNIEnv *_env, jobject _this, jint x, jint y, jint z, jint width, jint height) {
187 glDrawTexxOES(
188 (GLfixed)x,
189 (GLfixed)y,
190 (GLfixed)z,
191 (GLfixed)width,
192 (GLfixed)height
193 );
194 }
195
196 /* void glDrawTexsvOES ( const GLshort *coords ) */
197 static void
android_glDrawTexsvOES___3SI(JNIEnv * _env,jobject _this,jshortArray coords_ref,jint offset)198 android_glDrawTexsvOES___3SI
199 (JNIEnv *_env, jobject _this, jshortArray coords_ref, jint offset) {
200 GLshort *coords_base = (GLshort *) 0;
201 jint _remaining;
202 GLshort *coords = (GLshort *) 0;
203
204 if (!coords_ref) {
205 jniThrowException(_env, "java/lang/IllegalArgumentException", "coords == null");
206 goto exit;
207 }
208 if (offset < 0) {
209 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
210 goto exit;
211 }
212 _remaining = _env->GetArrayLength(coords_ref) - offset;
213 if (_remaining < 5) {
214 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < 5");
215 goto exit;
216 }
217 coords_base = (GLshort *)
218 _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0);
219 coords = coords_base + offset;
220
221 glDrawTexsvOES(
222 (GLshort *)coords
223 );
224
225 exit:
226 if (coords_base) {
227 _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base,
228 JNI_ABORT);
229 }
230 }
231
232 /* void glDrawTexsvOES ( const GLshort *coords ) */
233 static void
android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2(JNIEnv * _env,jobject _this,jobject coords_buf)234 android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2
235 (JNIEnv *_env, jobject _this, jobject coords_buf) {
236 jarray _array = (jarray) 0;
237 jint _remaining;
238 GLshort *coords = (GLshort *) 0;
239
240 coords = (GLshort *)getPointer(_env, coords_buf, &_array, &_remaining);
241 if (_remaining < 5) {
242 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < 5");
243 goto exit;
244 }
245 glDrawTexsvOES(
246 (GLshort *)coords
247 );
248
249 exit:
250 if (_array) {
251 releasePointer(_env, _array, coords, JNI_FALSE);
252 }
253 }
254
255 /* void glDrawTexivOES ( const GLint *coords ) */
256 static void
android_glDrawTexivOES___3II(JNIEnv * _env,jobject _this,jintArray coords_ref,jint offset)257 android_glDrawTexivOES___3II
258 (JNIEnv *_env, jobject _this, jintArray coords_ref, jint offset) {
259 GLint *coords_base = (GLint *) 0;
260 jint _remaining;
261 GLint *coords = (GLint *) 0;
262
263 if (!coords_ref) {
264 jniThrowException(_env, "java/lang/IllegalArgumentException", "coords == null");
265 goto exit;
266 }
267 if (offset < 0) {
268 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
269 goto exit;
270 }
271 _remaining = _env->GetArrayLength(coords_ref) - offset;
272 if (_remaining < 5) {
273 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < 5");
274 goto exit;
275 }
276 coords_base = (GLint *)
277 _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0);
278 coords = coords_base + offset;
279
280 glDrawTexivOES(
281 (GLint *)coords
282 );
283
284 exit:
285 if (coords_base) {
286 _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base,
287 JNI_ABORT);
288 }
289 }
290
291 /* void glDrawTexivOES ( const GLint *coords ) */
292 static void
android_glDrawTexivOES__Ljava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jobject coords_buf)293 android_glDrawTexivOES__Ljava_nio_IntBuffer_2
294 (JNIEnv *_env, jobject _this, jobject coords_buf) {
295 jarray _array = (jarray) 0;
296 jint _remaining;
297 GLint *coords = (GLint *) 0;
298
299 coords = (GLint *)getPointer(_env, coords_buf, &_array, &_remaining);
300 if (_remaining < 5) {
301 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < 5");
302 goto exit;
303 }
304 glDrawTexivOES(
305 (GLint *)coords
306 );
307
308 exit:
309 if (_array) {
310 releasePointer(_env, _array, coords, JNI_FALSE);
311 }
312 }
313
314 /* void glDrawTexxvOES ( const GLfixed *coords ) */
315 static void
android_glDrawTexxvOES___3II(JNIEnv * _env,jobject _this,jintArray coords_ref,jint offset)316 android_glDrawTexxvOES___3II
317 (JNIEnv *_env, jobject _this, jintArray coords_ref, jint offset) {
318 GLfixed *coords_base = (GLfixed *) 0;
319 jint _remaining;
320 GLfixed *coords = (GLfixed *) 0;
321
322 if (!coords_ref) {
323 jniThrowException(_env, "java/lang/IllegalArgumentException", "coords == null");
324 goto exit;
325 }
326 if (offset < 0) {
327 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
328 goto exit;
329 }
330 _remaining = _env->GetArrayLength(coords_ref) - offset;
331 if (_remaining < 5) {
332 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < 5");
333 goto exit;
334 }
335 coords_base = (GLfixed *)
336 _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0);
337 coords = coords_base + offset;
338
339 glDrawTexxvOES(
340 (GLfixed *)coords
341 );
342
343 exit:
344 if (coords_base) {
345 _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base,
346 JNI_ABORT);
347 }
348 }
349
350 /* void glDrawTexxvOES ( const GLfixed *coords ) */
351 static void
android_glDrawTexxvOES__Ljava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jobject coords_buf)352 android_glDrawTexxvOES__Ljava_nio_IntBuffer_2
353 (JNIEnv *_env, jobject _this, jobject coords_buf) {
354 jarray _array = (jarray) 0;
355 jint _remaining;
356 GLfixed *coords = (GLfixed *) 0;
357
358 coords = (GLfixed *)getPointer(_env, coords_buf, &_array, &_remaining);
359 if (_remaining < 5) {
360 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < 5");
361 goto exit;
362 }
363 glDrawTexxvOES(
364 (GLfixed *)coords
365 );
366
367 exit:
368 if (_array) {
369 releasePointer(_env, _array, coords, JNI_FALSE);
370 }
371 }
372
373 /* void glDrawTexfOES ( GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height ) */
374 static void
android_glDrawTexfOES__FFFFF(JNIEnv * _env,jobject _this,jfloat x,jfloat y,jfloat z,jfloat width,jfloat height)375 android_glDrawTexfOES__FFFFF
376 (JNIEnv *_env, jobject _this, jfloat x, jfloat y, jfloat z, jfloat width, jfloat height) {
377 glDrawTexfOES(
378 (GLfloat)x,
379 (GLfloat)y,
380 (GLfloat)z,
381 (GLfloat)width,
382 (GLfloat)height
383 );
384 }
385
386 /* void glDrawTexfvOES ( const GLfloat *coords ) */
387 static void
android_glDrawTexfvOES___3FI(JNIEnv * _env,jobject _this,jfloatArray coords_ref,jint offset)388 android_glDrawTexfvOES___3FI
389 (JNIEnv *_env, jobject _this, jfloatArray coords_ref, jint offset) {
390 GLfloat *coords_base = (GLfloat *) 0;
391 jint _remaining;
392 GLfloat *coords = (GLfloat *) 0;
393
394 if (!coords_ref) {
395 jniThrowException(_env, "java/lang/IllegalArgumentException", "coords == null");
396 goto exit;
397 }
398 if (offset < 0) {
399 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
400 goto exit;
401 }
402 _remaining = _env->GetArrayLength(coords_ref) - offset;
403 if (_remaining < 5) {
404 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < 5");
405 goto exit;
406 }
407 coords_base = (GLfloat *)
408 _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0);
409 coords = coords_base + offset;
410
411 glDrawTexfvOES(
412 (GLfloat *)coords
413 );
414
415 exit:
416 if (coords_base) {
417 _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base,
418 JNI_ABORT);
419 }
420 }
421
422 /* void glDrawTexfvOES ( const GLfloat *coords ) */
423 static void
android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jobject coords_buf)424 android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2
425 (JNIEnv *_env, jobject _this, jobject coords_buf) {
426 jarray _array = (jarray) 0;
427 jint _remaining;
428 GLfloat *coords = (GLfloat *) 0;
429
430 coords = (GLfloat *)getPointer(_env, coords_buf, &_array, &_remaining);
431 if (_remaining < 5) {
432 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < 5");
433 goto exit;
434 }
435 glDrawTexfvOES(
436 (GLfloat *)coords
437 );
438
439 exit:
440 if (_array) {
441 releasePointer(_env, _array, coords, JNI_FALSE);
442 }
443 }
444
445 /* void glEGLImageTargetTexture2DOES ( GLenum target, GLeglImageOES image ) */
446 static void
android_glEGLImageTargetTexture2DOES__ILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint target,jobject image_buf)447 android_glEGLImageTargetTexture2DOES__ILjava_nio_Buffer_2
448 (JNIEnv *_env, jobject _this, jint target, jobject image_buf) {
449 jint _exception = 0;
450 jarray _array = (jarray) 0;
451 jint _remaining;
452 GLeglImageOES image = (GLeglImageOES) 0;
453
454 image = (GLeglImageOES)getPointer(_env, image_buf, &_array, &_remaining);
455 glEGLImageTargetTexture2DOES(
456 (GLenum)target,
457 (GLeglImageOES)image
458 );
459 if (_array) {
460 releasePointer(_env, _array, image, _exception ? JNI_FALSE : JNI_TRUE);
461 }
462 }
463
464 /* void glEGLImageTargetRenderbufferStorageOES ( GLenum target, GLeglImageOES image ) */
465 static void
android_glEGLImageTargetRenderbufferStorageOES__ILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint target,jobject image_buf)466 android_glEGLImageTargetRenderbufferStorageOES__ILjava_nio_Buffer_2
467 (JNIEnv *_env, jobject _this, jint target, jobject image_buf) {
468 jint _exception = 0;
469 jarray _array = (jarray) 0;
470 jint _remaining;
471 GLeglImageOES image = (GLeglImageOES) 0;
472
473 image = (GLeglImageOES)getPointer(_env, image_buf, &_array, &_remaining);
474 glEGLImageTargetRenderbufferStorageOES(
475 (GLenum)target,
476 (GLeglImageOES)image
477 );
478 if (_array) {
479 releasePointer(_env, _array, image, _exception ? JNI_FALSE : JNI_TRUE);
480 }
481 }
482
483 /* void glAlphaFuncxOES ( GLenum func, GLclampx ref ) */
484 static void
android_glAlphaFuncxOES__II(JNIEnv * _env,jobject _this,jint func,jint ref)485 android_glAlphaFuncxOES__II
486 (JNIEnv *_env, jobject _this, jint func, jint ref) {
487 glAlphaFuncxOES(
488 (GLenum)func,
489 (GLclampx)ref
490 );
491 }
492
493 /* void glClearColorxOES ( GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha ) */
494 static void
android_glClearColorxOES__IIII(JNIEnv * _env,jobject _this,jint red,jint green,jint blue,jint alpha)495 android_glClearColorxOES__IIII
496 (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) {
497 glClearColorxOES(
498 (GLclampx)red,
499 (GLclampx)green,
500 (GLclampx)blue,
501 (GLclampx)alpha
502 );
503 }
504
505 /* void glClearDepthxOES ( GLclampx depth ) */
506 static void
android_glClearDepthxOES__I(JNIEnv * _env,jobject _this,jint depth)507 android_glClearDepthxOES__I
508 (JNIEnv *_env, jobject _this, jint depth) {
509 glClearDepthxOES(
510 (GLclampx)depth
511 );
512 }
513
514 /* void glClipPlanexOES ( GLenum plane, const GLfixed *equation ) */
515 static void
android_glClipPlanexOES__I_3II(JNIEnv * _env,jobject _this,jint plane,jintArray equation_ref,jint offset)516 android_glClipPlanexOES__I_3II
517 (JNIEnv *_env, jobject _this, jint plane, jintArray equation_ref, jint offset) {
518 GLfixed *equation_base = (GLfixed *) 0;
519 jint _remaining;
520 GLfixed *equation = (GLfixed *) 0;
521
522 if (!equation_ref) {
523 jniThrowException(_env, "java/lang/IllegalArgumentException", "equation == null");
524 goto exit;
525 }
526 if (offset < 0) {
527 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
528 goto exit;
529 }
530 _remaining = _env->GetArrayLength(equation_ref) - offset;
531 equation_base = (GLfixed *)
532 _env->GetPrimitiveArrayCritical(equation_ref, (jboolean *)0);
533 equation = equation_base + offset;
534
535 glClipPlanexOES(
536 (GLenum)plane,
537 (GLfixed *)equation
538 );
539
540 exit:
541 if (equation_base) {
542 _env->ReleasePrimitiveArrayCritical(equation_ref, equation_base,
543 JNI_ABORT);
544 }
545 }
546
547 /* void glClipPlanexOES ( GLenum plane, const GLfixed *equation ) */
548 static void
android_glClipPlanexOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint plane,jobject equation_buf)549 android_glClipPlanexOES__ILjava_nio_IntBuffer_2
550 (JNIEnv *_env, jobject _this, jint plane, jobject equation_buf) {
551 jarray _array = (jarray) 0;
552 jint _remaining;
553 GLfixed *equation = (GLfixed *) 0;
554
555 equation = (GLfixed *)getPointer(_env, equation_buf, &_array, &_remaining);
556 glClipPlanexOES(
557 (GLenum)plane,
558 (GLfixed *)equation
559 );
560 if (_array) {
561 releasePointer(_env, _array, equation, JNI_FALSE);
562 }
563 }
564
565 /* void glColor4xOES ( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) */
566 static void
android_glColor4xOES__IIII(JNIEnv * _env,jobject _this,jint red,jint green,jint blue,jint alpha)567 android_glColor4xOES__IIII
568 (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) {
569 glColor4xOES(
570 (GLfixed)red,
571 (GLfixed)green,
572 (GLfixed)blue,
573 (GLfixed)alpha
574 );
575 }
576
577 /* void glDepthRangexOES ( GLclampx zNear, GLclampx zFar ) */
578 static void
android_glDepthRangexOES__II(JNIEnv * _env,jobject _this,jint zNear,jint zFar)579 android_glDepthRangexOES__II
580 (JNIEnv *_env, jobject _this, jint zNear, jint zFar) {
581 glDepthRangexOES(
582 (GLclampx)zNear,
583 (GLclampx)zFar
584 );
585 }
586
587 /* void glFogxOES ( GLenum pname, GLfixed param ) */
588 static void
android_glFogxOES__II(JNIEnv * _env,jobject _this,jint pname,jint param)589 android_glFogxOES__II
590 (JNIEnv *_env, jobject _this, jint pname, jint param) {
591 glFogxOES(
592 (GLenum)pname,
593 (GLfixed)param
594 );
595 }
596
597 /* void glFogxvOES ( GLenum pname, const GLfixed *params ) */
598 static void
android_glFogxvOES__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray params_ref,jint offset)599 android_glFogxvOES__I_3II
600 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
601 GLfixed *params_base = (GLfixed *) 0;
602 jint _remaining;
603 GLfixed *params = (GLfixed *) 0;
604
605 if (!params_ref) {
606 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
607 goto exit;
608 }
609 if (offset < 0) {
610 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
611 goto exit;
612 }
613 _remaining = _env->GetArrayLength(params_ref) - offset;
614 params_base = (GLfixed *)
615 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
616 params = params_base + offset;
617
618 glFogxvOES(
619 (GLenum)pname,
620 (GLfixed *)params
621 );
622
623 exit:
624 if (params_base) {
625 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
626 JNI_ABORT);
627 }
628 }
629
630 /* void glFogxvOES ( GLenum pname, const GLfixed *params ) */
631 static void
android_glFogxvOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)632 android_glFogxvOES__ILjava_nio_IntBuffer_2
633 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
634 jarray _array = (jarray) 0;
635 jint _remaining;
636 GLfixed *params = (GLfixed *) 0;
637
638 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
639 glFogxvOES(
640 (GLenum)pname,
641 (GLfixed *)params
642 );
643 if (_array) {
644 releasePointer(_env, _array, params, JNI_FALSE);
645 }
646 }
647
648 /* void glFrustumxOES ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */
649 static void
android_glFrustumxOES__IIIIII(JNIEnv * _env,jobject _this,jint left,jint right,jint bottom,jint top,jint zNear,jint zFar)650 android_glFrustumxOES__IIIIII
651 (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) {
652 glFrustumxOES(
653 (GLfixed)left,
654 (GLfixed)right,
655 (GLfixed)bottom,
656 (GLfixed)top,
657 (GLfixed)zNear,
658 (GLfixed)zFar
659 );
660 }
661
662 /* void glGetClipPlanexOES ( GLenum pname, GLfixed *eqn ) */
663 static void
android_glGetClipPlanexOES__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray eqn_ref,jint offset)664 android_glGetClipPlanexOES__I_3II
665 (JNIEnv *_env, jobject _this, jint pname, jintArray eqn_ref, jint offset) {
666 jint _exception = 0;
667 GLfixed *eqn_base = (GLfixed *) 0;
668 jint _remaining;
669 GLfixed *eqn = (GLfixed *) 0;
670
671 if (!eqn_ref) {
672 _exception = 1;
673 jniThrowException(_env, "java/lang/IllegalArgumentException", "eqn == null");
674 goto exit;
675 }
676 if (offset < 0) {
677 _exception = 1;
678 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
679 goto exit;
680 }
681 _remaining = _env->GetArrayLength(eqn_ref) - offset;
682 if (_remaining < 4) {
683 _exception = 1;
684 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < 4");
685 goto exit;
686 }
687 eqn_base = (GLfixed *)
688 _env->GetPrimitiveArrayCritical(eqn_ref, (jboolean *)0);
689 eqn = eqn_base + offset;
690
691 glGetClipPlanexOES(
692 (GLenum)pname,
693 (GLfixed *)eqn
694 );
695
696 exit:
697 if (eqn_base) {
698 _env->ReleasePrimitiveArrayCritical(eqn_ref, eqn_base,
699 _exception ? JNI_ABORT: 0);
700 }
701 }
702
703 /* void glGetClipPlanexOES ( GLenum pname, GLfixed *eqn ) */
704 static void
android_glGetClipPlanexOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject eqn_buf)705 android_glGetClipPlanexOES__ILjava_nio_IntBuffer_2
706 (JNIEnv *_env, jobject _this, jint pname, jobject eqn_buf) {
707 jint _exception = 0;
708 jarray _array = (jarray) 0;
709 jint _remaining;
710 GLfixed *eqn = (GLfixed *) 0;
711
712 eqn = (GLfixed *)getPointer(_env, eqn_buf, &_array, &_remaining);
713 if (_remaining < 4) {
714 _exception = 1;
715 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < 4");
716 goto exit;
717 }
718 glGetClipPlanexOES(
719 (GLenum)pname,
720 (GLfixed *)eqn
721 );
722
723 exit:
724 if (_array) {
725 releasePointer(_env, _array, eqn, _exception ? JNI_FALSE : JNI_TRUE);
726 }
727 }
728
729 /* void glGetFixedvOES ( GLenum pname, GLfixed *params ) */
730 static void
android_glGetFixedvOES__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray params_ref,jint offset)731 android_glGetFixedvOES__I_3II
732 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
733 jint _exception = 0;
734 GLfixed *params_base = (GLfixed *) 0;
735 jint _remaining;
736 GLfixed *params = (GLfixed *) 0;
737
738 if (!params_ref) {
739 _exception = 1;
740 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
741 goto exit;
742 }
743 if (offset < 0) {
744 _exception = 1;
745 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
746 goto exit;
747 }
748 _remaining = _env->GetArrayLength(params_ref) - offset;
749 params_base = (GLfixed *)
750 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
751 params = params_base + offset;
752
753 glGetFixedvOES(
754 (GLenum)pname,
755 (GLfixed *)params
756 );
757
758 exit:
759 if (params_base) {
760 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
761 _exception ? JNI_ABORT: 0);
762 }
763 }
764
765 /* void glGetFixedvOES ( GLenum pname, GLfixed *params ) */
766 static void
android_glGetFixedvOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)767 android_glGetFixedvOES__ILjava_nio_IntBuffer_2
768 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
769 jint _exception = 0;
770 jarray _array = (jarray) 0;
771 jint _remaining;
772 GLfixed *params = (GLfixed *) 0;
773
774 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
775 glGetFixedvOES(
776 (GLenum)pname,
777 (GLfixed *)params
778 );
779 if (_array) {
780 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
781 }
782 }
783
784 /* void glGetLightxvOES ( GLenum light, GLenum pname, GLfixed *params ) */
785 static void
android_glGetLightxvOES__II_3II(JNIEnv * _env,jobject _this,jint light,jint pname,jintArray params_ref,jint offset)786 android_glGetLightxvOES__II_3II
787 (JNIEnv *_env, jobject _this, jint light, jint pname, jintArray params_ref, jint offset) {
788 jint _exception = 0;
789 GLfixed *params_base = (GLfixed *) 0;
790 jint _remaining;
791 GLfixed *params = (GLfixed *) 0;
792
793 if (!params_ref) {
794 _exception = 1;
795 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
796 goto exit;
797 }
798 if (offset < 0) {
799 _exception = 1;
800 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
801 goto exit;
802 }
803 _remaining = _env->GetArrayLength(params_ref) - offset;
804 params_base = (GLfixed *)
805 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
806 params = params_base + offset;
807
808 glGetLightxvOES(
809 (GLenum)light,
810 (GLenum)pname,
811 (GLfixed *)params
812 );
813
814 exit:
815 if (params_base) {
816 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
817 _exception ? JNI_ABORT: 0);
818 }
819 }
820
821 /* void glGetLightxvOES ( GLenum light, GLenum pname, GLfixed *params ) */
822 static void
android_glGetLightxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint light,jint pname,jobject params_buf)823 android_glGetLightxvOES__IILjava_nio_IntBuffer_2
824 (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) {
825 jint _exception = 0;
826 jarray _array = (jarray) 0;
827 jint _remaining;
828 GLfixed *params = (GLfixed *) 0;
829
830 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
831 glGetLightxvOES(
832 (GLenum)light,
833 (GLenum)pname,
834 (GLfixed *)params
835 );
836 if (_array) {
837 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
838 }
839 }
840
841 /* void glGetMaterialxvOES ( GLenum face, GLenum pname, GLfixed *params ) */
842 static void
android_glGetMaterialxvOES__II_3II(JNIEnv * _env,jobject _this,jint face,jint pname,jintArray params_ref,jint offset)843 android_glGetMaterialxvOES__II_3II
844 (JNIEnv *_env, jobject _this, jint face, jint pname, jintArray params_ref, jint offset) {
845 jint _exception = 0;
846 GLfixed *params_base = (GLfixed *) 0;
847 jint _remaining;
848 GLfixed *params = (GLfixed *) 0;
849
850 if (!params_ref) {
851 _exception = 1;
852 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
853 goto exit;
854 }
855 if (offset < 0) {
856 _exception = 1;
857 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
858 goto exit;
859 }
860 _remaining = _env->GetArrayLength(params_ref) - offset;
861 params_base = (GLfixed *)
862 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
863 params = params_base + offset;
864
865 glGetMaterialxvOES(
866 (GLenum)face,
867 (GLenum)pname,
868 (GLfixed *)params
869 );
870
871 exit:
872 if (params_base) {
873 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
874 _exception ? JNI_ABORT: 0);
875 }
876 }
877
878 /* void glGetMaterialxvOES ( GLenum face, GLenum pname, GLfixed *params ) */
879 static void
android_glGetMaterialxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint face,jint pname,jobject params_buf)880 android_glGetMaterialxvOES__IILjava_nio_IntBuffer_2
881 (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) {
882 jint _exception = 0;
883 jarray _array = (jarray) 0;
884 jint _remaining;
885 GLfixed *params = (GLfixed *) 0;
886
887 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
888 glGetMaterialxvOES(
889 (GLenum)face,
890 (GLenum)pname,
891 (GLfixed *)params
892 );
893 if (_array) {
894 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
895 }
896 }
897
898 /* void glGetTexEnvxvOES ( GLenum env, GLenum pname, GLfixed *params ) */
899 static void
android_glGetTexEnvxvOES__II_3II(JNIEnv * _env,jobject _this,jint env,jint pname,jintArray params_ref,jint offset)900 android_glGetTexEnvxvOES__II_3II
901 (JNIEnv *_env, jobject _this, jint env, jint pname, jintArray params_ref, jint offset) {
902 jint _exception = 0;
903 GLfixed *params_base = (GLfixed *) 0;
904 jint _remaining;
905 GLfixed *params = (GLfixed *) 0;
906
907 if (!params_ref) {
908 _exception = 1;
909 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
910 goto exit;
911 }
912 if (offset < 0) {
913 _exception = 1;
914 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
915 goto exit;
916 }
917 _remaining = _env->GetArrayLength(params_ref) - offset;
918 params_base = (GLfixed *)
919 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
920 params = params_base + offset;
921
922 glGetTexEnvxvOES(
923 (GLenum)env,
924 (GLenum)pname,
925 (GLfixed *)params
926 );
927
928 exit:
929 if (params_base) {
930 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
931 _exception ? JNI_ABORT: 0);
932 }
933 }
934
935 /* void glGetTexEnvxvOES ( GLenum env, GLenum pname, GLfixed *params ) */
936 static void
android_glGetTexEnvxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint env,jint pname,jobject params_buf)937 android_glGetTexEnvxvOES__IILjava_nio_IntBuffer_2
938 (JNIEnv *_env, jobject _this, jint env, jint pname, jobject params_buf) {
939 jint _exception = 0;
940 jarray _array = (jarray) 0;
941 jint _remaining;
942 GLfixed *params = (GLfixed *) 0;
943
944 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
945 glGetTexEnvxvOES(
946 (GLenum)env,
947 (GLenum)pname,
948 (GLfixed *)params
949 );
950 if (_array) {
951 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
952 }
953 }
954
955 /* void glGetTexParameterxvOES ( GLenum target, GLenum pname, GLfixed *params ) */
956 static void
android_glGetTexParameterxvOES__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)957 android_glGetTexParameterxvOES__II_3II
958 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
959 jint _exception = 0;
960 GLfixed *params_base = (GLfixed *) 0;
961 jint _remaining;
962 GLfixed *params = (GLfixed *) 0;
963
964 if (!params_ref) {
965 _exception = 1;
966 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
967 goto exit;
968 }
969 if (offset < 0) {
970 _exception = 1;
971 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
972 goto exit;
973 }
974 _remaining = _env->GetArrayLength(params_ref) - offset;
975 params_base = (GLfixed *)
976 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
977 params = params_base + offset;
978
979 glGetTexParameterxvOES(
980 (GLenum)target,
981 (GLenum)pname,
982 (GLfixed *)params
983 );
984
985 exit:
986 if (params_base) {
987 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
988 _exception ? JNI_ABORT: 0);
989 }
990 }
991
992 /* void glGetTexParameterxvOES ( GLenum target, GLenum pname, GLfixed *params ) */
993 static void
android_glGetTexParameterxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)994 android_glGetTexParameterxvOES__IILjava_nio_IntBuffer_2
995 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
996 jint _exception = 0;
997 jarray _array = (jarray) 0;
998 jint _remaining;
999 GLfixed *params = (GLfixed *) 0;
1000
1001 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
1002 glGetTexParameterxvOES(
1003 (GLenum)target,
1004 (GLenum)pname,
1005 (GLfixed *)params
1006 );
1007 if (_array) {
1008 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
1009 }
1010 }
1011
1012 /* void glLightModelxOES ( GLenum pname, GLfixed param ) */
1013 static void
android_glLightModelxOES__II(JNIEnv * _env,jobject _this,jint pname,jint param)1014 android_glLightModelxOES__II
1015 (JNIEnv *_env, jobject _this, jint pname, jint param) {
1016 glLightModelxOES(
1017 (GLenum)pname,
1018 (GLfixed)param
1019 );
1020 }
1021
1022 /* void glLightModelxvOES ( GLenum pname, const GLfixed *params ) */
1023 static void
android_glLightModelxvOES__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray params_ref,jint offset)1024 android_glLightModelxvOES__I_3II
1025 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
1026 GLfixed *params_base = (GLfixed *) 0;
1027 jint _remaining;
1028 GLfixed *params = (GLfixed *) 0;
1029
1030 if (!params_ref) {
1031 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
1032 goto exit;
1033 }
1034 if (offset < 0) {
1035 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
1036 goto exit;
1037 }
1038 _remaining = _env->GetArrayLength(params_ref) - offset;
1039 params_base = (GLfixed *)
1040 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1041 params = params_base + offset;
1042
1043 glLightModelxvOES(
1044 (GLenum)pname,
1045 (GLfixed *)params
1046 );
1047
1048 exit:
1049 if (params_base) {
1050 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1051 JNI_ABORT);
1052 }
1053 }
1054
1055 /* void glLightModelxvOES ( GLenum pname, const GLfixed *params ) */
1056 static void
android_glLightModelxvOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)1057 android_glLightModelxvOES__ILjava_nio_IntBuffer_2
1058 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
1059 jarray _array = (jarray) 0;
1060 jint _remaining;
1061 GLfixed *params = (GLfixed *) 0;
1062
1063 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
1064 glLightModelxvOES(
1065 (GLenum)pname,
1066 (GLfixed *)params
1067 );
1068 if (_array) {
1069 releasePointer(_env, _array, params, JNI_FALSE);
1070 }
1071 }
1072
1073 /* void glLightxOES ( GLenum light, GLenum pname, GLfixed param ) */
1074 static void
android_glLightxOES__III(JNIEnv * _env,jobject _this,jint light,jint pname,jint param)1075 android_glLightxOES__III
1076 (JNIEnv *_env, jobject _this, jint light, jint pname, jint param) {
1077 glLightxOES(
1078 (GLenum)light,
1079 (GLenum)pname,
1080 (GLfixed)param
1081 );
1082 }
1083
1084 /* void glLightxvOES ( GLenum light, GLenum pname, const GLfixed *params ) */
1085 static void
android_glLightxvOES__II_3II(JNIEnv * _env,jobject _this,jint light,jint pname,jintArray params_ref,jint offset)1086 android_glLightxvOES__II_3II
1087 (JNIEnv *_env, jobject _this, jint light, jint pname, jintArray params_ref, jint offset) {
1088 GLfixed *params_base = (GLfixed *) 0;
1089 jint _remaining;
1090 GLfixed *params = (GLfixed *) 0;
1091
1092 if (!params_ref) {
1093 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
1094 goto exit;
1095 }
1096 if (offset < 0) {
1097 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
1098 goto exit;
1099 }
1100 _remaining = _env->GetArrayLength(params_ref) - offset;
1101 params_base = (GLfixed *)
1102 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1103 params = params_base + offset;
1104
1105 glLightxvOES(
1106 (GLenum)light,
1107 (GLenum)pname,
1108 (GLfixed *)params
1109 );
1110
1111 exit:
1112 if (params_base) {
1113 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1114 JNI_ABORT);
1115 }
1116 }
1117
1118 /* void glLightxvOES ( GLenum light, GLenum pname, const GLfixed *params ) */
1119 static void
android_glLightxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint light,jint pname,jobject params_buf)1120 android_glLightxvOES__IILjava_nio_IntBuffer_2
1121 (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) {
1122 jarray _array = (jarray) 0;
1123 jint _remaining;
1124 GLfixed *params = (GLfixed *) 0;
1125
1126 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
1127 glLightxvOES(
1128 (GLenum)light,
1129 (GLenum)pname,
1130 (GLfixed *)params
1131 );
1132 if (_array) {
1133 releasePointer(_env, _array, params, JNI_FALSE);
1134 }
1135 }
1136
1137 /* void glLineWidthxOES ( GLfixed width ) */
1138 static void
android_glLineWidthxOES__I(JNIEnv * _env,jobject _this,jint width)1139 android_glLineWidthxOES__I
1140 (JNIEnv *_env, jobject _this, jint width) {
1141 glLineWidthxOES(
1142 (GLfixed)width
1143 );
1144 }
1145
1146 /* void glLoadMatrixxOES ( const GLfixed *m ) */
1147 static void
android_glLoadMatrixxOES___3II(JNIEnv * _env,jobject _this,jintArray m_ref,jint offset)1148 android_glLoadMatrixxOES___3II
1149 (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) {
1150 GLfixed *m_base = (GLfixed *) 0;
1151 jint _remaining;
1152 GLfixed *m = (GLfixed *) 0;
1153
1154 if (!m_ref) {
1155 jniThrowException(_env, "java/lang/IllegalArgumentException", "m == null");
1156 goto exit;
1157 }
1158 if (offset < 0) {
1159 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
1160 goto exit;
1161 }
1162 _remaining = _env->GetArrayLength(m_ref) - offset;
1163 m_base = (GLfixed *)
1164 _env->GetPrimitiveArrayCritical(m_ref, (jboolean *)0);
1165 m = m_base + offset;
1166
1167 glLoadMatrixxOES(
1168 (GLfixed *)m
1169 );
1170
1171 exit:
1172 if (m_base) {
1173 _env->ReleasePrimitiveArrayCritical(m_ref, m_base,
1174 JNI_ABORT);
1175 }
1176 }
1177
1178 /* void glLoadMatrixxOES ( const GLfixed *m ) */
1179 static void
android_glLoadMatrixxOES__Ljava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jobject m_buf)1180 android_glLoadMatrixxOES__Ljava_nio_IntBuffer_2
1181 (JNIEnv *_env, jobject _this, jobject m_buf) {
1182 jarray _array = (jarray) 0;
1183 jint _remaining;
1184 GLfixed *m = (GLfixed *) 0;
1185
1186 m = (GLfixed *)getPointer(_env, m_buf, &_array, &_remaining);
1187 glLoadMatrixxOES(
1188 (GLfixed *)m
1189 );
1190 if (_array) {
1191 releasePointer(_env, _array, m, JNI_FALSE);
1192 }
1193 }
1194
1195 /* void glMaterialxOES ( GLenum face, GLenum pname, GLfixed param ) */
1196 static void
android_glMaterialxOES__III(JNIEnv * _env,jobject _this,jint face,jint pname,jint param)1197 android_glMaterialxOES__III
1198 (JNIEnv *_env, jobject _this, jint face, jint pname, jint param) {
1199 glMaterialxOES(
1200 (GLenum)face,
1201 (GLenum)pname,
1202 (GLfixed)param
1203 );
1204 }
1205
1206 /* void glMaterialxvOES ( GLenum face, GLenum pname, const GLfixed *params ) */
1207 static void
android_glMaterialxvOES__II_3II(JNIEnv * _env,jobject _this,jint face,jint pname,jintArray params_ref,jint offset)1208 android_glMaterialxvOES__II_3II
1209 (JNIEnv *_env, jobject _this, jint face, jint pname, jintArray params_ref, jint offset) {
1210 GLfixed *params_base = (GLfixed *) 0;
1211 jint _remaining;
1212 GLfixed *params = (GLfixed *) 0;
1213
1214 if (!params_ref) {
1215 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
1216 goto exit;
1217 }
1218 if (offset < 0) {
1219 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
1220 goto exit;
1221 }
1222 _remaining = _env->GetArrayLength(params_ref) - offset;
1223 params_base = (GLfixed *)
1224 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1225 params = params_base + offset;
1226
1227 glMaterialxvOES(
1228 (GLenum)face,
1229 (GLenum)pname,
1230 (GLfixed *)params
1231 );
1232
1233 exit:
1234 if (params_base) {
1235 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1236 JNI_ABORT);
1237 }
1238 }
1239
1240 /* void glMaterialxvOES ( GLenum face, GLenum pname, const GLfixed *params ) */
1241 static void
android_glMaterialxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint face,jint pname,jobject params_buf)1242 android_glMaterialxvOES__IILjava_nio_IntBuffer_2
1243 (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) {
1244 jarray _array = (jarray) 0;
1245 jint _remaining;
1246 GLfixed *params = (GLfixed *) 0;
1247
1248 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
1249 glMaterialxvOES(
1250 (GLenum)face,
1251 (GLenum)pname,
1252 (GLfixed *)params
1253 );
1254 if (_array) {
1255 releasePointer(_env, _array, params, JNI_FALSE);
1256 }
1257 }
1258
1259 /* void glMultMatrixxOES ( const GLfixed *m ) */
1260 static void
android_glMultMatrixxOES___3II(JNIEnv * _env,jobject _this,jintArray m_ref,jint offset)1261 android_glMultMatrixxOES___3II
1262 (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) {
1263 GLfixed *m_base = (GLfixed *) 0;
1264 jint _remaining;
1265 GLfixed *m = (GLfixed *) 0;
1266
1267 if (!m_ref) {
1268 jniThrowException(_env, "java/lang/IllegalArgumentException", "m == null");
1269 goto exit;
1270 }
1271 if (offset < 0) {
1272 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
1273 goto exit;
1274 }
1275 _remaining = _env->GetArrayLength(m_ref) - offset;
1276 m_base = (GLfixed *)
1277 _env->GetPrimitiveArrayCritical(m_ref, (jboolean *)0);
1278 m = m_base + offset;
1279
1280 glMultMatrixxOES(
1281 (GLfixed *)m
1282 );
1283
1284 exit:
1285 if (m_base) {
1286 _env->ReleasePrimitiveArrayCritical(m_ref, m_base,
1287 JNI_ABORT);
1288 }
1289 }
1290
1291 /* void glMultMatrixxOES ( const GLfixed *m ) */
1292 static void
android_glMultMatrixxOES__Ljava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jobject m_buf)1293 android_glMultMatrixxOES__Ljava_nio_IntBuffer_2
1294 (JNIEnv *_env, jobject _this, jobject m_buf) {
1295 jarray _array = (jarray) 0;
1296 jint _remaining;
1297 GLfixed *m = (GLfixed *) 0;
1298
1299 m = (GLfixed *)getPointer(_env, m_buf, &_array, &_remaining);
1300 glMultMatrixxOES(
1301 (GLfixed *)m
1302 );
1303 if (_array) {
1304 releasePointer(_env, _array, m, JNI_FALSE);
1305 }
1306 }
1307
1308 /* void glMultiTexCoord4xOES ( GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q ) */
1309 static void
android_glMultiTexCoord4xOES__IIIII(JNIEnv * _env,jobject _this,jint target,jint s,jint t,jint r,jint q)1310 android_glMultiTexCoord4xOES__IIIII
1311 (JNIEnv *_env, jobject _this, jint target, jint s, jint t, jint r, jint q) {
1312 glMultiTexCoord4xOES(
1313 (GLenum)target,
1314 (GLfixed)s,
1315 (GLfixed)t,
1316 (GLfixed)r,
1317 (GLfixed)q
1318 );
1319 }
1320
1321 /* void glNormal3xOES ( GLfixed nx, GLfixed ny, GLfixed nz ) */
1322 static void
android_glNormal3xOES__III(JNIEnv * _env,jobject _this,jint nx,jint ny,jint nz)1323 android_glNormal3xOES__III
1324 (JNIEnv *_env, jobject _this, jint nx, jint ny, jint nz) {
1325 glNormal3xOES(
1326 (GLfixed)nx,
1327 (GLfixed)ny,
1328 (GLfixed)nz
1329 );
1330 }
1331
1332 /* void glOrthoxOES ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */
1333 static void
android_glOrthoxOES__IIIIII(JNIEnv * _env,jobject _this,jint left,jint right,jint bottom,jint top,jint zNear,jint zFar)1334 android_glOrthoxOES__IIIIII
1335 (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) {
1336 glOrthoxOES(
1337 (GLfixed)left,
1338 (GLfixed)right,
1339 (GLfixed)bottom,
1340 (GLfixed)top,
1341 (GLfixed)zNear,
1342 (GLfixed)zFar
1343 );
1344 }
1345
1346 /* void glPointParameterxOES ( GLenum pname, GLfixed param ) */
1347 static void
android_glPointParameterxOES__II(JNIEnv * _env,jobject _this,jint pname,jint param)1348 android_glPointParameterxOES__II
1349 (JNIEnv *_env, jobject _this, jint pname, jint param) {
1350 glPointParameterxOES(
1351 (GLenum)pname,
1352 (GLfixed)param
1353 );
1354 }
1355
1356 /* void glPointParameterxvOES ( GLenum pname, const GLfixed *params ) */
1357 static void
android_glPointParameterxvOES__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray params_ref,jint offset)1358 android_glPointParameterxvOES__I_3II
1359 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
1360 GLfixed *params_base = (GLfixed *) 0;
1361 jint _remaining;
1362 GLfixed *params = (GLfixed *) 0;
1363
1364 if (!params_ref) {
1365 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
1366 goto exit;
1367 }
1368 if (offset < 0) {
1369 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
1370 goto exit;
1371 }
1372 _remaining = _env->GetArrayLength(params_ref) - offset;
1373 params_base = (GLfixed *)
1374 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1375 params = params_base + offset;
1376
1377 glPointParameterxvOES(
1378 (GLenum)pname,
1379 (GLfixed *)params
1380 );
1381
1382 exit:
1383 if (params_base) {
1384 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1385 JNI_ABORT);
1386 }
1387 }
1388
1389 /* void glPointParameterxvOES ( GLenum pname, const GLfixed *params ) */
1390 static void
android_glPointParameterxvOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)1391 android_glPointParameterxvOES__ILjava_nio_IntBuffer_2
1392 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
1393 jarray _array = (jarray) 0;
1394 jint _remaining;
1395 GLfixed *params = (GLfixed *) 0;
1396
1397 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
1398 glPointParameterxvOES(
1399 (GLenum)pname,
1400 (GLfixed *)params
1401 );
1402 if (_array) {
1403 releasePointer(_env, _array, params, JNI_FALSE);
1404 }
1405 }
1406
1407 /* void glPointSizexOES ( GLfixed size ) */
1408 static void
android_glPointSizexOES__I(JNIEnv * _env,jobject _this,jint size)1409 android_glPointSizexOES__I
1410 (JNIEnv *_env, jobject _this, jint size) {
1411 glPointSizexOES(
1412 (GLfixed)size
1413 );
1414 }
1415
1416 /* void glPolygonOffsetxOES ( GLfixed factor, GLfixed units ) */
1417 static void
android_glPolygonOffsetxOES__II(JNIEnv * _env,jobject _this,jint factor,jint units)1418 android_glPolygonOffsetxOES__II
1419 (JNIEnv *_env, jobject _this, jint factor, jint units) {
1420 glPolygonOffsetxOES(
1421 (GLfixed)factor,
1422 (GLfixed)units
1423 );
1424 }
1425
1426 /* void glRotatexOES ( GLfixed angle, GLfixed x, GLfixed y, GLfixed z ) */
1427 static void
android_glRotatexOES__IIII(JNIEnv * _env,jobject _this,jint angle,jint x,jint y,jint z)1428 android_glRotatexOES__IIII
1429 (JNIEnv *_env, jobject _this, jint angle, jint x, jint y, jint z) {
1430 glRotatexOES(
1431 (GLfixed)angle,
1432 (GLfixed)x,
1433 (GLfixed)y,
1434 (GLfixed)z
1435 );
1436 }
1437
1438 /* void glSampleCoveragexOES ( GLclampx value, GLboolean invert ) */
1439 static void
android_glSampleCoveragexOES__IZ(JNIEnv * _env,jobject _this,jint value,jboolean invert)1440 android_glSampleCoveragexOES__IZ
1441 (JNIEnv *_env, jobject _this, jint value, jboolean invert) {
1442 glSampleCoveragexOES(
1443 (GLclampx)value,
1444 (GLboolean)invert
1445 );
1446 }
1447
1448 /* void glScalexOES ( GLfixed x, GLfixed y, GLfixed z ) */
1449 static void
android_glScalexOES__III(JNIEnv * _env,jobject _this,jint x,jint y,jint z)1450 android_glScalexOES__III
1451 (JNIEnv *_env, jobject _this, jint x, jint y, jint z) {
1452 glScalexOES(
1453 (GLfixed)x,
1454 (GLfixed)y,
1455 (GLfixed)z
1456 );
1457 }
1458
1459 /* void glTexEnvxOES ( GLenum target, GLenum pname, GLfixed param ) */
1460 static void
android_glTexEnvxOES__III(JNIEnv * _env,jobject _this,jint target,jint pname,jint param)1461 android_glTexEnvxOES__III
1462 (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) {
1463 glTexEnvxOES(
1464 (GLenum)target,
1465 (GLenum)pname,
1466 (GLfixed)param
1467 );
1468 }
1469
1470 /* void glTexEnvxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */
1471 static void
android_glTexEnvxvOES__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)1472 android_glTexEnvxvOES__II_3II
1473 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
1474 GLfixed *params_base = (GLfixed *) 0;
1475 jint _remaining;
1476 GLfixed *params = (GLfixed *) 0;
1477
1478 if (!params_ref) {
1479 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
1480 goto exit;
1481 }
1482 if (offset < 0) {
1483 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
1484 goto exit;
1485 }
1486 _remaining = _env->GetArrayLength(params_ref) - offset;
1487 params_base = (GLfixed *)
1488 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1489 params = params_base + offset;
1490
1491 glTexEnvxvOES(
1492 (GLenum)target,
1493 (GLenum)pname,
1494 (GLfixed *)params
1495 );
1496
1497 exit:
1498 if (params_base) {
1499 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1500 JNI_ABORT);
1501 }
1502 }
1503
1504 /* void glTexEnvxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */
1505 static void
android_glTexEnvxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)1506 android_glTexEnvxvOES__IILjava_nio_IntBuffer_2
1507 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
1508 jarray _array = (jarray) 0;
1509 jint _remaining;
1510 GLfixed *params = (GLfixed *) 0;
1511
1512 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
1513 glTexEnvxvOES(
1514 (GLenum)target,
1515 (GLenum)pname,
1516 (GLfixed *)params
1517 );
1518 if (_array) {
1519 releasePointer(_env, _array, params, JNI_FALSE);
1520 }
1521 }
1522
1523 /* void glTexParameterxOES ( GLenum target, GLenum pname, GLfixed param ) */
1524 static void
android_glTexParameterxOES__III(JNIEnv * _env,jobject _this,jint target,jint pname,jint param)1525 android_glTexParameterxOES__III
1526 (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) {
1527 glTexParameterxOES(
1528 (GLenum)target,
1529 (GLenum)pname,
1530 (GLfixed)param
1531 );
1532 }
1533
1534 /* void glTexParameterxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */
1535 static void
android_glTexParameterxvOES__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)1536 android_glTexParameterxvOES__II_3II
1537 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
1538 GLfixed *params_base = (GLfixed *) 0;
1539 jint _remaining;
1540 GLfixed *params = (GLfixed *) 0;
1541
1542 if (!params_ref) {
1543 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
1544 goto exit;
1545 }
1546 if (offset < 0) {
1547 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
1548 goto exit;
1549 }
1550 _remaining = _env->GetArrayLength(params_ref) - offset;
1551 params_base = (GLfixed *)
1552 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1553 params = params_base + offset;
1554
1555 glTexParameterxvOES(
1556 (GLenum)target,
1557 (GLenum)pname,
1558 (GLfixed *)params
1559 );
1560
1561 exit:
1562 if (params_base) {
1563 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1564 JNI_ABORT);
1565 }
1566 }
1567
1568 /* void glTexParameterxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */
1569 static void
android_glTexParameterxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)1570 android_glTexParameterxvOES__IILjava_nio_IntBuffer_2
1571 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
1572 jarray _array = (jarray) 0;
1573 jint _remaining;
1574 GLfixed *params = (GLfixed *) 0;
1575
1576 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
1577 glTexParameterxvOES(
1578 (GLenum)target,
1579 (GLenum)pname,
1580 (GLfixed *)params
1581 );
1582 if (_array) {
1583 releasePointer(_env, _array, params, JNI_FALSE);
1584 }
1585 }
1586
1587 /* void glTranslatexOES ( GLfixed x, GLfixed y, GLfixed z ) */
1588 static void
android_glTranslatexOES__III(JNIEnv * _env,jobject _this,jint x,jint y,jint z)1589 android_glTranslatexOES__III
1590 (JNIEnv *_env, jobject _this, jint x, jint y, jint z) {
1591 glTranslatexOES(
1592 (GLfixed)x,
1593 (GLfixed)y,
1594 (GLfixed)z
1595 );
1596 }
1597
1598 /* GLboolean glIsRenderbufferOES ( GLuint renderbuffer ) */
1599 static jboolean
android_glIsRenderbufferOES__I(JNIEnv * _env,jobject _this,jint renderbuffer)1600 android_glIsRenderbufferOES__I
1601 (JNIEnv *_env, jobject _this, jint renderbuffer) {
1602 GLboolean _returnValue;
1603 _returnValue = glIsRenderbufferOES(
1604 (GLuint)renderbuffer
1605 );
1606 return _returnValue;
1607 }
1608
1609 /* void glBindRenderbufferOES ( GLenum target, GLuint renderbuffer ) */
1610 static void
android_glBindRenderbufferOES__II(JNIEnv * _env,jobject _this,jint target,jint renderbuffer)1611 android_glBindRenderbufferOES__II
1612 (JNIEnv *_env, jobject _this, jint target, jint renderbuffer) {
1613 glBindRenderbufferOES(
1614 (GLenum)target,
1615 (GLuint)renderbuffer
1616 );
1617 }
1618
1619 /* void glDeleteRenderbuffersOES ( GLsizei n, const GLuint *renderbuffers ) */
1620 static void
android_glDeleteRenderbuffersOES__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray renderbuffers_ref,jint offset)1621 android_glDeleteRenderbuffersOES__I_3II
1622 (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) {
1623 GLuint *renderbuffers_base = (GLuint *) 0;
1624 jint _remaining;
1625 GLuint *renderbuffers = (GLuint *) 0;
1626
1627 if (!renderbuffers_ref) {
1628 jniThrowException(_env, "java/lang/IllegalArgumentException", "renderbuffers == null");
1629 goto exit;
1630 }
1631 if (offset < 0) {
1632 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
1633 goto exit;
1634 }
1635 _remaining = _env->GetArrayLength(renderbuffers_ref) - offset;
1636 if (_remaining < n) {
1637 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < n");
1638 goto exit;
1639 }
1640 renderbuffers_base = (GLuint *)
1641 _env->GetPrimitiveArrayCritical(renderbuffers_ref, (jboolean *)0);
1642 renderbuffers = renderbuffers_base + offset;
1643
1644 glDeleteRenderbuffersOES(
1645 (GLsizei)n,
1646 (GLuint *)renderbuffers
1647 );
1648
1649 exit:
1650 if (renderbuffers_base) {
1651 _env->ReleasePrimitiveArrayCritical(renderbuffers_ref, renderbuffers_base,
1652 JNI_ABORT);
1653 }
1654 }
1655
1656 /* void glDeleteRenderbuffersOES ( GLsizei n, const GLuint *renderbuffers ) */
1657 static void
android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject renderbuffers_buf)1658 android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2
1659 (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) {
1660 jarray _array = (jarray) 0;
1661 jint _remaining;
1662 GLuint *renderbuffers = (GLuint *) 0;
1663
1664 renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, &_array, &_remaining);
1665 if (_remaining < n) {
1666 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < n");
1667 goto exit;
1668 }
1669 glDeleteRenderbuffersOES(
1670 (GLsizei)n,
1671 (GLuint *)renderbuffers
1672 );
1673
1674 exit:
1675 if (_array) {
1676 releasePointer(_env, _array, renderbuffers, JNI_FALSE);
1677 }
1678 }
1679
1680 /* void glGenRenderbuffersOES ( GLsizei n, GLuint *renderbuffers ) */
1681 static void
android_glGenRenderbuffersOES__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray renderbuffers_ref,jint offset)1682 android_glGenRenderbuffersOES__I_3II
1683 (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) {
1684 jint _exception = 0;
1685 GLuint *renderbuffers_base = (GLuint *) 0;
1686 jint _remaining;
1687 GLuint *renderbuffers = (GLuint *) 0;
1688
1689 if (!renderbuffers_ref) {
1690 _exception = 1;
1691 jniThrowException(_env, "java/lang/IllegalArgumentException", "renderbuffers == null");
1692 goto exit;
1693 }
1694 if (offset < 0) {
1695 _exception = 1;
1696 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
1697 goto exit;
1698 }
1699 _remaining = _env->GetArrayLength(renderbuffers_ref) - offset;
1700 if (_remaining < n) {
1701 _exception = 1;
1702 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < n");
1703 goto exit;
1704 }
1705 renderbuffers_base = (GLuint *)
1706 _env->GetPrimitiveArrayCritical(renderbuffers_ref, (jboolean *)0);
1707 renderbuffers = renderbuffers_base + offset;
1708
1709 glGenRenderbuffersOES(
1710 (GLsizei)n,
1711 (GLuint *)renderbuffers
1712 );
1713
1714 exit:
1715 if (renderbuffers_base) {
1716 _env->ReleasePrimitiveArrayCritical(renderbuffers_ref, renderbuffers_base,
1717 _exception ? JNI_ABORT: 0);
1718 }
1719 }
1720
1721 /* void glGenRenderbuffersOES ( GLsizei n, GLuint *renderbuffers ) */
1722 static void
android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject renderbuffers_buf)1723 android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2
1724 (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) {
1725 jint _exception = 0;
1726 jarray _array = (jarray) 0;
1727 jint _remaining;
1728 GLuint *renderbuffers = (GLuint *) 0;
1729
1730 renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, &_array, &_remaining);
1731 if (_remaining < n) {
1732 _exception = 1;
1733 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < n");
1734 goto exit;
1735 }
1736 glGenRenderbuffersOES(
1737 (GLsizei)n,
1738 (GLuint *)renderbuffers
1739 );
1740
1741 exit:
1742 if (_array) {
1743 releasePointer(_env, _array, renderbuffers, _exception ? JNI_FALSE : JNI_TRUE);
1744 }
1745 }
1746
1747 /* void glRenderbufferStorageOES ( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) */
1748 static void
android_glRenderbufferStorageOES__IIII(JNIEnv * _env,jobject _this,jint target,jint internalformat,jint width,jint height)1749 android_glRenderbufferStorageOES__IIII
1750 (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint width, jint height) {
1751 glRenderbufferStorageOES(
1752 (GLenum)target,
1753 (GLenum)internalformat,
1754 (GLsizei)width,
1755 (GLsizei)height
1756 );
1757 }
1758
1759 /* void glGetRenderbufferParameterivOES ( GLenum target, GLenum pname, GLint *params ) */
1760 static void
android_glGetRenderbufferParameterivOES__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)1761 android_glGetRenderbufferParameterivOES__II_3II
1762 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
1763 jint _exception = 0;
1764 GLint *params_base = (GLint *) 0;
1765 jint _remaining;
1766 GLint *params = (GLint *) 0;
1767
1768 if (!params_ref) {
1769 _exception = 1;
1770 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
1771 goto exit;
1772 }
1773 if (offset < 0) {
1774 _exception = 1;
1775 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
1776 goto exit;
1777 }
1778 _remaining = _env->GetArrayLength(params_ref) - offset;
1779 if (_remaining < 1) {
1780 _exception = 1;
1781 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < 1");
1782 goto exit;
1783 }
1784 params_base = (GLint *)
1785 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1786 params = params_base + offset;
1787
1788 glGetRenderbufferParameterivOES(
1789 (GLenum)target,
1790 (GLenum)pname,
1791 (GLint *)params
1792 );
1793
1794 exit:
1795 if (params_base) {
1796 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1797 _exception ? JNI_ABORT: 0);
1798 }
1799 }
1800
1801 /* void glGetRenderbufferParameterivOES ( GLenum target, GLenum pname, GLint *params ) */
1802 static void
android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)1803 android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2
1804 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
1805 jint _exception = 0;
1806 jarray _array = (jarray) 0;
1807 jint _remaining;
1808 GLint *params = (GLint *) 0;
1809
1810 params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
1811 if (_remaining < 1) {
1812 _exception = 1;
1813 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < 1");
1814 goto exit;
1815 }
1816 glGetRenderbufferParameterivOES(
1817 (GLenum)target,
1818 (GLenum)pname,
1819 (GLint *)params
1820 );
1821
1822 exit:
1823 if (_array) {
1824 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
1825 }
1826 }
1827
1828 /* GLboolean glIsFramebufferOES ( GLuint framebuffer ) */
1829 static jboolean
android_glIsFramebufferOES__I(JNIEnv * _env,jobject _this,jint framebuffer)1830 android_glIsFramebufferOES__I
1831 (JNIEnv *_env, jobject _this, jint framebuffer) {
1832 GLboolean _returnValue;
1833 _returnValue = glIsFramebufferOES(
1834 (GLuint)framebuffer
1835 );
1836 return _returnValue;
1837 }
1838
1839 /* void glBindFramebufferOES ( GLenum target, GLuint framebuffer ) */
1840 static void
android_glBindFramebufferOES__II(JNIEnv * _env,jobject _this,jint target,jint framebuffer)1841 android_glBindFramebufferOES__II
1842 (JNIEnv *_env, jobject _this, jint target, jint framebuffer) {
1843 glBindFramebufferOES(
1844 (GLenum)target,
1845 (GLuint)framebuffer
1846 );
1847 }
1848
1849 /* void glDeleteFramebuffersOES ( GLsizei n, const GLuint *framebuffers ) */
1850 static void
android_glDeleteFramebuffersOES__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray framebuffers_ref,jint offset)1851 android_glDeleteFramebuffersOES__I_3II
1852 (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) {
1853 GLuint *framebuffers_base = (GLuint *) 0;
1854 jint _remaining;
1855 GLuint *framebuffers = (GLuint *) 0;
1856
1857 if (!framebuffers_ref) {
1858 jniThrowException(_env, "java/lang/IllegalArgumentException", "framebuffers == null");
1859 goto exit;
1860 }
1861 if (offset < 0) {
1862 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
1863 goto exit;
1864 }
1865 _remaining = _env->GetArrayLength(framebuffers_ref) - offset;
1866 if (_remaining < n) {
1867 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < n");
1868 goto exit;
1869 }
1870 framebuffers_base = (GLuint *)
1871 _env->GetPrimitiveArrayCritical(framebuffers_ref, (jboolean *)0);
1872 framebuffers = framebuffers_base + offset;
1873
1874 glDeleteFramebuffersOES(
1875 (GLsizei)n,
1876 (GLuint *)framebuffers
1877 );
1878
1879 exit:
1880 if (framebuffers_base) {
1881 _env->ReleasePrimitiveArrayCritical(framebuffers_ref, framebuffers_base,
1882 JNI_ABORT);
1883 }
1884 }
1885
1886 /* void glDeleteFramebuffersOES ( GLsizei n, const GLuint *framebuffers ) */
1887 static void
android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject framebuffers_buf)1888 android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2
1889 (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) {
1890 jarray _array = (jarray) 0;
1891 jint _remaining;
1892 GLuint *framebuffers = (GLuint *) 0;
1893
1894 framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, &_array, &_remaining);
1895 if (_remaining < n) {
1896 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < n");
1897 goto exit;
1898 }
1899 glDeleteFramebuffersOES(
1900 (GLsizei)n,
1901 (GLuint *)framebuffers
1902 );
1903
1904 exit:
1905 if (_array) {
1906 releasePointer(_env, _array, framebuffers, JNI_FALSE);
1907 }
1908 }
1909
1910 /* void glGenFramebuffersOES ( GLsizei n, GLuint *framebuffers ) */
1911 static void
android_glGenFramebuffersOES__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray framebuffers_ref,jint offset)1912 android_glGenFramebuffersOES__I_3II
1913 (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) {
1914 jint _exception = 0;
1915 GLuint *framebuffers_base = (GLuint *) 0;
1916 jint _remaining;
1917 GLuint *framebuffers = (GLuint *) 0;
1918
1919 if (!framebuffers_ref) {
1920 _exception = 1;
1921 jniThrowException(_env, "java/lang/IllegalArgumentException", "framebuffers == null");
1922 goto exit;
1923 }
1924 if (offset < 0) {
1925 _exception = 1;
1926 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
1927 goto exit;
1928 }
1929 _remaining = _env->GetArrayLength(framebuffers_ref) - offset;
1930 if (_remaining < n) {
1931 _exception = 1;
1932 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < n");
1933 goto exit;
1934 }
1935 framebuffers_base = (GLuint *)
1936 _env->GetPrimitiveArrayCritical(framebuffers_ref, (jboolean *)0);
1937 framebuffers = framebuffers_base + offset;
1938
1939 glGenFramebuffersOES(
1940 (GLsizei)n,
1941 (GLuint *)framebuffers
1942 );
1943
1944 exit:
1945 if (framebuffers_base) {
1946 _env->ReleasePrimitiveArrayCritical(framebuffers_ref, framebuffers_base,
1947 _exception ? JNI_ABORT: 0);
1948 }
1949 }
1950
1951 /* void glGenFramebuffersOES ( GLsizei n, GLuint *framebuffers ) */
1952 static void
android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject framebuffers_buf)1953 android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2
1954 (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) {
1955 jint _exception = 0;
1956 jarray _array = (jarray) 0;
1957 jint _remaining;
1958 GLuint *framebuffers = (GLuint *) 0;
1959
1960 framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, &_array, &_remaining);
1961 if (_remaining < n) {
1962 _exception = 1;
1963 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < n");
1964 goto exit;
1965 }
1966 glGenFramebuffersOES(
1967 (GLsizei)n,
1968 (GLuint *)framebuffers
1969 );
1970
1971 exit:
1972 if (_array) {
1973 releasePointer(_env, _array, framebuffers, _exception ? JNI_FALSE : JNI_TRUE);
1974 }
1975 }
1976
1977 /* GLenum glCheckFramebufferStatusOES ( GLenum target ) */
1978 static jint
android_glCheckFramebufferStatusOES__I(JNIEnv * _env,jobject _this,jint target)1979 android_glCheckFramebufferStatusOES__I
1980 (JNIEnv *_env, jobject _this, jint target) {
1981 GLenum _returnValue;
1982 _returnValue = glCheckFramebufferStatusOES(
1983 (GLenum)target
1984 );
1985 return _returnValue;
1986 }
1987
1988 /* void glFramebufferRenderbufferOES ( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) */
1989 static void
android_glFramebufferRenderbufferOES__IIII(JNIEnv * _env,jobject _this,jint target,jint attachment,jint renderbuffertarget,jint renderbuffer)1990 android_glFramebufferRenderbufferOES__IIII
1991 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint renderbuffertarget, jint renderbuffer) {
1992 glFramebufferRenderbufferOES(
1993 (GLenum)target,
1994 (GLenum)attachment,
1995 (GLenum)renderbuffertarget,
1996 (GLuint)renderbuffer
1997 );
1998 }
1999
2000 /* void glFramebufferTexture2DOES ( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) */
2001 static void
android_glFramebufferTexture2DOES__IIIII(JNIEnv * _env,jobject _this,jint target,jint attachment,jint textarget,jint texture,jint level)2002 android_glFramebufferTexture2DOES__IIIII
2003 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint textarget, jint texture, jint level) {
2004 glFramebufferTexture2DOES(
2005 (GLenum)target,
2006 (GLenum)attachment,
2007 (GLenum)textarget,
2008 (GLuint)texture,
2009 (GLint)level
2010 );
2011 }
2012
2013 /* void glGetFramebufferAttachmentParameterivOES ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */
2014 static void
android_glGetFramebufferAttachmentParameterivOES__III_3II(JNIEnv * _env,jobject _this,jint target,jint attachment,jint pname,jintArray params_ref,jint offset)2015 android_glGetFramebufferAttachmentParameterivOES__III_3II
2016 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jintArray params_ref, jint offset) {
2017 jint _exception = 0;
2018 GLint *params_base = (GLint *) 0;
2019 jint _remaining;
2020 GLint *params = (GLint *) 0;
2021
2022 if (!params_ref) {
2023 _exception = 1;
2024 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
2025 goto exit;
2026 }
2027 if (offset < 0) {
2028 _exception = 1;
2029 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
2030 goto exit;
2031 }
2032 _remaining = _env->GetArrayLength(params_ref) - offset;
2033 if (_remaining < 1) {
2034 _exception = 1;
2035 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < 1");
2036 goto exit;
2037 }
2038 params_base = (GLint *)
2039 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2040 params = params_base + offset;
2041
2042 glGetFramebufferAttachmentParameterivOES(
2043 (GLenum)target,
2044 (GLenum)attachment,
2045 (GLenum)pname,
2046 (GLint *)params
2047 );
2048
2049 exit:
2050 if (params_base) {
2051 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2052 _exception ? JNI_ABORT: 0);
2053 }
2054 }
2055
2056 /* void glGetFramebufferAttachmentParameterivOES ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */
2057 static void
android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint attachment,jint pname,jobject params_buf)2058 android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2
2059 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jobject params_buf) {
2060 jint _exception = 0;
2061 jarray _array = (jarray) 0;
2062 jint _remaining;
2063 GLint *params = (GLint *) 0;
2064
2065 params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
2066 if (_remaining < 1) {
2067 _exception = 1;
2068 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < 1");
2069 goto exit;
2070 }
2071 glGetFramebufferAttachmentParameterivOES(
2072 (GLenum)target,
2073 (GLenum)attachment,
2074 (GLenum)pname,
2075 (GLint *)params
2076 );
2077
2078 exit:
2079 if (_array) {
2080 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
2081 }
2082 }
2083
2084 /* void glGenerateMipmapOES ( GLenum target ) */
2085 static void
android_glGenerateMipmapOES__I(JNIEnv * _env,jobject _this,jint target)2086 android_glGenerateMipmapOES__I
2087 (JNIEnv *_env, jobject _this, jint target) {
2088 glGenerateMipmapOES(
2089 (GLenum)target
2090 );
2091 }
2092
2093 /* void glCurrentPaletteMatrixOES ( GLuint matrixpaletteindex ) */
2094 static void
android_glCurrentPaletteMatrixOES__I(JNIEnv * _env,jobject _this,jint matrixpaletteindex)2095 android_glCurrentPaletteMatrixOES__I
2096 (JNIEnv *_env, jobject _this, jint matrixpaletteindex) {
2097 glCurrentPaletteMatrixOES(
2098 (GLuint)matrixpaletteindex
2099 );
2100 }
2101
2102 /* void glLoadPaletteFromModelViewMatrixOES ( void ) */
2103 static void
android_glLoadPaletteFromModelViewMatrixOES__(JNIEnv * _env,jobject _this)2104 android_glLoadPaletteFromModelViewMatrixOES__
2105 (JNIEnv *_env, jobject _this) {
2106 glLoadPaletteFromModelViewMatrixOES();
2107 }
2108
2109 /* void glMatrixIndexPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
2110 static void
android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint size,jint type,jint stride,jobject pointer_buf,jint remaining)2111 android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I
2112 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
2113 jarray _array = (jarray) 0;
2114 jint _remaining;
2115 GLvoid *pointer = (GLvoid *) 0;
2116
2117 if (pointer_buf) {
2118 pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
2119 if ( ! pointer ) {
2120 return;
2121 }
2122 }
2123 glMatrixIndexPointerOESBounds(
2124 (GLint)size,
2125 (GLenum)type,
2126 (GLsizei)stride,
2127 (GLvoid *)pointer,
2128 (GLsizei)remaining
2129 );
2130 }
2131
2132 /* void glWeightPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
2133 static void
android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint size,jint type,jint stride,jobject pointer_buf,jint remaining)2134 android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I
2135 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
2136 jarray _array = (jarray) 0;
2137 jint _remaining;
2138 GLvoid *pointer = (GLvoid *) 0;
2139
2140 if (pointer_buf) {
2141 pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
2142 if ( ! pointer ) {
2143 return;
2144 }
2145 }
2146 glWeightPointerOESBounds(
2147 (GLint)size,
2148 (GLenum)type,
2149 (GLsizei)stride,
2150 (GLvoid *)pointer,
2151 (GLsizei)remaining
2152 );
2153 }
2154
2155 /* void glDepthRangefOES ( GLclampf zNear, GLclampf zFar ) */
2156 static void
android_glDepthRangefOES__FF(JNIEnv * _env,jobject _this,jfloat zNear,jfloat zFar)2157 android_glDepthRangefOES__FF
2158 (JNIEnv *_env, jobject _this, jfloat zNear, jfloat zFar) {
2159 glDepthRangefOES(
2160 (GLclampf)zNear,
2161 (GLclampf)zFar
2162 );
2163 }
2164
2165 /* void glFrustumfOES ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */
2166 static void
android_glFrustumfOES__FFFFFF(JNIEnv * _env,jobject _this,jfloat left,jfloat right,jfloat bottom,jfloat top,jfloat zNear,jfloat zFar)2167 android_glFrustumfOES__FFFFFF
2168 (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) {
2169 glFrustumfOES(
2170 (GLfloat)left,
2171 (GLfloat)right,
2172 (GLfloat)bottom,
2173 (GLfloat)top,
2174 (GLfloat)zNear,
2175 (GLfloat)zFar
2176 );
2177 }
2178
2179 /* void glOrthofOES ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */
2180 static void
android_glOrthofOES__FFFFFF(JNIEnv * _env,jobject _this,jfloat left,jfloat right,jfloat bottom,jfloat top,jfloat zNear,jfloat zFar)2181 android_glOrthofOES__FFFFFF
2182 (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) {
2183 glOrthofOES(
2184 (GLfloat)left,
2185 (GLfloat)right,
2186 (GLfloat)bottom,
2187 (GLfloat)top,
2188 (GLfloat)zNear,
2189 (GLfloat)zFar
2190 );
2191 }
2192
2193 /* void glClipPlanefOES ( GLenum plane, const GLfloat *equation ) */
2194 static void
android_glClipPlanefOES__I_3FI(JNIEnv * _env,jobject _this,jint plane,jfloatArray equation_ref,jint offset)2195 android_glClipPlanefOES__I_3FI
2196 (JNIEnv *_env, jobject _this, jint plane, jfloatArray equation_ref, jint offset) {
2197 GLfloat *equation_base = (GLfloat *) 0;
2198 jint _remaining;
2199 GLfloat *equation = (GLfloat *) 0;
2200
2201 if (!equation_ref) {
2202 jniThrowException(_env, "java/lang/IllegalArgumentException", "equation == null");
2203 goto exit;
2204 }
2205 if (offset < 0) {
2206 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
2207 goto exit;
2208 }
2209 _remaining = _env->GetArrayLength(equation_ref) - offset;
2210 equation_base = (GLfloat *)
2211 _env->GetPrimitiveArrayCritical(equation_ref, (jboolean *)0);
2212 equation = equation_base + offset;
2213
2214 glClipPlanefOES(
2215 (GLenum)plane,
2216 (GLfloat *)equation
2217 );
2218
2219 exit:
2220 if (equation_base) {
2221 _env->ReleasePrimitiveArrayCritical(equation_ref, equation_base,
2222 JNI_ABORT);
2223 }
2224 }
2225
2226 /* void glClipPlanefOES ( GLenum plane, const GLfloat *equation ) */
2227 static void
android_glClipPlanefOES__ILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint plane,jobject equation_buf)2228 android_glClipPlanefOES__ILjava_nio_FloatBuffer_2
2229 (JNIEnv *_env, jobject _this, jint plane, jobject equation_buf) {
2230 jarray _array = (jarray) 0;
2231 jint _remaining;
2232 GLfloat *equation = (GLfloat *) 0;
2233
2234 equation = (GLfloat *)getPointer(_env, equation_buf, &_array, &_remaining);
2235 glClipPlanefOES(
2236 (GLenum)plane,
2237 (GLfloat *)equation
2238 );
2239 if (_array) {
2240 releasePointer(_env, _array, equation, JNI_FALSE);
2241 }
2242 }
2243
2244 /* void glGetClipPlanefOES ( GLenum pname, GLfloat *eqn ) */
2245 static void
android_glGetClipPlanefOES__I_3FI(JNIEnv * _env,jobject _this,jint pname,jfloatArray eqn_ref,jint offset)2246 android_glGetClipPlanefOES__I_3FI
2247 (JNIEnv *_env, jobject _this, jint pname, jfloatArray eqn_ref, jint offset) {
2248 jint _exception = 0;
2249 GLfloat *eqn_base = (GLfloat *) 0;
2250 jint _remaining;
2251 GLfloat *eqn = (GLfloat *) 0;
2252
2253 if (!eqn_ref) {
2254 _exception = 1;
2255 jniThrowException(_env, "java/lang/IllegalArgumentException", "eqn == null");
2256 goto exit;
2257 }
2258 if (offset < 0) {
2259 _exception = 1;
2260 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
2261 goto exit;
2262 }
2263 _remaining = _env->GetArrayLength(eqn_ref) - offset;
2264 if (_remaining < 4) {
2265 _exception = 1;
2266 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < 4");
2267 goto exit;
2268 }
2269 eqn_base = (GLfloat *)
2270 _env->GetPrimitiveArrayCritical(eqn_ref, (jboolean *)0);
2271 eqn = eqn_base + offset;
2272
2273 glGetClipPlanefOES(
2274 (GLenum)pname,
2275 (GLfloat *)eqn
2276 );
2277
2278 exit:
2279 if (eqn_base) {
2280 _env->ReleasePrimitiveArrayCritical(eqn_ref, eqn_base,
2281 _exception ? JNI_ABORT: 0);
2282 }
2283 }
2284
2285 /* void glGetClipPlanefOES ( GLenum pname, GLfloat *eqn ) */
2286 static void
android_glGetClipPlanefOES__ILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject eqn_buf)2287 android_glGetClipPlanefOES__ILjava_nio_FloatBuffer_2
2288 (JNIEnv *_env, jobject _this, jint pname, jobject eqn_buf) {
2289 jint _exception = 0;
2290 jarray _array = (jarray) 0;
2291 jint _remaining;
2292 GLfloat *eqn = (GLfloat *) 0;
2293
2294 eqn = (GLfloat *)getPointer(_env, eqn_buf, &_array, &_remaining);
2295 if (_remaining < 4) {
2296 _exception = 1;
2297 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < 4");
2298 goto exit;
2299 }
2300 glGetClipPlanefOES(
2301 (GLenum)pname,
2302 (GLfloat *)eqn
2303 );
2304
2305 exit:
2306 if (_array) {
2307 releasePointer(_env, _array, eqn, _exception ? JNI_FALSE : JNI_TRUE);
2308 }
2309 }
2310
2311 /* void glClearDepthfOES ( GLclampf depth ) */
2312 static void
android_glClearDepthfOES__F(JNIEnv * _env,jobject _this,jfloat depth)2313 android_glClearDepthfOES__F
2314 (JNIEnv *_env, jobject _this, jfloat depth) {
2315 glClearDepthfOES(
2316 (GLclampf)depth
2317 );
2318 }
2319
2320 /* void glTexGenfOES ( GLenum coord, GLenum pname, GLfloat param ) */
2321 static void
android_glTexGenfOES__IIF(JNIEnv * _env,jobject _this,jint coord,jint pname,jfloat param)2322 android_glTexGenfOES__IIF
2323 (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloat param) {
2324 glTexGenfOES(
2325 (GLenum)coord,
2326 (GLenum)pname,
2327 (GLfloat)param
2328 );
2329 }
2330
2331 /* void glTexGenfvOES ( GLenum coord, GLenum pname, const GLfloat *params ) */
2332 static void
android_glTexGenfvOES__II_3FI(JNIEnv * _env,jobject _this,jint coord,jint pname,jfloatArray params_ref,jint offset)2333 android_glTexGenfvOES__II_3FI
2334 (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) {
2335 GLfloat *params_base = (GLfloat *) 0;
2336 jint _remaining;
2337 GLfloat *params = (GLfloat *) 0;
2338
2339 if (!params_ref) {
2340 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
2341 goto exit;
2342 }
2343 if (offset < 0) {
2344 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
2345 goto exit;
2346 }
2347 _remaining = _env->GetArrayLength(params_ref) - offset;
2348 params_base = (GLfloat *)
2349 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2350 params = params_base + offset;
2351
2352 glTexGenfvOES(
2353 (GLenum)coord,
2354 (GLenum)pname,
2355 (GLfloat *)params
2356 );
2357
2358 exit:
2359 if (params_base) {
2360 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2361 JNI_ABORT);
2362 }
2363 }
2364
2365 /* void glTexGenfvOES ( GLenum coord, GLenum pname, const GLfloat *params ) */
2366 static void
android_glTexGenfvOES__IILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)2367 android_glTexGenfvOES__IILjava_nio_FloatBuffer_2
2368 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2369 jarray _array = (jarray) 0;
2370 jint _remaining;
2371 GLfloat *params = (GLfloat *) 0;
2372
2373 params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining);
2374 glTexGenfvOES(
2375 (GLenum)coord,
2376 (GLenum)pname,
2377 (GLfloat *)params
2378 );
2379 if (_array) {
2380 releasePointer(_env, _array, params, JNI_FALSE);
2381 }
2382 }
2383
2384 /* void glTexGeniOES ( GLenum coord, GLenum pname, GLint param ) */
2385 static void
android_glTexGeniOES__III(JNIEnv * _env,jobject _this,jint coord,jint pname,jint param)2386 android_glTexGeniOES__III
2387 (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) {
2388 glTexGeniOES(
2389 (GLenum)coord,
2390 (GLenum)pname,
2391 (GLint)param
2392 );
2393 }
2394
2395 /* void glTexGenivOES ( GLenum coord, GLenum pname, const GLint *params ) */
2396 static void
android_glTexGenivOES__II_3II(JNIEnv * _env,jobject _this,jint coord,jint pname,jintArray params_ref,jint offset)2397 android_glTexGenivOES__II_3II
2398 (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
2399 GLint *params_base = (GLint *) 0;
2400 jint _remaining;
2401 GLint *params = (GLint *) 0;
2402
2403 if (!params_ref) {
2404 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
2405 goto exit;
2406 }
2407 if (offset < 0) {
2408 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
2409 goto exit;
2410 }
2411 _remaining = _env->GetArrayLength(params_ref) - offset;
2412 params_base = (GLint *)
2413 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2414 params = params_base + offset;
2415
2416 glTexGenivOES(
2417 (GLenum)coord,
2418 (GLenum)pname,
2419 (GLint *)params
2420 );
2421
2422 exit:
2423 if (params_base) {
2424 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2425 JNI_ABORT);
2426 }
2427 }
2428
2429 /* void glTexGenivOES ( GLenum coord, GLenum pname, const GLint *params ) */
2430 static void
android_glTexGenivOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)2431 android_glTexGenivOES__IILjava_nio_IntBuffer_2
2432 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2433 jarray _array = (jarray) 0;
2434 jint _remaining;
2435 GLint *params = (GLint *) 0;
2436
2437 params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
2438 glTexGenivOES(
2439 (GLenum)coord,
2440 (GLenum)pname,
2441 (GLint *)params
2442 );
2443 if (_array) {
2444 releasePointer(_env, _array, params, JNI_FALSE);
2445 }
2446 }
2447
2448 /* void glTexGenxOES ( GLenum coord, GLenum pname, GLfixed param ) */
2449 static void
android_glTexGenxOES__III(JNIEnv * _env,jobject _this,jint coord,jint pname,jint param)2450 android_glTexGenxOES__III
2451 (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) {
2452 glTexGenxOES(
2453 (GLenum)coord,
2454 (GLenum)pname,
2455 (GLfixed)param
2456 );
2457 }
2458
2459 /* void glTexGenxvOES ( GLenum coord, GLenum pname, const GLfixed *params ) */
2460 static void
android_glTexGenxvOES__II_3II(JNIEnv * _env,jobject _this,jint coord,jint pname,jintArray params_ref,jint offset)2461 android_glTexGenxvOES__II_3II
2462 (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
2463 GLfixed *params_base = (GLfixed *) 0;
2464 jint _remaining;
2465 GLfixed *params = (GLfixed *) 0;
2466
2467 if (!params_ref) {
2468 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
2469 goto exit;
2470 }
2471 if (offset < 0) {
2472 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
2473 goto exit;
2474 }
2475 _remaining = _env->GetArrayLength(params_ref) - offset;
2476 params_base = (GLfixed *)
2477 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2478 params = params_base + offset;
2479
2480 glTexGenxvOES(
2481 (GLenum)coord,
2482 (GLenum)pname,
2483 (GLfixed *)params
2484 );
2485
2486 exit:
2487 if (params_base) {
2488 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2489 JNI_ABORT);
2490 }
2491 }
2492
2493 /* void glTexGenxvOES ( GLenum coord, GLenum pname, const GLfixed *params ) */
2494 static void
android_glTexGenxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)2495 android_glTexGenxvOES__IILjava_nio_IntBuffer_2
2496 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2497 jarray _array = (jarray) 0;
2498 jint _remaining;
2499 GLfixed *params = (GLfixed *) 0;
2500
2501 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
2502 glTexGenxvOES(
2503 (GLenum)coord,
2504 (GLenum)pname,
2505 (GLfixed *)params
2506 );
2507 if (_array) {
2508 releasePointer(_env, _array, params, JNI_FALSE);
2509 }
2510 }
2511
2512 /* void glGetTexGenfvOES ( GLenum coord, GLenum pname, GLfloat *params ) */
2513 static void
android_glGetTexGenfvOES__II_3FI(JNIEnv * _env,jobject _this,jint coord,jint pname,jfloatArray params_ref,jint offset)2514 android_glGetTexGenfvOES__II_3FI
2515 (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) {
2516 jint _exception = 0;
2517 GLfloat *params_base = (GLfloat *) 0;
2518 jint _remaining;
2519 GLfloat *params = (GLfloat *) 0;
2520
2521 if (!params_ref) {
2522 _exception = 1;
2523 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
2524 goto exit;
2525 }
2526 if (offset < 0) {
2527 _exception = 1;
2528 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
2529 goto exit;
2530 }
2531 _remaining = _env->GetArrayLength(params_ref) - offset;
2532 params_base = (GLfloat *)
2533 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2534 params = params_base + offset;
2535
2536 glGetTexGenfvOES(
2537 (GLenum)coord,
2538 (GLenum)pname,
2539 (GLfloat *)params
2540 );
2541
2542 exit:
2543 if (params_base) {
2544 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2545 _exception ? JNI_ABORT: 0);
2546 }
2547 }
2548
2549 /* void glGetTexGenfvOES ( GLenum coord, GLenum pname, GLfloat *params ) */
2550 static void
android_glGetTexGenfvOES__IILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)2551 android_glGetTexGenfvOES__IILjava_nio_FloatBuffer_2
2552 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2553 jint _exception = 0;
2554 jarray _array = (jarray) 0;
2555 jint _remaining;
2556 GLfloat *params = (GLfloat *) 0;
2557
2558 params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining);
2559 glGetTexGenfvOES(
2560 (GLenum)coord,
2561 (GLenum)pname,
2562 (GLfloat *)params
2563 );
2564 if (_array) {
2565 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
2566 }
2567 }
2568
2569 /* void glGetTexGenivOES ( GLenum coord, GLenum pname, GLint *params ) */
2570 static void
android_glGetTexGenivOES__II_3II(JNIEnv * _env,jobject _this,jint coord,jint pname,jintArray params_ref,jint offset)2571 android_glGetTexGenivOES__II_3II
2572 (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
2573 jint _exception = 0;
2574 GLint *params_base = (GLint *) 0;
2575 jint _remaining;
2576 GLint *params = (GLint *) 0;
2577
2578 if (!params_ref) {
2579 _exception = 1;
2580 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
2581 goto exit;
2582 }
2583 if (offset < 0) {
2584 _exception = 1;
2585 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
2586 goto exit;
2587 }
2588 _remaining = _env->GetArrayLength(params_ref) - offset;
2589 params_base = (GLint *)
2590 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2591 params = params_base + offset;
2592
2593 glGetTexGenivOES(
2594 (GLenum)coord,
2595 (GLenum)pname,
2596 (GLint *)params
2597 );
2598
2599 exit:
2600 if (params_base) {
2601 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2602 _exception ? JNI_ABORT: 0);
2603 }
2604 }
2605
2606 /* void glGetTexGenivOES ( GLenum coord, GLenum pname, GLint *params ) */
2607 static void
android_glGetTexGenivOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)2608 android_glGetTexGenivOES__IILjava_nio_IntBuffer_2
2609 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2610 jint _exception = 0;
2611 jarray _array = (jarray) 0;
2612 jint _remaining;
2613 GLint *params = (GLint *) 0;
2614
2615 params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
2616 glGetTexGenivOES(
2617 (GLenum)coord,
2618 (GLenum)pname,
2619 (GLint *)params
2620 );
2621 if (_array) {
2622 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
2623 }
2624 }
2625
2626 /* void glGetTexGenxvOES ( GLenum coord, GLenum pname, GLfixed *params ) */
2627 static void
android_glGetTexGenxvOES__II_3II(JNIEnv * _env,jobject _this,jint coord,jint pname,jintArray params_ref,jint offset)2628 android_glGetTexGenxvOES__II_3II
2629 (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) {
2630 jint _exception = 0;
2631 GLfixed *params_base = (GLfixed *) 0;
2632 jint _remaining;
2633 GLfixed *params = (GLfixed *) 0;
2634
2635 if (!params_ref) {
2636 _exception = 1;
2637 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null");
2638 goto exit;
2639 }
2640 if (offset < 0) {
2641 _exception = 1;
2642 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0");
2643 goto exit;
2644 }
2645 _remaining = _env->GetArrayLength(params_ref) - offset;
2646 params_base = (GLfixed *)
2647 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
2648 params = params_base + offset;
2649
2650 glGetTexGenxvOES(
2651 (GLenum)coord,
2652 (GLenum)pname,
2653 (GLfixed *)params
2654 );
2655
2656 exit:
2657 if (params_base) {
2658 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
2659 _exception ? JNI_ABORT: 0);
2660 }
2661 }
2662
2663 /* void glGetTexGenxvOES ( GLenum coord, GLenum pname, GLfixed *params ) */
2664 static void
android_glGetTexGenxvOES__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint coord,jint pname,jobject params_buf)2665 android_glGetTexGenxvOES__IILjava_nio_IntBuffer_2
2666 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) {
2667 jint _exception = 0;
2668 jarray _array = (jarray) 0;
2669 jint _remaining;
2670 GLfixed *params = (GLfixed *) 0;
2671
2672 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining);
2673 glGetTexGenxvOES(
2674 (GLenum)coord,
2675 (GLenum)pname,
2676 (GLfixed *)params
2677 );
2678 if (_array) {
2679 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
2680 }
2681 }
2682
2683 static const char *classPathName = "android/opengl/GLES11Ext";
2684
2685 static JNINativeMethod methods[] = {
2686 {"_nativeClassInit", "()V", (void*)nativeClassInit },
2687 {"glBlendEquationSeparateOES", "(II)V", (void *) android_glBlendEquationSeparateOES__II },
2688 {"glBlendFuncSeparateOES", "(IIII)V", (void *) android_glBlendFuncSeparateOES__IIII },
2689 {"glBlendEquationOES", "(I)V", (void *) android_glBlendEquationOES__I },
2690 {"glDrawTexsOES", "(SSSSS)V", (void *) android_glDrawTexsOES__SSSSS },
2691 {"glDrawTexiOES", "(IIIII)V", (void *) android_glDrawTexiOES__IIIII },
2692 {"glDrawTexxOES", "(IIIII)V", (void *) android_glDrawTexxOES__IIIII },
2693 {"glDrawTexsvOES", "([SI)V", (void *) android_glDrawTexsvOES___3SI },
2694 {"glDrawTexsvOES", "(Ljava/nio/ShortBuffer;)V", (void *) android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2 },
2695 {"glDrawTexivOES", "([II)V", (void *) android_glDrawTexivOES___3II },
2696 {"glDrawTexivOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexivOES__Ljava_nio_IntBuffer_2 },
2697 {"glDrawTexxvOES", "([II)V", (void *) android_glDrawTexxvOES___3II },
2698 {"glDrawTexxvOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexxvOES__Ljava_nio_IntBuffer_2 },
2699 {"glDrawTexfOES", "(FFFFF)V", (void *) android_glDrawTexfOES__FFFFF },
2700 {"glDrawTexfvOES", "([FI)V", (void *) android_glDrawTexfvOES___3FI },
2701 {"glDrawTexfvOES", "(Ljava/nio/FloatBuffer;)V", (void *) android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2 },
2702 {"glEGLImageTargetTexture2DOES", "(ILjava/nio/Buffer;)V", (void *) android_glEGLImageTargetTexture2DOES__ILjava_nio_Buffer_2 },
2703 {"glEGLImageTargetRenderbufferStorageOES", "(ILjava/nio/Buffer;)V", (void *) android_glEGLImageTargetRenderbufferStorageOES__ILjava_nio_Buffer_2 },
2704 {"glAlphaFuncxOES", "(II)V", (void *) android_glAlphaFuncxOES__II },
2705 {"glClearColorxOES", "(IIII)V", (void *) android_glClearColorxOES__IIII },
2706 {"glClearDepthxOES", "(I)V", (void *) android_glClearDepthxOES__I },
2707 {"glClipPlanexOES", "(I[II)V", (void *) android_glClipPlanexOES__I_3II },
2708 {"glClipPlanexOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glClipPlanexOES__ILjava_nio_IntBuffer_2 },
2709 {"glColor4xOES", "(IIII)V", (void *) android_glColor4xOES__IIII },
2710 {"glDepthRangexOES", "(II)V", (void *) android_glDepthRangexOES__II },
2711 {"glFogxOES", "(II)V", (void *) android_glFogxOES__II },
2712 {"glFogxvOES", "(I[II)V", (void *) android_glFogxvOES__I_3II },
2713 {"glFogxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glFogxvOES__ILjava_nio_IntBuffer_2 },
2714 {"glFrustumxOES", "(IIIIII)V", (void *) android_glFrustumxOES__IIIIII },
2715 {"glGetClipPlanexOES", "(I[II)V", (void *) android_glGetClipPlanexOES__I_3II },
2716 {"glGetClipPlanexOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetClipPlanexOES__ILjava_nio_IntBuffer_2 },
2717 {"glGetFixedvOES", "(I[II)V", (void *) android_glGetFixedvOES__I_3II },
2718 {"glGetFixedvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetFixedvOES__ILjava_nio_IntBuffer_2 },
2719 {"glGetLightxvOES", "(II[II)V", (void *) android_glGetLightxvOES__II_3II },
2720 {"glGetLightxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetLightxvOES__IILjava_nio_IntBuffer_2 },
2721 {"glGetMaterialxvOES", "(II[II)V", (void *) android_glGetMaterialxvOES__II_3II },
2722 {"glGetMaterialxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetMaterialxvOES__IILjava_nio_IntBuffer_2 },
2723 {"glGetTexEnvxvOES", "(II[II)V", (void *) android_glGetTexEnvxvOES__II_3II },
2724 {"glGetTexEnvxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexEnvxvOES__IILjava_nio_IntBuffer_2 },
2725 {"glGetTexParameterxvOES", "(II[II)V", (void *) android_glGetTexParameterxvOES__II_3II },
2726 {"glGetTexParameterxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameterxvOES__IILjava_nio_IntBuffer_2 },
2727 {"glLightModelxOES", "(II)V", (void *) android_glLightModelxOES__II },
2728 {"glLightModelxvOES", "(I[II)V", (void *) android_glLightModelxvOES__I_3II },
2729 {"glLightModelxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glLightModelxvOES__ILjava_nio_IntBuffer_2 },
2730 {"glLightxOES", "(III)V", (void *) android_glLightxOES__III },
2731 {"glLightxvOES", "(II[II)V", (void *) android_glLightxvOES__II_3II },
2732 {"glLightxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glLightxvOES__IILjava_nio_IntBuffer_2 },
2733 {"glLineWidthxOES", "(I)V", (void *) android_glLineWidthxOES__I },
2734 {"glLoadMatrixxOES", "([II)V", (void *) android_glLoadMatrixxOES___3II },
2735 {"glLoadMatrixxOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glLoadMatrixxOES__Ljava_nio_IntBuffer_2 },
2736 {"glMaterialxOES", "(III)V", (void *) android_glMaterialxOES__III },
2737 {"glMaterialxvOES", "(II[II)V", (void *) android_glMaterialxvOES__II_3II },
2738 {"glMaterialxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glMaterialxvOES__IILjava_nio_IntBuffer_2 },
2739 {"glMultMatrixxOES", "([II)V", (void *) android_glMultMatrixxOES___3II },
2740 {"glMultMatrixxOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glMultMatrixxOES__Ljava_nio_IntBuffer_2 },
2741 {"glMultiTexCoord4xOES", "(IIIII)V", (void *) android_glMultiTexCoord4xOES__IIIII },
2742 {"glNormal3xOES", "(III)V", (void *) android_glNormal3xOES__III },
2743 {"glOrthoxOES", "(IIIIII)V", (void *) android_glOrthoxOES__IIIIII },
2744 {"glPointParameterxOES", "(II)V", (void *) android_glPointParameterxOES__II },
2745 {"glPointParameterxvOES", "(I[II)V", (void *) android_glPointParameterxvOES__I_3II },
2746 {"glPointParameterxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glPointParameterxvOES__ILjava_nio_IntBuffer_2 },
2747 {"glPointSizexOES", "(I)V", (void *) android_glPointSizexOES__I },
2748 {"glPolygonOffsetxOES", "(II)V", (void *) android_glPolygonOffsetxOES__II },
2749 {"glRotatexOES", "(IIII)V", (void *) android_glRotatexOES__IIII },
2750 {"glSampleCoveragexOES", "(IZ)V", (void *) android_glSampleCoveragexOES__IZ },
2751 {"glScalexOES", "(III)V", (void *) android_glScalexOES__III },
2752 {"glTexEnvxOES", "(III)V", (void *) android_glTexEnvxOES__III },
2753 {"glTexEnvxvOES", "(II[II)V", (void *) android_glTexEnvxvOES__II_3II },
2754 {"glTexEnvxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexEnvxvOES__IILjava_nio_IntBuffer_2 },
2755 {"glTexParameterxOES", "(III)V", (void *) android_glTexParameterxOES__III },
2756 {"glTexParameterxvOES", "(II[II)V", (void *) android_glTexParameterxvOES__II_3II },
2757 {"glTexParameterxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameterxvOES__IILjava_nio_IntBuffer_2 },
2758 {"glTranslatexOES", "(III)V", (void *) android_glTranslatexOES__III },
2759 {"glIsRenderbufferOES", "(I)Z", (void *) android_glIsRenderbufferOES__I },
2760 {"glBindRenderbufferOES", "(II)V", (void *) android_glBindRenderbufferOES__II },
2761 {"glDeleteRenderbuffersOES", "(I[II)V", (void *) android_glDeleteRenderbuffersOES__I_3II },
2762 {"glDeleteRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2 },
2763 {"glGenRenderbuffersOES", "(I[II)V", (void *) android_glGenRenderbuffersOES__I_3II },
2764 {"glGenRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2 },
2765 {"glRenderbufferStorageOES", "(IIII)V", (void *) android_glRenderbufferStorageOES__IIII },
2766 {"glGetRenderbufferParameterivOES", "(II[II)V", (void *) android_glGetRenderbufferParameterivOES__II_3II },
2767 {"glGetRenderbufferParameterivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2 },
2768 {"glIsFramebufferOES", "(I)Z", (void *) android_glIsFramebufferOES__I },
2769 {"glBindFramebufferOES", "(II)V", (void *) android_glBindFramebufferOES__II },
2770 {"glDeleteFramebuffersOES", "(I[II)V", (void *) android_glDeleteFramebuffersOES__I_3II },
2771 {"glDeleteFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2 },
2772 {"glGenFramebuffersOES", "(I[II)V", (void *) android_glGenFramebuffersOES__I_3II },
2773 {"glGenFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2 },
2774 {"glCheckFramebufferStatusOES", "(I)I", (void *) android_glCheckFramebufferStatusOES__I },
2775 {"glFramebufferRenderbufferOES", "(IIII)V", (void *) android_glFramebufferRenderbufferOES__IIII },
2776 {"glFramebufferTexture2DOES", "(IIIII)V", (void *) android_glFramebufferTexture2DOES__IIIII },
2777 {"glGetFramebufferAttachmentParameterivOES", "(III[II)V", (void *) android_glGetFramebufferAttachmentParameterivOES__III_3II },
2778 {"glGetFramebufferAttachmentParameterivOES", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2 },
2779 {"glGenerateMipmapOES", "(I)V", (void *) android_glGenerateMipmapOES__I },
2780 {"glCurrentPaletteMatrixOES", "(I)V", (void *) android_glCurrentPaletteMatrixOES__I },
2781 {"glLoadPaletteFromModelViewMatrixOES", "()V", (void *) android_glLoadPaletteFromModelViewMatrixOES__ },
2782 {"glMatrixIndexPointerOESBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I },
2783 {"glWeightPointerOESBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I },
2784 {"glDepthRangefOES", "(FF)V", (void *) android_glDepthRangefOES__FF },
2785 {"glFrustumfOES", "(FFFFFF)V", (void *) android_glFrustumfOES__FFFFFF },
2786 {"glOrthofOES", "(FFFFFF)V", (void *) android_glOrthofOES__FFFFFF },
2787 {"glClipPlanefOES", "(I[FI)V", (void *) android_glClipPlanefOES__I_3FI },
2788 {"glClipPlanefOES", "(ILjava/nio/FloatBuffer;)V", (void *) android_glClipPlanefOES__ILjava_nio_FloatBuffer_2 },
2789 {"glGetClipPlanefOES", "(I[FI)V", (void *) android_glGetClipPlanefOES__I_3FI },
2790 {"glGetClipPlanefOES", "(ILjava/nio/FloatBuffer;)V", (void *) android_glGetClipPlanefOES__ILjava_nio_FloatBuffer_2 },
2791 {"glClearDepthfOES", "(F)V", (void *) android_glClearDepthfOES__F },
2792 {"glTexGenfOES", "(IIF)V", (void *) android_glTexGenfOES__IIF },
2793 {"glTexGenfvOES", "(II[FI)V", (void *) android_glTexGenfvOES__II_3FI },
2794 {"glTexGenfvOES", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexGenfvOES__IILjava_nio_FloatBuffer_2 },
2795 {"glTexGeniOES", "(III)V", (void *) android_glTexGeniOES__III },
2796 {"glTexGenivOES", "(II[II)V", (void *) android_glTexGenivOES__II_3II },
2797 {"glTexGenivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGenivOES__IILjava_nio_IntBuffer_2 },
2798 {"glTexGenxOES", "(III)V", (void *) android_glTexGenxOES__III },
2799 {"glTexGenxvOES", "(II[II)V", (void *) android_glTexGenxvOES__II_3II },
2800 {"glTexGenxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGenxvOES__IILjava_nio_IntBuffer_2 },
2801 {"glGetTexGenfvOES", "(II[FI)V", (void *) android_glGetTexGenfvOES__II_3FI },
2802 {"glGetTexGenfvOES", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetTexGenfvOES__IILjava_nio_FloatBuffer_2 },
2803 {"glGetTexGenivOES", "(II[II)V", (void *) android_glGetTexGenivOES__II_3II },
2804 {"glGetTexGenivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGenivOES__IILjava_nio_IntBuffer_2 },
2805 {"glGetTexGenxvOES", "(II[II)V", (void *) android_glGetTexGenxvOES__II_3II },
2806 {"glGetTexGenxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGenxvOES__IILjava_nio_IntBuffer_2 },
2807 };
2808
register_android_opengl_jni_GLES11Ext(JNIEnv * _env)2809 int register_android_opengl_jni_GLES11Ext(JNIEnv *_env)
2810 {
2811 int err;
2812 err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));
2813 return err;
2814 }
2815