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