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