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_3_0
276 // GLES 3.x pnames
277 switch (pname) {
278 case GL_MAX_VIEWPORT_DIMS:
279 needed = 2;
280 break;
281
282 case GL_PROGRAM_BINARY_FORMATS:
283 glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &needed);
284 break;
285 }
286 #endif
287
288 #ifdef GL_ES_VERSION_2_0
289 // GLES 2.x pnames
290 switch (pname) {
291 case GL_ALIASED_LINE_WIDTH_RANGE:
292 case GL_ALIASED_POINT_SIZE_RANGE:
293 needed = 2;
294 break;
295
296 case GL_BLEND_COLOR:
297 case GL_COLOR_CLEAR_VALUE:
298 case GL_COLOR_WRITEMASK:
299 case GL_SCISSOR_BOX:
300 case GL_VIEWPORT:
301 needed = 4;
302 break;
303
304 case GL_COMPRESSED_TEXTURE_FORMATS:
305 glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed);
306 break;
307
308 case GL_SHADER_BINARY_FORMATS:
309 glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &needed);
310 break;
311 }
312 #endif
313
314 #ifdef GL_VERSION_ES_CM_1_1
315 // GLES 1.x pnames
316 switch (pname) {
317 case GL_ALIASED_LINE_WIDTH_RANGE:
318 case GL_ALIASED_POINT_SIZE_RANGE:
319 case GL_DEPTH_RANGE:
320 case GL_SMOOTH_LINE_WIDTH_RANGE:
321 case GL_SMOOTH_POINT_SIZE_RANGE:
322 needed = 2;
323 break;
324
325 case GL_CURRENT_NORMAL:
326 case GL_POINT_DISTANCE_ATTENUATION:
327 needed = 3;
328 break;
329
330 case GL_COLOR_CLEAR_VALUE:
331 case GL_COLOR_WRITEMASK:
332 case GL_CURRENT_COLOR:
333 case GL_CURRENT_TEXTURE_COORDS:
334 case GL_FOG_COLOR:
335 case GL_LIGHT_MODEL_AMBIENT:
336 case GL_SCISSOR_BOX:
337 case GL_VIEWPORT:
338 needed = 4;
339 break;
340
341 case GL_MODELVIEW_MATRIX:
342 case GL_PROJECTION_MATRIX:
343 case GL_TEXTURE_MATRIX:
344 needed = 16;
345 break;
346
347 case GL_COMPRESSED_TEXTURE_FORMATS:
348 glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed);
349 break;
350 }
351 #endif
352 return needed;
353 }
354
355 template <typename JTYPEARRAY, typename ARRAYGETTER, typename NTYPEARRAY,
356 typename ARRAYRELEASER, typename CTYPE, void GET(GLenum, CTYPE*)>
357 static void
get(JNIEnv * _env,jobject _this,jint pname,JTYPEARRAY params_ref,jint offset)358 get
359 (JNIEnv *_env, jobject _this, jint pname, JTYPEARRAY params_ref, jint offset) {
360 jint _exception = 0;
361 const char * _exceptionType;
362 const char * _exceptionMessage;
363 CTYPE *params_base = (CTYPE *) 0;
364 jint _remaining;
365 CTYPE *params = (CTYPE *) 0;
366 int _needed = 0;
367
368 if (!params_ref) {
369 _exception = 1;
370 _exceptionType = "java/lang/IllegalArgumentException";
371 _exceptionMessage = "params == null";
372 goto exit;
373 }
374 if (offset < 0) {
375 _exception = 1;
376 _exceptionType = "java/lang/IllegalArgumentException";
377 _exceptionMessage = "offset < 0";
378 goto exit;
379 }
380 _remaining = _env->GetArrayLength(params_ref) - offset;
381 _needed = getNeededCount(pname);
382 // if we didn't find this pname, we just assume the user passed
383 // an array of the right size -- this might happen with extensions
384 // or if we forget an enum here.
385 if (_remaining < _needed) {
386 _exception = 1;
387 _exceptionType = "java/lang/IllegalArgumentException";
388 _exceptionMessage = "length - offset < needed";
389 goto exit;
390 }
391 params_base = (CTYPE *) getArrayPointer<JTYPEARRAY, ARRAYGETTER>(
392 _env, params_ref, (jboolean *)0);
393 params = params_base + offset;
394
395 GET(
396 (GLenum)pname,
397 (CTYPE *)params
398 );
399
400 exit:
401 if (params_base) {
402 releaseArrayPointer<JTYPEARRAY, NTYPEARRAY, ARRAYRELEASER>(
403 _env, params_ref, params_base, !_exception);
404 }
405 if (_exception) {
406 jniThrowException(_env, _exceptionType, _exceptionMessage);
407 }
408 }
409
410
411 template <typename CTYPE, typename JTYPEARRAY, typename ARRAYGETTER, typename NTYPEARRAY,
412 typename ARRAYRELEASER, void GET(GLenum, CTYPE*)>
413 static void
getarray(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)414 getarray
415 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
416 jint _exception = 0;
417 const char * _exceptionType;
418 const char * _exceptionMessage;
419 JTYPEARRAY _array = (JTYPEARRAY) 0;
420 jint _bufferOffset = (jint) 0;
421 jint _remaining;
422 CTYPE *params = (CTYPE *) 0;
423 int _needed = 0;
424
425 params = (CTYPE *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
426 _remaining /= sizeof(CTYPE); // convert from bytes to item count
427 _needed = getNeededCount(pname);
428 // if we didn't find this pname, we just assume the user passed
429 // an array of the right size -- this might happen with extensions
430 // or if we forget an enum here.
431 if (_needed>0 && _remaining < _needed) {
432 _exception = 1;
433 _exceptionType = "java/lang/IllegalArgumentException";
434 _exceptionMessage = "remaining() < needed";
435 goto exit;
436 }
437 if (params == NULL) {
438 char * _paramsBase = (char *) getArrayPointer<JTYPEARRAY, ARRAYGETTER>(
439 _env, _array, (jboolean *) 0);
440 params = (CTYPE *) (_paramsBase + _bufferOffset);
441 }
442 GET(
443 (GLenum)pname,
444 (CTYPE *)params
445 );
446
447 exit:
448 if (_array) {
449 releaseArrayPointer<JTYPEARRAY, NTYPEARRAY, ARRAYRELEASER>(
450 _env, _array, (NTYPEARRAY)params, _exception ? JNI_FALSE : JNI_TRUE);
451 }
452 if (_exception) {
453 jniThrowException(_env, _exceptionType, _exceptionMessage);
454 }
455 }
456
457 // --------------------------------------------------------------------------
458 /* void glActiveTexture ( GLenum texture ) */
459 static void
android_glActiveTexture__I(JNIEnv * _env,jobject _this,jint texture)460 android_glActiveTexture__I
461 (JNIEnv *_env, jobject _this, jint texture) {
462 glActiveTexture(
463 (GLenum)texture
464 );
465 }
466
467 /* void glAlphaFunc ( GLenum func, GLclampf ref ) */
468 static void
android_glAlphaFunc__IF(JNIEnv * _env,jobject _this,jint func,jfloat ref)469 android_glAlphaFunc__IF
470 (JNIEnv *_env, jobject _this, jint func, jfloat ref) {
471 glAlphaFunc(
472 (GLenum)func,
473 (GLclampf)ref
474 );
475 }
476
477 /* void glAlphaFuncx ( GLenum func, GLclampx ref ) */
478 static void
android_glAlphaFuncx__II(JNIEnv * _env,jobject _this,jint func,jint ref)479 android_glAlphaFuncx__II
480 (JNIEnv *_env, jobject _this, jint func, jint ref) {
481 glAlphaFuncx(
482 (GLenum)func,
483 (GLclampx)ref
484 );
485 }
486
487 /* void glBindTexture ( GLenum target, GLuint texture ) */
488 static void
android_glBindTexture__II(JNIEnv * _env,jobject _this,jint target,jint texture)489 android_glBindTexture__II
490 (JNIEnv *_env, jobject _this, jint target, jint texture) {
491 glBindTexture(
492 (GLenum)target,
493 (GLuint)texture
494 );
495 }
496
497 /* void glBlendFunc ( GLenum sfactor, GLenum dfactor ) */
498 static void
android_glBlendFunc__II(JNIEnv * _env,jobject _this,jint sfactor,jint dfactor)499 android_glBlendFunc__II
500 (JNIEnv *_env, jobject _this, jint sfactor, jint dfactor) {
501 glBlendFunc(
502 (GLenum)sfactor,
503 (GLenum)dfactor
504 );
505 }
506
507 /* void glClear ( GLbitfield mask ) */
508 static void
android_glClear__I(JNIEnv * _env,jobject _this,jint mask)509 android_glClear__I
510 (JNIEnv *_env, jobject _this, jint mask) {
511 glClear(
512 (GLbitfield)mask
513 );
514 }
515
516 /* void glClearColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) */
517 static void
android_glClearColor__FFFF(JNIEnv * _env,jobject _this,jfloat red,jfloat green,jfloat blue,jfloat alpha)518 android_glClearColor__FFFF
519 (JNIEnv *_env, jobject _this, jfloat red, jfloat green, jfloat blue, jfloat alpha) {
520 glClearColor(
521 (GLclampf)red,
522 (GLclampf)green,
523 (GLclampf)blue,
524 (GLclampf)alpha
525 );
526 }
527
528 /* void glClearColorx ( GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha ) */
529 static void
android_glClearColorx__IIII(JNIEnv * _env,jobject _this,jint red,jint green,jint blue,jint alpha)530 android_glClearColorx__IIII
531 (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) {
532 glClearColorx(
533 (GLclampx)red,
534 (GLclampx)green,
535 (GLclampx)blue,
536 (GLclampx)alpha
537 );
538 }
539
540 /* void glClearDepthf ( GLclampf depth ) */
541 static void
android_glClearDepthf__F(JNIEnv * _env,jobject _this,jfloat depth)542 android_glClearDepthf__F
543 (JNIEnv *_env, jobject _this, jfloat depth) {
544 glClearDepthf(
545 (GLclampf)depth
546 );
547 }
548
549 /* void glClearDepthx ( GLclampx depth ) */
550 static void
android_glClearDepthx__I(JNIEnv * _env,jobject _this,jint depth)551 android_glClearDepthx__I
552 (JNIEnv *_env, jobject _this, jint depth) {
553 glClearDepthx(
554 (GLclampx)depth
555 );
556 }
557
558 /* void glClearStencil ( GLint s ) */
559 static void
android_glClearStencil__I(JNIEnv * _env,jobject _this,jint s)560 android_glClearStencil__I
561 (JNIEnv *_env, jobject _this, jint s) {
562 glClearStencil(
563 (GLint)s
564 );
565 }
566
567 /* void glClientActiveTexture ( GLenum texture ) */
568 static void
android_glClientActiveTexture__I(JNIEnv * _env,jobject _this,jint texture)569 android_glClientActiveTexture__I
570 (JNIEnv *_env, jobject _this, jint texture) {
571 glClientActiveTexture(
572 (GLenum)texture
573 );
574 }
575
576 /* void glColor4f ( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) */
577 static void
android_glColor4f__FFFF(JNIEnv * _env,jobject _this,jfloat red,jfloat green,jfloat blue,jfloat alpha)578 android_glColor4f__FFFF
579 (JNIEnv *_env, jobject _this, jfloat red, jfloat green, jfloat blue, jfloat alpha) {
580 glColor4f(
581 (GLfloat)red,
582 (GLfloat)green,
583 (GLfloat)blue,
584 (GLfloat)alpha
585 );
586 }
587
588 /* void glColor4x ( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) */
589 static void
android_glColor4x__IIII(JNIEnv * _env,jobject _this,jint red,jint green,jint blue,jint alpha)590 android_glColor4x__IIII
591 (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) {
592 glColor4x(
593 (GLfixed)red,
594 (GLfixed)green,
595 (GLfixed)blue,
596 (GLfixed)alpha
597 );
598 }
599
600 /* void glColorMask ( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) */
601 static void
android_glColorMask__ZZZZ(JNIEnv * _env,jobject _this,jboolean red,jboolean green,jboolean blue,jboolean alpha)602 android_glColorMask__ZZZZ
603 (JNIEnv *_env, jobject _this, jboolean red, jboolean green, jboolean blue, jboolean alpha) {
604 glColorMask(
605 (GLboolean)red,
606 (GLboolean)green,
607 (GLboolean)blue,
608 (GLboolean)alpha
609 );
610 }
611
612 /* void glColorPointer ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
613 static void
android_glColorPointerBounds__IIILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint size,jint type,jint stride,jobject pointer_buf,jint remaining)614 android_glColorPointerBounds__IIILjava_nio_Buffer_2I
615 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
616 jint _exception = 0;
617 const char * _exceptionType = NULL;
618 const char * _exceptionMessage = NULL;
619 jarray _array = (jarray) 0;
620 jint _bufferOffset = (jint) 0;
621 jint _remaining;
622 GLvoid *pointer = (GLvoid *) 0;
623
624 if (pointer_buf) {
625 pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
626 if ( ! pointer ) {
627 return;
628 }
629 }
630 glColorPointerBounds(
631 (GLint)size,
632 (GLenum)type,
633 (GLsizei)stride,
634 (GLvoid *)pointer,
635 (GLsizei)remaining
636 );
637 if (_exception) {
638 jniThrowException(_env, _exceptionType, _exceptionMessage);
639 }
640 }
641
642 /* void glCompressedTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data ) */
643 static void
android_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint target,jint level,jint internalformat,jint width,jint height,jint border,jint imageSize,jobject data_buf)644 android_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2
645 (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint imageSize, jobject data_buf) {
646 jint _exception = 0;
647 const char * _exceptionType = NULL;
648 const char * _exceptionMessage = NULL;
649 jarray _array = (jarray) 0;
650 jint _bufferOffset = (jint) 0;
651 jint _remaining;
652 GLvoid *data = (GLvoid *) 0;
653
654 if (!data_buf) {
655 _exception = 1;
656 _exceptionType = "java/lang/IllegalArgumentException";
657 _exceptionMessage = "data == null";
658 goto exit;
659 }
660 data = (GLvoid *)getPointer(_env, data_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
661 if (data == NULL) {
662 char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
663 data = (GLvoid *) (_dataBase + _bufferOffset);
664 }
665 glCompressedTexImage2D(
666 (GLenum)target,
667 (GLint)level,
668 (GLenum)internalformat,
669 (GLsizei)width,
670 (GLsizei)height,
671 (GLint)border,
672 (GLsizei)imageSize,
673 (GLvoid *)data
674 );
675
676 exit:
677 if (_array) {
678 releasePointer(_env, _array, data, JNI_FALSE);
679 }
680 if (_exception) {
681 jniThrowException(_env, _exceptionType, _exceptionMessage);
682 }
683 }
684
685 /* void glCompressedTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data ) */
686 static void
android_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint target,jint level,jint xoffset,jint yoffset,jint width,jint height,jint format,jint imageSize,jobject data_buf)687 android_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2
688 (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint imageSize, jobject data_buf) {
689 jint _exception = 0;
690 const char * _exceptionType = NULL;
691 const char * _exceptionMessage = NULL;
692 jarray _array = (jarray) 0;
693 jint _bufferOffset = (jint) 0;
694 jint _remaining;
695 GLvoid *data = (GLvoid *) 0;
696
697 if (!data_buf) {
698 _exception = 1;
699 _exceptionType = "java/lang/IllegalArgumentException";
700 _exceptionMessage = "data == null";
701 goto exit;
702 }
703 data = (GLvoid *)getPointer(_env, data_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
704 if (data == NULL) {
705 char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
706 data = (GLvoid *) (_dataBase + _bufferOffset);
707 }
708 glCompressedTexSubImage2D(
709 (GLenum)target,
710 (GLint)level,
711 (GLint)xoffset,
712 (GLint)yoffset,
713 (GLsizei)width,
714 (GLsizei)height,
715 (GLenum)format,
716 (GLsizei)imageSize,
717 (GLvoid *)data
718 );
719
720 exit:
721 if (_array) {
722 releasePointer(_env, _array, data, JNI_FALSE);
723 }
724 if (_exception) {
725 jniThrowException(_env, _exceptionType, _exceptionMessage);
726 }
727 }
728
729 /* void glCopyTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) */
730 static void
android_glCopyTexImage2D__IIIIIIII(JNIEnv * _env,jobject _this,jint target,jint level,jint internalformat,jint x,jint y,jint width,jint height,jint border)731 android_glCopyTexImage2D__IIIIIIII
732 (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint x, jint y, jint width, jint height, jint border) {
733 glCopyTexImage2D(
734 (GLenum)target,
735 (GLint)level,
736 (GLenum)internalformat,
737 (GLint)x,
738 (GLint)y,
739 (GLsizei)width,
740 (GLsizei)height,
741 (GLint)border
742 );
743 }
744
745 /* void glCopyTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) */
746 static void
android_glCopyTexSubImage2D__IIIIIIII(JNIEnv * _env,jobject _this,jint target,jint level,jint xoffset,jint yoffset,jint x,jint y,jint width,jint height)747 android_glCopyTexSubImage2D__IIIIIIII
748 (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint x, jint y, jint width, jint height) {
749 glCopyTexSubImage2D(
750 (GLenum)target,
751 (GLint)level,
752 (GLint)xoffset,
753 (GLint)yoffset,
754 (GLint)x,
755 (GLint)y,
756 (GLsizei)width,
757 (GLsizei)height
758 );
759 }
760
761 /* void glCullFace ( GLenum mode ) */
762 static void
android_glCullFace__I(JNIEnv * _env,jobject _this,jint mode)763 android_glCullFace__I
764 (JNIEnv *_env, jobject _this, jint mode) {
765 glCullFace(
766 (GLenum)mode
767 );
768 }
769
770 /* void glDeleteTextures ( GLsizei n, const GLuint *textures ) */
771 static void
android_glDeleteTextures__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray textures_ref,jint offset)772 android_glDeleteTextures__I_3II
773 (JNIEnv *_env, jobject _this, jint n, jintArray textures_ref, jint offset) {
774 jint _exception = 0;
775 const char * _exceptionType = NULL;
776 const char * _exceptionMessage = NULL;
777 GLuint *textures_base = (GLuint *) 0;
778 jint _remaining;
779 GLuint *textures = (GLuint *) 0;
780
781 if (!textures_ref) {
782 _exception = 1;
783 _exceptionType = "java/lang/IllegalArgumentException";
784 _exceptionMessage = "textures == null";
785 goto exit;
786 }
787 if (offset < 0) {
788 _exception = 1;
789 _exceptionType = "java/lang/IllegalArgumentException";
790 _exceptionMessage = "offset < 0";
791 goto exit;
792 }
793 _remaining = _env->GetArrayLength(textures_ref) - offset;
794 if (_remaining < n) {
795 _exception = 1;
796 _exceptionType = "java/lang/IllegalArgumentException";
797 _exceptionMessage = "length - offset < n < needed";
798 goto exit;
799 }
800 textures_base = (GLuint *)
801 _env->GetIntArrayElements(textures_ref, (jboolean *)0);
802 textures = textures_base + offset;
803
804 glDeleteTextures(
805 (GLsizei)n,
806 (GLuint *)textures
807 );
808
809 exit:
810 if (textures_base) {
811 _env->ReleaseIntArrayElements(textures_ref, (jint*)textures_base,
812 JNI_ABORT);
813 }
814 if (_exception) {
815 jniThrowException(_env, _exceptionType, _exceptionMessage);
816 }
817 }
818
819 /* void glDeleteTextures ( GLsizei n, const GLuint *textures ) */
820 static void
android_glDeleteTextures__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject textures_buf)821 android_glDeleteTextures__ILjava_nio_IntBuffer_2
822 (JNIEnv *_env, jobject _this, jint n, jobject textures_buf) {
823 jint _exception = 0;
824 const char * _exceptionType = NULL;
825 const char * _exceptionMessage = NULL;
826 jintArray _array = (jintArray) 0;
827 jint _bufferOffset = (jint) 0;
828 jint _remaining;
829 GLuint *textures = (GLuint *) 0;
830
831 if (!textures_buf) {
832 _exception = 1;
833 _exceptionType = "java/lang/IllegalArgumentException";
834 _exceptionMessage = "textures == null";
835 goto exit;
836 }
837 textures = (GLuint *)getPointer(_env, textures_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
838 if (_remaining < n) {
839 _exception = 1;
840 _exceptionType = "java/lang/IllegalArgumentException";
841 _exceptionMessage = "remaining() < n < needed";
842 goto exit;
843 }
844 if (textures == NULL) {
845 char * _texturesBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
846 textures = (GLuint *) (_texturesBase + _bufferOffset);
847 }
848 glDeleteTextures(
849 (GLsizei)n,
850 (GLuint *)textures
851 );
852
853 exit:
854 if (_array) {
855 _env->ReleaseIntArrayElements(_array, (jint*)textures, JNI_ABORT);
856 }
857 if (_exception) {
858 jniThrowException(_env, _exceptionType, _exceptionMessage);
859 }
860 }
861
862 /* void glDepthFunc ( GLenum func ) */
863 static void
android_glDepthFunc__I(JNIEnv * _env,jobject _this,jint func)864 android_glDepthFunc__I
865 (JNIEnv *_env, jobject _this, jint func) {
866 glDepthFunc(
867 (GLenum)func
868 );
869 }
870
871 /* void glDepthMask ( GLboolean flag ) */
872 static void
android_glDepthMask__Z(JNIEnv * _env,jobject _this,jboolean flag)873 android_glDepthMask__Z
874 (JNIEnv *_env, jobject _this, jboolean flag) {
875 glDepthMask(
876 (GLboolean)flag
877 );
878 }
879
880 /* void glDepthRangef ( GLclampf zNear, GLclampf zFar ) */
881 static void
android_glDepthRangef__FF(JNIEnv * _env,jobject _this,jfloat zNear,jfloat zFar)882 android_glDepthRangef__FF
883 (JNIEnv *_env, jobject _this, jfloat zNear, jfloat zFar) {
884 glDepthRangef(
885 (GLclampf)zNear,
886 (GLclampf)zFar
887 );
888 }
889
890 /* void glDepthRangex ( GLclampx zNear, GLclampx zFar ) */
891 static void
android_glDepthRangex__II(JNIEnv * _env,jobject _this,jint zNear,jint zFar)892 android_glDepthRangex__II
893 (JNIEnv *_env, jobject _this, jint zNear, jint zFar) {
894 glDepthRangex(
895 (GLclampx)zNear,
896 (GLclampx)zFar
897 );
898 }
899
900 /* void glDisable ( GLenum cap ) */
901 static void
android_glDisable__I(JNIEnv * _env,jobject _this,jint cap)902 android_glDisable__I
903 (JNIEnv *_env, jobject _this, jint cap) {
904 glDisable(
905 (GLenum)cap
906 );
907 }
908
909 /* void glDisableClientState ( GLenum array ) */
910 static void
android_glDisableClientState__I(JNIEnv * _env,jobject _this,jint array)911 android_glDisableClientState__I
912 (JNIEnv *_env, jobject _this, jint array) {
913 glDisableClientState(
914 (GLenum)array
915 );
916 }
917
918 /* void glDrawArrays ( GLenum mode, GLint first, GLsizei count ) */
919 static void
android_glDrawArrays__III(JNIEnv * _env,jobject _this,jint mode,jint first,jint count)920 android_glDrawArrays__III
921 (JNIEnv *_env, jobject _this, jint mode, jint first, jint count) {
922 glDrawArrays(
923 (GLenum)mode,
924 (GLint)first,
925 (GLsizei)count
926 );
927 }
928
929 /* void glDrawElements ( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices ) */
930 static void
android_glDrawElements__IIILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint mode,jint count,jint type,jobject indices_buf)931 android_glDrawElements__IIILjava_nio_Buffer_2
932 (JNIEnv *_env, jobject _this, jint mode, jint count, jint type, jobject indices_buf) {
933 jint _exception = 0;
934 const char * _exceptionType = NULL;
935 const char * _exceptionMessage = NULL;
936 jarray _array = (jarray) 0;
937 jint _bufferOffset = (jint) 0;
938 jint _remaining;
939 GLvoid *indices = (GLvoid *) 0;
940
941 if (!indices_buf) {
942 _exception = 1;
943 _exceptionType = "java/lang/IllegalArgumentException";
944 _exceptionMessage = "indices == null";
945 goto exit;
946 }
947 indices = (GLvoid *)getPointer(_env, indices_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
948 if (_remaining < count) {
949 _exception = 1;
950 _exceptionType = "java/lang/ArrayIndexOutOfBoundsException";
951 _exceptionMessage = "remaining() < count < needed";
952 goto exit;
953 }
954 if (indices == NULL) {
955 char * _indicesBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
956 indices = (GLvoid *) (_indicesBase + _bufferOffset);
957 }
958 glDrawElements(
959 (GLenum)mode,
960 (GLsizei)count,
961 (GLenum)type,
962 (GLvoid *)indices
963 );
964
965 exit:
966 if (_array) {
967 releasePointer(_env, _array, indices, JNI_FALSE);
968 }
969 if (_exception) {
970 jniThrowException(_env, _exceptionType, _exceptionMessage);
971 }
972 }
973
974 /* void glEnable ( GLenum cap ) */
975 static void
android_glEnable__I(JNIEnv * _env,jobject _this,jint cap)976 android_glEnable__I
977 (JNIEnv *_env, jobject _this, jint cap) {
978 glEnable(
979 (GLenum)cap
980 );
981 }
982
983 /* void glEnableClientState ( GLenum array ) */
984 static void
android_glEnableClientState__I(JNIEnv * _env,jobject _this,jint array)985 android_glEnableClientState__I
986 (JNIEnv *_env, jobject _this, jint array) {
987 glEnableClientState(
988 (GLenum)array
989 );
990 }
991
992 /* void glFinish ( void ) */
993 static void
android_glFinish__(JNIEnv * _env,jobject _this)994 android_glFinish__
995 (JNIEnv *_env, jobject _this) {
996 glFinish();
997 }
998
999 /* void glFlush ( void ) */
1000 static void
android_glFlush__(JNIEnv * _env,jobject _this)1001 android_glFlush__
1002 (JNIEnv *_env, jobject _this) {
1003 glFlush();
1004 }
1005
1006 /* void glFogf ( GLenum pname, GLfloat param ) */
1007 static void
android_glFogf__IF(JNIEnv * _env,jobject _this,jint pname,jfloat param)1008 android_glFogf__IF
1009 (JNIEnv *_env, jobject _this, jint pname, jfloat param) {
1010 glFogf(
1011 (GLenum)pname,
1012 (GLfloat)param
1013 );
1014 }
1015
1016 /* void glFogfv ( GLenum pname, const GLfloat *params ) */
1017 static void
android_glFogfv__I_3FI(JNIEnv * _env,jobject _this,jint pname,jfloatArray params_ref,jint offset)1018 android_glFogfv__I_3FI
1019 (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) {
1020 jint _exception = 0;
1021 const char * _exceptionType = NULL;
1022 const char * _exceptionMessage = NULL;
1023 GLfloat *params_base = (GLfloat *) 0;
1024 jint _remaining;
1025 GLfloat *params = (GLfloat *) 0;
1026
1027 if (!params_ref) {
1028 _exception = 1;
1029 _exceptionType = "java/lang/IllegalArgumentException";
1030 _exceptionMessage = "params == null";
1031 goto exit;
1032 }
1033 if (offset < 0) {
1034 _exception = 1;
1035 _exceptionType = "java/lang/IllegalArgumentException";
1036 _exceptionMessage = "offset < 0";
1037 goto exit;
1038 }
1039 _remaining = _env->GetArrayLength(params_ref) - offset;
1040 int _needed;
1041 switch (pname) {
1042 #if defined(GL_FOG_COLOR)
1043 case GL_FOG_COLOR:
1044 #endif // defined(GL_FOG_COLOR)
1045 _needed = 4;
1046 break;
1047 default:
1048 _needed = 1;
1049 break;
1050 }
1051 if (_remaining < _needed) {
1052 _exception = 1;
1053 _exceptionType = "java/lang/IllegalArgumentException";
1054 _exceptionMessage = "length - offset < needed";
1055 goto exit;
1056 }
1057 params_base = (GLfloat *)
1058 _env->GetFloatArrayElements(params_ref, (jboolean *)0);
1059 params = params_base + offset;
1060
1061 glFogfv(
1062 (GLenum)pname,
1063 (GLfloat *)params
1064 );
1065
1066 exit:
1067 if (params_base) {
1068 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
1069 JNI_ABORT);
1070 }
1071 if (_exception) {
1072 jniThrowException(_env, _exceptionType, _exceptionMessage);
1073 }
1074 }
1075
1076 /* void glFogfv ( GLenum pname, const GLfloat *params ) */
1077 static void
android_glFogfv__ILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)1078 android_glFogfv__ILjava_nio_FloatBuffer_2
1079 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
1080 jint _exception = 0;
1081 const char * _exceptionType = NULL;
1082 const char * _exceptionMessage = NULL;
1083 jfloatArray _array = (jfloatArray) 0;
1084 jint _bufferOffset = (jint) 0;
1085 jint _remaining;
1086 GLfloat *params = (GLfloat *) 0;
1087
1088 if (!params_buf) {
1089 _exception = 1;
1090 _exceptionType = "java/lang/IllegalArgumentException";
1091 _exceptionMessage = "params == null";
1092 goto exit;
1093 }
1094 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1095 int _needed;
1096 switch (pname) {
1097 #if defined(GL_FOG_COLOR)
1098 case GL_FOG_COLOR:
1099 #endif // defined(GL_FOG_COLOR)
1100 _needed = 4;
1101 break;
1102 default:
1103 _needed = 1;
1104 break;
1105 }
1106 if (_remaining < _needed) {
1107 _exception = 1;
1108 _exceptionType = "java/lang/IllegalArgumentException";
1109 _exceptionMessage = "remaining() < needed";
1110 goto exit;
1111 }
1112 if (params == NULL) {
1113 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
1114 params = (GLfloat *) (_paramsBase + _bufferOffset);
1115 }
1116 glFogfv(
1117 (GLenum)pname,
1118 (GLfloat *)params
1119 );
1120
1121 exit:
1122 if (_array) {
1123 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT);
1124 }
1125 if (_exception) {
1126 jniThrowException(_env, _exceptionType, _exceptionMessage);
1127 }
1128 }
1129
1130 /* void glFogx ( GLenum pname, GLfixed param ) */
1131 static void
android_glFogx__II(JNIEnv * _env,jobject _this,jint pname,jint param)1132 android_glFogx__II
1133 (JNIEnv *_env, jobject _this, jint pname, jint param) {
1134 glFogx(
1135 (GLenum)pname,
1136 (GLfixed)param
1137 );
1138 }
1139
1140 /* void glFogxv ( GLenum pname, const GLfixed *params ) */
1141 static void
android_glFogxv__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray params_ref,jint offset)1142 android_glFogxv__I_3II
1143 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
1144 jint _exception = 0;
1145 const char * _exceptionType = NULL;
1146 const char * _exceptionMessage = NULL;
1147 GLfixed *params_base = (GLfixed *) 0;
1148 jint _remaining;
1149 GLfixed *params = (GLfixed *) 0;
1150
1151 if (!params_ref) {
1152 _exception = 1;
1153 _exceptionType = "java/lang/IllegalArgumentException";
1154 _exceptionMessage = "params == null";
1155 goto exit;
1156 }
1157 if (offset < 0) {
1158 _exception = 1;
1159 _exceptionType = "java/lang/IllegalArgumentException";
1160 _exceptionMessage = "offset < 0";
1161 goto exit;
1162 }
1163 _remaining = _env->GetArrayLength(params_ref) - offset;
1164 int _needed;
1165 switch (pname) {
1166 #if defined(GL_FOG_COLOR)
1167 case GL_FOG_COLOR:
1168 #endif // defined(GL_FOG_COLOR)
1169 _needed = 4;
1170 break;
1171 default:
1172 _needed = 1;
1173 break;
1174 }
1175 if (_remaining < _needed) {
1176 _exception = 1;
1177 _exceptionType = "java/lang/IllegalArgumentException";
1178 _exceptionMessage = "length - offset < needed";
1179 goto exit;
1180 }
1181 params_base = (GLfixed *)
1182 _env->GetIntArrayElements(params_ref, (jboolean *)0);
1183 params = params_base + offset;
1184
1185 glFogxv(
1186 (GLenum)pname,
1187 (GLfixed *)params
1188 );
1189
1190 exit:
1191 if (params_base) {
1192 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
1193 JNI_ABORT);
1194 }
1195 if (_exception) {
1196 jniThrowException(_env, _exceptionType, _exceptionMessage);
1197 }
1198 }
1199
1200 /* void glFogxv ( GLenum pname, const GLfixed *params ) */
1201 static void
android_glFogxv__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)1202 android_glFogxv__ILjava_nio_IntBuffer_2
1203 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
1204 jint _exception = 0;
1205 const char * _exceptionType = NULL;
1206 const char * _exceptionMessage = NULL;
1207 jintArray _array = (jintArray) 0;
1208 jint _bufferOffset = (jint) 0;
1209 jint _remaining;
1210 GLfixed *params = (GLfixed *) 0;
1211
1212 if (!params_buf) {
1213 _exception = 1;
1214 _exceptionType = "java/lang/IllegalArgumentException";
1215 _exceptionMessage = "params == null";
1216 goto exit;
1217 }
1218 params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1219 int _needed;
1220 switch (pname) {
1221 #if defined(GL_FOG_COLOR)
1222 case GL_FOG_COLOR:
1223 #endif // defined(GL_FOG_COLOR)
1224 _needed = 4;
1225 break;
1226 default:
1227 _needed = 1;
1228 break;
1229 }
1230 if (_remaining < _needed) {
1231 _exception = 1;
1232 _exceptionType = "java/lang/IllegalArgumentException";
1233 _exceptionMessage = "remaining() < needed";
1234 goto exit;
1235 }
1236 if (params == NULL) {
1237 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1238 params = (GLfixed *) (_paramsBase + _bufferOffset);
1239 }
1240 glFogxv(
1241 (GLenum)pname,
1242 (GLfixed *)params
1243 );
1244
1245 exit:
1246 if (_array) {
1247 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT);
1248 }
1249 if (_exception) {
1250 jniThrowException(_env, _exceptionType, _exceptionMessage);
1251 }
1252 }
1253
1254 /* void glFrontFace ( GLenum mode ) */
1255 static void
android_glFrontFace__I(JNIEnv * _env,jobject _this,jint mode)1256 android_glFrontFace__I
1257 (JNIEnv *_env, jobject _this, jint mode) {
1258 glFrontFace(
1259 (GLenum)mode
1260 );
1261 }
1262
1263 /* void glFrustumf ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */
1264 static void
android_glFrustumf__FFFFFF(JNIEnv * _env,jobject _this,jfloat left,jfloat right,jfloat bottom,jfloat top,jfloat zNear,jfloat zFar)1265 android_glFrustumf__FFFFFF
1266 (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) {
1267 glFrustumf(
1268 (GLfloat)left,
1269 (GLfloat)right,
1270 (GLfloat)bottom,
1271 (GLfloat)top,
1272 (GLfloat)zNear,
1273 (GLfloat)zFar
1274 );
1275 }
1276
1277 /* void glFrustumx ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */
1278 static void
android_glFrustumx__IIIIII(JNIEnv * _env,jobject _this,jint left,jint right,jint bottom,jint top,jint zNear,jint zFar)1279 android_glFrustumx__IIIIII
1280 (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) {
1281 glFrustumx(
1282 (GLfixed)left,
1283 (GLfixed)right,
1284 (GLfixed)bottom,
1285 (GLfixed)top,
1286 (GLfixed)zNear,
1287 (GLfixed)zFar
1288 );
1289 }
1290
1291 /* void glGenTextures ( GLsizei n, GLuint *textures ) */
1292 static void
android_glGenTextures__I_3II(JNIEnv * _env,jobject _this,jint n,jintArray textures_ref,jint offset)1293 android_glGenTextures__I_3II
1294 (JNIEnv *_env, jobject _this, jint n, jintArray textures_ref, jint offset) {
1295 jint _exception = 0;
1296 const char * _exceptionType = NULL;
1297 const char * _exceptionMessage = NULL;
1298 GLuint *textures_base = (GLuint *) 0;
1299 jint _remaining;
1300 GLuint *textures = (GLuint *) 0;
1301
1302 if (!textures_ref) {
1303 _exception = 1;
1304 _exceptionType = "java/lang/IllegalArgumentException";
1305 _exceptionMessage = "textures == null";
1306 goto exit;
1307 }
1308 if (offset < 0) {
1309 _exception = 1;
1310 _exceptionType = "java/lang/IllegalArgumentException";
1311 _exceptionMessage = "offset < 0";
1312 goto exit;
1313 }
1314 _remaining = _env->GetArrayLength(textures_ref) - offset;
1315 if (_remaining < n) {
1316 _exception = 1;
1317 _exceptionType = "java/lang/IllegalArgumentException";
1318 _exceptionMessage = "length - offset < n < needed";
1319 goto exit;
1320 }
1321 textures_base = (GLuint *)
1322 _env->GetIntArrayElements(textures_ref, (jboolean *)0);
1323 textures = textures_base + offset;
1324
1325 glGenTextures(
1326 (GLsizei)n,
1327 (GLuint *)textures
1328 );
1329
1330 exit:
1331 if (textures_base) {
1332 _env->ReleaseIntArrayElements(textures_ref, (jint*)textures_base,
1333 _exception ? JNI_ABORT: 0);
1334 }
1335 if (_exception) {
1336 jniThrowException(_env, _exceptionType, _exceptionMessage);
1337 }
1338 }
1339
1340 /* void glGenTextures ( GLsizei n, GLuint *textures ) */
1341 static void
android_glGenTextures__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint n,jobject textures_buf)1342 android_glGenTextures__ILjava_nio_IntBuffer_2
1343 (JNIEnv *_env, jobject _this, jint n, jobject textures_buf) {
1344 jint _exception = 0;
1345 const char * _exceptionType = NULL;
1346 const char * _exceptionMessage = NULL;
1347 jintArray _array = (jintArray) 0;
1348 jint _bufferOffset = (jint) 0;
1349 jint _remaining;
1350 GLuint *textures = (GLuint *) 0;
1351
1352 if (!textures_buf) {
1353 _exception = 1;
1354 _exceptionType = "java/lang/IllegalArgumentException";
1355 _exceptionMessage = "textures == null";
1356 goto exit;
1357 }
1358 textures = (GLuint *)getPointer(_env, textures_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1359 if (_remaining < n) {
1360 _exception = 1;
1361 _exceptionType = "java/lang/IllegalArgumentException";
1362 _exceptionMessage = "remaining() < n < needed";
1363 goto exit;
1364 }
1365 if (textures == NULL) {
1366 char * _texturesBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1367 textures = (GLuint *) (_texturesBase + _bufferOffset);
1368 }
1369 glGenTextures(
1370 (GLsizei)n,
1371 (GLuint *)textures
1372 );
1373
1374 exit:
1375 if (_array) {
1376 _env->ReleaseIntArrayElements(_array, (jint*)textures, _exception ? JNI_ABORT : 0);
1377 }
1378 if (_exception) {
1379 jniThrowException(_env, _exceptionType, _exceptionMessage);
1380 }
1381 }
1382
1383 /* GLenum glGetError ( void ) */
1384 static jint
android_glGetError__(JNIEnv * _env,jobject _this)1385 android_glGetError__
1386 (JNIEnv *_env, jobject _this) {
1387 GLenum _returnValue;
1388 _returnValue = glGetError();
1389 return (jint)_returnValue;
1390 }
1391
1392 /* void glGetIntegerv ( GLenum pname, GLint *params ) */
1393 static void
android_glGetIntegerv__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray params_ref,jint offset)1394 android_glGetIntegerv__I_3II
1395 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
1396 get<jintArray, IntArrayGetter, jint*, IntArrayReleaser, GLint, glGetIntegerv>(
1397 _env, _this, pname, params_ref, offset);
1398 }
1399
1400 /* void glGetIntegerv ( GLenum pname, GLint *params ) */
1401 static void
android_glGetIntegerv__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)1402 android_glGetIntegerv__ILjava_nio_IntBuffer_2
1403 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
1404 getarray<GLint, jintArray, IntArrayGetter, jint*, IntArrayReleaser, glGetIntegerv>(
1405 _env, _this, pname, params_buf);
1406 }
1407 /* const GLubyte * glGetString ( GLenum name ) */
android_glGetString(JNIEnv * _env,jobject,jint name)1408 static jstring android_glGetString(JNIEnv* _env, jobject, jint name) {
1409 const char* chars = (const char*) glGetString((GLenum) name);
1410 return _env->NewStringUTF(chars);
1411 }
1412 /* void glHint ( GLenum target, GLenum mode ) */
1413 static void
android_glHint__II(JNIEnv * _env,jobject _this,jint target,jint mode)1414 android_glHint__II
1415 (JNIEnv *_env, jobject _this, jint target, jint mode) {
1416 glHint(
1417 (GLenum)target,
1418 (GLenum)mode
1419 );
1420 }
1421
1422 /* void glLightModelf ( GLenum pname, GLfloat param ) */
1423 static void
android_glLightModelf__IF(JNIEnv * _env,jobject _this,jint pname,jfloat param)1424 android_glLightModelf__IF
1425 (JNIEnv *_env, jobject _this, jint pname, jfloat param) {
1426 glLightModelf(
1427 (GLenum)pname,
1428 (GLfloat)param
1429 );
1430 }
1431
1432 /* void glLightModelfv ( GLenum pname, const GLfloat *params ) */
1433 static void
android_glLightModelfv__I_3FI(JNIEnv * _env,jobject _this,jint pname,jfloatArray params_ref,jint offset)1434 android_glLightModelfv__I_3FI
1435 (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) {
1436 jint _exception = 0;
1437 const char * _exceptionType = NULL;
1438 const char * _exceptionMessage = NULL;
1439 GLfloat *params_base = (GLfloat *) 0;
1440 jint _remaining;
1441 GLfloat *params = (GLfloat *) 0;
1442
1443 if (!params_ref) {
1444 _exception = 1;
1445 _exceptionType = "java/lang/IllegalArgumentException";
1446 _exceptionMessage = "params == null";
1447 goto exit;
1448 }
1449 if (offset < 0) {
1450 _exception = 1;
1451 _exceptionType = "java/lang/IllegalArgumentException";
1452 _exceptionMessage = "offset < 0";
1453 goto exit;
1454 }
1455 _remaining = _env->GetArrayLength(params_ref) - offset;
1456 int _needed;
1457 switch (pname) {
1458 #if defined(GL_LIGHT_MODEL_AMBIENT)
1459 case GL_LIGHT_MODEL_AMBIENT:
1460 #endif // defined(GL_LIGHT_MODEL_AMBIENT)
1461 _needed = 4;
1462 break;
1463 default:
1464 _needed = 1;
1465 break;
1466 }
1467 if (_remaining < _needed) {
1468 _exception = 1;
1469 _exceptionType = "java/lang/IllegalArgumentException";
1470 _exceptionMessage = "length - offset < needed";
1471 goto exit;
1472 }
1473 params_base = (GLfloat *)
1474 _env->GetFloatArrayElements(params_ref, (jboolean *)0);
1475 params = params_base + offset;
1476
1477 glLightModelfv(
1478 (GLenum)pname,
1479 (GLfloat *)params
1480 );
1481
1482 exit:
1483 if (params_base) {
1484 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
1485 JNI_ABORT);
1486 }
1487 if (_exception) {
1488 jniThrowException(_env, _exceptionType, _exceptionMessage);
1489 }
1490 }
1491
1492 /* void glLightModelfv ( GLenum pname, const GLfloat *params ) */
1493 static void
android_glLightModelfv__ILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)1494 android_glLightModelfv__ILjava_nio_FloatBuffer_2
1495 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
1496 jint _exception = 0;
1497 const char * _exceptionType = NULL;
1498 const char * _exceptionMessage = NULL;
1499 jfloatArray _array = (jfloatArray) 0;
1500 jint _bufferOffset = (jint) 0;
1501 jint _remaining;
1502 GLfloat *params = (GLfloat *) 0;
1503
1504 if (!params_buf) {
1505 _exception = 1;
1506 _exceptionType = "java/lang/IllegalArgumentException";
1507 _exceptionMessage = "params == null";
1508 goto exit;
1509 }
1510 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1511 int _needed;
1512 switch (pname) {
1513 #if defined(GL_LIGHT_MODEL_AMBIENT)
1514 case GL_LIGHT_MODEL_AMBIENT:
1515 #endif // defined(GL_LIGHT_MODEL_AMBIENT)
1516 _needed = 4;
1517 break;
1518 default:
1519 _needed = 1;
1520 break;
1521 }
1522 if (_remaining < _needed) {
1523 _exception = 1;
1524 _exceptionType = "java/lang/IllegalArgumentException";
1525 _exceptionMessage = "remaining() < needed";
1526 goto exit;
1527 }
1528 if (params == NULL) {
1529 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
1530 params = (GLfloat *) (_paramsBase + _bufferOffset);
1531 }
1532 glLightModelfv(
1533 (GLenum)pname,
1534 (GLfloat *)params
1535 );
1536
1537 exit:
1538 if (_array) {
1539 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT);
1540 }
1541 if (_exception) {
1542 jniThrowException(_env, _exceptionType, _exceptionMessage);
1543 }
1544 }
1545
1546 /* void glLightModelx ( GLenum pname, GLfixed param ) */
1547 static void
android_glLightModelx__II(JNIEnv * _env,jobject _this,jint pname,jint param)1548 android_glLightModelx__II
1549 (JNIEnv *_env, jobject _this, jint pname, jint param) {
1550 glLightModelx(
1551 (GLenum)pname,
1552 (GLfixed)param
1553 );
1554 }
1555
1556 /* void glLightModelxv ( GLenum pname, const GLfixed *params ) */
1557 static void
android_glLightModelxv__I_3II(JNIEnv * _env,jobject _this,jint pname,jintArray params_ref,jint offset)1558 android_glLightModelxv__I_3II
1559 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
1560 jint _exception = 0;
1561 const char * _exceptionType = NULL;
1562 const char * _exceptionMessage = NULL;
1563 GLfixed *params_base = (GLfixed *) 0;
1564 jint _remaining;
1565 GLfixed *params = (GLfixed *) 0;
1566
1567 if (!params_ref) {
1568 _exception = 1;
1569 _exceptionType = "java/lang/IllegalArgumentException";
1570 _exceptionMessage = "params == null";
1571 goto exit;
1572 }
1573 if (offset < 0) {
1574 _exception = 1;
1575 _exceptionType = "java/lang/IllegalArgumentException";
1576 _exceptionMessage = "offset < 0";
1577 goto exit;
1578 }
1579 _remaining = _env->GetArrayLength(params_ref) - offset;
1580 int _needed;
1581 switch (pname) {
1582 #if defined(GL_LIGHT_MODEL_AMBIENT)
1583 case GL_LIGHT_MODEL_AMBIENT:
1584 #endif // defined(GL_LIGHT_MODEL_AMBIENT)
1585 _needed = 4;
1586 break;
1587 default:
1588 _needed = 1;
1589 break;
1590 }
1591 if (_remaining < _needed) {
1592 _exception = 1;
1593 _exceptionType = "java/lang/IllegalArgumentException";
1594 _exceptionMessage = "length - offset < needed";
1595 goto exit;
1596 }
1597 params_base = (GLfixed *)
1598 _env->GetIntArrayElements(params_ref, (jboolean *)0);
1599 params = params_base + offset;
1600
1601 glLightModelxv(
1602 (GLenum)pname,
1603 (GLfixed *)params
1604 );
1605
1606 exit:
1607 if (params_base) {
1608 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
1609 JNI_ABORT);
1610 }
1611 if (_exception) {
1612 jniThrowException(_env, _exceptionType, _exceptionMessage);
1613 }
1614 }
1615
1616 /* void glLightModelxv ( GLenum pname, const GLfixed *params ) */
1617 static void
android_glLightModelxv__ILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)1618 android_glLightModelxv__ILjava_nio_IntBuffer_2
1619 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
1620 jint _exception = 0;
1621 const char * _exceptionType = NULL;
1622 const char * _exceptionMessage = NULL;
1623 jintArray _array = (jintArray) 0;
1624 jint _bufferOffset = (jint) 0;
1625 jint _remaining;
1626 GLfixed *params = (GLfixed *) 0;
1627
1628 if (!params_buf) {
1629 _exception = 1;
1630 _exceptionType = "java/lang/IllegalArgumentException";
1631 _exceptionMessage = "params == null";
1632 goto exit;
1633 }
1634 params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1635 int _needed;
1636 switch (pname) {
1637 #if defined(GL_LIGHT_MODEL_AMBIENT)
1638 case GL_LIGHT_MODEL_AMBIENT:
1639 #endif // defined(GL_LIGHT_MODEL_AMBIENT)
1640 _needed = 4;
1641 break;
1642 default:
1643 _needed = 1;
1644 break;
1645 }
1646 if (_remaining < _needed) {
1647 _exception = 1;
1648 _exceptionType = "java/lang/IllegalArgumentException";
1649 _exceptionMessage = "remaining() < needed";
1650 goto exit;
1651 }
1652 if (params == NULL) {
1653 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1654 params = (GLfixed *) (_paramsBase + _bufferOffset);
1655 }
1656 glLightModelxv(
1657 (GLenum)pname,
1658 (GLfixed *)params
1659 );
1660
1661 exit:
1662 if (_array) {
1663 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT);
1664 }
1665 if (_exception) {
1666 jniThrowException(_env, _exceptionType, _exceptionMessage);
1667 }
1668 }
1669
1670 /* void glLightf ( GLenum light, GLenum pname, GLfloat param ) */
1671 static void
android_glLightf__IIF(JNIEnv * _env,jobject _this,jint light,jint pname,jfloat param)1672 android_glLightf__IIF
1673 (JNIEnv *_env, jobject _this, jint light, jint pname, jfloat param) {
1674 glLightf(
1675 (GLenum)light,
1676 (GLenum)pname,
1677 (GLfloat)param
1678 );
1679 }
1680
1681 /* void glLightfv ( GLenum light, GLenum pname, const GLfloat *params ) */
1682 static void
android_glLightfv__II_3FI(JNIEnv * _env,jobject _this,jint light,jint pname,jfloatArray params_ref,jint offset)1683 android_glLightfv__II_3FI
1684 (JNIEnv *_env, jobject _this, jint light, jint pname, jfloatArray params_ref, jint offset) {
1685 jint _exception = 0;
1686 const char * _exceptionType = NULL;
1687 const char * _exceptionMessage = NULL;
1688 GLfloat *params_base = (GLfloat *) 0;
1689 jint _remaining;
1690 GLfloat *params = (GLfloat *) 0;
1691
1692 if (!params_ref) {
1693 _exception = 1;
1694 _exceptionType = "java/lang/IllegalArgumentException";
1695 _exceptionMessage = "params == null";
1696 goto exit;
1697 }
1698 if (offset < 0) {
1699 _exception = 1;
1700 _exceptionType = "java/lang/IllegalArgumentException";
1701 _exceptionMessage = "offset < 0";
1702 goto exit;
1703 }
1704 _remaining = _env->GetArrayLength(params_ref) - offset;
1705 int _needed;
1706 switch (pname) {
1707 #if defined(GL_SPOT_DIRECTION)
1708 case GL_SPOT_DIRECTION:
1709 #endif // defined(GL_SPOT_DIRECTION)
1710 _needed = 3;
1711 break;
1712 #if defined(GL_AMBIENT)
1713 case GL_AMBIENT:
1714 #endif // defined(GL_AMBIENT)
1715 #if defined(GL_DIFFUSE)
1716 case GL_DIFFUSE:
1717 #endif // defined(GL_DIFFUSE)
1718 #if defined(GL_SPECULAR)
1719 case GL_SPECULAR:
1720 #endif // defined(GL_SPECULAR)
1721 #if defined(GL_EMISSION)
1722 case GL_EMISSION:
1723 #endif // defined(GL_EMISSION)
1724 _needed = 4;
1725 break;
1726 default:
1727 _needed = 1;
1728 break;
1729 }
1730 if (_remaining < _needed) {
1731 _exception = 1;
1732 _exceptionType = "java/lang/IllegalArgumentException";
1733 _exceptionMessage = "length - offset < needed";
1734 goto exit;
1735 }
1736 params_base = (GLfloat *)
1737 _env->GetFloatArrayElements(params_ref, (jboolean *)0);
1738 params = params_base + offset;
1739
1740 glLightfv(
1741 (GLenum)light,
1742 (GLenum)pname,
1743 (GLfloat *)params
1744 );
1745
1746 exit:
1747 if (params_base) {
1748 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
1749 JNI_ABORT);
1750 }
1751 if (_exception) {
1752 jniThrowException(_env, _exceptionType, _exceptionMessage);
1753 }
1754 }
1755
1756 /* void glLightfv ( GLenum light, GLenum pname, const GLfloat *params ) */
1757 static void
android_glLightfv__IILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint light,jint pname,jobject params_buf)1758 android_glLightfv__IILjava_nio_FloatBuffer_2
1759 (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) {
1760 jint _exception = 0;
1761 const char * _exceptionType = NULL;
1762 const char * _exceptionMessage = NULL;
1763 jfloatArray _array = (jfloatArray) 0;
1764 jint _bufferOffset = (jint) 0;
1765 jint _remaining;
1766 GLfloat *params = (GLfloat *) 0;
1767
1768 if (!params_buf) {
1769 _exception = 1;
1770 _exceptionType = "java/lang/IllegalArgumentException";
1771 _exceptionMessage = "params == null";
1772 goto exit;
1773 }
1774 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1775 int _needed;
1776 switch (pname) {
1777 #if defined(GL_SPOT_DIRECTION)
1778 case GL_SPOT_DIRECTION:
1779 #endif // defined(GL_SPOT_DIRECTION)
1780 _needed = 3;
1781 break;
1782 #if defined(GL_AMBIENT)
1783 case GL_AMBIENT:
1784 #endif // defined(GL_AMBIENT)
1785 #if defined(GL_DIFFUSE)
1786 case GL_DIFFUSE:
1787 #endif // defined(GL_DIFFUSE)
1788 #if defined(GL_SPECULAR)
1789 case GL_SPECULAR:
1790 #endif // defined(GL_SPECULAR)
1791 #if defined(GL_EMISSION)
1792 case GL_EMISSION:
1793 #endif // defined(GL_EMISSION)
1794 _needed = 4;
1795 break;
1796 default:
1797 _needed = 1;
1798 break;
1799 }
1800 if (_remaining < _needed) {
1801 _exception = 1;
1802 _exceptionType = "java/lang/IllegalArgumentException";
1803 _exceptionMessage = "remaining() < needed";
1804 goto exit;
1805 }
1806 if (params == NULL) {
1807 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
1808 params = (GLfloat *) (_paramsBase + _bufferOffset);
1809 }
1810 glLightfv(
1811 (GLenum)light,
1812 (GLenum)pname,
1813 (GLfloat *)params
1814 );
1815
1816 exit:
1817 if (_array) {
1818 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT);
1819 }
1820 if (_exception) {
1821 jniThrowException(_env, _exceptionType, _exceptionMessage);
1822 }
1823 }
1824
1825 /* void glLightx ( GLenum light, GLenum pname, GLfixed param ) */
1826 static void
android_glLightx__III(JNIEnv * _env,jobject _this,jint light,jint pname,jint param)1827 android_glLightx__III
1828 (JNIEnv *_env, jobject _this, jint light, jint pname, jint param) {
1829 glLightx(
1830 (GLenum)light,
1831 (GLenum)pname,
1832 (GLfixed)param
1833 );
1834 }
1835
1836 /* void glLightxv ( GLenum light, GLenum pname, const GLfixed *params ) */
1837 static void
android_glLightxv__II_3II(JNIEnv * _env,jobject _this,jint light,jint pname,jintArray params_ref,jint offset)1838 android_glLightxv__II_3II
1839 (JNIEnv *_env, jobject _this, jint light, jint pname, jintArray params_ref, jint offset) {
1840 jint _exception = 0;
1841 const char * _exceptionType = NULL;
1842 const char * _exceptionMessage = NULL;
1843 GLfixed *params_base = (GLfixed *) 0;
1844 jint _remaining;
1845 GLfixed *params = (GLfixed *) 0;
1846
1847 if (!params_ref) {
1848 _exception = 1;
1849 _exceptionType = "java/lang/IllegalArgumentException";
1850 _exceptionMessage = "params == null";
1851 goto exit;
1852 }
1853 if (offset < 0) {
1854 _exception = 1;
1855 _exceptionType = "java/lang/IllegalArgumentException";
1856 _exceptionMessage = "offset < 0";
1857 goto exit;
1858 }
1859 _remaining = _env->GetArrayLength(params_ref) - offset;
1860 int _needed;
1861 switch (pname) {
1862 #if defined(GL_SPOT_DIRECTION)
1863 case GL_SPOT_DIRECTION:
1864 #endif // defined(GL_SPOT_DIRECTION)
1865 _needed = 3;
1866 break;
1867 #if defined(GL_AMBIENT)
1868 case GL_AMBIENT:
1869 #endif // defined(GL_AMBIENT)
1870 #if defined(GL_DIFFUSE)
1871 case GL_DIFFUSE:
1872 #endif // defined(GL_DIFFUSE)
1873 #if defined(GL_SPECULAR)
1874 case GL_SPECULAR:
1875 #endif // defined(GL_SPECULAR)
1876 #if defined(GL_EMISSION)
1877 case GL_EMISSION:
1878 #endif // defined(GL_EMISSION)
1879 _needed = 4;
1880 break;
1881 default:
1882 _needed = 1;
1883 break;
1884 }
1885 if (_remaining < _needed) {
1886 _exception = 1;
1887 _exceptionType = "java/lang/IllegalArgumentException";
1888 _exceptionMessage = "length - offset < needed";
1889 goto exit;
1890 }
1891 params_base = (GLfixed *)
1892 _env->GetIntArrayElements(params_ref, (jboolean *)0);
1893 params = params_base + offset;
1894
1895 glLightxv(
1896 (GLenum)light,
1897 (GLenum)pname,
1898 (GLfixed *)params
1899 );
1900
1901 exit:
1902 if (params_base) {
1903 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
1904 JNI_ABORT);
1905 }
1906 if (_exception) {
1907 jniThrowException(_env, _exceptionType, _exceptionMessage);
1908 }
1909 }
1910
1911 /* void glLightxv ( GLenum light, GLenum pname, const GLfixed *params ) */
1912 static void
android_glLightxv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint light,jint pname,jobject params_buf)1913 android_glLightxv__IILjava_nio_IntBuffer_2
1914 (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) {
1915 jint _exception = 0;
1916 const char * _exceptionType = NULL;
1917 const char * _exceptionMessage = NULL;
1918 jintArray _array = (jintArray) 0;
1919 jint _bufferOffset = (jint) 0;
1920 jint _remaining;
1921 GLfixed *params = (GLfixed *) 0;
1922
1923 if (!params_buf) {
1924 _exception = 1;
1925 _exceptionType = "java/lang/IllegalArgumentException";
1926 _exceptionMessage = "params == null";
1927 goto exit;
1928 }
1929 params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
1930 int _needed;
1931 switch (pname) {
1932 #if defined(GL_SPOT_DIRECTION)
1933 case GL_SPOT_DIRECTION:
1934 #endif // defined(GL_SPOT_DIRECTION)
1935 _needed = 3;
1936 break;
1937 #if defined(GL_AMBIENT)
1938 case GL_AMBIENT:
1939 #endif // defined(GL_AMBIENT)
1940 #if defined(GL_DIFFUSE)
1941 case GL_DIFFUSE:
1942 #endif // defined(GL_DIFFUSE)
1943 #if defined(GL_SPECULAR)
1944 case GL_SPECULAR:
1945 #endif // defined(GL_SPECULAR)
1946 #if defined(GL_EMISSION)
1947 case GL_EMISSION:
1948 #endif // defined(GL_EMISSION)
1949 _needed = 4;
1950 break;
1951 default:
1952 _needed = 1;
1953 break;
1954 }
1955 if (_remaining < _needed) {
1956 _exception = 1;
1957 _exceptionType = "java/lang/IllegalArgumentException";
1958 _exceptionMessage = "remaining() < needed";
1959 goto exit;
1960 }
1961 if (params == NULL) {
1962 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
1963 params = (GLfixed *) (_paramsBase + _bufferOffset);
1964 }
1965 glLightxv(
1966 (GLenum)light,
1967 (GLenum)pname,
1968 (GLfixed *)params
1969 );
1970
1971 exit:
1972 if (_array) {
1973 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT);
1974 }
1975 if (_exception) {
1976 jniThrowException(_env, _exceptionType, _exceptionMessage);
1977 }
1978 }
1979
1980 /* void glLineWidth ( GLfloat width ) */
1981 static void
android_glLineWidth__F(JNIEnv * _env,jobject _this,jfloat width)1982 android_glLineWidth__F
1983 (JNIEnv *_env, jobject _this, jfloat width) {
1984 glLineWidth(
1985 (GLfloat)width
1986 );
1987 }
1988
1989 /* void glLineWidthx ( GLfixed width ) */
1990 static void
android_glLineWidthx__I(JNIEnv * _env,jobject _this,jint width)1991 android_glLineWidthx__I
1992 (JNIEnv *_env, jobject _this, jint width) {
1993 glLineWidthx(
1994 (GLfixed)width
1995 );
1996 }
1997
1998 /* void glLoadIdentity ( void ) */
1999 static void
android_glLoadIdentity__(JNIEnv * _env,jobject _this)2000 android_glLoadIdentity__
2001 (JNIEnv *_env, jobject _this) {
2002 glLoadIdentity();
2003 }
2004
2005 /* void glLoadMatrixf ( const GLfloat *m ) */
2006 static void
android_glLoadMatrixf___3FI(JNIEnv * _env,jobject _this,jfloatArray m_ref,jint offset)2007 android_glLoadMatrixf___3FI
2008 (JNIEnv *_env, jobject _this, jfloatArray m_ref, jint offset) {
2009 jint _exception = 0;
2010 const char * _exceptionType = NULL;
2011 const char * _exceptionMessage = NULL;
2012 GLfloat *m_base = (GLfloat *) 0;
2013 jint _remaining;
2014 GLfloat *m = (GLfloat *) 0;
2015
2016 if (!m_ref) {
2017 _exception = 1;
2018 _exceptionType = "java/lang/IllegalArgumentException";
2019 _exceptionMessage = "m == null";
2020 goto exit;
2021 }
2022 if (offset < 0) {
2023 _exception = 1;
2024 _exceptionType = "java/lang/IllegalArgumentException";
2025 _exceptionMessage = "offset < 0";
2026 goto exit;
2027 }
2028 _remaining = _env->GetArrayLength(m_ref) - offset;
2029 m_base = (GLfloat *)
2030 _env->GetFloatArrayElements(m_ref, (jboolean *)0);
2031 m = m_base + offset;
2032
2033 glLoadMatrixf(
2034 (GLfloat *)m
2035 );
2036
2037 exit:
2038 if (m_base) {
2039 _env->ReleaseFloatArrayElements(m_ref, (jfloat*)m_base,
2040 JNI_ABORT);
2041 }
2042 if (_exception) {
2043 jniThrowException(_env, _exceptionType, _exceptionMessage);
2044 }
2045 }
2046
2047 /* void glLoadMatrixf ( const GLfloat *m ) */
2048 static void
android_glLoadMatrixf__Ljava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jobject m_buf)2049 android_glLoadMatrixf__Ljava_nio_FloatBuffer_2
2050 (JNIEnv *_env, jobject _this, jobject m_buf) {
2051 jint _exception = 0;
2052 const char * _exceptionType = NULL;
2053 const char * _exceptionMessage = NULL;
2054 jfloatArray _array = (jfloatArray) 0;
2055 jint _bufferOffset = (jint) 0;
2056 jint _remaining;
2057 GLfloat *m = (GLfloat *) 0;
2058
2059 if (!m_buf) {
2060 _exception = 1;
2061 _exceptionType = "java/lang/IllegalArgumentException";
2062 _exceptionMessage = "m == null";
2063 goto exit;
2064 }
2065 m = (GLfloat *)getPointer(_env, m_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2066 if (m == NULL) {
2067 char * _mBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
2068 m = (GLfloat *) (_mBase + _bufferOffset);
2069 }
2070 glLoadMatrixf(
2071 (GLfloat *)m
2072 );
2073
2074 exit:
2075 if (_array) {
2076 _env->ReleaseFloatArrayElements(_array, (jfloat*)m, JNI_ABORT);
2077 }
2078 if (_exception) {
2079 jniThrowException(_env, _exceptionType, _exceptionMessage);
2080 }
2081 }
2082
2083 /* void glLoadMatrixx ( const GLfixed *m ) */
2084 static void
android_glLoadMatrixx___3II(JNIEnv * _env,jobject _this,jintArray m_ref,jint offset)2085 android_glLoadMatrixx___3II
2086 (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) {
2087 jint _exception = 0;
2088 const char * _exceptionType = NULL;
2089 const char * _exceptionMessage = NULL;
2090 GLfixed *m_base = (GLfixed *) 0;
2091 jint _remaining;
2092 GLfixed *m = (GLfixed *) 0;
2093
2094 if (!m_ref) {
2095 _exception = 1;
2096 _exceptionType = "java/lang/IllegalArgumentException";
2097 _exceptionMessage = "m == null";
2098 goto exit;
2099 }
2100 if (offset < 0) {
2101 _exception = 1;
2102 _exceptionType = "java/lang/IllegalArgumentException";
2103 _exceptionMessage = "offset < 0";
2104 goto exit;
2105 }
2106 _remaining = _env->GetArrayLength(m_ref) - offset;
2107 m_base = (GLfixed *)
2108 _env->GetIntArrayElements(m_ref, (jboolean *)0);
2109 m = m_base + offset;
2110
2111 glLoadMatrixx(
2112 (GLfixed *)m
2113 );
2114
2115 exit:
2116 if (m_base) {
2117 _env->ReleaseIntArrayElements(m_ref, (jint*)m_base,
2118 JNI_ABORT);
2119 }
2120 if (_exception) {
2121 jniThrowException(_env, _exceptionType, _exceptionMessage);
2122 }
2123 }
2124
2125 /* void glLoadMatrixx ( const GLfixed *m ) */
2126 static void
android_glLoadMatrixx__Ljava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jobject m_buf)2127 android_glLoadMatrixx__Ljava_nio_IntBuffer_2
2128 (JNIEnv *_env, jobject _this, jobject m_buf) {
2129 jint _exception = 0;
2130 const char * _exceptionType = NULL;
2131 const char * _exceptionMessage = NULL;
2132 jintArray _array = (jintArray) 0;
2133 jint _bufferOffset = (jint) 0;
2134 jint _remaining;
2135 GLfixed *m = (GLfixed *) 0;
2136
2137 if (!m_buf) {
2138 _exception = 1;
2139 _exceptionType = "java/lang/IllegalArgumentException";
2140 _exceptionMessage = "m == null";
2141 goto exit;
2142 }
2143 m = (GLfixed *)getPointer(_env, m_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2144 if (m == NULL) {
2145 char * _mBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
2146 m = (GLfixed *) (_mBase + _bufferOffset);
2147 }
2148 glLoadMatrixx(
2149 (GLfixed *)m
2150 );
2151
2152 exit:
2153 if (_array) {
2154 _env->ReleaseIntArrayElements(_array, (jint*)m, JNI_ABORT);
2155 }
2156 if (_exception) {
2157 jniThrowException(_env, _exceptionType, _exceptionMessage);
2158 }
2159 }
2160
2161 /* void glLogicOp ( GLenum opcode ) */
2162 static void
android_glLogicOp__I(JNIEnv * _env,jobject _this,jint opcode)2163 android_glLogicOp__I
2164 (JNIEnv *_env, jobject _this, jint opcode) {
2165 glLogicOp(
2166 (GLenum)opcode
2167 );
2168 }
2169
2170 /* void glMaterialf ( GLenum face, GLenum pname, GLfloat param ) */
2171 static void
android_glMaterialf__IIF(JNIEnv * _env,jobject _this,jint face,jint pname,jfloat param)2172 android_glMaterialf__IIF
2173 (JNIEnv *_env, jobject _this, jint face, jint pname, jfloat param) {
2174 glMaterialf(
2175 (GLenum)face,
2176 (GLenum)pname,
2177 (GLfloat)param
2178 );
2179 }
2180
2181 /* void glMaterialfv ( GLenum face, GLenum pname, const GLfloat *params ) */
2182 static void
android_glMaterialfv__II_3FI(JNIEnv * _env,jobject _this,jint face,jint pname,jfloatArray params_ref,jint offset)2183 android_glMaterialfv__II_3FI
2184 (JNIEnv *_env, jobject _this, jint face, jint pname, jfloatArray params_ref, jint offset) {
2185 jint _exception = 0;
2186 const char * _exceptionType = NULL;
2187 const char * _exceptionMessage = NULL;
2188 GLfloat *params_base = (GLfloat *) 0;
2189 jint _remaining;
2190 GLfloat *params = (GLfloat *) 0;
2191
2192 if (!params_ref) {
2193 _exception = 1;
2194 _exceptionType = "java/lang/IllegalArgumentException";
2195 _exceptionMessage = "params == null";
2196 goto exit;
2197 }
2198 if (offset < 0) {
2199 _exception = 1;
2200 _exceptionType = "java/lang/IllegalArgumentException";
2201 _exceptionMessage = "offset < 0";
2202 goto exit;
2203 }
2204 _remaining = _env->GetArrayLength(params_ref) - offset;
2205 int _needed;
2206 switch (pname) {
2207 #if defined(GL_AMBIENT)
2208 case GL_AMBIENT:
2209 #endif // defined(GL_AMBIENT)
2210 #if defined(GL_DIFFUSE)
2211 case GL_DIFFUSE:
2212 #endif // defined(GL_DIFFUSE)
2213 #if defined(GL_SPECULAR)
2214 case GL_SPECULAR:
2215 #endif // defined(GL_SPECULAR)
2216 #if defined(GL_EMISSION)
2217 case GL_EMISSION:
2218 #endif // defined(GL_EMISSION)
2219 #if defined(GL_AMBIENT_AND_DIFFUSE)
2220 case GL_AMBIENT_AND_DIFFUSE:
2221 #endif // defined(GL_AMBIENT_AND_DIFFUSE)
2222 _needed = 4;
2223 break;
2224 default:
2225 _needed = 1;
2226 break;
2227 }
2228 if (_remaining < _needed) {
2229 _exception = 1;
2230 _exceptionType = "java/lang/IllegalArgumentException";
2231 _exceptionMessage = "length - offset < needed";
2232 goto exit;
2233 }
2234 params_base = (GLfloat *)
2235 _env->GetFloatArrayElements(params_ref, (jboolean *)0);
2236 params = params_base + offset;
2237
2238 glMaterialfv(
2239 (GLenum)face,
2240 (GLenum)pname,
2241 (GLfloat *)params
2242 );
2243
2244 exit:
2245 if (params_base) {
2246 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
2247 JNI_ABORT);
2248 }
2249 if (_exception) {
2250 jniThrowException(_env, _exceptionType, _exceptionMessage);
2251 }
2252 }
2253
2254 /* void glMaterialfv ( GLenum face, GLenum pname, const GLfloat *params ) */
2255 static void
android_glMaterialfv__IILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint face,jint pname,jobject params_buf)2256 android_glMaterialfv__IILjava_nio_FloatBuffer_2
2257 (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) {
2258 jint _exception = 0;
2259 const char * _exceptionType = NULL;
2260 const char * _exceptionMessage = NULL;
2261 jfloatArray _array = (jfloatArray) 0;
2262 jint _bufferOffset = (jint) 0;
2263 jint _remaining;
2264 GLfloat *params = (GLfloat *) 0;
2265
2266 if (!params_buf) {
2267 _exception = 1;
2268 _exceptionType = "java/lang/IllegalArgumentException";
2269 _exceptionMessage = "params == null";
2270 goto exit;
2271 }
2272 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2273 int _needed;
2274 switch (pname) {
2275 #if defined(GL_AMBIENT)
2276 case GL_AMBIENT:
2277 #endif // defined(GL_AMBIENT)
2278 #if defined(GL_DIFFUSE)
2279 case GL_DIFFUSE:
2280 #endif // defined(GL_DIFFUSE)
2281 #if defined(GL_SPECULAR)
2282 case GL_SPECULAR:
2283 #endif // defined(GL_SPECULAR)
2284 #if defined(GL_EMISSION)
2285 case GL_EMISSION:
2286 #endif // defined(GL_EMISSION)
2287 #if defined(GL_AMBIENT_AND_DIFFUSE)
2288 case GL_AMBIENT_AND_DIFFUSE:
2289 #endif // defined(GL_AMBIENT_AND_DIFFUSE)
2290 _needed = 4;
2291 break;
2292 default:
2293 _needed = 1;
2294 break;
2295 }
2296 if (_remaining < _needed) {
2297 _exception = 1;
2298 _exceptionType = "java/lang/IllegalArgumentException";
2299 _exceptionMessage = "remaining() < needed";
2300 goto exit;
2301 }
2302 if (params == NULL) {
2303 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
2304 params = (GLfloat *) (_paramsBase + _bufferOffset);
2305 }
2306 glMaterialfv(
2307 (GLenum)face,
2308 (GLenum)pname,
2309 (GLfloat *)params
2310 );
2311
2312 exit:
2313 if (_array) {
2314 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT);
2315 }
2316 if (_exception) {
2317 jniThrowException(_env, _exceptionType, _exceptionMessage);
2318 }
2319 }
2320
2321 /* void glMaterialx ( GLenum face, GLenum pname, GLfixed param ) */
2322 static void
android_glMaterialx__III(JNIEnv * _env,jobject _this,jint face,jint pname,jint param)2323 android_glMaterialx__III
2324 (JNIEnv *_env, jobject _this, jint face, jint pname, jint param) {
2325 glMaterialx(
2326 (GLenum)face,
2327 (GLenum)pname,
2328 (GLfixed)param
2329 );
2330 }
2331
2332 /* void glMaterialxv ( GLenum face, GLenum pname, const GLfixed *params ) */
2333 static void
android_glMaterialxv__II_3II(JNIEnv * _env,jobject _this,jint face,jint pname,jintArray params_ref,jint offset)2334 android_glMaterialxv__II_3II
2335 (JNIEnv *_env, jobject _this, jint face, jint pname, jintArray params_ref, jint offset) {
2336 jint _exception = 0;
2337 const char * _exceptionType = NULL;
2338 const char * _exceptionMessage = NULL;
2339 GLfixed *params_base = (GLfixed *) 0;
2340 jint _remaining;
2341 GLfixed *params = (GLfixed *) 0;
2342
2343 if (!params_ref) {
2344 _exception = 1;
2345 _exceptionType = "java/lang/IllegalArgumentException";
2346 _exceptionMessage = "params == null";
2347 goto exit;
2348 }
2349 if (offset < 0) {
2350 _exception = 1;
2351 _exceptionType = "java/lang/IllegalArgumentException";
2352 _exceptionMessage = "offset < 0";
2353 goto exit;
2354 }
2355 _remaining = _env->GetArrayLength(params_ref) - offset;
2356 int _needed;
2357 switch (pname) {
2358 #if defined(GL_AMBIENT)
2359 case GL_AMBIENT:
2360 #endif // defined(GL_AMBIENT)
2361 #if defined(GL_DIFFUSE)
2362 case GL_DIFFUSE:
2363 #endif // defined(GL_DIFFUSE)
2364 #if defined(GL_SPECULAR)
2365 case GL_SPECULAR:
2366 #endif // defined(GL_SPECULAR)
2367 #if defined(GL_EMISSION)
2368 case GL_EMISSION:
2369 #endif // defined(GL_EMISSION)
2370 #if defined(GL_AMBIENT_AND_DIFFUSE)
2371 case GL_AMBIENT_AND_DIFFUSE:
2372 #endif // defined(GL_AMBIENT_AND_DIFFUSE)
2373 _needed = 4;
2374 break;
2375 default:
2376 _needed = 1;
2377 break;
2378 }
2379 if (_remaining < _needed) {
2380 _exception = 1;
2381 _exceptionType = "java/lang/IllegalArgumentException";
2382 _exceptionMessage = "length - offset < needed";
2383 goto exit;
2384 }
2385 params_base = (GLfixed *)
2386 _env->GetIntArrayElements(params_ref, (jboolean *)0);
2387 params = params_base + offset;
2388
2389 glMaterialxv(
2390 (GLenum)face,
2391 (GLenum)pname,
2392 (GLfixed *)params
2393 );
2394
2395 exit:
2396 if (params_base) {
2397 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
2398 JNI_ABORT);
2399 }
2400 if (_exception) {
2401 jniThrowException(_env, _exceptionType, _exceptionMessage);
2402 }
2403 }
2404
2405 /* void glMaterialxv ( GLenum face, GLenum pname, const GLfixed *params ) */
2406 static void
android_glMaterialxv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint face,jint pname,jobject params_buf)2407 android_glMaterialxv__IILjava_nio_IntBuffer_2
2408 (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_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 GLfixed *params = (GLfixed *) 0;
2416
2417 if (!params_buf) {
2418 _exception = 1;
2419 _exceptionType = "java/lang/IllegalArgumentException";
2420 _exceptionMessage = "params == null";
2421 goto exit;
2422 }
2423 params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2424 int _needed;
2425 switch (pname) {
2426 #if defined(GL_AMBIENT)
2427 case GL_AMBIENT:
2428 #endif // defined(GL_AMBIENT)
2429 #if defined(GL_DIFFUSE)
2430 case GL_DIFFUSE:
2431 #endif // defined(GL_DIFFUSE)
2432 #if defined(GL_SPECULAR)
2433 case GL_SPECULAR:
2434 #endif // defined(GL_SPECULAR)
2435 #if defined(GL_EMISSION)
2436 case GL_EMISSION:
2437 #endif // defined(GL_EMISSION)
2438 #if defined(GL_AMBIENT_AND_DIFFUSE)
2439 case GL_AMBIENT_AND_DIFFUSE:
2440 #endif // defined(GL_AMBIENT_AND_DIFFUSE)
2441 _needed = 4;
2442 break;
2443 default:
2444 _needed = 1;
2445 break;
2446 }
2447 if (_remaining < _needed) {
2448 _exception = 1;
2449 _exceptionType = "java/lang/IllegalArgumentException";
2450 _exceptionMessage = "remaining() < needed";
2451 goto exit;
2452 }
2453 if (params == NULL) {
2454 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
2455 params = (GLfixed *) (_paramsBase + _bufferOffset);
2456 }
2457 glMaterialxv(
2458 (GLenum)face,
2459 (GLenum)pname,
2460 (GLfixed *)params
2461 );
2462
2463 exit:
2464 if (_array) {
2465 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT);
2466 }
2467 if (_exception) {
2468 jniThrowException(_env, _exceptionType, _exceptionMessage);
2469 }
2470 }
2471
2472 /* void glMatrixMode ( GLenum mode ) */
2473 static void
android_glMatrixMode__I(JNIEnv * _env,jobject _this,jint mode)2474 android_glMatrixMode__I
2475 (JNIEnv *_env, jobject _this, jint mode) {
2476 glMatrixMode(
2477 (GLenum)mode
2478 );
2479 }
2480
2481 /* void glMultMatrixf ( const GLfloat *m ) */
2482 static void
android_glMultMatrixf___3FI(JNIEnv * _env,jobject _this,jfloatArray m_ref,jint offset)2483 android_glMultMatrixf___3FI
2484 (JNIEnv *_env, jobject _this, jfloatArray m_ref, jint offset) {
2485 jint _exception = 0;
2486 const char * _exceptionType = NULL;
2487 const char * _exceptionMessage = NULL;
2488 GLfloat *m_base = (GLfloat *) 0;
2489 jint _remaining;
2490 GLfloat *m = (GLfloat *) 0;
2491
2492 if (!m_ref) {
2493 _exception = 1;
2494 _exceptionType = "java/lang/IllegalArgumentException";
2495 _exceptionMessage = "m == null";
2496 goto exit;
2497 }
2498 if (offset < 0) {
2499 _exception = 1;
2500 _exceptionType = "java/lang/IllegalArgumentException";
2501 _exceptionMessage = "offset < 0";
2502 goto exit;
2503 }
2504 _remaining = _env->GetArrayLength(m_ref) - offset;
2505 m_base = (GLfloat *)
2506 _env->GetFloatArrayElements(m_ref, (jboolean *)0);
2507 m = m_base + offset;
2508
2509 glMultMatrixf(
2510 (GLfloat *)m
2511 );
2512
2513 exit:
2514 if (m_base) {
2515 _env->ReleaseFloatArrayElements(m_ref, (jfloat*)m_base,
2516 JNI_ABORT);
2517 }
2518 if (_exception) {
2519 jniThrowException(_env, _exceptionType, _exceptionMessage);
2520 }
2521 }
2522
2523 /* void glMultMatrixf ( const GLfloat *m ) */
2524 static void
android_glMultMatrixf__Ljava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jobject m_buf)2525 android_glMultMatrixf__Ljava_nio_FloatBuffer_2
2526 (JNIEnv *_env, jobject _this, jobject m_buf) {
2527 jint _exception = 0;
2528 const char * _exceptionType = NULL;
2529 const char * _exceptionMessage = NULL;
2530 jfloatArray _array = (jfloatArray) 0;
2531 jint _bufferOffset = (jint) 0;
2532 jint _remaining;
2533 GLfloat *m = (GLfloat *) 0;
2534
2535 if (!m_buf) {
2536 _exception = 1;
2537 _exceptionType = "java/lang/IllegalArgumentException";
2538 _exceptionMessage = "m == null";
2539 goto exit;
2540 }
2541 m = (GLfloat *)getPointer(_env, m_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2542 if (m == NULL) {
2543 char * _mBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
2544 m = (GLfloat *) (_mBase + _bufferOffset);
2545 }
2546 glMultMatrixf(
2547 (GLfloat *)m
2548 );
2549
2550 exit:
2551 if (_array) {
2552 _env->ReleaseFloatArrayElements(_array, (jfloat*)m, JNI_ABORT);
2553 }
2554 if (_exception) {
2555 jniThrowException(_env, _exceptionType, _exceptionMessage);
2556 }
2557 }
2558
2559 /* void glMultMatrixx ( const GLfixed *m ) */
2560 static void
android_glMultMatrixx___3II(JNIEnv * _env,jobject _this,jintArray m_ref,jint offset)2561 android_glMultMatrixx___3II
2562 (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) {
2563 jint _exception = 0;
2564 const char * _exceptionType = NULL;
2565 const char * _exceptionMessage = NULL;
2566 GLfixed *m_base = (GLfixed *) 0;
2567 jint _remaining;
2568 GLfixed *m = (GLfixed *) 0;
2569
2570 if (!m_ref) {
2571 _exception = 1;
2572 _exceptionType = "java/lang/IllegalArgumentException";
2573 _exceptionMessage = "m == null";
2574 goto exit;
2575 }
2576 if (offset < 0) {
2577 _exception = 1;
2578 _exceptionType = "java/lang/IllegalArgumentException";
2579 _exceptionMessage = "offset < 0";
2580 goto exit;
2581 }
2582 _remaining = _env->GetArrayLength(m_ref) - offset;
2583 m_base = (GLfixed *)
2584 _env->GetIntArrayElements(m_ref, (jboolean *)0);
2585 m = m_base + offset;
2586
2587 glMultMatrixx(
2588 (GLfixed *)m
2589 );
2590
2591 exit:
2592 if (m_base) {
2593 _env->ReleaseIntArrayElements(m_ref, (jint*)m_base,
2594 JNI_ABORT);
2595 }
2596 if (_exception) {
2597 jniThrowException(_env, _exceptionType, _exceptionMessage);
2598 }
2599 }
2600
2601 /* void glMultMatrixx ( const GLfixed *m ) */
2602 static void
android_glMultMatrixx__Ljava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jobject m_buf)2603 android_glMultMatrixx__Ljava_nio_IntBuffer_2
2604 (JNIEnv *_env, jobject _this, jobject m_buf) {
2605 jint _exception = 0;
2606 const char * _exceptionType = NULL;
2607 const char * _exceptionMessage = NULL;
2608 jintArray _array = (jintArray) 0;
2609 jint _bufferOffset = (jint) 0;
2610 jint _remaining;
2611 GLfixed *m = (GLfixed *) 0;
2612
2613 if (!m_buf) {
2614 _exception = 1;
2615 _exceptionType = "java/lang/IllegalArgumentException";
2616 _exceptionMessage = "m == null";
2617 goto exit;
2618 }
2619 m = (GLfixed *)getPointer(_env, m_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2620 if (m == NULL) {
2621 char * _mBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
2622 m = (GLfixed *) (_mBase + _bufferOffset);
2623 }
2624 glMultMatrixx(
2625 (GLfixed *)m
2626 );
2627
2628 exit:
2629 if (_array) {
2630 _env->ReleaseIntArrayElements(_array, (jint*)m, JNI_ABORT);
2631 }
2632 if (_exception) {
2633 jniThrowException(_env, _exceptionType, _exceptionMessage);
2634 }
2635 }
2636
2637 /* void glMultiTexCoord4f ( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q ) */
2638 static void
android_glMultiTexCoord4f__IFFFF(JNIEnv * _env,jobject _this,jint target,jfloat s,jfloat t,jfloat r,jfloat q)2639 android_glMultiTexCoord4f__IFFFF
2640 (JNIEnv *_env, jobject _this, jint target, jfloat s, jfloat t, jfloat r, jfloat q) {
2641 glMultiTexCoord4f(
2642 (GLenum)target,
2643 (GLfloat)s,
2644 (GLfloat)t,
2645 (GLfloat)r,
2646 (GLfloat)q
2647 );
2648 }
2649
2650 /* void glMultiTexCoord4x ( GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q ) */
2651 static void
android_glMultiTexCoord4x__IIIII(JNIEnv * _env,jobject _this,jint target,jint s,jint t,jint r,jint q)2652 android_glMultiTexCoord4x__IIIII
2653 (JNIEnv *_env, jobject _this, jint target, jint s, jint t, jint r, jint q) {
2654 glMultiTexCoord4x(
2655 (GLenum)target,
2656 (GLfixed)s,
2657 (GLfixed)t,
2658 (GLfixed)r,
2659 (GLfixed)q
2660 );
2661 }
2662
2663 /* void glNormal3f ( GLfloat nx, GLfloat ny, GLfloat nz ) */
2664 static void
android_glNormal3f__FFF(JNIEnv * _env,jobject _this,jfloat nx,jfloat ny,jfloat nz)2665 android_glNormal3f__FFF
2666 (JNIEnv *_env, jobject _this, jfloat nx, jfloat ny, jfloat nz) {
2667 glNormal3f(
2668 (GLfloat)nx,
2669 (GLfloat)ny,
2670 (GLfloat)nz
2671 );
2672 }
2673
2674 /* void glNormal3x ( GLfixed nx, GLfixed ny, GLfixed nz ) */
2675 static void
android_glNormal3x__III(JNIEnv * _env,jobject _this,jint nx,jint ny,jint nz)2676 android_glNormal3x__III
2677 (JNIEnv *_env, jobject _this, jint nx, jint ny, jint nz) {
2678 glNormal3x(
2679 (GLfixed)nx,
2680 (GLfixed)ny,
2681 (GLfixed)nz
2682 );
2683 }
2684
2685 /* void glNormalPointer ( GLenum type, GLsizei stride, const GLvoid *pointer ) */
2686 static void
android_glNormalPointerBounds__IILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint type,jint stride,jobject pointer_buf,jint remaining)2687 android_glNormalPointerBounds__IILjava_nio_Buffer_2I
2688 (JNIEnv *_env, jobject _this, jint type, jint stride, jobject pointer_buf, jint remaining) {
2689 jint _exception = 0;
2690 const char * _exceptionType = NULL;
2691 const char * _exceptionMessage = NULL;
2692 jarray _array = (jarray) 0;
2693 jint _bufferOffset = (jint) 0;
2694 jint _remaining;
2695 GLvoid *pointer = (GLvoid *) 0;
2696
2697 if (pointer_buf) {
2698 pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
2699 if ( ! pointer ) {
2700 return;
2701 }
2702 }
2703 glNormalPointerBounds(
2704 (GLenum)type,
2705 (GLsizei)stride,
2706 (GLvoid *)pointer,
2707 (GLsizei)remaining
2708 );
2709 if (_exception) {
2710 jniThrowException(_env, _exceptionType, _exceptionMessage);
2711 }
2712 }
2713
2714 /* void glOrthof ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */
2715 static void
android_glOrthof__FFFFFF(JNIEnv * _env,jobject _this,jfloat left,jfloat right,jfloat bottom,jfloat top,jfloat zNear,jfloat zFar)2716 android_glOrthof__FFFFFF
2717 (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) {
2718 glOrthof(
2719 (GLfloat)left,
2720 (GLfloat)right,
2721 (GLfloat)bottom,
2722 (GLfloat)top,
2723 (GLfloat)zNear,
2724 (GLfloat)zFar
2725 );
2726 }
2727
2728 /* void glOrthox ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */
2729 static void
android_glOrthox__IIIIII(JNIEnv * _env,jobject _this,jint left,jint right,jint bottom,jint top,jint zNear,jint zFar)2730 android_glOrthox__IIIIII
2731 (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) {
2732 glOrthox(
2733 (GLfixed)left,
2734 (GLfixed)right,
2735 (GLfixed)bottom,
2736 (GLfixed)top,
2737 (GLfixed)zNear,
2738 (GLfixed)zFar
2739 );
2740 }
2741
2742 /* void glPixelStorei ( GLenum pname, GLint param ) */
2743 static void
android_glPixelStorei__II(JNIEnv * _env,jobject _this,jint pname,jint param)2744 android_glPixelStorei__II
2745 (JNIEnv *_env, jobject _this, jint pname, jint param) {
2746 glPixelStorei(
2747 (GLenum)pname,
2748 (GLint)param
2749 );
2750 }
2751
2752 /* void glPointSize ( GLfloat size ) */
2753 static void
android_glPointSize__F(JNIEnv * _env,jobject _this,jfloat size)2754 android_glPointSize__F
2755 (JNIEnv *_env, jobject _this, jfloat size) {
2756 glPointSize(
2757 (GLfloat)size
2758 );
2759 }
2760
2761 /* void glPointSizex ( GLfixed size ) */
2762 static void
android_glPointSizex__I(JNIEnv * _env,jobject _this,jint size)2763 android_glPointSizex__I
2764 (JNIEnv *_env, jobject _this, jint size) {
2765 glPointSizex(
2766 (GLfixed)size
2767 );
2768 }
2769
2770 /* void glPolygonOffset ( GLfloat factor, GLfloat units ) */
2771 static void
android_glPolygonOffset__FF(JNIEnv * _env,jobject _this,jfloat factor,jfloat units)2772 android_glPolygonOffset__FF
2773 (JNIEnv *_env, jobject _this, jfloat factor, jfloat units) {
2774 glPolygonOffset(
2775 (GLfloat)factor,
2776 (GLfloat)units
2777 );
2778 }
2779
2780 /* void glPolygonOffsetx ( GLfixed factor, GLfixed units ) */
2781 static void
android_glPolygonOffsetx__II(JNIEnv * _env,jobject _this,jint factor,jint units)2782 android_glPolygonOffsetx__II
2783 (JNIEnv *_env, jobject _this, jint factor, jint units) {
2784 glPolygonOffsetx(
2785 (GLfixed)factor,
2786 (GLfixed)units
2787 );
2788 }
2789
2790 /* void glPopMatrix ( void ) */
2791 static void
android_glPopMatrix__(JNIEnv * _env,jobject _this)2792 android_glPopMatrix__
2793 (JNIEnv *_env, jobject _this) {
2794 glPopMatrix();
2795 }
2796
2797 /* void glPushMatrix ( void ) */
2798 static void
android_glPushMatrix__(JNIEnv * _env,jobject _this)2799 android_glPushMatrix__
2800 (JNIEnv *_env, jobject _this) {
2801 glPushMatrix();
2802 }
2803
2804 /* void glReadPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) */
2805 static void
android_glReadPixels__IIIIIILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint x,jint y,jint width,jint height,jint format,jint type,jobject pixels_buf)2806 android_glReadPixels__IIIIIILjava_nio_Buffer_2
2807 (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height, jint format, jint type, jobject pixels_buf) {
2808 jint _exception = 0;
2809 const char * _exceptionType = NULL;
2810 const char * _exceptionMessage = NULL;
2811 jarray _array = (jarray) 0;
2812 jint _bufferOffset = (jint) 0;
2813 jint _remaining;
2814 GLvoid *pixels = (GLvoid *) 0;
2815
2816 if (!pixels_buf) {
2817 _exception = 1;
2818 _exceptionType = "java/lang/IllegalArgumentException";
2819 _exceptionMessage = "pixels == null";
2820 goto exit;
2821 }
2822 pixels = (GLvoid *)getPointer(_env, pixels_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
2823 if (pixels == NULL) {
2824 char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
2825 pixels = (GLvoid *) (_pixelsBase + _bufferOffset);
2826 }
2827 glReadPixels(
2828 (GLint)x,
2829 (GLint)y,
2830 (GLsizei)width,
2831 (GLsizei)height,
2832 (GLenum)format,
2833 (GLenum)type,
2834 (GLvoid *)pixels
2835 );
2836
2837 exit:
2838 if (_array) {
2839 releasePointer(_env, _array, pixels, _exception ? JNI_FALSE : JNI_TRUE);
2840 }
2841 if (_exception) {
2842 jniThrowException(_env, _exceptionType, _exceptionMessage);
2843 }
2844 }
2845
2846 /* void glRotatef ( GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) */
2847 static void
android_glRotatef__FFFF(JNIEnv * _env,jobject _this,jfloat angle,jfloat x,jfloat y,jfloat z)2848 android_glRotatef__FFFF
2849 (JNIEnv *_env, jobject _this, jfloat angle, jfloat x, jfloat y, jfloat z) {
2850 glRotatef(
2851 (GLfloat)angle,
2852 (GLfloat)x,
2853 (GLfloat)y,
2854 (GLfloat)z
2855 );
2856 }
2857
2858 /* void glRotatex ( GLfixed angle, GLfixed x, GLfixed y, GLfixed z ) */
2859 static void
android_glRotatex__IIII(JNIEnv * _env,jobject _this,jint angle,jint x,jint y,jint z)2860 android_glRotatex__IIII
2861 (JNIEnv *_env, jobject _this, jint angle, jint x, jint y, jint z) {
2862 glRotatex(
2863 (GLfixed)angle,
2864 (GLfixed)x,
2865 (GLfixed)y,
2866 (GLfixed)z
2867 );
2868 }
2869
2870 /* void glSampleCoverage ( GLclampf value, GLboolean invert ) */
2871 static void
android_glSampleCoverage__FZ(JNIEnv * _env,jobject _this,jfloat value,jboolean invert)2872 android_glSampleCoverage__FZ
2873 (JNIEnv *_env, jobject _this, jfloat value, jboolean invert) {
2874 glSampleCoverage(
2875 (GLclampf)value,
2876 (GLboolean)invert
2877 );
2878 }
2879
2880 /* void glSampleCoveragex ( GLclampx value, GLboolean invert ) */
2881 static void
android_glSampleCoveragex__IZ(JNIEnv * _env,jobject _this,jint value,jboolean invert)2882 android_glSampleCoveragex__IZ
2883 (JNIEnv *_env, jobject _this, jint value, jboolean invert) {
2884 glSampleCoveragex(
2885 (GLclampx)value,
2886 (GLboolean)invert
2887 );
2888 }
2889
2890 /* void glScalef ( GLfloat x, GLfloat y, GLfloat z ) */
2891 static void
android_glScalef__FFF(JNIEnv * _env,jobject _this,jfloat x,jfloat y,jfloat z)2892 android_glScalef__FFF
2893 (JNIEnv *_env, jobject _this, jfloat x, jfloat y, jfloat z) {
2894 glScalef(
2895 (GLfloat)x,
2896 (GLfloat)y,
2897 (GLfloat)z
2898 );
2899 }
2900
2901 /* void glScalex ( GLfixed x, GLfixed y, GLfixed z ) */
2902 static void
android_glScalex__III(JNIEnv * _env,jobject _this,jint x,jint y,jint z)2903 android_glScalex__III
2904 (JNIEnv *_env, jobject _this, jint x, jint y, jint z) {
2905 glScalex(
2906 (GLfixed)x,
2907 (GLfixed)y,
2908 (GLfixed)z
2909 );
2910 }
2911
2912 /* void glScissor ( GLint x, GLint y, GLsizei width, GLsizei height ) */
2913 static void
android_glScissor__IIII(JNIEnv * _env,jobject _this,jint x,jint y,jint width,jint height)2914 android_glScissor__IIII
2915 (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height) {
2916 glScissor(
2917 (GLint)x,
2918 (GLint)y,
2919 (GLsizei)width,
2920 (GLsizei)height
2921 );
2922 }
2923
2924 /* void glShadeModel ( GLenum mode ) */
2925 static void
android_glShadeModel__I(JNIEnv * _env,jobject _this,jint mode)2926 android_glShadeModel__I
2927 (JNIEnv *_env, jobject _this, jint mode) {
2928 glShadeModel(
2929 (GLenum)mode
2930 );
2931 }
2932
2933 /* void glStencilFunc ( GLenum func, GLint ref, GLuint mask ) */
2934 static void
android_glStencilFunc__III(JNIEnv * _env,jobject _this,jint func,jint ref,jint mask)2935 android_glStencilFunc__III
2936 (JNIEnv *_env, jobject _this, jint func, jint ref, jint mask) {
2937 glStencilFunc(
2938 (GLenum)func,
2939 (GLint)ref,
2940 (GLuint)mask
2941 );
2942 }
2943
2944 /* void glStencilMask ( GLuint mask ) */
2945 static void
android_glStencilMask__I(JNIEnv * _env,jobject _this,jint mask)2946 android_glStencilMask__I
2947 (JNIEnv *_env, jobject _this, jint mask) {
2948 glStencilMask(
2949 (GLuint)mask
2950 );
2951 }
2952
2953 /* void glStencilOp ( GLenum fail, GLenum zfail, GLenum zpass ) */
2954 static void
android_glStencilOp__III(JNIEnv * _env,jobject _this,jint fail,jint zfail,jint zpass)2955 android_glStencilOp__III
2956 (JNIEnv *_env, jobject _this, jint fail, jint zfail, jint zpass) {
2957 glStencilOp(
2958 (GLenum)fail,
2959 (GLenum)zfail,
2960 (GLenum)zpass
2961 );
2962 }
2963
2964 /* void glTexCoordPointer ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
2965 static void
android_glTexCoordPointerBounds__IIILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint size,jint type,jint stride,jobject pointer_buf,jint remaining)2966 android_glTexCoordPointerBounds__IIILjava_nio_Buffer_2I
2967 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
2968 jint _exception = 0;
2969 const char * _exceptionType = NULL;
2970 const char * _exceptionMessage = NULL;
2971 jarray _array = (jarray) 0;
2972 jint _bufferOffset = (jint) 0;
2973 jint _remaining;
2974 GLvoid *pointer = (GLvoid *) 0;
2975
2976 if (pointer_buf) {
2977 pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
2978 if ( ! pointer ) {
2979 return;
2980 }
2981 }
2982 glTexCoordPointerBounds(
2983 (GLint)size,
2984 (GLenum)type,
2985 (GLsizei)stride,
2986 (GLvoid *)pointer,
2987 (GLsizei)remaining
2988 );
2989 if (_exception) {
2990 jniThrowException(_env, _exceptionType, _exceptionMessage);
2991 }
2992 }
2993
2994 /* void glTexEnvf ( GLenum target, GLenum pname, GLfloat param ) */
2995 static void
android_glTexEnvf__IIF(JNIEnv * _env,jobject _this,jint target,jint pname,jfloat param)2996 android_glTexEnvf__IIF
2997 (JNIEnv *_env, jobject _this, jint target, jint pname, jfloat param) {
2998 glTexEnvf(
2999 (GLenum)target,
3000 (GLenum)pname,
3001 (GLfloat)param
3002 );
3003 }
3004
3005 /* void glTexEnvfv ( GLenum target, GLenum pname, const GLfloat *params ) */
3006 static void
android_glTexEnvfv__II_3FI(JNIEnv * _env,jobject _this,jint target,jint pname,jfloatArray params_ref,jint offset)3007 android_glTexEnvfv__II_3FI
3008 (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) {
3009 jint _exception = 0;
3010 const char * _exceptionType = NULL;
3011 const char * _exceptionMessage = NULL;
3012 GLfloat *params_base = (GLfloat *) 0;
3013 jint _remaining;
3014 GLfloat *params = (GLfloat *) 0;
3015
3016 if (!params_ref) {
3017 _exception = 1;
3018 _exceptionType = "java/lang/IllegalArgumentException";
3019 _exceptionMessage = "params == null";
3020 goto exit;
3021 }
3022 if (offset < 0) {
3023 _exception = 1;
3024 _exceptionType = "java/lang/IllegalArgumentException";
3025 _exceptionMessage = "offset < 0";
3026 goto exit;
3027 }
3028 _remaining = _env->GetArrayLength(params_ref) - offset;
3029 int _needed;
3030 switch (pname) {
3031 #if defined(GL_TEXTURE_ENV_COLOR)
3032 case GL_TEXTURE_ENV_COLOR:
3033 #endif // defined(GL_TEXTURE_ENV_COLOR)
3034 _needed = 4;
3035 break;
3036 default:
3037 _needed = 1;
3038 break;
3039 }
3040 if (_remaining < _needed) {
3041 _exception = 1;
3042 _exceptionType = "java/lang/IllegalArgumentException";
3043 _exceptionMessage = "length - offset < needed";
3044 goto exit;
3045 }
3046 params_base = (GLfloat *)
3047 _env->GetFloatArrayElements(params_ref, (jboolean *)0);
3048 params = params_base + offset;
3049
3050 glTexEnvfv(
3051 (GLenum)target,
3052 (GLenum)pname,
3053 (GLfloat *)params
3054 );
3055
3056 exit:
3057 if (params_base) {
3058 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base,
3059 JNI_ABORT);
3060 }
3061 if (_exception) {
3062 jniThrowException(_env, _exceptionType, _exceptionMessage);
3063 }
3064 }
3065
3066 /* void glTexEnvfv ( GLenum target, GLenum pname, const GLfloat *params ) */
3067 static void
android_glTexEnvfv__IILjava_nio_FloatBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)3068 android_glTexEnvfv__IILjava_nio_FloatBuffer_2
3069 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
3070 jint _exception = 0;
3071 const char * _exceptionType = NULL;
3072 const char * _exceptionMessage = NULL;
3073 jfloatArray _array = (jfloatArray) 0;
3074 jint _bufferOffset = (jint) 0;
3075 jint _remaining;
3076 GLfloat *params = (GLfloat *) 0;
3077
3078 if (!params_buf) {
3079 _exception = 1;
3080 _exceptionType = "java/lang/IllegalArgumentException";
3081 _exceptionMessage = "params == null";
3082 goto exit;
3083 }
3084 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
3085 int _needed;
3086 switch (pname) {
3087 #if defined(GL_TEXTURE_ENV_COLOR)
3088 case GL_TEXTURE_ENV_COLOR:
3089 #endif // defined(GL_TEXTURE_ENV_COLOR)
3090 _needed = 4;
3091 break;
3092 default:
3093 _needed = 1;
3094 break;
3095 }
3096 if (_remaining < _needed) {
3097 _exception = 1;
3098 _exceptionType = "java/lang/IllegalArgumentException";
3099 _exceptionMessage = "remaining() < needed";
3100 goto exit;
3101 }
3102 if (params == NULL) {
3103 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0);
3104 params = (GLfloat *) (_paramsBase + _bufferOffset);
3105 }
3106 glTexEnvfv(
3107 (GLenum)target,
3108 (GLenum)pname,
3109 (GLfloat *)params
3110 );
3111
3112 exit:
3113 if (_array) {
3114 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT);
3115 }
3116 if (_exception) {
3117 jniThrowException(_env, _exceptionType, _exceptionMessage);
3118 }
3119 }
3120
3121 /* void glTexEnvx ( GLenum target, GLenum pname, GLfixed param ) */
3122 static void
android_glTexEnvx__III(JNIEnv * _env,jobject _this,jint target,jint pname,jint param)3123 android_glTexEnvx__III
3124 (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) {
3125 glTexEnvx(
3126 (GLenum)target,
3127 (GLenum)pname,
3128 (GLfixed)param
3129 );
3130 }
3131
3132 /* void glTexEnvxv ( GLenum target, GLenum pname, const GLfixed *params ) */
3133 static void
android_glTexEnvxv__II_3II(JNIEnv * _env,jobject _this,jint target,jint pname,jintArray params_ref,jint offset)3134 android_glTexEnvxv__II_3II
3135 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
3136 jint _exception = 0;
3137 const char * _exceptionType = NULL;
3138 const char * _exceptionMessage = NULL;
3139 GLfixed *params_base = (GLfixed *) 0;
3140 jint _remaining;
3141 GLfixed *params = (GLfixed *) 0;
3142
3143 if (!params_ref) {
3144 _exception = 1;
3145 _exceptionType = "java/lang/IllegalArgumentException";
3146 _exceptionMessage = "params == null";
3147 goto exit;
3148 }
3149 if (offset < 0) {
3150 _exception = 1;
3151 _exceptionType = "java/lang/IllegalArgumentException";
3152 _exceptionMessage = "offset < 0";
3153 goto exit;
3154 }
3155 _remaining = _env->GetArrayLength(params_ref) - offset;
3156 int _needed;
3157 switch (pname) {
3158 #if defined(GL_TEXTURE_ENV_COLOR)
3159 case GL_TEXTURE_ENV_COLOR:
3160 #endif // defined(GL_TEXTURE_ENV_COLOR)
3161 _needed = 4;
3162 break;
3163 default:
3164 _needed = 1;
3165 break;
3166 }
3167 if (_remaining < _needed) {
3168 _exception = 1;
3169 _exceptionType = "java/lang/IllegalArgumentException";
3170 _exceptionMessage = "length - offset < needed";
3171 goto exit;
3172 }
3173 params_base = (GLfixed *)
3174 _env->GetIntArrayElements(params_ref, (jboolean *)0);
3175 params = params_base + offset;
3176
3177 glTexEnvxv(
3178 (GLenum)target,
3179 (GLenum)pname,
3180 (GLfixed *)params
3181 );
3182
3183 exit:
3184 if (params_base) {
3185 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base,
3186 JNI_ABORT);
3187 }
3188 if (_exception) {
3189 jniThrowException(_env, _exceptionType, _exceptionMessage);
3190 }
3191 }
3192
3193 /* void glTexEnvxv ( GLenum target, GLenum pname, const GLfixed *params ) */
3194 static void
android_glTexEnvxv__IILjava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jint target,jint pname,jobject params_buf)3195 android_glTexEnvxv__IILjava_nio_IntBuffer_2
3196 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
3197 jint _exception = 0;
3198 const char * _exceptionType = NULL;
3199 const char * _exceptionMessage = NULL;
3200 jintArray _array = (jintArray) 0;
3201 jint _bufferOffset = (jint) 0;
3202 jint _remaining;
3203 GLfixed *params = (GLfixed *) 0;
3204
3205 if (!params_buf) {
3206 _exception = 1;
3207 _exceptionType = "java/lang/IllegalArgumentException";
3208 _exceptionMessage = "params == null";
3209 goto exit;
3210 }
3211 params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
3212 int _needed;
3213 switch (pname) {
3214 #if defined(GL_TEXTURE_ENV_COLOR)
3215 case GL_TEXTURE_ENV_COLOR:
3216 #endif // defined(GL_TEXTURE_ENV_COLOR)
3217 _needed = 4;
3218 break;
3219 default:
3220 _needed = 1;
3221 break;
3222 }
3223 if (_remaining < _needed) {
3224 _exception = 1;
3225 _exceptionType = "java/lang/IllegalArgumentException";
3226 _exceptionMessage = "remaining() < needed";
3227 goto exit;
3228 }
3229 if (params == NULL) {
3230 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0);
3231 params = (GLfixed *) (_paramsBase + _bufferOffset);
3232 }
3233 glTexEnvxv(
3234 (GLenum)target,
3235 (GLenum)pname,
3236 (GLfixed *)params
3237 );
3238
3239 exit:
3240 if (_array) {
3241 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT);
3242 }
3243 if (_exception) {
3244 jniThrowException(_env, _exceptionType, _exceptionMessage);
3245 }
3246 }
3247
3248 /* void glTexImage2D ( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) */
3249 static void
android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint target,jint level,jint internalformat,jint width,jint height,jint border,jint format,jint type,jobject pixels_buf)3250 android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2
3251 (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint format, jint type, jobject pixels_buf) {
3252 jint _exception = 0;
3253 const char * _exceptionType = NULL;
3254 const char * _exceptionMessage = NULL;
3255 jarray _array = (jarray) 0;
3256 jint _bufferOffset = (jint) 0;
3257 jint _remaining;
3258 GLvoid *pixels = (GLvoid *) 0;
3259
3260 if (pixels_buf) {
3261 pixels = (GLvoid *)getPointer(_env, pixels_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
3262 }
3263 if (pixels_buf && pixels == NULL) {
3264 char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3265 pixels = (GLvoid *) (_pixelsBase + _bufferOffset);
3266 }
3267 glTexImage2D(
3268 (GLenum)target,
3269 (GLint)level,
3270 (GLint)internalformat,
3271 (GLsizei)width,
3272 (GLsizei)height,
3273 (GLint)border,
3274 (GLenum)format,
3275 (GLenum)type,
3276 (GLvoid *)pixels
3277 );
3278 if (_array) {
3279 releasePointer(_env, _array, pixels, JNI_FALSE);
3280 }
3281 if (_exception) {
3282 jniThrowException(_env, _exceptionType, _exceptionMessage);
3283 }
3284 }
3285
3286 /* void glTexParameterf ( GLenum target, GLenum pname, GLfloat param ) */
3287 static void
android_glTexParameterf__IIF(JNIEnv * _env,jobject _this,jint target,jint pname,jfloat param)3288 android_glTexParameterf__IIF
3289 (JNIEnv *_env, jobject _this, jint target, jint pname, jfloat param) {
3290 glTexParameterf(
3291 (GLenum)target,
3292 (GLenum)pname,
3293 (GLfloat)param
3294 );
3295 }
3296
3297 /* void glTexParameterx ( GLenum target, GLenum pname, GLfixed param ) */
3298 static void
android_glTexParameterx__III(JNIEnv * _env,jobject _this,jint target,jint pname,jint param)3299 android_glTexParameterx__III
3300 (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) {
3301 glTexParameterx(
3302 (GLenum)target,
3303 (GLenum)pname,
3304 (GLfixed)param
3305 );
3306 }
3307
3308 /* void glTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels ) */
3309 static void
android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2(JNIEnv * _env,jobject _this,jint target,jint level,jint xoffset,jint yoffset,jint width,jint height,jint format,jint type,jobject pixels_buf)3310 android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2
3311 (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint type, jobject pixels_buf) {
3312 jint _exception = 0;
3313 const char * _exceptionType = NULL;
3314 const char * _exceptionMessage = NULL;
3315 jarray _array = (jarray) 0;
3316 jint _bufferOffset = (jint) 0;
3317 jint _remaining;
3318 GLvoid *pixels = (GLvoid *) 0;
3319
3320 if (pixels_buf) {
3321 pixels = (GLvoid *)getPointer(_env, pixels_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
3322 }
3323 if (pixels_buf && pixels == NULL) {
3324 char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
3325 pixels = (GLvoid *) (_pixelsBase + _bufferOffset);
3326 }
3327 glTexSubImage2D(
3328 (GLenum)target,
3329 (GLint)level,
3330 (GLint)xoffset,
3331 (GLint)yoffset,
3332 (GLsizei)width,
3333 (GLsizei)height,
3334 (GLenum)format,
3335 (GLenum)type,
3336 (GLvoid *)pixels
3337 );
3338 if (_array) {
3339 releasePointer(_env, _array, pixels, JNI_FALSE);
3340 }
3341 if (_exception) {
3342 jniThrowException(_env, _exceptionType, _exceptionMessage);
3343 }
3344 }
3345
3346 /* void glTranslatef ( GLfloat x, GLfloat y, GLfloat z ) */
3347 static void
android_glTranslatef__FFF(JNIEnv * _env,jobject _this,jfloat x,jfloat y,jfloat z)3348 android_glTranslatef__FFF
3349 (JNIEnv *_env, jobject _this, jfloat x, jfloat y, jfloat z) {
3350 glTranslatef(
3351 (GLfloat)x,
3352 (GLfloat)y,
3353 (GLfloat)z
3354 );
3355 }
3356
3357 /* void glTranslatex ( GLfixed x, GLfixed y, GLfixed z ) */
3358 static void
android_glTranslatex__III(JNIEnv * _env,jobject _this,jint x,jint y,jint z)3359 android_glTranslatex__III
3360 (JNIEnv *_env, jobject _this, jint x, jint y, jint z) {
3361 glTranslatex(
3362 (GLfixed)x,
3363 (GLfixed)y,
3364 (GLfixed)z
3365 );
3366 }
3367
3368 /* void glVertexPointer ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */
3369 static void
android_glVertexPointerBounds__IIILjava_nio_Buffer_2I(JNIEnv * _env,jobject _this,jint size,jint type,jint stride,jobject pointer_buf,jint remaining)3370 android_glVertexPointerBounds__IIILjava_nio_Buffer_2I
3371 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) {
3372 jint _exception = 0;
3373 const char * _exceptionType = NULL;
3374 const char * _exceptionMessage = NULL;
3375 jarray _array = (jarray) 0;
3376 jint _bufferOffset = (jint) 0;
3377 jint _remaining;
3378 GLvoid *pointer = (GLvoid *) 0;
3379
3380 if (pointer_buf) {
3381 pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf);
3382 if ( ! pointer ) {
3383 return;
3384 }
3385 }
3386 glVertexPointerBounds(
3387 (GLint)size,
3388 (GLenum)type,
3389 (GLsizei)stride,
3390 (GLvoid *)pointer,
3391 (GLsizei)remaining
3392 );
3393 if (_exception) {
3394 jniThrowException(_env, _exceptionType, _exceptionMessage);
3395 }
3396 }
3397
3398 /* void glViewport ( GLint x, GLint y, GLsizei width, GLsizei height ) */
3399 static void
android_glViewport__IIII(JNIEnv * _env,jobject _this,jint x,jint y,jint width,jint height)3400 android_glViewport__IIII
3401 (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height) {
3402 glViewport(
3403 (GLint)x,
3404 (GLint)y,
3405 (GLsizei)width,
3406 (GLsizei)height
3407 );
3408 }
3409
3410 static const char *classPathName = "android/opengl/GLES10";
3411
3412 static const JNINativeMethod methods[] = {
3413 {"_nativeClassInit", "()V", (void*)nativeClassInit },
3414 {"glActiveTexture", "(I)V", (void *) android_glActiveTexture__I },
3415 {"glAlphaFunc", "(IF)V", (void *) android_glAlphaFunc__IF },
3416 {"glAlphaFuncx", "(II)V", (void *) android_glAlphaFuncx__II },
3417 {"glBindTexture", "(II)V", (void *) android_glBindTexture__II },
3418 {"glBlendFunc", "(II)V", (void *) android_glBlendFunc__II },
3419 {"glClear", "(I)V", (void *) android_glClear__I },
3420 {"glClearColor", "(FFFF)V", (void *) android_glClearColor__FFFF },
3421 {"glClearColorx", "(IIII)V", (void *) android_glClearColorx__IIII },
3422 {"glClearDepthf", "(F)V", (void *) android_glClearDepthf__F },
3423 {"glClearDepthx", "(I)V", (void *) android_glClearDepthx__I },
3424 {"glClearStencil", "(I)V", (void *) android_glClearStencil__I },
3425 {"glClientActiveTexture", "(I)V", (void *) android_glClientActiveTexture__I },
3426 {"glColor4f", "(FFFF)V", (void *) android_glColor4f__FFFF },
3427 {"glColor4x", "(IIII)V", (void *) android_glColor4x__IIII },
3428 {"glColorMask", "(ZZZZ)V", (void *) android_glColorMask__ZZZZ },
3429 {"glColorPointerBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glColorPointerBounds__IIILjava_nio_Buffer_2I },
3430 {"glCompressedTexImage2D", "(IIIIIIILjava/nio/Buffer;)V", (void *) android_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2 },
3431 {"glCompressedTexSubImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 },
3432 {"glCopyTexImage2D", "(IIIIIIII)V", (void *) android_glCopyTexImage2D__IIIIIIII },
3433 {"glCopyTexSubImage2D", "(IIIIIIII)V", (void *) android_glCopyTexSubImage2D__IIIIIIII },
3434 {"glCullFace", "(I)V", (void *) android_glCullFace__I },
3435 {"glDeleteTextures", "(I[II)V", (void *) android_glDeleteTextures__I_3II },
3436 {"glDeleteTextures", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteTextures__ILjava_nio_IntBuffer_2 },
3437 {"glDepthFunc", "(I)V", (void *) android_glDepthFunc__I },
3438 {"glDepthMask", "(Z)V", (void *) android_glDepthMask__Z },
3439 {"glDepthRangef", "(FF)V", (void *) android_glDepthRangef__FF },
3440 {"glDepthRangex", "(II)V", (void *) android_glDepthRangex__II },
3441 {"glDisable", "(I)V", (void *) android_glDisable__I },
3442 {"glDisableClientState", "(I)V", (void *) android_glDisableClientState__I },
3443 {"glDrawArrays", "(III)V", (void *) android_glDrawArrays__III },
3444 {"glDrawElements", "(IIILjava/nio/Buffer;)V", (void *) android_glDrawElements__IIILjava_nio_Buffer_2 },
3445 {"glEnable", "(I)V", (void *) android_glEnable__I },
3446 {"glEnableClientState", "(I)V", (void *) android_glEnableClientState__I },
3447 {"glFinish", "()V", (void *) android_glFinish__ },
3448 {"glFlush", "()V", (void *) android_glFlush__ },
3449 {"glFogf", "(IF)V", (void *) android_glFogf__IF },
3450 {"glFogfv", "(I[FI)V", (void *) android_glFogfv__I_3FI },
3451 {"glFogfv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glFogfv__ILjava_nio_FloatBuffer_2 },
3452 {"glFogx", "(II)V", (void *) android_glFogx__II },
3453 {"glFogxv", "(I[II)V", (void *) android_glFogxv__I_3II },
3454 {"glFogxv", "(ILjava/nio/IntBuffer;)V", (void *) android_glFogxv__ILjava_nio_IntBuffer_2 },
3455 {"glFrontFace", "(I)V", (void *) android_glFrontFace__I },
3456 {"glFrustumf", "(FFFFFF)V", (void *) android_glFrustumf__FFFFFF },
3457 {"glFrustumx", "(IIIIII)V", (void *) android_glFrustumx__IIIIII },
3458 {"glGenTextures", "(I[II)V", (void *) android_glGenTextures__I_3II },
3459 {"glGenTextures", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenTextures__ILjava_nio_IntBuffer_2 },
3460 {"glGetError", "()I", (void *) android_glGetError__ },
3461 {"glGetIntegerv", "(I[II)V", (void *) android_glGetIntegerv__I_3II },
3462 {"glGetIntegerv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetIntegerv__ILjava_nio_IntBuffer_2 },
3463 {"glGetString", "(I)Ljava/lang/String;", (void *) android_glGetString },
3464 {"glHint", "(II)V", (void *) android_glHint__II },
3465 {"glLightModelf", "(IF)V", (void *) android_glLightModelf__IF },
3466 {"glLightModelfv", "(I[FI)V", (void *) android_glLightModelfv__I_3FI },
3467 {"glLightModelfv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glLightModelfv__ILjava_nio_FloatBuffer_2 },
3468 {"glLightModelx", "(II)V", (void *) android_glLightModelx__II },
3469 {"glLightModelxv", "(I[II)V", (void *) android_glLightModelxv__I_3II },
3470 {"glLightModelxv", "(ILjava/nio/IntBuffer;)V", (void *) android_glLightModelxv__ILjava_nio_IntBuffer_2 },
3471 {"glLightf", "(IIF)V", (void *) android_glLightf__IIF },
3472 {"glLightfv", "(II[FI)V", (void *) android_glLightfv__II_3FI },
3473 {"glLightfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glLightfv__IILjava_nio_FloatBuffer_2 },
3474 {"glLightx", "(III)V", (void *) android_glLightx__III },
3475 {"glLightxv", "(II[II)V", (void *) android_glLightxv__II_3II },
3476 {"glLightxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glLightxv__IILjava_nio_IntBuffer_2 },
3477 {"glLineWidth", "(F)V", (void *) android_glLineWidth__F },
3478 {"glLineWidthx", "(I)V", (void *) android_glLineWidthx__I },
3479 {"glLoadIdentity", "()V", (void *) android_glLoadIdentity__ },
3480 {"glLoadMatrixf", "([FI)V", (void *) android_glLoadMatrixf___3FI },
3481 {"glLoadMatrixf", "(Ljava/nio/FloatBuffer;)V", (void *) android_glLoadMatrixf__Ljava_nio_FloatBuffer_2 },
3482 {"glLoadMatrixx", "([II)V", (void *) android_glLoadMatrixx___3II },
3483 {"glLoadMatrixx", "(Ljava/nio/IntBuffer;)V", (void *) android_glLoadMatrixx__Ljava_nio_IntBuffer_2 },
3484 {"glLogicOp", "(I)V", (void *) android_glLogicOp__I },
3485 {"glMaterialf", "(IIF)V", (void *) android_glMaterialf__IIF },
3486 {"glMaterialfv", "(II[FI)V", (void *) android_glMaterialfv__II_3FI },
3487 {"glMaterialfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glMaterialfv__IILjava_nio_FloatBuffer_2 },
3488 {"glMaterialx", "(III)V", (void *) android_glMaterialx__III },
3489 {"glMaterialxv", "(II[II)V", (void *) android_glMaterialxv__II_3II },
3490 {"glMaterialxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glMaterialxv__IILjava_nio_IntBuffer_2 },
3491 {"glMatrixMode", "(I)V", (void *) android_glMatrixMode__I },
3492 {"glMultMatrixf", "([FI)V", (void *) android_glMultMatrixf___3FI },
3493 {"glMultMatrixf", "(Ljava/nio/FloatBuffer;)V", (void *) android_glMultMatrixf__Ljava_nio_FloatBuffer_2 },
3494 {"glMultMatrixx", "([II)V", (void *) android_glMultMatrixx___3II },
3495 {"glMultMatrixx", "(Ljava/nio/IntBuffer;)V", (void *) android_glMultMatrixx__Ljava_nio_IntBuffer_2 },
3496 {"glMultiTexCoord4f", "(IFFFF)V", (void *) android_glMultiTexCoord4f__IFFFF },
3497 {"glMultiTexCoord4x", "(IIIII)V", (void *) android_glMultiTexCoord4x__IIIII },
3498 {"glNormal3f", "(FFF)V", (void *) android_glNormal3f__FFF },
3499 {"glNormal3x", "(III)V", (void *) android_glNormal3x__III },
3500 {"glNormalPointerBounds", "(IILjava/nio/Buffer;I)V", (void *) android_glNormalPointerBounds__IILjava_nio_Buffer_2I },
3501 {"glOrthof", "(FFFFFF)V", (void *) android_glOrthof__FFFFFF },
3502 {"glOrthox", "(IIIIII)V", (void *) android_glOrthox__IIIIII },
3503 {"glPixelStorei", "(II)V", (void *) android_glPixelStorei__II },
3504 {"glPointSize", "(F)V", (void *) android_glPointSize__F },
3505 {"glPointSizex", "(I)V", (void *) android_glPointSizex__I },
3506 {"glPolygonOffset", "(FF)V", (void *) android_glPolygonOffset__FF },
3507 {"glPolygonOffsetx", "(II)V", (void *) android_glPolygonOffsetx__II },
3508 {"glPopMatrix", "()V", (void *) android_glPopMatrix__ },
3509 {"glPushMatrix", "()V", (void *) android_glPushMatrix__ },
3510 {"glReadPixels", "(IIIIIILjava/nio/Buffer;)V", (void *) android_glReadPixels__IIIIIILjava_nio_Buffer_2 },
3511 {"glRotatef", "(FFFF)V", (void *) android_glRotatef__FFFF },
3512 {"glRotatex", "(IIII)V", (void *) android_glRotatex__IIII },
3513 {"glSampleCoverage", "(FZ)V", (void *) android_glSampleCoverage__FZ },
3514 {"glSampleCoveragex", "(IZ)V", (void *) android_glSampleCoveragex__IZ },
3515 {"glScalef", "(FFF)V", (void *) android_glScalef__FFF },
3516 {"glScalex", "(III)V", (void *) android_glScalex__III },
3517 {"glScissor", "(IIII)V", (void *) android_glScissor__IIII },
3518 {"glShadeModel", "(I)V", (void *) android_glShadeModel__I },
3519 {"glStencilFunc", "(III)V", (void *) android_glStencilFunc__III },
3520 {"glStencilMask", "(I)V", (void *) android_glStencilMask__I },
3521 {"glStencilOp", "(III)V", (void *) android_glStencilOp__III },
3522 {"glTexCoordPointerBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glTexCoordPointerBounds__IIILjava_nio_Buffer_2I },
3523 {"glTexEnvf", "(IIF)V", (void *) android_glTexEnvf__IIF },
3524 {"glTexEnvfv", "(II[FI)V", (void *) android_glTexEnvfv__II_3FI },
3525 {"glTexEnvfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexEnvfv__IILjava_nio_FloatBuffer_2 },
3526 {"glTexEnvx", "(III)V", (void *) android_glTexEnvx__III },
3527 {"glTexEnvxv", "(II[II)V", (void *) android_glTexEnvxv__II_3II },
3528 {"glTexEnvxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexEnvxv__IILjava_nio_IntBuffer_2 },
3529 {"glTexImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2 },
3530 {"glTexParameterf", "(IIF)V", (void *) android_glTexParameterf__IIF },
3531 {"glTexParameterx", "(III)V", (void *) android_glTexParameterx__III },
3532 {"glTexSubImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 },
3533 {"glTranslatef", "(FFF)V", (void *) android_glTranslatef__FFF },
3534 {"glTranslatex", "(III)V", (void *) android_glTranslatex__III },
3535 {"glVertexPointerBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glVertexPointerBounds__IIILjava_nio_Buffer_2I },
3536 {"glViewport", "(IIII)V", (void *) android_glViewport__IIII },
3537 };
3538
register_android_opengl_jni_GLES10(JNIEnv * _env)3539 int register_android_opengl_jni_GLES10(JNIEnv *_env)
3540 {
3541 int err;
3542 err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));
3543 return err;
3544 }
3545