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