1 /* //device/libs/android_runtime/com_google_android_gles_jni_GLImpl.cpp 2 ** 3 ** Copyright 2006, The Android Open Source Project 4 ** 5 ** Licensed under the Apache License, Version 2.0 (the "License"); 6 ** you may not use this file except in compliance with the License. 7 ** You may obtain a copy of the License at 8 ** 9 ** http://www.apache.org/licenses/LICENSE-2.0 10 ** 11 ** Unless required by applicable law or agreed to in writing, software 12 ** distributed under the License is distributed on an "AS IS" BASIS, 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 ** See the License for the specific language governing permissions and 15 ** limitations under the License. 16 */ 17 18 // This source file is automatically generated 19 20 #pragma GCC diagnostic ignored "-Wunused-variable" 21 #pragma GCC diagnostic ignored "-Wunused-but-set-variable" 22 #pragma GCC diagnostic ignored "-Wunused-function" 23 24 #include "jni.h" 25 #include <nativehelper/JNIHelp.h> 26 #include <android_runtime/AndroidRuntime.h> 27 #include <utils/misc.h> 28 29 #include <assert.h> 30 #include <GLES/gl.h> 31 #include <GLES/glext.h> 32 33 // Work around differences between the generated name and the actual name. 34 35 #define glBlendEquation glBlendEquationOES 36 #define glBlendEquationSeparate glBlendEquationSeparateOES 37 #define glBlendFuncSeparate glBlendFuncSeparateOES 38 #define glGetTexGenfv glGetTexGenfvOES 39 #define glGetTexGeniv glGetTexGenivOES 40 #define glGetTexGenxv glGetTexGenxvOES 41 #define glTexGenf glTexGenfOES 42 #define glTexGenfv glTexGenfvOES 43 #define glTexGeni glTexGeniOES 44 #define glTexGeniv glTexGenivOES 45 #define glTexGenx glTexGenxOES 46 #define glTexGenxv glTexGenxvOES 47 48 49 50 /* special calls implemented in Android's GLES wrapper used to more 51 * efficiently bound-check passed arrays */ 52 extern "C" { 53 GL_API void GL_APIENTRY glColorPointerBounds(GLint size, GLenum type, GLsizei stride, 54 const GLvoid *ptr, GLsizei count); 55 GL_API void GL_APIENTRY glNormalPointerBounds(GLenum type, GLsizei stride, 56 const GLvoid *pointer, GLsizei count); 57 GL_API void GL_APIENTRY glTexCoordPointerBounds(GLint size, GLenum type, 58 GLsizei stride, const GLvoid *pointer, GLsizei count); 59 GL_API void GL_APIENTRY glVertexPointerBounds(GLint size, GLenum type, 60 GLsizei stride, const GLvoid *pointer, GLsizei count); 61 GL_API void GL_APIENTRY glPointSizePointerOESBounds(GLenum type, 62 GLsizei stride, const GLvoid *pointer, GLsizei count); 63 GL_API void GL_APIENTRY glMatrixIndexPointerOESBounds(GLint size, GLenum type, 64 GLsizei stride, const GLvoid *pointer, GLsizei count); 65 GL_API void GL_APIENTRY glWeightPointerOESBounds(GLint size, GLenum type, 66 GLsizei stride, const GLvoid *pointer, GLsizei count); 67 } 68 69 static int initialized = 0; 70 71 static jclass nioAccessClass; 72 static jclass bufferClass; 73 static jclass G11ImplClass; 74 static jmethodID getBasePointerID; 75 static jmethodID getBaseArrayID; 76 static jmethodID getBaseArrayOffsetID; 77 static jmethodID allowIndirectBuffersID; 78 static jfieldID positionID; 79 static jfieldID limitID; 80 static jfieldID elementSizeShiftID; 81 static jfieldID haveCheckedExtensionsID; 82 static jfieldID have_OES_blend_equation_separateID; 83 static jfieldID have_OES_blend_subtractID; 84 static jfieldID have_OES_framebuffer_objectID; 85 static jfieldID have_OES_texture_cube_mapID; 86 87 /* Cache method IDs each time the class is loaded. */ 88 89 static void 90 nativeClassInit(JNIEnv *_env, jclass glImplClass) 91 { 92 jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess"); 93 nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal); 94 95 jclass bufferClassLocal = _env->FindClass("java/nio/Buffer"); 96 bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal); 97 98 jclass g11impClassLocal = _env->FindClass("com/google/android/gles_jni/GLImpl"); 99 G11ImplClass = (jclass) _env->NewGlobalRef(g11impClassLocal); 100 haveCheckedExtensionsID = _env->GetFieldID(G11ImplClass, "haveCheckedExtensions", "Z"); 101 have_OES_blend_equation_separateID = _env->GetFieldID(G11ImplClass, "have_OES_blend_equation_separate", "Z"); 102 have_OES_blend_subtractID = _env->GetFieldID(G11ImplClass, "have_OES_blend_subtract", "Z"); 103 have_OES_framebuffer_objectID = _env->GetFieldID(G11ImplClass, "have_OES_framebuffer_object", "Z"); 104 have_OES_texture_cube_mapID = _env->GetFieldID(G11ImplClass, "have_OES_texture_cube_map", "Z"); 105 106 getBasePointerID = _env->GetStaticMethodID(nioAccessClass, 107 "getBasePointer", "(Ljava/nio/Buffer;)J"); 108 getBaseArrayID = _env->GetStaticMethodID(nioAccessClass, 109 "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;"); 110 getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass, 111 "getBaseArrayOffset", "(Ljava/nio/Buffer;)I"); 112 allowIndirectBuffersID = _env->GetStaticMethodID(g11impClassLocal, 113 "allowIndirectBuffers", "(Ljava/lang/String;)Z"); 114 positionID = _env->GetFieldID(bufferClass, "position", "I"); 115 limitID = _env->GetFieldID(bufferClass, "limit", "I"); 116 elementSizeShiftID = 117 _env->GetFieldID(bufferClass, "_elementSizeShift", "I"); 118 } 119 120 static void * 121 getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining, jint *offset) 122 { 123 jint position; 124 jint limit; 125 jint elementSizeShift; 126 jlong pointer; 127 128 position = _env->GetIntField(buffer, positionID); 129 limit = _env->GetIntField(buffer, limitID); 130 elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID); 131 *remaining = (limit - position) << elementSizeShift; 132 pointer = _env->CallStaticLongMethod(nioAccessClass, 133 getBasePointerID, buffer); 134 if (pointer != 0L) { 135 *offset = 0; 136 *array = NULL; 137 return reinterpret_cast<void *>(pointer); 138 } 139 140 *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass, 141 getBaseArrayID, buffer); 142 if (*array == NULL) { 143 *offset = 0; 144 return (void*) NULL; 145 } 146 *offset = _env->CallStaticIntMethod(nioAccessClass, 147 getBaseArrayOffsetID, buffer); 148 149 return NULL; 150 } 151 152 static void 153 releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit) 154 { 155 _env->ReleasePrimitiveArrayCritical(array, data, 156 commit ? 0 : JNI_ABORT); 157 } 158 159 extern "C" { 160 extern char* __progname; 161 } 162 163 static bool 164 allowIndirectBuffers(JNIEnv *_env) { 165 static jint sIndirectBufferCompatability; 166 if (sIndirectBufferCompatability == 0) { 167 jobject appName = _env->NewStringUTF(::__progname); 168 sIndirectBufferCompatability = _env->CallStaticBooleanMethod(G11ImplClass, allowIndirectBuffersID, appName) ? 2 : 1; 169 } 170 return sIndirectBufferCompatability == 2; 171 } 172 173 static void * 174 getDirectBufferPointer(JNIEnv *_env, jobject buffer) { 175 if (!buffer) { 176 return NULL; 177 } 178 void* buf = _env->GetDirectBufferAddress(buffer); 179 if (buf) { 180 jint position = _env->GetIntField(buffer, positionID); 181 jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID); 182 buf = ((char*) buf) + (position << elementSizeShift); 183 } else { 184 if (allowIndirectBuffers(_env)) { 185 jarray array = 0; 186 jint remaining; 187 jint offset; 188 buf = getPointer(_env, buffer, &array, &remaining, &offset); 189 if (array) { 190 releasePointer(_env, array, buf, 0); 191 } 192 buf = (char*)buf + offset; 193 } else { 194 jniThrowException(_env, "java/lang/IllegalArgumentException", 195 "Must use a native order direct Buffer"); 196 } 197 } 198 return buf; 199 } 200 201 static int 202 getNumCompressedTextureFormats() { 203 int numCompressedTextureFormats = 0; 204 glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numCompressedTextureFormats); 205 return numCompressedTextureFormats; 206 } 207 208 // Check if the extension at the head of pExtensions is pExtension. Note that pExtensions is 209 // terminated by either 0 or space, while pExtension is terminated by 0. 210 211 static bool 212 extensionEqual(const GLubyte* pExtensions, const GLubyte* pExtension) { 213 while (true) { 214 char a = *pExtensions++; 215 char b = *pExtension++; 216 bool aEnd = a == '\0' || a == ' '; 217 bool bEnd = b == '\0'; 218 if ( aEnd || bEnd) { 219 return aEnd == bEnd; 220 } 221 if ( a != b ) { 222 return false; 223 } 224 } 225 } 226 227 static const GLubyte* 228 nextExtension(const GLubyte* pExtensions) { 229 while (true) { 230 char a = *pExtensions++; 231 if ( a == '\0') { 232 return pExtensions-1; 233 } else if ( a == ' ') { 234 return pExtensions; 235 } 236 } 237 } 238 239 static bool 240 checkForExtension(const GLubyte* pExtensions, const GLubyte* pExtension) { 241 for (;*pExtensions != '\0'; pExtensions = nextExtension(pExtensions)) { 242 if (extensionEqual(pExtensions, pExtension)) { 243 return true; 244 } 245 } 246 return false; 247 } 248 249 static bool 250 supportsExtension(JNIEnv *_env, jobject impl, jfieldID fieldId) { 251 if (!_env->GetBooleanField(impl, haveCheckedExtensionsID)) { 252 _env->SetBooleanField(impl, haveCheckedExtensionsID, true); 253 const GLubyte* sExtensions = glGetString(GL_EXTENSIONS); 254 _env->SetBooleanField(impl, have_OES_blend_equation_separateID, 255 checkForExtension(sExtensions, (const GLubyte*) "GL_OES_blend_equation_separate")); 256 _env->SetBooleanField(impl, have_OES_blend_subtractID, 257 checkForExtension(sExtensions, (const GLubyte*) "GL_OES_blend_subtract")); 258 _env->SetBooleanField(impl, have_OES_framebuffer_objectID, 259 checkForExtension(sExtensions, (const GLubyte*) "GL_OES_framebuffer_object")); 260 _env->SetBooleanField(impl, have_OES_texture_cube_mapID, 261 checkForExtension(sExtensions, (const GLubyte*) "GL_OES_texture_cube_map")); 262 } 263 return _env->GetBooleanField(impl, fieldId); 264 } 265 266 // -------------------------------------------------------------------------- 267 /* void glActiveTexture ( GLenum texture ) */ 268 static void 269 android_glActiveTexture__I 270 (JNIEnv *_env, jobject _this, jint texture) { 271 glActiveTexture( 272 (GLenum)texture 273 ); 274 } 275 276 /* void glAlphaFunc ( GLenum func, GLclampf ref ) */ 277 static void 278 android_glAlphaFunc__IF 279 (JNIEnv *_env, jobject _this, jint func, jfloat ref) { 280 glAlphaFunc( 281 (GLenum)func, 282 (GLclampf)ref 283 ); 284 } 285 286 /* void glAlphaFuncx ( GLenum func, GLclampx ref ) */ 287 static void 288 android_glAlphaFuncx__II 289 (JNIEnv *_env, jobject _this, jint func, jint ref) { 290 glAlphaFuncx( 291 (GLenum)func, 292 (GLclampx)ref 293 ); 294 } 295 296 /* void glBindTexture ( GLenum target, GLuint texture ) */ 297 static void 298 android_glBindTexture__II 299 (JNIEnv *_env, jobject _this, jint target, jint texture) { 300 glBindTexture( 301 (GLenum)target, 302 (GLuint)texture 303 ); 304 } 305 306 /* void glBlendFunc ( GLenum sfactor, GLenum dfactor ) */ 307 static void 308 android_glBlendFunc__II 309 (JNIEnv *_env, jobject _this, jint sfactor, jint dfactor) { 310 glBlendFunc( 311 (GLenum)sfactor, 312 (GLenum)dfactor 313 ); 314 } 315 316 /* void glClear ( GLbitfield mask ) */ 317 static void 318 android_glClear__I 319 (JNIEnv *_env, jobject _this, jint mask) { 320 glClear( 321 (GLbitfield)mask 322 ); 323 } 324 325 /* void glClearColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) */ 326 static void 327 android_glClearColor__FFFF 328 (JNIEnv *_env, jobject _this, jfloat red, jfloat green, jfloat blue, jfloat alpha) { 329 glClearColor( 330 (GLclampf)red, 331 (GLclampf)green, 332 (GLclampf)blue, 333 (GLclampf)alpha 334 ); 335 } 336 337 /* void glClearColorx ( GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha ) */ 338 static void 339 android_glClearColorx__IIII 340 (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) { 341 glClearColorx( 342 (GLclampx)red, 343 (GLclampx)green, 344 (GLclampx)blue, 345 (GLclampx)alpha 346 ); 347 } 348 349 /* void glClearDepthf ( GLclampf depth ) */ 350 static void 351 android_glClearDepthf__F 352 (JNIEnv *_env, jobject _this, jfloat depth) { 353 glClearDepthf( 354 (GLclampf)depth 355 ); 356 } 357 358 /* void glClearDepthx ( GLclampx depth ) */ 359 static void 360 android_glClearDepthx__I 361 (JNIEnv *_env, jobject _this, jint depth) { 362 glClearDepthx( 363 (GLclampx)depth 364 ); 365 } 366 367 /* void glClearStencil ( GLint s ) */ 368 static void 369 android_glClearStencil__I 370 (JNIEnv *_env, jobject _this, jint s) { 371 glClearStencil( 372 (GLint)s 373 ); 374 } 375 376 /* void glClientActiveTexture ( GLenum texture ) */ 377 static void 378 android_glClientActiveTexture__I 379 (JNIEnv *_env, jobject _this, jint texture) { 380 glClientActiveTexture( 381 (GLenum)texture 382 ); 383 } 384 385 /* void glColor4f ( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) */ 386 static void 387 android_glColor4f__FFFF 388 (JNIEnv *_env, jobject _this, jfloat red, jfloat green, jfloat blue, jfloat alpha) { 389 glColor4f( 390 (GLfloat)red, 391 (GLfloat)green, 392 (GLfloat)blue, 393 (GLfloat)alpha 394 ); 395 } 396 397 /* void glColor4x ( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) */ 398 static void 399 android_glColor4x__IIII 400 (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) { 401 glColor4x( 402 (GLfixed)red, 403 (GLfixed)green, 404 (GLfixed)blue, 405 (GLfixed)alpha 406 ); 407 } 408 409 /* void glColorMask ( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) */ 410 static void 411 android_glColorMask__ZZZZ 412 (JNIEnv *_env, jobject _this, jboolean red, jboolean green, jboolean blue, jboolean alpha) { 413 glColorMask( 414 (GLboolean)red, 415 (GLboolean)green, 416 (GLboolean)blue, 417 (GLboolean)alpha 418 ); 419 } 420 421 /* void glColorPointer ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */ 422 static void 423 android_glColorPointerBounds__IIILjava_nio_Buffer_2I 424 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) { 425 jint _exception = 0; 426 const char * _exceptionType = NULL; 427 const char * _exceptionMessage = NULL; 428 jarray _array = (jarray) 0; 429 jint _bufferOffset = (jint) 0; 430 jint _remaining; 431 GLvoid *pointer = (GLvoid *) 0; 432 433 if (pointer_buf) { 434 pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf); 435 if ( ! pointer ) { 436 return; 437 } 438 } 439 glColorPointerBounds( 440 (GLint)size, 441 (GLenum)type, 442 (GLsizei)stride, 443 (GLvoid *)pointer, 444 (GLsizei)remaining 445 ); 446 if (_exception) { 447 jniThrowException(_env, _exceptionType, _exceptionMessage); 448 } 449 } 450 451 /* void glCompressedTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data ) */ 452 static void 453 android_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2 454 (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint imageSize, jobject data_buf) { 455 jint _exception = 0; 456 const char * _exceptionType = NULL; 457 const char * _exceptionMessage = NULL; 458 jarray _array = (jarray) 0; 459 jint _bufferOffset = (jint) 0; 460 jint _remaining; 461 GLvoid *data = (GLvoid *) 0; 462 463 if (!data_buf) { 464 _exception = 1; 465 _exceptionType = "java/lang/IllegalArgumentException"; 466 _exceptionMessage = "data == null"; 467 goto exit; 468 } 469 data = (GLvoid *)getPointer(_env, data_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 470 if (data == NULL) { 471 char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 472 data = (GLvoid *) (_dataBase + _bufferOffset); 473 } 474 glCompressedTexImage2D( 475 (GLenum)target, 476 (GLint)level, 477 (GLenum)internalformat, 478 (GLsizei)width, 479 (GLsizei)height, 480 (GLint)border, 481 (GLsizei)imageSize, 482 (GLvoid *)data 483 ); 484 485 exit: 486 if (_array) { 487 releasePointer(_env, _array, data, JNI_FALSE); 488 } 489 if (_exception) { 490 jniThrowException(_env, _exceptionType, _exceptionMessage); 491 } 492 } 493 494 /* void glCompressedTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data ) */ 495 static void 496 android_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 497 (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint imageSize, jobject data_buf) { 498 jint _exception = 0; 499 const char * _exceptionType = NULL; 500 const char * _exceptionMessage = NULL; 501 jarray _array = (jarray) 0; 502 jint _bufferOffset = (jint) 0; 503 jint _remaining; 504 GLvoid *data = (GLvoid *) 0; 505 506 if (!data_buf) { 507 _exception = 1; 508 _exceptionType = "java/lang/IllegalArgumentException"; 509 _exceptionMessage = "data == null"; 510 goto exit; 511 } 512 data = (GLvoid *)getPointer(_env, data_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 513 if (data == NULL) { 514 char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 515 data = (GLvoid *) (_dataBase + _bufferOffset); 516 } 517 glCompressedTexSubImage2D( 518 (GLenum)target, 519 (GLint)level, 520 (GLint)xoffset, 521 (GLint)yoffset, 522 (GLsizei)width, 523 (GLsizei)height, 524 (GLenum)format, 525 (GLsizei)imageSize, 526 (GLvoid *)data 527 ); 528 529 exit: 530 if (_array) { 531 releasePointer(_env, _array, data, JNI_FALSE); 532 } 533 if (_exception) { 534 jniThrowException(_env, _exceptionType, _exceptionMessage); 535 } 536 } 537 538 /* void glCopyTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) */ 539 static void 540 android_glCopyTexImage2D__IIIIIIII 541 (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint x, jint y, jint width, jint height, jint border) { 542 glCopyTexImage2D( 543 (GLenum)target, 544 (GLint)level, 545 (GLenum)internalformat, 546 (GLint)x, 547 (GLint)y, 548 (GLsizei)width, 549 (GLsizei)height, 550 (GLint)border 551 ); 552 } 553 554 /* void glCopyTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) */ 555 static void 556 android_glCopyTexSubImage2D__IIIIIIII 557 (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint x, jint y, jint width, jint height) { 558 glCopyTexSubImage2D( 559 (GLenum)target, 560 (GLint)level, 561 (GLint)xoffset, 562 (GLint)yoffset, 563 (GLint)x, 564 (GLint)y, 565 (GLsizei)width, 566 (GLsizei)height 567 ); 568 } 569 570 /* void glCullFace ( GLenum mode ) */ 571 static void 572 android_glCullFace__I 573 (JNIEnv *_env, jobject _this, jint mode) { 574 glCullFace( 575 (GLenum)mode 576 ); 577 } 578 579 /* void glDeleteTextures ( GLsizei n, const GLuint *textures ) */ 580 static void 581 android_glDeleteTextures__I_3II 582 (JNIEnv *_env, jobject _this, jint n, jintArray textures_ref, jint offset) { 583 jint _exception = 0; 584 const char * _exceptionType = NULL; 585 const char * _exceptionMessage = NULL; 586 GLuint *textures_base = (GLuint *) 0; 587 jint _remaining; 588 GLuint *textures = (GLuint *) 0; 589 590 if (!textures_ref) { 591 _exception = 1; 592 _exceptionType = "java/lang/IllegalArgumentException"; 593 _exceptionMessage = "textures == null"; 594 goto exit; 595 } 596 if (offset < 0) { 597 _exception = 1; 598 _exceptionType = "java/lang/IllegalArgumentException"; 599 _exceptionMessage = "offset < 0"; 600 goto exit; 601 } 602 _remaining = _env->GetArrayLength(textures_ref) - offset; 603 if (_remaining < n) { 604 _exception = 1; 605 _exceptionType = "java/lang/IllegalArgumentException"; 606 _exceptionMessage = "length - offset < n < needed"; 607 goto exit; 608 } 609 textures_base = (GLuint *) 610 _env->GetIntArrayElements(textures_ref, (jboolean *)0); 611 textures = textures_base + offset; 612 613 glDeleteTextures( 614 (GLsizei)n, 615 (GLuint *)textures 616 ); 617 618 exit: 619 if (textures_base) { 620 _env->ReleaseIntArrayElements(textures_ref, (jint*)textures_base, 621 JNI_ABORT); 622 } 623 if (_exception) { 624 jniThrowException(_env, _exceptionType, _exceptionMessage); 625 } 626 } 627 628 /* void glDeleteTextures ( GLsizei n, const GLuint *textures ) */ 629 static void 630 android_glDeleteTextures__ILjava_nio_IntBuffer_2 631 (JNIEnv *_env, jobject _this, jint n, jobject textures_buf) { 632 jint _exception = 0; 633 const char * _exceptionType = NULL; 634 const char * _exceptionMessage = NULL; 635 jintArray _array = (jintArray) 0; 636 jint _bufferOffset = (jint) 0; 637 jint _remaining; 638 GLuint *textures = (GLuint *) 0; 639 640 if (!textures_buf) { 641 _exception = 1; 642 _exceptionType = "java/lang/IllegalArgumentException"; 643 _exceptionMessage = "textures == null"; 644 goto exit; 645 } 646 textures = (GLuint *)getPointer(_env, textures_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 647 if (_remaining < n) { 648 _exception = 1; 649 _exceptionType = "java/lang/IllegalArgumentException"; 650 _exceptionMessage = "remaining() < n < needed"; 651 goto exit; 652 } 653 if (textures == NULL) { 654 char * _texturesBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 655 textures = (GLuint *) (_texturesBase + _bufferOffset); 656 } 657 glDeleteTextures( 658 (GLsizei)n, 659 (GLuint *)textures 660 ); 661 662 exit: 663 if (_array) { 664 _env->ReleaseIntArrayElements(_array, (jint*)textures, JNI_ABORT); 665 } 666 if (_exception) { 667 jniThrowException(_env, _exceptionType, _exceptionMessage); 668 } 669 } 670 671 /* void glDepthFunc ( GLenum func ) */ 672 static void 673 android_glDepthFunc__I 674 (JNIEnv *_env, jobject _this, jint func) { 675 glDepthFunc( 676 (GLenum)func 677 ); 678 } 679 680 /* void glDepthMask ( GLboolean flag ) */ 681 static void 682 android_glDepthMask__Z 683 (JNIEnv *_env, jobject _this, jboolean flag) { 684 glDepthMask( 685 (GLboolean)flag 686 ); 687 } 688 689 /* void glDepthRangef ( GLclampf zNear, GLclampf zFar ) */ 690 static void 691 android_glDepthRangef__FF 692 (JNIEnv *_env, jobject _this, jfloat zNear, jfloat zFar) { 693 glDepthRangef( 694 (GLclampf)zNear, 695 (GLclampf)zFar 696 ); 697 } 698 699 /* void glDepthRangex ( GLclampx zNear, GLclampx zFar ) */ 700 static void 701 android_glDepthRangex__II 702 (JNIEnv *_env, jobject _this, jint zNear, jint zFar) { 703 glDepthRangex( 704 (GLclampx)zNear, 705 (GLclampx)zFar 706 ); 707 } 708 709 /* void glDisable ( GLenum cap ) */ 710 static void 711 android_glDisable__I 712 (JNIEnv *_env, jobject _this, jint cap) { 713 glDisable( 714 (GLenum)cap 715 ); 716 } 717 718 /* void glDisableClientState ( GLenum array ) */ 719 static void 720 android_glDisableClientState__I 721 (JNIEnv *_env, jobject _this, jint array) { 722 glDisableClientState( 723 (GLenum)array 724 ); 725 } 726 727 /* void glDrawArrays ( GLenum mode, GLint first, GLsizei count ) */ 728 static void 729 android_glDrawArrays__III 730 (JNIEnv *_env, jobject _this, jint mode, jint first, jint count) { 731 glDrawArrays( 732 (GLenum)mode, 733 (GLint)first, 734 (GLsizei)count 735 ); 736 } 737 738 /* void glDrawElements ( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices ) */ 739 static void 740 android_glDrawElements__IIILjava_nio_Buffer_2 741 (JNIEnv *_env, jobject _this, jint mode, jint count, jint type, jobject indices_buf) { 742 jint _exception = 0; 743 const char * _exceptionType = NULL; 744 const char * _exceptionMessage = NULL; 745 jarray _array = (jarray) 0; 746 jint _bufferOffset = (jint) 0; 747 jint _remaining; 748 GLvoid *indices = (GLvoid *) 0; 749 750 if (!indices_buf) { 751 _exception = 1; 752 _exceptionType = "java/lang/IllegalArgumentException"; 753 _exceptionMessage = "indices == null"; 754 goto exit; 755 } 756 indices = (GLvoid *)getPointer(_env, indices_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 757 if (_remaining < count) { 758 _exception = 1; 759 _exceptionType = "java/lang/ArrayIndexOutOfBoundsException"; 760 _exceptionMessage = "remaining() < count < needed"; 761 goto exit; 762 } 763 if (indices == NULL) { 764 char * _indicesBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 765 indices = (GLvoid *) (_indicesBase + _bufferOffset); 766 } 767 glDrawElements( 768 (GLenum)mode, 769 (GLsizei)count, 770 (GLenum)type, 771 (GLvoid *)indices 772 ); 773 774 exit: 775 if (_array) { 776 releasePointer(_env, _array, indices, JNI_FALSE); 777 } 778 if (_exception) { 779 jniThrowException(_env, _exceptionType, _exceptionMessage); 780 } 781 } 782 783 /* void glEnable ( GLenum cap ) */ 784 static void 785 android_glEnable__I 786 (JNIEnv *_env, jobject _this, jint cap) { 787 glEnable( 788 (GLenum)cap 789 ); 790 } 791 792 /* void glEnableClientState ( GLenum array ) */ 793 static void 794 android_glEnableClientState__I 795 (JNIEnv *_env, jobject _this, jint array) { 796 glEnableClientState( 797 (GLenum)array 798 ); 799 } 800 801 /* void glFinish ( void ) */ 802 static void 803 android_glFinish__ 804 (JNIEnv *_env, jobject _this) { 805 glFinish(); 806 } 807 808 /* void glFlush ( void ) */ 809 static void 810 android_glFlush__ 811 (JNIEnv *_env, jobject _this) { 812 glFlush(); 813 } 814 815 /* void glFogf ( GLenum pname, GLfloat param ) */ 816 static void 817 android_glFogf__IF 818 (JNIEnv *_env, jobject _this, jint pname, jfloat param) { 819 glFogf( 820 (GLenum)pname, 821 (GLfloat)param 822 ); 823 } 824 825 /* void glFogfv ( GLenum pname, const GLfloat *params ) */ 826 static void 827 android_glFogfv__I_3FI 828 (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) { 829 jint _exception = 0; 830 const char * _exceptionType = NULL; 831 const char * _exceptionMessage = NULL; 832 GLfloat *params_base = (GLfloat *) 0; 833 jint _remaining; 834 GLfloat *params = (GLfloat *) 0; 835 836 if (!params_ref) { 837 _exception = 1; 838 _exceptionType = "java/lang/IllegalArgumentException"; 839 _exceptionMessage = "params == null"; 840 goto exit; 841 } 842 if (offset < 0) { 843 _exception = 1; 844 _exceptionType = "java/lang/IllegalArgumentException"; 845 _exceptionMessage = "offset < 0"; 846 goto exit; 847 } 848 _remaining = _env->GetArrayLength(params_ref) - offset; 849 int _needed; 850 switch (pname) { 851 #if defined(GL_FOG_MODE) 852 case GL_FOG_MODE: 853 #endif // defined(GL_FOG_MODE) 854 #if defined(GL_FOG_DENSITY) 855 case GL_FOG_DENSITY: 856 #endif // defined(GL_FOG_DENSITY) 857 #if defined(GL_FOG_START) 858 case GL_FOG_START: 859 #endif // defined(GL_FOG_START) 860 #if defined(GL_FOG_END) 861 case GL_FOG_END: 862 #endif // defined(GL_FOG_END) 863 _needed = 1; 864 break; 865 #if defined(GL_FOG_COLOR) 866 case GL_FOG_COLOR: 867 #endif // defined(GL_FOG_COLOR) 868 _needed = 4; 869 break; 870 default: 871 _needed = 1; 872 break; 873 } 874 if (_remaining < _needed) { 875 _exception = 1; 876 _exceptionType = "java/lang/IllegalArgumentException"; 877 _exceptionMessage = "length - offset < needed"; 878 goto exit; 879 } 880 params_base = (GLfloat *) 881 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 882 params = params_base + offset; 883 884 glFogfv( 885 (GLenum)pname, 886 (GLfloat *)params 887 ); 888 889 exit: 890 if (params_base) { 891 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 892 JNI_ABORT); 893 } 894 if (_exception) { 895 jniThrowException(_env, _exceptionType, _exceptionMessage); 896 } 897 } 898 899 /* void glFogfv ( GLenum pname, const GLfloat *params ) */ 900 static void 901 android_glFogfv__ILjava_nio_FloatBuffer_2 902 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 903 jint _exception = 0; 904 const char * _exceptionType = NULL; 905 const char * _exceptionMessage = NULL; 906 jfloatArray _array = (jfloatArray) 0; 907 jint _bufferOffset = (jint) 0; 908 jint _remaining; 909 GLfloat *params = (GLfloat *) 0; 910 911 if (!params_buf) { 912 _exception = 1; 913 _exceptionType = "java/lang/IllegalArgumentException"; 914 _exceptionMessage = "params == null"; 915 goto exit; 916 } 917 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 918 int _needed; 919 switch (pname) { 920 #if defined(GL_FOG_MODE) 921 case GL_FOG_MODE: 922 #endif // defined(GL_FOG_MODE) 923 #if defined(GL_FOG_DENSITY) 924 case GL_FOG_DENSITY: 925 #endif // defined(GL_FOG_DENSITY) 926 #if defined(GL_FOG_START) 927 case GL_FOG_START: 928 #endif // defined(GL_FOG_START) 929 #if defined(GL_FOG_END) 930 case GL_FOG_END: 931 #endif // defined(GL_FOG_END) 932 _needed = 1; 933 break; 934 #if defined(GL_FOG_COLOR) 935 case GL_FOG_COLOR: 936 #endif // defined(GL_FOG_COLOR) 937 _needed = 4; 938 break; 939 default: 940 _needed = 1; 941 break; 942 } 943 if (_remaining < _needed) { 944 _exception = 1; 945 _exceptionType = "java/lang/IllegalArgumentException"; 946 _exceptionMessage = "remaining() < needed"; 947 goto exit; 948 } 949 if (params == NULL) { 950 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 951 params = (GLfloat *) (_paramsBase + _bufferOffset); 952 } 953 glFogfv( 954 (GLenum)pname, 955 (GLfloat *)params 956 ); 957 958 exit: 959 if (_array) { 960 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT); 961 } 962 if (_exception) { 963 jniThrowException(_env, _exceptionType, _exceptionMessage); 964 } 965 } 966 967 /* void glFogx ( GLenum pname, GLfixed param ) */ 968 static void 969 android_glFogx__II 970 (JNIEnv *_env, jobject _this, jint pname, jint param) { 971 glFogx( 972 (GLenum)pname, 973 (GLfixed)param 974 ); 975 } 976 977 /* void glFogxv ( GLenum pname, const GLfixed *params ) */ 978 static void 979 android_glFogxv__I_3II 980 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) { 981 jint _exception = 0; 982 const char * _exceptionType = NULL; 983 const char * _exceptionMessage = NULL; 984 GLfixed *params_base = (GLfixed *) 0; 985 jint _remaining; 986 GLfixed *params = (GLfixed *) 0; 987 988 if (!params_ref) { 989 _exception = 1; 990 _exceptionType = "java/lang/IllegalArgumentException"; 991 _exceptionMessage = "params == null"; 992 goto exit; 993 } 994 if (offset < 0) { 995 _exception = 1; 996 _exceptionType = "java/lang/IllegalArgumentException"; 997 _exceptionMessage = "offset < 0"; 998 goto exit; 999 } 1000 _remaining = _env->GetArrayLength(params_ref) - offset; 1001 int _needed; 1002 switch (pname) { 1003 #if defined(GL_FOG_MODE) 1004 case GL_FOG_MODE: 1005 #endif // defined(GL_FOG_MODE) 1006 #if defined(GL_FOG_DENSITY) 1007 case GL_FOG_DENSITY: 1008 #endif // defined(GL_FOG_DENSITY) 1009 #if defined(GL_FOG_START) 1010 case GL_FOG_START: 1011 #endif // defined(GL_FOG_START) 1012 #if defined(GL_FOG_END) 1013 case GL_FOG_END: 1014 #endif // defined(GL_FOG_END) 1015 _needed = 1; 1016 break; 1017 #if defined(GL_FOG_COLOR) 1018 case GL_FOG_COLOR: 1019 #endif // defined(GL_FOG_COLOR) 1020 _needed = 4; 1021 break; 1022 default: 1023 _needed = 1; 1024 break; 1025 } 1026 if (_remaining < _needed) { 1027 _exception = 1; 1028 _exceptionType = "java/lang/IllegalArgumentException"; 1029 _exceptionMessage = "length - offset < needed"; 1030 goto exit; 1031 } 1032 params_base = (GLfixed *) 1033 _env->GetIntArrayElements(params_ref, (jboolean *)0); 1034 params = params_base + offset; 1035 1036 glFogxv( 1037 (GLenum)pname, 1038 (GLfixed *)params 1039 ); 1040 1041 exit: 1042 if (params_base) { 1043 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 1044 JNI_ABORT); 1045 } 1046 if (_exception) { 1047 jniThrowException(_env, _exceptionType, _exceptionMessage); 1048 } 1049 } 1050 1051 /* void glFogxv ( GLenum pname, const GLfixed *params ) */ 1052 static void 1053 android_glFogxv__ILjava_nio_IntBuffer_2 1054 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 1055 jint _exception = 0; 1056 const char * _exceptionType = NULL; 1057 const char * _exceptionMessage = NULL; 1058 jintArray _array = (jintArray) 0; 1059 jint _bufferOffset = (jint) 0; 1060 jint _remaining; 1061 GLfixed *params = (GLfixed *) 0; 1062 1063 if (!params_buf) { 1064 _exception = 1; 1065 _exceptionType = "java/lang/IllegalArgumentException"; 1066 _exceptionMessage = "params == null"; 1067 goto exit; 1068 } 1069 params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1070 int _needed; 1071 switch (pname) { 1072 #if defined(GL_FOG_MODE) 1073 case GL_FOG_MODE: 1074 #endif // defined(GL_FOG_MODE) 1075 #if defined(GL_FOG_DENSITY) 1076 case GL_FOG_DENSITY: 1077 #endif // defined(GL_FOG_DENSITY) 1078 #if defined(GL_FOG_START) 1079 case GL_FOG_START: 1080 #endif // defined(GL_FOG_START) 1081 #if defined(GL_FOG_END) 1082 case GL_FOG_END: 1083 #endif // defined(GL_FOG_END) 1084 _needed = 1; 1085 break; 1086 #if defined(GL_FOG_COLOR) 1087 case GL_FOG_COLOR: 1088 #endif // defined(GL_FOG_COLOR) 1089 _needed = 4; 1090 break; 1091 default: 1092 _needed = 1; 1093 break; 1094 } 1095 if (_remaining < _needed) { 1096 _exception = 1; 1097 _exceptionType = "java/lang/IllegalArgumentException"; 1098 _exceptionMessage = "remaining() < needed"; 1099 goto exit; 1100 } 1101 if (params == NULL) { 1102 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1103 params = (GLfixed *) (_paramsBase + _bufferOffset); 1104 } 1105 glFogxv( 1106 (GLenum)pname, 1107 (GLfixed *)params 1108 ); 1109 1110 exit: 1111 if (_array) { 1112 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT); 1113 } 1114 if (_exception) { 1115 jniThrowException(_env, _exceptionType, _exceptionMessage); 1116 } 1117 } 1118 1119 /* void glFrontFace ( GLenum mode ) */ 1120 static void 1121 android_glFrontFace__I 1122 (JNIEnv *_env, jobject _this, jint mode) { 1123 glFrontFace( 1124 (GLenum)mode 1125 ); 1126 } 1127 1128 /* void glFrustumf ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */ 1129 static void 1130 android_glFrustumf__FFFFFF 1131 (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) { 1132 glFrustumf( 1133 (GLfloat)left, 1134 (GLfloat)right, 1135 (GLfloat)bottom, 1136 (GLfloat)top, 1137 (GLfloat)zNear, 1138 (GLfloat)zFar 1139 ); 1140 } 1141 1142 /* void glFrustumx ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */ 1143 static void 1144 android_glFrustumx__IIIIII 1145 (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) { 1146 glFrustumx( 1147 (GLfixed)left, 1148 (GLfixed)right, 1149 (GLfixed)bottom, 1150 (GLfixed)top, 1151 (GLfixed)zNear, 1152 (GLfixed)zFar 1153 ); 1154 } 1155 1156 /* void glGenTextures ( GLsizei n, GLuint *textures ) */ 1157 static void 1158 android_glGenTextures__I_3II 1159 (JNIEnv *_env, jobject _this, jint n, jintArray textures_ref, jint offset) { 1160 jint _exception = 0; 1161 const char * _exceptionType = NULL; 1162 const char * _exceptionMessage = NULL; 1163 GLuint *textures_base = (GLuint *) 0; 1164 jint _remaining; 1165 GLuint *textures = (GLuint *) 0; 1166 1167 if (!textures_ref) { 1168 _exception = 1; 1169 _exceptionType = "java/lang/IllegalArgumentException"; 1170 _exceptionMessage = "textures == null"; 1171 goto exit; 1172 } 1173 if (offset < 0) { 1174 _exception = 1; 1175 _exceptionType = "java/lang/IllegalArgumentException"; 1176 _exceptionMessage = "offset < 0"; 1177 goto exit; 1178 } 1179 _remaining = _env->GetArrayLength(textures_ref) - offset; 1180 if (_remaining < n) { 1181 _exception = 1; 1182 _exceptionType = "java/lang/IllegalArgumentException"; 1183 _exceptionMessage = "length - offset < n < needed"; 1184 goto exit; 1185 } 1186 textures_base = (GLuint *) 1187 _env->GetIntArrayElements(textures_ref, (jboolean *)0); 1188 textures = textures_base + offset; 1189 1190 glGenTextures( 1191 (GLsizei)n, 1192 (GLuint *)textures 1193 ); 1194 1195 exit: 1196 if (textures_base) { 1197 _env->ReleaseIntArrayElements(textures_ref, (jint*)textures_base, 1198 _exception ? JNI_ABORT: 0); 1199 } 1200 if (_exception) { 1201 jniThrowException(_env, _exceptionType, _exceptionMessage); 1202 } 1203 } 1204 1205 /* void glGenTextures ( GLsizei n, GLuint *textures ) */ 1206 static void 1207 android_glGenTextures__ILjava_nio_IntBuffer_2 1208 (JNIEnv *_env, jobject _this, jint n, jobject textures_buf) { 1209 jint _exception = 0; 1210 const char * _exceptionType = NULL; 1211 const char * _exceptionMessage = NULL; 1212 jintArray _array = (jintArray) 0; 1213 jint _bufferOffset = (jint) 0; 1214 jint _remaining; 1215 GLuint *textures = (GLuint *) 0; 1216 1217 if (!textures_buf) { 1218 _exception = 1; 1219 _exceptionType = "java/lang/IllegalArgumentException"; 1220 _exceptionMessage = "textures == null"; 1221 goto exit; 1222 } 1223 textures = (GLuint *)getPointer(_env, textures_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1224 if (_remaining < n) { 1225 _exception = 1; 1226 _exceptionType = "java/lang/IllegalArgumentException"; 1227 _exceptionMessage = "remaining() < n < needed"; 1228 goto exit; 1229 } 1230 if (textures == NULL) { 1231 char * _texturesBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1232 textures = (GLuint *) (_texturesBase + _bufferOffset); 1233 } 1234 glGenTextures( 1235 (GLsizei)n, 1236 (GLuint *)textures 1237 ); 1238 1239 exit: 1240 if (_array) { 1241 _env->ReleaseIntArrayElements(_array, (jint*)textures, _exception ? JNI_ABORT : 0); 1242 } 1243 if (_exception) { 1244 jniThrowException(_env, _exceptionType, _exceptionMessage); 1245 } 1246 } 1247 1248 /* GLenum glGetError ( void ) */ 1249 static jint 1250 android_glGetError__ 1251 (JNIEnv *_env, jobject _this) { 1252 GLenum _returnValue; 1253 _returnValue = glGetError(); 1254 return (jint)_returnValue; 1255 } 1256 1257 /* void glGetIntegerv ( GLenum pname, GLint *params ) */ 1258 static void 1259 android_glGetIntegerv__I_3II 1260 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) { 1261 jint _exception = 0; 1262 const char * _exceptionType = NULL; 1263 const char * _exceptionMessage = NULL; 1264 GLint *params_base = (GLint *) 0; 1265 jint _remaining; 1266 GLint *params = (GLint *) 0; 1267 1268 if (!params_ref) { 1269 _exception = 1; 1270 _exceptionType = "java/lang/IllegalArgumentException"; 1271 _exceptionMessage = "params == null"; 1272 goto exit; 1273 } 1274 if (offset < 0) { 1275 _exception = 1; 1276 _exceptionType = "java/lang/IllegalArgumentException"; 1277 _exceptionMessage = "offset < 0"; 1278 goto exit; 1279 } 1280 _remaining = _env->GetArrayLength(params_ref) - offset; 1281 int _needed; 1282 switch (pname) { 1283 #if defined(GL_ALPHA_BITS) 1284 case GL_ALPHA_BITS: 1285 #endif // defined(GL_ALPHA_BITS) 1286 #if defined(GL_ALPHA_TEST_FUNC) 1287 case GL_ALPHA_TEST_FUNC: 1288 #endif // defined(GL_ALPHA_TEST_FUNC) 1289 #if defined(GL_ALPHA_TEST_REF) 1290 case GL_ALPHA_TEST_REF: 1291 #endif // defined(GL_ALPHA_TEST_REF) 1292 #if defined(GL_BLEND_DST) 1293 case GL_BLEND_DST: 1294 #endif // defined(GL_BLEND_DST) 1295 #if defined(GL_BLUE_BITS) 1296 case GL_BLUE_BITS: 1297 #endif // defined(GL_BLUE_BITS) 1298 #if defined(GL_COLOR_ARRAY_BUFFER_BINDING) 1299 case GL_COLOR_ARRAY_BUFFER_BINDING: 1300 #endif // defined(GL_COLOR_ARRAY_BUFFER_BINDING) 1301 #if defined(GL_COLOR_ARRAY_SIZE) 1302 case GL_COLOR_ARRAY_SIZE: 1303 #endif // defined(GL_COLOR_ARRAY_SIZE) 1304 #if defined(GL_COLOR_ARRAY_STRIDE) 1305 case GL_COLOR_ARRAY_STRIDE: 1306 #endif // defined(GL_COLOR_ARRAY_STRIDE) 1307 #if defined(GL_COLOR_ARRAY_TYPE) 1308 case GL_COLOR_ARRAY_TYPE: 1309 #endif // defined(GL_COLOR_ARRAY_TYPE) 1310 #if defined(GL_CULL_FACE) 1311 case GL_CULL_FACE: 1312 #endif // defined(GL_CULL_FACE) 1313 #if defined(GL_DEPTH_BITS) 1314 case GL_DEPTH_BITS: 1315 #endif // defined(GL_DEPTH_BITS) 1316 #if defined(GL_DEPTH_CLEAR_VALUE) 1317 case GL_DEPTH_CLEAR_VALUE: 1318 #endif // defined(GL_DEPTH_CLEAR_VALUE) 1319 #if defined(GL_DEPTH_FUNC) 1320 case GL_DEPTH_FUNC: 1321 #endif // defined(GL_DEPTH_FUNC) 1322 #if defined(GL_DEPTH_WRITEMASK) 1323 case GL_DEPTH_WRITEMASK: 1324 #endif // defined(GL_DEPTH_WRITEMASK) 1325 #if defined(GL_FOG_DENSITY) 1326 case GL_FOG_DENSITY: 1327 #endif // defined(GL_FOG_DENSITY) 1328 #if defined(GL_FOG_END) 1329 case GL_FOG_END: 1330 #endif // defined(GL_FOG_END) 1331 #if defined(GL_FOG_MODE) 1332 case GL_FOG_MODE: 1333 #endif // defined(GL_FOG_MODE) 1334 #if defined(GL_FOG_START) 1335 case GL_FOG_START: 1336 #endif // defined(GL_FOG_START) 1337 #if defined(GL_FRONT_FACE) 1338 case GL_FRONT_FACE: 1339 #endif // defined(GL_FRONT_FACE) 1340 #if defined(GL_GREEN_BITS) 1341 case GL_GREEN_BITS: 1342 #endif // defined(GL_GREEN_BITS) 1343 #if defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES) 1344 case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES: 1345 #endif // defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES) 1346 #if defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES) 1347 case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES: 1348 #endif // defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES) 1349 #if defined(GL_LIGHT_MODEL_COLOR_CONTROL) 1350 case GL_LIGHT_MODEL_COLOR_CONTROL: 1351 #endif // defined(GL_LIGHT_MODEL_COLOR_CONTROL) 1352 #if defined(GL_LIGHT_MODEL_LOCAL_VIEWER) 1353 case GL_LIGHT_MODEL_LOCAL_VIEWER: 1354 #endif // defined(GL_LIGHT_MODEL_LOCAL_VIEWER) 1355 #if defined(GL_LIGHT_MODEL_TWO_SIDE) 1356 case GL_LIGHT_MODEL_TWO_SIDE: 1357 #endif // defined(GL_LIGHT_MODEL_TWO_SIDE) 1358 #if defined(GL_LINE_SMOOTH_HINT) 1359 case GL_LINE_SMOOTH_HINT: 1360 #endif // defined(GL_LINE_SMOOTH_HINT) 1361 #if defined(GL_LINE_WIDTH) 1362 case GL_LINE_WIDTH: 1363 #endif // defined(GL_LINE_WIDTH) 1364 #if defined(GL_LOGIC_OP_MODE) 1365 case GL_LOGIC_OP_MODE: 1366 #endif // defined(GL_LOGIC_OP_MODE) 1367 #if defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES) 1368 case GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES: 1369 #endif // defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES) 1370 #if defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES) 1371 case GL_MATRIX_INDEX_ARRAY_SIZE_OES: 1372 #endif // defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES) 1373 #if defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES) 1374 case GL_MATRIX_INDEX_ARRAY_STRIDE_OES: 1375 #endif // defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES) 1376 #if defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES) 1377 case GL_MATRIX_INDEX_ARRAY_TYPE_OES: 1378 #endif // defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES) 1379 #if defined(GL_MATRIX_MODE) 1380 case GL_MATRIX_MODE: 1381 #endif // defined(GL_MATRIX_MODE) 1382 #if defined(GL_MAX_CLIP_PLANES) 1383 case GL_MAX_CLIP_PLANES: 1384 #endif // defined(GL_MAX_CLIP_PLANES) 1385 #if defined(GL_MAX_ELEMENTS_INDICES) 1386 case GL_MAX_ELEMENTS_INDICES: 1387 #endif // defined(GL_MAX_ELEMENTS_INDICES) 1388 #if defined(GL_MAX_ELEMENTS_VERTICES) 1389 case GL_MAX_ELEMENTS_VERTICES: 1390 #endif // defined(GL_MAX_ELEMENTS_VERTICES) 1391 #if defined(GL_MAX_LIGHTS) 1392 case GL_MAX_LIGHTS: 1393 #endif // defined(GL_MAX_LIGHTS) 1394 #if defined(GL_MAX_MODELVIEW_STACK_DEPTH) 1395 case GL_MAX_MODELVIEW_STACK_DEPTH: 1396 #endif // defined(GL_MAX_MODELVIEW_STACK_DEPTH) 1397 #if defined(GL_MAX_PALETTE_MATRICES_OES) 1398 case GL_MAX_PALETTE_MATRICES_OES: 1399 #endif // defined(GL_MAX_PALETTE_MATRICES_OES) 1400 #if defined(GL_MAX_PROJECTION_STACK_DEPTH) 1401 case GL_MAX_PROJECTION_STACK_DEPTH: 1402 #endif // defined(GL_MAX_PROJECTION_STACK_DEPTH) 1403 #if defined(GL_MAX_TEXTURE_SIZE) 1404 case GL_MAX_TEXTURE_SIZE: 1405 #endif // defined(GL_MAX_TEXTURE_SIZE) 1406 #if defined(GL_MAX_TEXTURE_STACK_DEPTH) 1407 case GL_MAX_TEXTURE_STACK_DEPTH: 1408 #endif // defined(GL_MAX_TEXTURE_STACK_DEPTH) 1409 #if defined(GL_MAX_TEXTURE_UNITS) 1410 case GL_MAX_TEXTURE_UNITS: 1411 #endif // defined(GL_MAX_TEXTURE_UNITS) 1412 #if defined(GL_MAX_VERTEX_UNITS_OES) 1413 case GL_MAX_VERTEX_UNITS_OES: 1414 #endif // defined(GL_MAX_VERTEX_UNITS_OES) 1415 #if defined(GL_MODELVIEW_STACK_DEPTH) 1416 case GL_MODELVIEW_STACK_DEPTH: 1417 #endif // defined(GL_MODELVIEW_STACK_DEPTH) 1418 #if defined(GL_NORMAL_ARRAY_BUFFER_BINDING) 1419 case GL_NORMAL_ARRAY_BUFFER_BINDING: 1420 #endif // defined(GL_NORMAL_ARRAY_BUFFER_BINDING) 1421 #if defined(GL_NORMAL_ARRAY_STRIDE) 1422 case GL_NORMAL_ARRAY_STRIDE: 1423 #endif // defined(GL_NORMAL_ARRAY_STRIDE) 1424 #if defined(GL_NORMAL_ARRAY_TYPE) 1425 case GL_NORMAL_ARRAY_TYPE: 1426 #endif // defined(GL_NORMAL_ARRAY_TYPE) 1427 #if defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS) 1428 case GL_NUM_COMPRESSED_TEXTURE_FORMATS: 1429 #endif // defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS) 1430 #if defined(GL_PACK_ALIGNMENT) 1431 case GL_PACK_ALIGNMENT: 1432 #endif // defined(GL_PACK_ALIGNMENT) 1433 #if defined(GL_PERSPECTIVE_CORRECTION_HINT) 1434 case GL_PERSPECTIVE_CORRECTION_HINT: 1435 #endif // defined(GL_PERSPECTIVE_CORRECTION_HINT) 1436 #if defined(GL_POINT_SIZE) 1437 case GL_POINT_SIZE: 1438 #endif // defined(GL_POINT_SIZE) 1439 #if defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES) 1440 case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES: 1441 #endif // defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES) 1442 #if defined(GL_POINT_SIZE_ARRAY_STRIDE_OES) 1443 case GL_POINT_SIZE_ARRAY_STRIDE_OES: 1444 #endif // defined(GL_POINT_SIZE_ARRAY_STRIDE_OES) 1445 #if defined(GL_POINT_SIZE_ARRAY_TYPE_OES) 1446 case GL_POINT_SIZE_ARRAY_TYPE_OES: 1447 #endif // defined(GL_POINT_SIZE_ARRAY_TYPE_OES) 1448 #if defined(GL_POINT_SMOOTH_HINT) 1449 case GL_POINT_SMOOTH_HINT: 1450 #endif // defined(GL_POINT_SMOOTH_HINT) 1451 #if defined(GL_POLYGON_OFFSET_FACTOR) 1452 case GL_POLYGON_OFFSET_FACTOR: 1453 #endif // defined(GL_POLYGON_OFFSET_FACTOR) 1454 #if defined(GL_POLYGON_OFFSET_UNITS) 1455 case GL_POLYGON_OFFSET_UNITS: 1456 #endif // defined(GL_POLYGON_OFFSET_UNITS) 1457 #if defined(GL_PROJECTION_STACK_DEPTH) 1458 case GL_PROJECTION_STACK_DEPTH: 1459 #endif // defined(GL_PROJECTION_STACK_DEPTH) 1460 #if defined(GL_RED_BITS) 1461 case GL_RED_BITS: 1462 #endif // defined(GL_RED_BITS) 1463 #if defined(GL_SHADE_MODEL) 1464 case GL_SHADE_MODEL: 1465 #endif // defined(GL_SHADE_MODEL) 1466 #if defined(GL_STENCIL_BITS) 1467 case GL_STENCIL_BITS: 1468 #endif // defined(GL_STENCIL_BITS) 1469 #if defined(GL_STENCIL_CLEAR_VALUE) 1470 case GL_STENCIL_CLEAR_VALUE: 1471 #endif // defined(GL_STENCIL_CLEAR_VALUE) 1472 #if defined(GL_STENCIL_FAIL) 1473 case GL_STENCIL_FAIL: 1474 #endif // defined(GL_STENCIL_FAIL) 1475 #if defined(GL_STENCIL_FUNC) 1476 case GL_STENCIL_FUNC: 1477 #endif // defined(GL_STENCIL_FUNC) 1478 #if defined(GL_STENCIL_PASS_DEPTH_FAIL) 1479 case GL_STENCIL_PASS_DEPTH_FAIL: 1480 #endif // defined(GL_STENCIL_PASS_DEPTH_FAIL) 1481 #if defined(GL_STENCIL_PASS_DEPTH_PASS) 1482 case GL_STENCIL_PASS_DEPTH_PASS: 1483 #endif // defined(GL_STENCIL_PASS_DEPTH_PASS) 1484 #if defined(GL_STENCIL_REF) 1485 case GL_STENCIL_REF: 1486 #endif // defined(GL_STENCIL_REF) 1487 #if defined(GL_STENCIL_VALUE_MASK) 1488 case GL_STENCIL_VALUE_MASK: 1489 #endif // defined(GL_STENCIL_VALUE_MASK) 1490 #if defined(GL_STENCIL_WRITEMASK) 1491 case GL_STENCIL_WRITEMASK: 1492 #endif // defined(GL_STENCIL_WRITEMASK) 1493 #if defined(GL_SUBPIXEL_BITS) 1494 case GL_SUBPIXEL_BITS: 1495 #endif // defined(GL_SUBPIXEL_BITS) 1496 #if defined(GL_TEXTURE_BINDING_2D) 1497 case GL_TEXTURE_BINDING_2D: 1498 #endif // defined(GL_TEXTURE_BINDING_2D) 1499 #if defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING) 1500 case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING: 1501 #endif // defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING) 1502 #if defined(GL_TEXTURE_COORD_ARRAY_SIZE) 1503 case GL_TEXTURE_COORD_ARRAY_SIZE: 1504 #endif // defined(GL_TEXTURE_COORD_ARRAY_SIZE) 1505 #if defined(GL_TEXTURE_COORD_ARRAY_STRIDE) 1506 case GL_TEXTURE_COORD_ARRAY_STRIDE: 1507 #endif // defined(GL_TEXTURE_COORD_ARRAY_STRIDE) 1508 #if defined(GL_TEXTURE_COORD_ARRAY_TYPE) 1509 case GL_TEXTURE_COORD_ARRAY_TYPE: 1510 #endif // defined(GL_TEXTURE_COORD_ARRAY_TYPE) 1511 #if defined(GL_TEXTURE_STACK_DEPTH) 1512 case GL_TEXTURE_STACK_DEPTH: 1513 #endif // defined(GL_TEXTURE_STACK_DEPTH) 1514 #if defined(GL_UNPACK_ALIGNMENT) 1515 case GL_UNPACK_ALIGNMENT: 1516 #endif // defined(GL_UNPACK_ALIGNMENT) 1517 #if defined(GL_VERTEX_ARRAY_BUFFER_BINDING) 1518 case GL_VERTEX_ARRAY_BUFFER_BINDING: 1519 #endif // defined(GL_VERTEX_ARRAY_BUFFER_BINDING) 1520 #if defined(GL_VERTEX_ARRAY_SIZE) 1521 case GL_VERTEX_ARRAY_SIZE: 1522 #endif // defined(GL_VERTEX_ARRAY_SIZE) 1523 #if defined(GL_VERTEX_ARRAY_STRIDE) 1524 case GL_VERTEX_ARRAY_STRIDE: 1525 #endif // defined(GL_VERTEX_ARRAY_STRIDE) 1526 #if defined(GL_VERTEX_ARRAY_TYPE) 1527 case GL_VERTEX_ARRAY_TYPE: 1528 #endif // defined(GL_VERTEX_ARRAY_TYPE) 1529 #if defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES) 1530 case GL_WEIGHT_ARRAY_BUFFER_BINDING_OES: 1531 #endif // defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES) 1532 #if defined(GL_WEIGHT_ARRAY_SIZE_OES) 1533 case GL_WEIGHT_ARRAY_SIZE_OES: 1534 #endif // defined(GL_WEIGHT_ARRAY_SIZE_OES) 1535 #if defined(GL_WEIGHT_ARRAY_STRIDE_OES) 1536 case GL_WEIGHT_ARRAY_STRIDE_OES: 1537 #endif // defined(GL_WEIGHT_ARRAY_STRIDE_OES) 1538 #if defined(GL_WEIGHT_ARRAY_TYPE_OES) 1539 case GL_WEIGHT_ARRAY_TYPE_OES: 1540 #endif // defined(GL_WEIGHT_ARRAY_TYPE_OES) 1541 _needed = 1; 1542 break; 1543 #if defined(GL_ALIASED_POINT_SIZE_RANGE) 1544 case GL_ALIASED_POINT_SIZE_RANGE: 1545 #endif // defined(GL_ALIASED_POINT_SIZE_RANGE) 1546 #if defined(GL_ALIASED_LINE_WIDTH_RANGE) 1547 case GL_ALIASED_LINE_WIDTH_RANGE: 1548 #endif // defined(GL_ALIASED_LINE_WIDTH_RANGE) 1549 #if defined(GL_DEPTH_RANGE) 1550 case GL_DEPTH_RANGE: 1551 #endif // defined(GL_DEPTH_RANGE) 1552 #if defined(GL_MAX_VIEWPORT_DIMS) 1553 case GL_MAX_VIEWPORT_DIMS: 1554 #endif // defined(GL_MAX_VIEWPORT_DIMS) 1555 #if defined(GL_SMOOTH_LINE_WIDTH_RANGE) 1556 case GL_SMOOTH_LINE_WIDTH_RANGE: 1557 #endif // defined(GL_SMOOTH_LINE_WIDTH_RANGE) 1558 #if defined(GL_SMOOTH_POINT_SIZE_RANGE) 1559 case GL_SMOOTH_POINT_SIZE_RANGE: 1560 #endif // defined(GL_SMOOTH_POINT_SIZE_RANGE) 1561 _needed = 2; 1562 break; 1563 #if defined(GL_COLOR_CLEAR_VALUE) 1564 case GL_COLOR_CLEAR_VALUE: 1565 #endif // defined(GL_COLOR_CLEAR_VALUE) 1566 #if defined(GL_COLOR_WRITEMASK) 1567 case GL_COLOR_WRITEMASK: 1568 #endif // defined(GL_COLOR_WRITEMASK) 1569 #if defined(GL_FOG_COLOR) 1570 case GL_FOG_COLOR: 1571 #endif // defined(GL_FOG_COLOR) 1572 #if defined(GL_LIGHT_MODEL_AMBIENT) 1573 case GL_LIGHT_MODEL_AMBIENT: 1574 #endif // defined(GL_LIGHT_MODEL_AMBIENT) 1575 #if defined(GL_SCISSOR_BOX) 1576 case GL_SCISSOR_BOX: 1577 #endif // defined(GL_SCISSOR_BOX) 1578 #if defined(GL_VIEWPORT) 1579 case GL_VIEWPORT: 1580 #endif // defined(GL_VIEWPORT) 1581 _needed = 4; 1582 break; 1583 #if defined(GL_MODELVIEW_MATRIX) 1584 case GL_MODELVIEW_MATRIX: 1585 #endif // defined(GL_MODELVIEW_MATRIX) 1586 #if defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES) 1587 case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES: 1588 #endif // defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES) 1589 #if defined(GL_PROJECTION_MATRIX) 1590 case GL_PROJECTION_MATRIX: 1591 #endif // defined(GL_PROJECTION_MATRIX) 1592 #if defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES) 1593 case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES: 1594 #endif // defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES) 1595 #if defined(GL_TEXTURE_MATRIX) 1596 case GL_TEXTURE_MATRIX: 1597 #endif // defined(GL_TEXTURE_MATRIX) 1598 #if defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES) 1599 case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES: 1600 #endif // defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES) 1601 _needed = 16; 1602 break; 1603 #if defined(GL_COMPRESSED_TEXTURE_FORMATS) 1604 case GL_COMPRESSED_TEXTURE_FORMATS: 1605 #endif // defined(GL_COMPRESSED_TEXTURE_FORMATS) 1606 _needed = getNumCompressedTextureFormats(); 1607 break; 1608 default: 1609 _needed = 1; 1610 break; 1611 } 1612 if (_remaining < _needed) { 1613 _exception = 1; 1614 _exceptionType = "java/lang/IllegalArgumentException"; 1615 _exceptionMessage = "length - offset < needed"; 1616 goto exit; 1617 } 1618 params_base = (GLint *) 1619 _env->GetIntArrayElements(params_ref, (jboolean *)0); 1620 params = params_base + offset; 1621 1622 glGetIntegerv( 1623 (GLenum)pname, 1624 (GLint *)params 1625 ); 1626 1627 exit: 1628 if (params_base) { 1629 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 1630 _exception ? JNI_ABORT: 0); 1631 } 1632 if (_exception) { 1633 jniThrowException(_env, _exceptionType, _exceptionMessage); 1634 } 1635 } 1636 1637 /* void glGetIntegerv ( GLenum pname, GLint *params ) */ 1638 static void 1639 android_glGetIntegerv__ILjava_nio_IntBuffer_2 1640 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 1641 jint _exception = 0; 1642 const char * _exceptionType = NULL; 1643 const char * _exceptionMessage = NULL; 1644 jintArray _array = (jintArray) 0; 1645 jint _bufferOffset = (jint) 0; 1646 jint _remaining; 1647 GLint *params = (GLint *) 0; 1648 1649 if (!params_buf) { 1650 _exception = 1; 1651 _exceptionType = "java/lang/IllegalArgumentException"; 1652 _exceptionMessage = "params == null"; 1653 goto exit; 1654 } 1655 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1656 int _needed; 1657 switch (pname) { 1658 #if defined(GL_ALPHA_BITS) 1659 case GL_ALPHA_BITS: 1660 #endif // defined(GL_ALPHA_BITS) 1661 #if defined(GL_ALPHA_TEST_FUNC) 1662 case GL_ALPHA_TEST_FUNC: 1663 #endif // defined(GL_ALPHA_TEST_FUNC) 1664 #if defined(GL_ALPHA_TEST_REF) 1665 case GL_ALPHA_TEST_REF: 1666 #endif // defined(GL_ALPHA_TEST_REF) 1667 #if defined(GL_BLEND_DST) 1668 case GL_BLEND_DST: 1669 #endif // defined(GL_BLEND_DST) 1670 #if defined(GL_BLUE_BITS) 1671 case GL_BLUE_BITS: 1672 #endif // defined(GL_BLUE_BITS) 1673 #if defined(GL_COLOR_ARRAY_BUFFER_BINDING) 1674 case GL_COLOR_ARRAY_BUFFER_BINDING: 1675 #endif // defined(GL_COLOR_ARRAY_BUFFER_BINDING) 1676 #if defined(GL_COLOR_ARRAY_SIZE) 1677 case GL_COLOR_ARRAY_SIZE: 1678 #endif // defined(GL_COLOR_ARRAY_SIZE) 1679 #if defined(GL_COLOR_ARRAY_STRIDE) 1680 case GL_COLOR_ARRAY_STRIDE: 1681 #endif // defined(GL_COLOR_ARRAY_STRIDE) 1682 #if defined(GL_COLOR_ARRAY_TYPE) 1683 case GL_COLOR_ARRAY_TYPE: 1684 #endif // defined(GL_COLOR_ARRAY_TYPE) 1685 #if defined(GL_CULL_FACE) 1686 case GL_CULL_FACE: 1687 #endif // defined(GL_CULL_FACE) 1688 #if defined(GL_DEPTH_BITS) 1689 case GL_DEPTH_BITS: 1690 #endif // defined(GL_DEPTH_BITS) 1691 #if defined(GL_DEPTH_CLEAR_VALUE) 1692 case GL_DEPTH_CLEAR_VALUE: 1693 #endif // defined(GL_DEPTH_CLEAR_VALUE) 1694 #if defined(GL_DEPTH_FUNC) 1695 case GL_DEPTH_FUNC: 1696 #endif // defined(GL_DEPTH_FUNC) 1697 #if defined(GL_DEPTH_WRITEMASK) 1698 case GL_DEPTH_WRITEMASK: 1699 #endif // defined(GL_DEPTH_WRITEMASK) 1700 #if defined(GL_FOG_DENSITY) 1701 case GL_FOG_DENSITY: 1702 #endif // defined(GL_FOG_DENSITY) 1703 #if defined(GL_FOG_END) 1704 case GL_FOG_END: 1705 #endif // defined(GL_FOG_END) 1706 #if defined(GL_FOG_MODE) 1707 case GL_FOG_MODE: 1708 #endif // defined(GL_FOG_MODE) 1709 #if defined(GL_FOG_START) 1710 case GL_FOG_START: 1711 #endif // defined(GL_FOG_START) 1712 #if defined(GL_FRONT_FACE) 1713 case GL_FRONT_FACE: 1714 #endif // defined(GL_FRONT_FACE) 1715 #if defined(GL_GREEN_BITS) 1716 case GL_GREEN_BITS: 1717 #endif // defined(GL_GREEN_BITS) 1718 #if defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES) 1719 case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES: 1720 #endif // defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES) 1721 #if defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES) 1722 case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES: 1723 #endif // defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES) 1724 #if defined(GL_LIGHT_MODEL_COLOR_CONTROL) 1725 case GL_LIGHT_MODEL_COLOR_CONTROL: 1726 #endif // defined(GL_LIGHT_MODEL_COLOR_CONTROL) 1727 #if defined(GL_LIGHT_MODEL_LOCAL_VIEWER) 1728 case GL_LIGHT_MODEL_LOCAL_VIEWER: 1729 #endif // defined(GL_LIGHT_MODEL_LOCAL_VIEWER) 1730 #if defined(GL_LIGHT_MODEL_TWO_SIDE) 1731 case GL_LIGHT_MODEL_TWO_SIDE: 1732 #endif // defined(GL_LIGHT_MODEL_TWO_SIDE) 1733 #if defined(GL_LINE_SMOOTH_HINT) 1734 case GL_LINE_SMOOTH_HINT: 1735 #endif // defined(GL_LINE_SMOOTH_HINT) 1736 #if defined(GL_LINE_WIDTH) 1737 case GL_LINE_WIDTH: 1738 #endif // defined(GL_LINE_WIDTH) 1739 #if defined(GL_LOGIC_OP_MODE) 1740 case GL_LOGIC_OP_MODE: 1741 #endif // defined(GL_LOGIC_OP_MODE) 1742 #if defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES) 1743 case GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES: 1744 #endif // defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES) 1745 #if defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES) 1746 case GL_MATRIX_INDEX_ARRAY_SIZE_OES: 1747 #endif // defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES) 1748 #if defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES) 1749 case GL_MATRIX_INDEX_ARRAY_STRIDE_OES: 1750 #endif // defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES) 1751 #if defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES) 1752 case GL_MATRIX_INDEX_ARRAY_TYPE_OES: 1753 #endif // defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES) 1754 #if defined(GL_MATRIX_MODE) 1755 case GL_MATRIX_MODE: 1756 #endif // defined(GL_MATRIX_MODE) 1757 #if defined(GL_MAX_CLIP_PLANES) 1758 case GL_MAX_CLIP_PLANES: 1759 #endif // defined(GL_MAX_CLIP_PLANES) 1760 #if defined(GL_MAX_ELEMENTS_INDICES) 1761 case GL_MAX_ELEMENTS_INDICES: 1762 #endif // defined(GL_MAX_ELEMENTS_INDICES) 1763 #if defined(GL_MAX_ELEMENTS_VERTICES) 1764 case GL_MAX_ELEMENTS_VERTICES: 1765 #endif // defined(GL_MAX_ELEMENTS_VERTICES) 1766 #if defined(GL_MAX_LIGHTS) 1767 case GL_MAX_LIGHTS: 1768 #endif // defined(GL_MAX_LIGHTS) 1769 #if defined(GL_MAX_MODELVIEW_STACK_DEPTH) 1770 case GL_MAX_MODELVIEW_STACK_DEPTH: 1771 #endif // defined(GL_MAX_MODELVIEW_STACK_DEPTH) 1772 #if defined(GL_MAX_PALETTE_MATRICES_OES) 1773 case GL_MAX_PALETTE_MATRICES_OES: 1774 #endif // defined(GL_MAX_PALETTE_MATRICES_OES) 1775 #if defined(GL_MAX_PROJECTION_STACK_DEPTH) 1776 case GL_MAX_PROJECTION_STACK_DEPTH: 1777 #endif // defined(GL_MAX_PROJECTION_STACK_DEPTH) 1778 #if defined(GL_MAX_TEXTURE_SIZE) 1779 case GL_MAX_TEXTURE_SIZE: 1780 #endif // defined(GL_MAX_TEXTURE_SIZE) 1781 #if defined(GL_MAX_TEXTURE_STACK_DEPTH) 1782 case GL_MAX_TEXTURE_STACK_DEPTH: 1783 #endif // defined(GL_MAX_TEXTURE_STACK_DEPTH) 1784 #if defined(GL_MAX_TEXTURE_UNITS) 1785 case GL_MAX_TEXTURE_UNITS: 1786 #endif // defined(GL_MAX_TEXTURE_UNITS) 1787 #if defined(GL_MAX_VERTEX_UNITS_OES) 1788 case GL_MAX_VERTEX_UNITS_OES: 1789 #endif // defined(GL_MAX_VERTEX_UNITS_OES) 1790 #if defined(GL_MODELVIEW_STACK_DEPTH) 1791 case GL_MODELVIEW_STACK_DEPTH: 1792 #endif // defined(GL_MODELVIEW_STACK_DEPTH) 1793 #if defined(GL_NORMAL_ARRAY_BUFFER_BINDING) 1794 case GL_NORMAL_ARRAY_BUFFER_BINDING: 1795 #endif // defined(GL_NORMAL_ARRAY_BUFFER_BINDING) 1796 #if defined(GL_NORMAL_ARRAY_STRIDE) 1797 case GL_NORMAL_ARRAY_STRIDE: 1798 #endif // defined(GL_NORMAL_ARRAY_STRIDE) 1799 #if defined(GL_NORMAL_ARRAY_TYPE) 1800 case GL_NORMAL_ARRAY_TYPE: 1801 #endif // defined(GL_NORMAL_ARRAY_TYPE) 1802 #if defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS) 1803 case GL_NUM_COMPRESSED_TEXTURE_FORMATS: 1804 #endif // defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS) 1805 #if defined(GL_PACK_ALIGNMENT) 1806 case GL_PACK_ALIGNMENT: 1807 #endif // defined(GL_PACK_ALIGNMENT) 1808 #if defined(GL_PERSPECTIVE_CORRECTION_HINT) 1809 case GL_PERSPECTIVE_CORRECTION_HINT: 1810 #endif // defined(GL_PERSPECTIVE_CORRECTION_HINT) 1811 #if defined(GL_POINT_SIZE) 1812 case GL_POINT_SIZE: 1813 #endif // defined(GL_POINT_SIZE) 1814 #if defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES) 1815 case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES: 1816 #endif // defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES) 1817 #if defined(GL_POINT_SIZE_ARRAY_STRIDE_OES) 1818 case GL_POINT_SIZE_ARRAY_STRIDE_OES: 1819 #endif // defined(GL_POINT_SIZE_ARRAY_STRIDE_OES) 1820 #if defined(GL_POINT_SIZE_ARRAY_TYPE_OES) 1821 case GL_POINT_SIZE_ARRAY_TYPE_OES: 1822 #endif // defined(GL_POINT_SIZE_ARRAY_TYPE_OES) 1823 #if defined(GL_POINT_SMOOTH_HINT) 1824 case GL_POINT_SMOOTH_HINT: 1825 #endif // defined(GL_POINT_SMOOTH_HINT) 1826 #if defined(GL_POLYGON_OFFSET_FACTOR) 1827 case GL_POLYGON_OFFSET_FACTOR: 1828 #endif // defined(GL_POLYGON_OFFSET_FACTOR) 1829 #if defined(GL_POLYGON_OFFSET_UNITS) 1830 case GL_POLYGON_OFFSET_UNITS: 1831 #endif // defined(GL_POLYGON_OFFSET_UNITS) 1832 #if defined(GL_PROJECTION_STACK_DEPTH) 1833 case GL_PROJECTION_STACK_DEPTH: 1834 #endif // defined(GL_PROJECTION_STACK_DEPTH) 1835 #if defined(GL_RED_BITS) 1836 case GL_RED_BITS: 1837 #endif // defined(GL_RED_BITS) 1838 #if defined(GL_SHADE_MODEL) 1839 case GL_SHADE_MODEL: 1840 #endif // defined(GL_SHADE_MODEL) 1841 #if defined(GL_STENCIL_BITS) 1842 case GL_STENCIL_BITS: 1843 #endif // defined(GL_STENCIL_BITS) 1844 #if defined(GL_STENCIL_CLEAR_VALUE) 1845 case GL_STENCIL_CLEAR_VALUE: 1846 #endif // defined(GL_STENCIL_CLEAR_VALUE) 1847 #if defined(GL_STENCIL_FAIL) 1848 case GL_STENCIL_FAIL: 1849 #endif // defined(GL_STENCIL_FAIL) 1850 #if defined(GL_STENCIL_FUNC) 1851 case GL_STENCIL_FUNC: 1852 #endif // defined(GL_STENCIL_FUNC) 1853 #if defined(GL_STENCIL_PASS_DEPTH_FAIL) 1854 case GL_STENCIL_PASS_DEPTH_FAIL: 1855 #endif // defined(GL_STENCIL_PASS_DEPTH_FAIL) 1856 #if defined(GL_STENCIL_PASS_DEPTH_PASS) 1857 case GL_STENCIL_PASS_DEPTH_PASS: 1858 #endif // defined(GL_STENCIL_PASS_DEPTH_PASS) 1859 #if defined(GL_STENCIL_REF) 1860 case GL_STENCIL_REF: 1861 #endif // defined(GL_STENCIL_REF) 1862 #if defined(GL_STENCIL_VALUE_MASK) 1863 case GL_STENCIL_VALUE_MASK: 1864 #endif // defined(GL_STENCIL_VALUE_MASK) 1865 #if defined(GL_STENCIL_WRITEMASK) 1866 case GL_STENCIL_WRITEMASK: 1867 #endif // defined(GL_STENCIL_WRITEMASK) 1868 #if defined(GL_SUBPIXEL_BITS) 1869 case GL_SUBPIXEL_BITS: 1870 #endif // defined(GL_SUBPIXEL_BITS) 1871 #if defined(GL_TEXTURE_BINDING_2D) 1872 case GL_TEXTURE_BINDING_2D: 1873 #endif // defined(GL_TEXTURE_BINDING_2D) 1874 #if defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING) 1875 case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING: 1876 #endif // defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING) 1877 #if defined(GL_TEXTURE_COORD_ARRAY_SIZE) 1878 case GL_TEXTURE_COORD_ARRAY_SIZE: 1879 #endif // defined(GL_TEXTURE_COORD_ARRAY_SIZE) 1880 #if defined(GL_TEXTURE_COORD_ARRAY_STRIDE) 1881 case GL_TEXTURE_COORD_ARRAY_STRIDE: 1882 #endif // defined(GL_TEXTURE_COORD_ARRAY_STRIDE) 1883 #if defined(GL_TEXTURE_COORD_ARRAY_TYPE) 1884 case GL_TEXTURE_COORD_ARRAY_TYPE: 1885 #endif // defined(GL_TEXTURE_COORD_ARRAY_TYPE) 1886 #if defined(GL_TEXTURE_STACK_DEPTH) 1887 case GL_TEXTURE_STACK_DEPTH: 1888 #endif // defined(GL_TEXTURE_STACK_DEPTH) 1889 #if defined(GL_UNPACK_ALIGNMENT) 1890 case GL_UNPACK_ALIGNMENT: 1891 #endif // defined(GL_UNPACK_ALIGNMENT) 1892 #if defined(GL_VERTEX_ARRAY_BUFFER_BINDING) 1893 case GL_VERTEX_ARRAY_BUFFER_BINDING: 1894 #endif // defined(GL_VERTEX_ARRAY_BUFFER_BINDING) 1895 #if defined(GL_VERTEX_ARRAY_SIZE) 1896 case GL_VERTEX_ARRAY_SIZE: 1897 #endif // defined(GL_VERTEX_ARRAY_SIZE) 1898 #if defined(GL_VERTEX_ARRAY_STRIDE) 1899 case GL_VERTEX_ARRAY_STRIDE: 1900 #endif // defined(GL_VERTEX_ARRAY_STRIDE) 1901 #if defined(GL_VERTEX_ARRAY_TYPE) 1902 case GL_VERTEX_ARRAY_TYPE: 1903 #endif // defined(GL_VERTEX_ARRAY_TYPE) 1904 #if defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES) 1905 case GL_WEIGHT_ARRAY_BUFFER_BINDING_OES: 1906 #endif // defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES) 1907 #if defined(GL_WEIGHT_ARRAY_SIZE_OES) 1908 case GL_WEIGHT_ARRAY_SIZE_OES: 1909 #endif // defined(GL_WEIGHT_ARRAY_SIZE_OES) 1910 #if defined(GL_WEIGHT_ARRAY_STRIDE_OES) 1911 case GL_WEIGHT_ARRAY_STRIDE_OES: 1912 #endif // defined(GL_WEIGHT_ARRAY_STRIDE_OES) 1913 #if defined(GL_WEIGHT_ARRAY_TYPE_OES) 1914 case GL_WEIGHT_ARRAY_TYPE_OES: 1915 #endif // defined(GL_WEIGHT_ARRAY_TYPE_OES) 1916 _needed = 1; 1917 break; 1918 #if defined(GL_ALIASED_POINT_SIZE_RANGE) 1919 case GL_ALIASED_POINT_SIZE_RANGE: 1920 #endif // defined(GL_ALIASED_POINT_SIZE_RANGE) 1921 #if defined(GL_ALIASED_LINE_WIDTH_RANGE) 1922 case GL_ALIASED_LINE_WIDTH_RANGE: 1923 #endif // defined(GL_ALIASED_LINE_WIDTH_RANGE) 1924 #if defined(GL_DEPTH_RANGE) 1925 case GL_DEPTH_RANGE: 1926 #endif // defined(GL_DEPTH_RANGE) 1927 #if defined(GL_MAX_VIEWPORT_DIMS) 1928 case GL_MAX_VIEWPORT_DIMS: 1929 #endif // defined(GL_MAX_VIEWPORT_DIMS) 1930 #if defined(GL_SMOOTH_LINE_WIDTH_RANGE) 1931 case GL_SMOOTH_LINE_WIDTH_RANGE: 1932 #endif // defined(GL_SMOOTH_LINE_WIDTH_RANGE) 1933 #if defined(GL_SMOOTH_POINT_SIZE_RANGE) 1934 case GL_SMOOTH_POINT_SIZE_RANGE: 1935 #endif // defined(GL_SMOOTH_POINT_SIZE_RANGE) 1936 _needed = 2; 1937 break; 1938 #if defined(GL_COLOR_CLEAR_VALUE) 1939 case GL_COLOR_CLEAR_VALUE: 1940 #endif // defined(GL_COLOR_CLEAR_VALUE) 1941 #if defined(GL_COLOR_WRITEMASK) 1942 case GL_COLOR_WRITEMASK: 1943 #endif // defined(GL_COLOR_WRITEMASK) 1944 #if defined(GL_FOG_COLOR) 1945 case GL_FOG_COLOR: 1946 #endif // defined(GL_FOG_COLOR) 1947 #if defined(GL_LIGHT_MODEL_AMBIENT) 1948 case GL_LIGHT_MODEL_AMBIENT: 1949 #endif // defined(GL_LIGHT_MODEL_AMBIENT) 1950 #if defined(GL_SCISSOR_BOX) 1951 case GL_SCISSOR_BOX: 1952 #endif // defined(GL_SCISSOR_BOX) 1953 #if defined(GL_VIEWPORT) 1954 case GL_VIEWPORT: 1955 #endif // defined(GL_VIEWPORT) 1956 _needed = 4; 1957 break; 1958 #if defined(GL_MODELVIEW_MATRIX) 1959 case GL_MODELVIEW_MATRIX: 1960 #endif // defined(GL_MODELVIEW_MATRIX) 1961 #if defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES) 1962 case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES: 1963 #endif // defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES) 1964 #if defined(GL_PROJECTION_MATRIX) 1965 case GL_PROJECTION_MATRIX: 1966 #endif // defined(GL_PROJECTION_MATRIX) 1967 #if defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES) 1968 case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES: 1969 #endif // defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES) 1970 #if defined(GL_TEXTURE_MATRIX) 1971 case GL_TEXTURE_MATRIX: 1972 #endif // defined(GL_TEXTURE_MATRIX) 1973 #if defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES) 1974 case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES: 1975 #endif // defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES) 1976 _needed = 16; 1977 break; 1978 #if defined(GL_COMPRESSED_TEXTURE_FORMATS) 1979 case GL_COMPRESSED_TEXTURE_FORMATS: 1980 #endif // defined(GL_COMPRESSED_TEXTURE_FORMATS) 1981 _needed = getNumCompressedTextureFormats(); 1982 break; 1983 default: 1984 _needed = 1; 1985 break; 1986 } 1987 if (_remaining < _needed) { 1988 _exception = 1; 1989 _exceptionType = "java/lang/IllegalArgumentException"; 1990 _exceptionMessage = "remaining() < needed"; 1991 goto exit; 1992 } 1993 if (params == NULL) { 1994 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1995 params = (GLint *) (_paramsBase + _bufferOffset); 1996 } 1997 glGetIntegerv( 1998 (GLenum)pname, 1999 (GLint *)params 2000 ); 2001 2002 exit: 2003 if (_array) { 2004 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 2005 } 2006 if (_exception) { 2007 jniThrowException(_env, _exceptionType, _exceptionMessage); 2008 } 2009 } 2010 2011 /* const GLubyte * glGetString ( GLenum name ) */ 2012 static jstring android_glGetString(JNIEnv *_env, jobject, jint name) { 2013 const char* chars = (const char*) glGetString((GLenum) name); 2014 return _env->NewStringUTF(chars); 2015 } 2016 /* void glHint ( GLenum target, GLenum mode ) */ 2017 static void 2018 android_glHint__II 2019 (JNIEnv *_env, jobject _this, jint target, jint mode) { 2020 glHint( 2021 (GLenum)target, 2022 (GLenum)mode 2023 ); 2024 } 2025 2026 /* void glLightModelf ( GLenum pname, GLfloat param ) */ 2027 static void 2028 android_glLightModelf__IF 2029 (JNIEnv *_env, jobject _this, jint pname, jfloat param) { 2030 glLightModelf( 2031 (GLenum)pname, 2032 (GLfloat)param 2033 ); 2034 } 2035 2036 /* void glLightModelfv ( GLenum pname, const GLfloat *params ) */ 2037 static void 2038 android_glLightModelfv__I_3FI 2039 (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) { 2040 jint _exception = 0; 2041 const char * _exceptionType = NULL; 2042 const char * _exceptionMessage = NULL; 2043 GLfloat *params_base = (GLfloat *) 0; 2044 jint _remaining; 2045 GLfloat *params = (GLfloat *) 0; 2046 2047 if (!params_ref) { 2048 _exception = 1; 2049 _exceptionType = "java/lang/IllegalArgumentException"; 2050 _exceptionMessage = "params == null"; 2051 goto exit; 2052 } 2053 if (offset < 0) { 2054 _exception = 1; 2055 _exceptionType = "java/lang/IllegalArgumentException"; 2056 _exceptionMessage = "offset < 0"; 2057 goto exit; 2058 } 2059 _remaining = _env->GetArrayLength(params_ref) - offset; 2060 int _needed; 2061 switch (pname) { 2062 #if defined(GL_LIGHT_MODEL_TWO_SIDE) 2063 case GL_LIGHT_MODEL_TWO_SIDE: 2064 #endif // defined(GL_LIGHT_MODEL_TWO_SIDE) 2065 _needed = 1; 2066 break; 2067 #if defined(GL_LIGHT_MODEL_AMBIENT) 2068 case GL_LIGHT_MODEL_AMBIENT: 2069 #endif // defined(GL_LIGHT_MODEL_AMBIENT) 2070 _needed = 4; 2071 break; 2072 default: 2073 _needed = 1; 2074 break; 2075 } 2076 if (_remaining < _needed) { 2077 _exception = 1; 2078 _exceptionType = "java/lang/IllegalArgumentException"; 2079 _exceptionMessage = "length - offset < needed"; 2080 goto exit; 2081 } 2082 params_base = (GLfloat *) 2083 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 2084 params = params_base + offset; 2085 2086 glLightModelfv( 2087 (GLenum)pname, 2088 (GLfloat *)params 2089 ); 2090 2091 exit: 2092 if (params_base) { 2093 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 2094 JNI_ABORT); 2095 } 2096 if (_exception) { 2097 jniThrowException(_env, _exceptionType, _exceptionMessage); 2098 } 2099 } 2100 2101 /* void glLightModelfv ( GLenum pname, const GLfloat *params ) */ 2102 static void 2103 android_glLightModelfv__ILjava_nio_FloatBuffer_2 2104 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 2105 jint _exception = 0; 2106 const char * _exceptionType = NULL; 2107 const char * _exceptionMessage = NULL; 2108 jfloatArray _array = (jfloatArray) 0; 2109 jint _bufferOffset = (jint) 0; 2110 jint _remaining; 2111 GLfloat *params = (GLfloat *) 0; 2112 2113 if (!params_buf) { 2114 _exception = 1; 2115 _exceptionType = "java/lang/IllegalArgumentException"; 2116 _exceptionMessage = "params == null"; 2117 goto exit; 2118 } 2119 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2120 int _needed; 2121 switch (pname) { 2122 #if defined(GL_LIGHT_MODEL_TWO_SIDE) 2123 case GL_LIGHT_MODEL_TWO_SIDE: 2124 #endif // defined(GL_LIGHT_MODEL_TWO_SIDE) 2125 _needed = 1; 2126 break; 2127 #if defined(GL_LIGHT_MODEL_AMBIENT) 2128 case GL_LIGHT_MODEL_AMBIENT: 2129 #endif // defined(GL_LIGHT_MODEL_AMBIENT) 2130 _needed = 4; 2131 break; 2132 default: 2133 _needed = 1; 2134 break; 2135 } 2136 if (_remaining < _needed) { 2137 _exception = 1; 2138 _exceptionType = "java/lang/IllegalArgumentException"; 2139 _exceptionMessage = "remaining() < needed"; 2140 goto exit; 2141 } 2142 if (params == NULL) { 2143 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 2144 params = (GLfloat *) (_paramsBase + _bufferOffset); 2145 } 2146 glLightModelfv( 2147 (GLenum)pname, 2148 (GLfloat *)params 2149 ); 2150 2151 exit: 2152 if (_array) { 2153 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT); 2154 } 2155 if (_exception) { 2156 jniThrowException(_env, _exceptionType, _exceptionMessage); 2157 } 2158 } 2159 2160 /* void glLightModelx ( GLenum pname, GLfixed param ) */ 2161 static void 2162 android_glLightModelx__II 2163 (JNIEnv *_env, jobject _this, jint pname, jint param) { 2164 glLightModelx( 2165 (GLenum)pname, 2166 (GLfixed)param 2167 ); 2168 } 2169 2170 /* void glLightModelxv ( GLenum pname, const GLfixed *params ) */ 2171 static void 2172 android_glLightModelxv__I_3II 2173 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) { 2174 jint _exception = 0; 2175 const char * _exceptionType = NULL; 2176 const char * _exceptionMessage = NULL; 2177 GLfixed *params_base = (GLfixed *) 0; 2178 jint _remaining; 2179 GLfixed *params = (GLfixed *) 0; 2180 2181 if (!params_ref) { 2182 _exception = 1; 2183 _exceptionType = "java/lang/IllegalArgumentException"; 2184 _exceptionMessage = "params == null"; 2185 goto exit; 2186 } 2187 if (offset < 0) { 2188 _exception = 1; 2189 _exceptionType = "java/lang/IllegalArgumentException"; 2190 _exceptionMessage = "offset < 0"; 2191 goto exit; 2192 } 2193 _remaining = _env->GetArrayLength(params_ref) - offset; 2194 int _needed; 2195 switch (pname) { 2196 #if defined(GL_LIGHT_MODEL_TWO_SIDE) 2197 case GL_LIGHT_MODEL_TWO_SIDE: 2198 #endif // defined(GL_LIGHT_MODEL_TWO_SIDE) 2199 _needed = 1; 2200 break; 2201 #if defined(GL_LIGHT_MODEL_AMBIENT) 2202 case GL_LIGHT_MODEL_AMBIENT: 2203 #endif // defined(GL_LIGHT_MODEL_AMBIENT) 2204 _needed = 4; 2205 break; 2206 default: 2207 _needed = 1; 2208 break; 2209 } 2210 if (_remaining < _needed) { 2211 _exception = 1; 2212 _exceptionType = "java/lang/IllegalArgumentException"; 2213 _exceptionMessage = "length - offset < needed"; 2214 goto exit; 2215 } 2216 params_base = (GLfixed *) 2217 _env->GetIntArrayElements(params_ref, (jboolean *)0); 2218 params = params_base + offset; 2219 2220 glLightModelxv( 2221 (GLenum)pname, 2222 (GLfixed *)params 2223 ); 2224 2225 exit: 2226 if (params_base) { 2227 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 2228 JNI_ABORT); 2229 } 2230 if (_exception) { 2231 jniThrowException(_env, _exceptionType, _exceptionMessage); 2232 } 2233 } 2234 2235 /* void glLightModelxv ( GLenum pname, const GLfixed *params ) */ 2236 static void 2237 android_glLightModelxv__ILjava_nio_IntBuffer_2 2238 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 2239 jint _exception = 0; 2240 const char * _exceptionType = NULL; 2241 const char * _exceptionMessage = NULL; 2242 jintArray _array = (jintArray) 0; 2243 jint _bufferOffset = (jint) 0; 2244 jint _remaining; 2245 GLfixed *params = (GLfixed *) 0; 2246 2247 if (!params_buf) { 2248 _exception = 1; 2249 _exceptionType = "java/lang/IllegalArgumentException"; 2250 _exceptionMessage = "params == null"; 2251 goto exit; 2252 } 2253 params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2254 int _needed; 2255 switch (pname) { 2256 #if defined(GL_LIGHT_MODEL_TWO_SIDE) 2257 case GL_LIGHT_MODEL_TWO_SIDE: 2258 #endif // defined(GL_LIGHT_MODEL_TWO_SIDE) 2259 _needed = 1; 2260 break; 2261 #if defined(GL_LIGHT_MODEL_AMBIENT) 2262 case GL_LIGHT_MODEL_AMBIENT: 2263 #endif // defined(GL_LIGHT_MODEL_AMBIENT) 2264 _needed = 4; 2265 break; 2266 default: 2267 _needed = 1; 2268 break; 2269 } 2270 if (_remaining < _needed) { 2271 _exception = 1; 2272 _exceptionType = "java/lang/IllegalArgumentException"; 2273 _exceptionMessage = "remaining() < needed"; 2274 goto exit; 2275 } 2276 if (params == NULL) { 2277 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 2278 params = (GLfixed *) (_paramsBase + _bufferOffset); 2279 } 2280 glLightModelxv( 2281 (GLenum)pname, 2282 (GLfixed *)params 2283 ); 2284 2285 exit: 2286 if (_array) { 2287 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT); 2288 } 2289 if (_exception) { 2290 jniThrowException(_env, _exceptionType, _exceptionMessage); 2291 } 2292 } 2293 2294 /* void glLightf ( GLenum light, GLenum pname, GLfloat param ) */ 2295 static void 2296 android_glLightf__IIF 2297 (JNIEnv *_env, jobject _this, jint light, jint pname, jfloat param) { 2298 glLightf( 2299 (GLenum)light, 2300 (GLenum)pname, 2301 (GLfloat)param 2302 ); 2303 } 2304 2305 /* void glLightfv ( GLenum light, GLenum pname, const GLfloat *params ) */ 2306 static void 2307 android_glLightfv__II_3FI 2308 (JNIEnv *_env, jobject _this, jint light, jint pname, jfloatArray params_ref, jint offset) { 2309 jint _exception = 0; 2310 const char * _exceptionType = NULL; 2311 const char * _exceptionMessage = NULL; 2312 GLfloat *params_base = (GLfloat *) 0; 2313 jint _remaining; 2314 GLfloat *params = (GLfloat *) 0; 2315 2316 if (!params_ref) { 2317 _exception = 1; 2318 _exceptionType = "java/lang/IllegalArgumentException"; 2319 _exceptionMessage = "params == null"; 2320 goto exit; 2321 } 2322 if (offset < 0) { 2323 _exception = 1; 2324 _exceptionType = "java/lang/IllegalArgumentException"; 2325 _exceptionMessage = "offset < 0"; 2326 goto exit; 2327 } 2328 _remaining = _env->GetArrayLength(params_ref) - offset; 2329 int _needed; 2330 switch (pname) { 2331 #if defined(GL_SPOT_EXPONENT) 2332 case GL_SPOT_EXPONENT: 2333 #endif // defined(GL_SPOT_EXPONENT) 2334 #if defined(GL_SPOT_CUTOFF) 2335 case GL_SPOT_CUTOFF: 2336 #endif // defined(GL_SPOT_CUTOFF) 2337 #if defined(GL_CONSTANT_ATTENUATION) 2338 case GL_CONSTANT_ATTENUATION: 2339 #endif // defined(GL_CONSTANT_ATTENUATION) 2340 #if defined(GL_LINEAR_ATTENUATION) 2341 case GL_LINEAR_ATTENUATION: 2342 #endif // defined(GL_LINEAR_ATTENUATION) 2343 #if defined(GL_QUADRATIC_ATTENUATION) 2344 case GL_QUADRATIC_ATTENUATION: 2345 #endif // defined(GL_QUADRATIC_ATTENUATION) 2346 _needed = 1; 2347 break; 2348 #if defined(GL_SPOT_DIRECTION) 2349 case GL_SPOT_DIRECTION: 2350 #endif // defined(GL_SPOT_DIRECTION) 2351 _needed = 3; 2352 break; 2353 #if defined(GL_AMBIENT) 2354 case GL_AMBIENT: 2355 #endif // defined(GL_AMBIENT) 2356 #if defined(GL_DIFFUSE) 2357 case GL_DIFFUSE: 2358 #endif // defined(GL_DIFFUSE) 2359 #if defined(GL_SPECULAR) 2360 case GL_SPECULAR: 2361 #endif // defined(GL_SPECULAR) 2362 #if defined(GL_EMISSION) 2363 case GL_EMISSION: 2364 #endif // defined(GL_EMISSION) 2365 _needed = 4; 2366 break; 2367 default: 2368 _needed = 1; 2369 break; 2370 } 2371 if (_remaining < _needed) { 2372 _exception = 1; 2373 _exceptionType = "java/lang/IllegalArgumentException"; 2374 _exceptionMessage = "length - offset < needed"; 2375 goto exit; 2376 } 2377 params_base = (GLfloat *) 2378 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 2379 params = params_base + offset; 2380 2381 glLightfv( 2382 (GLenum)light, 2383 (GLenum)pname, 2384 (GLfloat *)params 2385 ); 2386 2387 exit: 2388 if (params_base) { 2389 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 2390 JNI_ABORT); 2391 } 2392 if (_exception) { 2393 jniThrowException(_env, _exceptionType, _exceptionMessage); 2394 } 2395 } 2396 2397 /* void glLightfv ( GLenum light, GLenum pname, const GLfloat *params ) */ 2398 static void 2399 android_glLightfv__IILjava_nio_FloatBuffer_2 2400 (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) { 2401 jint _exception = 0; 2402 const char * _exceptionType = NULL; 2403 const char * _exceptionMessage = NULL; 2404 jfloatArray _array = (jfloatArray) 0; 2405 jint _bufferOffset = (jint) 0; 2406 jint _remaining; 2407 GLfloat *params = (GLfloat *) 0; 2408 2409 if (!params_buf) { 2410 _exception = 1; 2411 _exceptionType = "java/lang/IllegalArgumentException"; 2412 _exceptionMessage = "params == null"; 2413 goto exit; 2414 } 2415 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2416 int _needed; 2417 switch (pname) { 2418 #if defined(GL_SPOT_EXPONENT) 2419 case GL_SPOT_EXPONENT: 2420 #endif // defined(GL_SPOT_EXPONENT) 2421 #if defined(GL_SPOT_CUTOFF) 2422 case GL_SPOT_CUTOFF: 2423 #endif // defined(GL_SPOT_CUTOFF) 2424 #if defined(GL_CONSTANT_ATTENUATION) 2425 case GL_CONSTANT_ATTENUATION: 2426 #endif // defined(GL_CONSTANT_ATTENUATION) 2427 #if defined(GL_LINEAR_ATTENUATION) 2428 case GL_LINEAR_ATTENUATION: 2429 #endif // defined(GL_LINEAR_ATTENUATION) 2430 #if defined(GL_QUADRATIC_ATTENUATION) 2431 case GL_QUADRATIC_ATTENUATION: 2432 #endif // defined(GL_QUADRATIC_ATTENUATION) 2433 _needed = 1; 2434 break; 2435 #if defined(GL_SPOT_DIRECTION) 2436 case GL_SPOT_DIRECTION: 2437 #endif // defined(GL_SPOT_DIRECTION) 2438 _needed = 3; 2439 break; 2440 #if defined(GL_AMBIENT) 2441 case GL_AMBIENT: 2442 #endif // defined(GL_AMBIENT) 2443 #if defined(GL_DIFFUSE) 2444 case GL_DIFFUSE: 2445 #endif // defined(GL_DIFFUSE) 2446 #if defined(GL_SPECULAR) 2447 case GL_SPECULAR: 2448 #endif // defined(GL_SPECULAR) 2449 #if defined(GL_EMISSION) 2450 case GL_EMISSION: 2451 #endif // defined(GL_EMISSION) 2452 _needed = 4; 2453 break; 2454 default: 2455 _needed = 1; 2456 break; 2457 } 2458 if (_remaining < _needed) { 2459 _exception = 1; 2460 _exceptionType = "java/lang/IllegalArgumentException"; 2461 _exceptionMessage = "remaining() < needed"; 2462 goto exit; 2463 } 2464 if (params == NULL) { 2465 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 2466 params = (GLfloat *) (_paramsBase + _bufferOffset); 2467 } 2468 glLightfv( 2469 (GLenum)light, 2470 (GLenum)pname, 2471 (GLfloat *)params 2472 ); 2473 2474 exit: 2475 if (_array) { 2476 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT); 2477 } 2478 if (_exception) { 2479 jniThrowException(_env, _exceptionType, _exceptionMessage); 2480 } 2481 } 2482 2483 /* void glLightx ( GLenum light, GLenum pname, GLfixed param ) */ 2484 static void 2485 android_glLightx__III 2486 (JNIEnv *_env, jobject _this, jint light, jint pname, jint param) { 2487 glLightx( 2488 (GLenum)light, 2489 (GLenum)pname, 2490 (GLfixed)param 2491 ); 2492 } 2493 2494 /* void glLightxv ( GLenum light, GLenum pname, const GLfixed *params ) */ 2495 static void 2496 android_glLightxv__II_3II 2497 (JNIEnv *_env, jobject _this, jint light, jint pname, jintArray params_ref, jint offset) { 2498 jint _exception = 0; 2499 const char * _exceptionType = NULL; 2500 const char * _exceptionMessage = NULL; 2501 GLfixed *params_base = (GLfixed *) 0; 2502 jint _remaining; 2503 GLfixed *params = (GLfixed *) 0; 2504 2505 if (!params_ref) { 2506 _exception = 1; 2507 _exceptionType = "java/lang/IllegalArgumentException"; 2508 _exceptionMessage = "params == null"; 2509 goto exit; 2510 } 2511 if (offset < 0) { 2512 _exception = 1; 2513 _exceptionType = "java/lang/IllegalArgumentException"; 2514 _exceptionMessage = "offset < 0"; 2515 goto exit; 2516 } 2517 _remaining = _env->GetArrayLength(params_ref) - offset; 2518 int _needed; 2519 switch (pname) { 2520 #if defined(GL_SPOT_EXPONENT) 2521 case GL_SPOT_EXPONENT: 2522 #endif // defined(GL_SPOT_EXPONENT) 2523 #if defined(GL_SPOT_CUTOFF) 2524 case GL_SPOT_CUTOFF: 2525 #endif // defined(GL_SPOT_CUTOFF) 2526 #if defined(GL_CONSTANT_ATTENUATION) 2527 case GL_CONSTANT_ATTENUATION: 2528 #endif // defined(GL_CONSTANT_ATTENUATION) 2529 #if defined(GL_LINEAR_ATTENUATION) 2530 case GL_LINEAR_ATTENUATION: 2531 #endif // defined(GL_LINEAR_ATTENUATION) 2532 #if defined(GL_QUADRATIC_ATTENUATION) 2533 case GL_QUADRATIC_ATTENUATION: 2534 #endif // defined(GL_QUADRATIC_ATTENUATION) 2535 _needed = 1; 2536 break; 2537 #if defined(GL_SPOT_DIRECTION) 2538 case GL_SPOT_DIRECTION: 2539 #endif // defined(GL_SPOT_DIRECTION) 2540 _needed = 3; 2541 break; 2542 #if defined(GL_AMBIENT) 2543 case GL_AMBIENT: 2544 #endif // defined(GL_AMBIENT) 2545 #if defined(GL_DIFFUSE) 2546 case GL_DIFFUSE: 2547 #endif // defined(GL_DIFFUSE) 2548 #if defined(GL_SPECULAR) 2549 case GL_SPECULAR: 2550 #endif // defined(GL_SPECULAR) 2551 #if defined(GL_EMISSION) 2552 case GL_EMISSION: 2553 #endif // defined(GL_EMISSION) 2554 _needed = 4; 2555 break; 2556 default: 2557 _needed = 1; 2558 break; 2559 } 2560 if (_remaining < _needed) { 2561 _exception = 1; 2562 _exceptionType = "java/lang/IllegalArgumentException"; 2563 _exceptionMessage = "length - offset < needed"; 2564 goto exit; 2565 } 2566 params_base = (GLfixed *) 2567 _env->GetIntArrayElements(params_ref, (jboolean *)0); 2568 params = params_base + offset; 2569 2570 glLightxv( 2571 (GLenum)light, 2572 (GLenum)pname, 2573 (GLfixed *)params 2574 ); 2575 2576 exit: 2577 if (params_base) { 2578 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 2579 JNI_ABORT); 2580 } 2581 if (_exception) { 2582 jniThrowException(_env, _exceptionType, _exceptionMessage); 2583 } 2584 } 2585 2586 /* void glLightxv ( GLenum light, GLenum pname, const GLfixed *params ) */ 2587 static void 2588 android_glLightxv__IILjava_nio_IntBuffer_2 2589 (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) { 2590 jint _exception = 0; 2591 const char * _exceptionType = NULL; 2592 const char * _exceptionMessage = NULL; 2593 jintArray _array = (jintArray) 0; 2594 jint _bufferOffset = (jint) 0; 2595 jint _remaining; 2596 GLfixed *params = (GLfixed *) 0; 2597 2598 if (!params_buf) { 2599 _exception = 1; 2600 _exceptionType = "java/lang/IllegalArgumentException"; 2601 _exceptionMessage = "params == null"; 2602 goto exit; 2603 } 2604 params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2605 int _needed; 2606 switch (pname) { 2607 #if defined(GL_SPOT_EXPONENT) 2608 case GL_SPOT_EXPONENT: 2609 #endif // defined(GL_SPOT_EXPONENT) 2610 #if defined(GL_SPOT_CUTOFF) 2611 case GL_SPOT_CUTOFF: 2612 #endif // defined(GL_SPOT_CUTOFF) 2613 #if defined(GL_CONSTANT_ATTENUATION) 2614 case GL_CONSTANT_ATTENUATION: 2615 #endif // defined(GL_CONSTANT_ATTENUATION) 2616 #if defined(GL_LINEAR_ATTENUATION) 2617 case GL_LINEAR_ATTENUATION: 2618 #endif // defined(GL_LINEAR_ATTENUATION) 2619 #if defined(GL_QUADRATIC_ATTENUATION) 2620 case GL_QUADRATIC_ATTENUATION: 2621 #endif // defined(GL_QUADRATIC_ATTENUATION) 2622 _needed = 1; 2623 break; 2624 #if defined(GL_SPOT_DIRECTION) 2625 case GL_SPOT_DIRECTION: 2626 #endif // defined(GL_SPOT_DIRECTION) 2627 _needed = 3; 2628 break; 2629 #if defined(GL_AMBIENT) 2630 case GL_AMBIENT: 2631 #endif // defined(GL_AMBIENT) 2632 #if defined(GL_DIFFUSE) 2633 case GL_DIFFUSE: 2634 #endif // defined(GL_DIFFUSE) 2635 #if defined(GL_SPECULAR) 2636 case GL_SPECULAR: 2637 #endif // defined(GL_SPECULAR) 2638 #if defined(GL_EMISSION) 2639 case GL_EMISSION: 2640 #endif // defined(GL_EMISSION) 2641 _needed = 4; 2642 break; 2643 default: 2644 _needed = 1; 2645 break; 2646 } 2647 if (_remaining < _needed) { 2648 _exception = 1; 2649 _exceptionType = "java/lang/IllegalArgumentException"; 2650 _exceptionMessage = "remaining() < needed"; 2651 goto exit; 2652 } 2653 if (params == NULL) { 2654 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 2655 params = (GLfixed *) (_paramsBase + _bufferOffset); 2656 } 2657 glLightxv( 2658 (GLenum)light, 2659 (GLenum)pname, 2660 (GLfixed *)params 2661 ); 2662 2663 exit: 2664 if (_array) { 2665 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT); 2666 } 2667 if (_exception) { 2668 jniThrowException(_env, _exceptionType, _exceptionMessage); 2669 } 2670 } 2671 2672 /* void glLineWidth ( GLfloat width ) */ 2673 static void 2674 android_glLineWidth__F 2675 (JNIEnv *_env, jobject _this, jfloat width) { 2676 glLineWidth( 2677 (GLfloat)width 2678 ); 2679 } 2680 2681 /* void glLineWidthx ( GLfixed width ) */ 2682 static void 2683 android_glLineWidthx__I 2684 (JNIEnv *_env, jobject _this, jint width) { 2685 glLineWidthx( 2686 (GLfixed)width 2687 ); 2688 } 2689 2690 /* void glLoadIdentity ( void ) */ 2691 static void 2692 android_glLoadIdentity__ 2693 (JNIEnv *_env, jobject _this) { 2694 glLoadIdentity(); 2695 } 2696 2697 /* void glLoadMatrixf ( const GLfloat *m ) */ 2698 static void 2699 android_glLoadMatrixf___3FI 2700 (JNIEnv *_env, jobject _this, jfloatArray m_ref, jint offset) { 2701 jint _exception = 0; 2702 const char * _exceptionType = NULL; 2703 const char * _exceptionMessage = NULL; 2704 GLfloat *m_base = (GLfloat *) 0; 2705 jint _remaining; 2706 GLfloat *m = (GLfloat *) 0; 2707 2708 if (!m_ref) { 2709 _exception = 1; 2710 _exceptionType = "java/lang/IllegalArgumentException"; 2711 _exceptionMessage = "m == null"; 2712 goto exit; 2713 } 2714 if (offset < 0) { 2715 _exception = 1; 2716 _exceptionType = "java/lang/IllegalArgumentException"; 2717 _exceptionMessage = "offset < 0"; 2718 goto exit; 2719 } 2720 _remaining = _env->GetArrayLength(m_ref) - offset; 2721 m_base = (GLfloat *) 2722 _env->GetFloatArrayElements(m_ref, (jboolean *)0); 2723 m = m_base + offset; 2724 2725 glLoadMatrixf( 2726 (GLfloat *)m 2727 ); 2728 2729 exit: 2730 if (m_base) { 2731 _env->ReleaseFloatArrayElements(m_ref, (jfloat*)m_base, 2732 JNI_ABORT); 2733 } 2734 if (_exception) { 2735 jniThrowException(_env, _exceptionType, _exceptionMessage); 2736 } 2737 } 2738 2739 /* void glLoadMatrixf ( const GLfloat *m ) */ 2740 static void 2741 android_glLoadMatrixf__Ljava_nio_FloatBuffer_2 2742 (JNIEnv *_env, jobject _this, jobject m_buf) { 2743 jint _exception = 0; 2744 const char * _exceptionType = NULL; 2745 const char * _exceptionMessage = NULL; 2746 jfloatArray _array = (jfloatArray) 0; 2747 jint _bufferOffset = (jint) 0; 2748 jint _remaining; 2749 GLfloat *m = (GLfloat *) 0; 2750 2751 if (!m_buf) { 2752 _exception = 1; 2753 _exceptionType = "java/lang/IllegalArgumentException"; 2754 _exceptionMessage = "m == null"; 2755 goto exit; 2756 } 2757 m = (GLfloat *)getPointer(_env, m_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2758 if (m == NULL) { 2759 char * _mBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 2760 m = (GLfloat *) (_mBase + _bufferOffset); 2761 } 2762 glLoadMatrixf( 2763 (GLfloat *)m 2764 ); 2765 2766 exit: 2767 if (_array) { 2768 _env->ReleaseFloatArrayElements(_array, (jfloat*)m, JNI_ABORT); 2769 } 2770 if (_exception) { 2771 jniThrowException(_env, _exceptionType, _exceptionMessage); 2772 } 2773 } 2774 2775 /* void glLoadMatrixx ( const GLfixed *m ) */ 2776 static void 2777 android_glLoadMatrixx___3II 2778 (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) { 2779 jint _exception = 0; 2780 const char * _exceptionType = NULL; 2781 const char * _exceptionMessage = NULL; 2782 GLfixed *m_base = (GLfixed *) 0; 2783 jint _remaining; 2784 GLfixed *m = (GLfixed *) 0; 2785 2786 if (!m_ref) { 2787 _exception = 1; 2788 _exceptionType = "java/lang/IllegalArgumentException"; 2789 _exceptionMessage = "m == null"; 2790 goto exit; 2791 } 2792 if (offset < 0) { 2793 _exception = 1; 2794 _exceptionType = "java/lang/IllegalArgumentException"; 2795 _exceptionMessage = "offset < 0"; 2796 goto exit; 2797 } 2798 _remaining = _env->GetArrayLength(m_ref) - offset; 2799 m_base = (GLfixed *) 2800 _env->GetIntArrayElements(m_ref, (jboolean *)0); 2801 m = m_base + offset; 2802 2803 glLoadMatrixx( 2804 (GLfixed *)m 2805 ); 2806 2807 exit: 2808 if (m_base) { 2809 _env->ReleaseIntArrayElements(m_ref, (jint*)m_base, 2810 JNI_ABORT); 2811 } 2812 if (_exception) { 2813 jniThrowException(_env, _exceptionType, _exceptionMessage); 2814 } 2815 } 2816 2817 /* void glLoadMatrixx ( const GLfixed *m ) */ 2818 static void 2819 android_glLoadMatrixx__Ljava_nio_IntBuffer_2 2820 (JNIEnv *_env, jobject _this, jobject m_buf) { 2821 jint _exception = 0; 2822 const char * _exceptionType = NULL; 2823 const char * _exceptionMessage = NULL; 2824 jintArray _array = (jintArray) 0; 2825 jint _bufferOffset = (jint) 0; 2826 jint _remaining; 2827 GLfixed *m = (GLfixed *) 0; 2828 2829 if (!m_buf) { 2830 _exception = 1; 2831 _exceptionType = "java/lang/IllegalArgumentException"; 2832 _exceptionMessage = "m == null"; 2833 goto exit; 2834 } 2835 m = (GLfixed *)getPointer(_env, m_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2836 if (m == NULL) { 2837 char * _mBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 2838 m = (GLfixed *) (_mBase + _bufferOffset); 2839 } 2840 glLoadMatrixx( 2841 (GLfixed *)m 2842 ); 2843 2844 exit: 2845 if (_array) { 2846 _env->ReleaseIntArrayElements(_array, (jint*)m, JNI_ABORT); 2847 } 2848 if (_exception) { 2849 jniThrowException(_env, _exceptionType, _exceptionMessage); 2850 } 2851 } 2852 2853 /* void glLogicOp ( GLenum opcode ) */ 2854 static void 2855 android_glLogicOp__I 2856 (JNIEnv *_env, jobject _this, jint opcode) { 2857 glLogicOp( 2858 (GLenum)opcode 2859 ); 2860 } 2861 2862 /* void glMaterialf ( GLenum face, GLenum pname, GLfloat param ) */ 2863 static void 2864 android_glMaterialf__IIF 2865 (JNIEnv *_env, jobject _this, jint face, jint pname, jfloat param) { 2866 glMaterialf( 2867 (GLenum)face, 2868 (GLenum)pname, 2869 (GLfloat)param 2870 ); 2871 } 2872 2873 /* void glMaterialfv ( GLenum face, GLenum pname, const GLfloat *params ) */ 2874 static void 2875 android_glMaterialfv__II_3FI 2876 (JNIEnv *_env, jobject _this, jint face, jint pname, jfloatArray params_ref, jint offset) { 2877 jint _exception = 0; 2878 const char * _exceptionType = NULL; 2879 const char * _exceptionMessage = NULL; 2880 GLfloat *params_base = (GLfloat *) 0; 2881 jint _remaining; 2882 GLfloat *params = (GLfloat *) 0; 2883 2884 if (!params_ref) { 2885 _exception = 1; 2886 _exceptionType = "java/lang/IllegalArgumentException"; 2887 _exceptionMessage = "params == null"; 2888 goto exit; 2889 } 2890 if (offset < 0) { 2891 _exception = 1; 2892 _exceptionType = "java/lang/IllegalArgumentException"; 2893 _exceptionMessage = "offset < 0"; 2894 goto exit; 2895 } 2896 _remaining = _env->GetArrayLength(params_ref) - offset; 2897 int _needed; 2898 switch (pname) { 2899 #if defined(GL_SHININESS) 2900 case GL_SHININESS: 2901 #endif // defined(GL_SHININESS) 2902 _needed = 1; 2903 break; 2904 #if defined(GL_AMBIENT) 2905 case GL_AMBIENT: 2906 #endif // defined(GL_AMBIENT) 2907 #if defined(GL_DIFFUSE) 2908 case GL_DIFFUSE: 2909 #endif // defined(GL_DIFFUSE) 2910 #if defined(GL_SPECULAR) 2911 case GL_SPECULAR: 2912 #endif // defined(GL_SPECULAR) 2913 #if defined(GL_EMISSION) 2914 case GL_EMISSION: 2915 #endif // defined(GL_EMISSION) 2916 #if defined(GL_AMBIENT_AND_DIFFUSE) 2917 case GL_AMBIENT_AND_DIFFUSE: 2918 #endif // defined(GL_AMBIENT_AND_DIFFUSE) 2919 _needed = 4; 2920 break; 2921 default: 2922 _needed = 1; 2923 break; 2924 } 2925 if (_remaining < _needed) { 2926 _exception = 1; 2927 _exceptionType = "java/lang/IllegalArgumentException"; 2928 _exceptionMessage = "length - offset < needed"; 2929 goto exit; 2930 } 2931 params_base = (GLfloat *) 2932 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 2933 params = params_base + offset; 2934 2935 glMaterialfv( 2936 (GLenum)face, 2937 (GLenum)pname, 2938 (GLfloat *)params 2939 ); 2940 2941 exit: 2942 if (params_base) { 2943 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 2944 JNI_ABORT); 2945 } 2946 if (_exception) { 2947 jniThrowException(_env, _exceptionType, _exceptionMessage); 2948 } 2949 } 2950 2951 /* void glMaterialfv ( GLenum face, GLenum pname, const GLfloat *params ) */ 2952 static void 2953 android_glMaterialfv__IILjava_nio_FloatBuffer_2 2954 (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) { 2955 jint _exception = 0; 2956 const char * _exceptionType = NULL; 2957 const char * _exceptionMessage = NULL; 2958 jfloatArray _array = (jfloatArray) 0; 2959 jint _bufferOffset = (jint) 0; 2960 jint _remaining; 2961 GLfloat *params = (GLfloat *) 0; 2962 2963 if (!params_buf) { 2964 _exception = 1; 2965 _exceptionType = "java/lang/IllegalArgumentException"; 2966 _exceptionMessage = "params == null"; 2967 goto exit; 2968 } 2969 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2970 int _needed; 2971 switch (pname) { 2972 #if defined(GL_SHININESS) 2973 case GL_SHININESS: 2974 #endif // defined(GL_SHININESS) 2975 _needed = 1; 2976 break; 2977 #if defined(GL_AMBIENT) 2978 case GL_AMBIENT: 2979 #endif // defined(GL_AMBIENT) 2980 #if defined(GL_DIFFUSE) 2981 case GL_DIFFUSE: 2982 #endif // defined(GL_DIFFUSE) 2983 #if defined(GL_SPECULAR) 2984 case GL_SPECULAR: 2985 #endif // defined(GL_SPECULAR) 2986 #if defined(GL_EMISSION) 2987 case GL_EMISSION: 2988 #endif // defined(GL_EMISSION) 2989 #if defined(GL_AMBIENT_AND_DIFFUSE) 2990 case GL_AMBIENT_AND_DIFFUSE: 2991 #endif // defined(GL_AMBIENT_AND_DIFFUSE) 2992 _needed = 4; 2993 break; 2994 default: 2995 _needed = 1; 2996 break; 2997 } 2998 if (_remaining < _needed) { 2999 _exception = 1; 3000 _exceptionType = "java/lang/IllegalArgumentException"; 3001 _exceptionMessage = "remaining() < needed"; 3002 goto exit; 3003 } 3004 if (params == NULL) { 3005 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 3006 params = (GLfloat *) (_paramsBase + _bufferOffset); 3007 } 3008 glMaterialfv( 3009 (GLenum)face, 3010 (GLenum)pname, 3011 (GLfloat *)params 3012 ); 3013 3014 exit: 3015 if (_array) { 3016 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT); 3017 } 3018 if (_exception) { 3019 jniThrowException(_env, _exceptionType, _exceptionMessage); 3020 } 3021 } 3022 3023 /* void glMaterialx ( GLenum face, GLenum pname, GLfixed param ) */ 3024 static void 3025 android_glMaterialx__III 3026 (JNIEnv *_env, jobject _this, jint face, jint pname, jint param) { 3027 glMaterialx( 3028 (GLenum)face, 3029 (GLenum)pname, 3030 (GLfixed)param 3031 ); 3032 } 3033 3034 /* void glMaterialxv ( GLenum face, GLenum pname, const GLfixed *params ) */ 3035 static void 3036 android_glMaterialxv__II_3II 3037 (JNIEnv *_env, jobject _this, jint face, jint pname, jintArray params_ref, jint offset) { 3038 jint _exception = 0; 3039 const char * _exceptionType = NULL; 3040 const char * _exceptionMessage = NULL; 3041 GLfixed *params_base = (GLfixed *) 0; 3042 jint _remaining; 3043 GLfixed *params = (GLfixed *) 0; 3044 3045 if (!params_ref) { 3046 _exception = 1; 3047 _exceptionType = "java/lang/IllegalArgumentException"; 3048 _exceptionMessage = "params == null"; 3049 goto exit; 3050 } 3051 if (offset < 0) { 3052 _exception = 1; 3053 _exceptionType = "java/lang/IllegalArgumentException"; 3054 _exceptionMessage = "offset < 0"; 3055 goto exit; 3056 } 3057 _remaining = _env->GetArrayLength(params_ref) - offset; 3058 int _needed; 3059 switch (pname) { 3060 #if defined(GL_SHININESS) 3061 case GL_SHININESS: 3062 #endif // defined(GL_SHININESS) 3063 _needed = 1; 3064 break; 3065 #if defined(GL_AMBIENT) 3066 case GL_AMBIENT: 3067 #endif // defined(GL_AMBIENT) 3068 #if defined(GL_DIFFUSE) 3069 case GL_DIFFUSE: 3070 #endif // defined(GL_DIFFUSE) 3071 #if defined(GL_SPECULAR) 3072 case GL_SPECULAR: 3073 #endif // defined(GL_SPECULAR) 3074 #if defined(GL_EMISSION) 3075 case GL_EMISSION: 3076 #endif // defined(GL_EMISSION) 3077 #if defined(GL_AMBIENT_AND_DIFFUSE) 3078 case GL_AMBIENT_AND_DIFFUSE: 3079 #endif // defined(GL_AMBIENT_AND_DIFFUSE) 3080 _needed = 4; 3081 break; 3082 default: 3083 _needed = 1; 3084 break; 3085 } 3086 if (_remaining < _needed) { 3087 _exception = 1; 3088 _exceptionType = "java/lang/IllegalArgumentException"; 3089 _exceptionMessage = "length - offset < needed"; 3090 goto exit; 3091 } 3092 params_base = (GLfixed *) 3093 _env->GetIntArrayElements(params_ref, (jboolean *)0); 3094 params = params_base + offset; 3095 3096 glMaterialxv( 3097 (GLenum)face, 3098 (GLenum)pname, 3099 (GLfixed *)params 3100 ); 3101 3102 exit: 3103 if (params_base) { 3104 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 3105 JNI_ABORT); 3106 } 3107 if (_exception) { 3108 jniThrowException(_env, _exceptionType, _exceptionMessage); 3109 } 3110 } 3111 3112 /* void glMaterialxv ( GLenum face, GLenum pname, const GLfixed *params ) */ 3113 static void 3114 android_glMaterialxv__IILjava_nio_IntBuffer_2 3115 (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) { 3116 jint _exception = 0; 3117 const char * _exceptionType = NULL; 3118 const char * _exceptionMessage = NULL; 3119 jintArray _array = (jintArray) 0; 3120 jint _bufferOffset = (jint) 0; 3121 jint _remaining; 3122 GLfixed *params = (GLfixed *) 0; 3123 3124 if (!params_buf) { 3125 _exception = 1; 3126 _exceptionType = "java/lang/IllegalArgumentException"; 3127 _exceptionMessage = "params == null"; 3128 goto exit; 3129 } 3130 params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3131 int _needed; 3132 switch (pname) { 3133 #if defined(GL_SHININESS) 3134 case GL_SHININESS: 3135 #endif // defined(GL_SHININESS) 3136 _needed = 1; 3137 break; 3138 #if defined(GL_AMBIENT) 3139 case GL_AMBIENT: 3140 #endif // defined(GL_AMBIENT) 3141 #if defined(GL_DIFFUSE) 3142 case GL_DIFFUSE: 3143 #endif // defined(GL_DIFFUSE) 3144 #if defined(GL_SPECULAR) 3145 case GL_SPECULAR: 3146 #endif // defined(GL_SPECULAR) 3147 #if defined(GL_EMISSION) 3148 case GL_EMISSION: 3149 #endif // defined(GL_EMISSION) 3150 #if defined(GL_AMBIENT_AND_DIFFUSE) 3151 case GL_AMBIENT_AND_DIFFUSE: 3152 #endif // defined(GL_AMBIENT_AND_DIFFUSE) 3153 _needed = 4; 3154 break; 3155 default: 3156 _needed = 1; 3157 break; 3158 } 3159 if (_remaining < _needed) { 3160 _exception = 1; 3161 _exceptionType = "java/lang/IllegalArgumentException"; 3162 _exceptionMessage = "remaining() < needed"; 3163 goto exit; 3164 } 3165 if (params == NULL) { 3166 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 3167 params = (GLfixed *) (_paramsBase + _bufferOffset); 3168 } 3169 glMaterialxv( 3170 (GLenum)face, 3171 (GLenum)pname, 3172 (GLfixed *)params 3173 ); 3174 3175 exit: 3176 if (_array) { 3177 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT); 3178 } 3179 if (_exception) { 3180 jniThrowException(_env, _exceptionType, _exceptionMessage); 3181 } 3182 } 3183 3184 /* void glMatrixMode ( GLenum mode ) */ 3185 static void 3186 android_glMatrixMode__I 3187 (JNIEnv *_env, jobject _this, jint mode) { 3188 glMatrixMode( 3189 (GLenum)mode 3190 ); 3191 } 3192 3193 /* void glMultMatrixf ( const GLfloat *m ) */ 3194 static void 3195 android_glMultMatrixf___3FI 3196 (JNIEnv *_env, jobject _this, jfloatArray m_ref, jint offset) { 3197 jint _exception = 0; 3198 const char * _exceptionType = NULL; 3199 const char * _exceptionMessage = NULL; 3200 GLfloat *m_base = (GLfloat *) 0; 3201 jint _remaining; 3202 GLfloat *m = (GLfloat *) 0; 3203 3204 if (!m_ref) { 3205 _exception = 1; 3206 _exceptionType = "java/lang/IllegalArgumentException"; 3207 _exceptionMessage = "m == null"; 3208 goto exit; 3209 } 3210 if (offset < 0) { 3211 _exception = 1; 3212 _exceptionType = "java/lang/IllegalArgumentException"; 3213 _exceptionMessage = "offset < 0"; 3214 goto exit; 3215 } 3216 _remaining = _env->GetArrayLength(m_ref) - offset; 3217 m_base = (GLfloat *) 3218 _env->GetFloatArrayElements(m_ref, (jboolean *)0); 3219 m = m_base + offset; 3220 3221 glMultMatrixf( 3222 (GLfloat *)m 3223 ); 3224 3225 exit: 3226 if (m_base) { 3227 _env->ReleaseFloatArrayElements(m_ref, (jfloat*)m_base, 3228 JNI_ABORT); 3229 } 3230 if (_exception) { 3231 jniThrowException(_env, _exceptionType, _exceptionMessage); 3232 } 3233 } 3234 3235 /* void glMultMatrixf ( const GLfloat *m ) */ 3236 static void 3237 android_glMultMatrixf__Ljava_nio_FloatBuffer_2 3238 (JNIEnv *_env, jobject _this, jobject m_buf) { 3239 jint _exception = 0; 3240 const char * _exceptionType = NULL; 3241 const char * _exceptionMessage = NULL; 3242 jfloatArray _array = (jfloatArray) 0; 3243 jint _bufferOffset = (jint) 0; 3244 jint _remaining; 3245 GLfloat *m = (GLfloat *) 0; 3246 3247 if (!m_buf) { 3248 _exception = 1; 3249 _exceptionType = "java/lang/IllegalArgumentException"; 3250 _exceptionMessage = "m == null"; 3251 goto exit; 3252 } 3253 m = (GLfloat *)getPointer(_env, m_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3254 if (m == NULL) { 3255 char * _mBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 3256 m = (GLfloat *) (_mBase + _bufferOffset); 3257 } 3258 glMultMatrixf( 3259 (GLfloat *)m 3260 ); 3261 3262 exit: 3263 if (_array) { 3264 _env->ReleaseFloatArrayElements(_array, (jfloat*)m, JNI_ABORT); 3265 } 3266 if (_exception) { 3267 jniThrowException(_env, _exceptionType, _exceptionMessage); 3268 } 3269 } 3270 3271 /* void glMultMatrixx ( const GLfixed *m ) */ 3272 static void 3273 android_glMultMatrixx___3II 3274 (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) { 3275 jint _exception = 0; 3276 const char * _exceptionType = NULL; 3277 const char * _exceptionMessage = NULL; 3278 GLfixed *m_base = (GLfixed *) 0; 3279 jint _remaining; 3280 GLfixed *m = (GLfixed *) 0; 3281 3282 if (!m_ref) { 3283 _exception = 1; 3284 _exceptionType = "java/lang/IllegalArgumentException"; 3285 _exceptionMessage = "m == null"; 3286 goto exit; 3287 } 3288 if (offset < 0) { 3289 _exception = 1; 3290 _exceptionType = "java/lang/IllegalArgumentException"; 3291 _exceptionMessage = "offset < 0"; 3292 goto exit; 3293 } 3294 _remaining = _env->GetArrayLength(m_ref) - offset; 3295 m_base = (GLfixed *) 3296 _env->GetIntArrayElements(m_ref, (jboolean *)0); 3297 m = m_base + offset; 3298 3299 glMultMatrixx( 3300 (GLfixed *)m 3301 ); 3302 3303 exit: 3304 if (m_base) { 3305 _env->ReleaseIntArrayElements(m_ref, (jint*)m_base, 3306 JNI_ABORT); 3307 } 3308 if (_exception) { 3309 jniThrowException(_env, _exceptionType, _exceptionMessage); 3310 } 3311 } 3312 3313 /* void glMultMatrixx ( const GLfixed *m ) */ 3314 static void 3315 android_glMultMatrixx__Ljava_nio_IntBuffer_2 3316 (JNIEnv *_env, jobject _this, jobject m_buf) { 3317 jint _exception = 0; 3318 const char * _exceptionType = NULL; 3319 const char * _exceptionMessage = NULL; 3320 jintArray _array = (jintArray) 0; 3321 jint _bufferOffset = (jint) 0; 3322 jint _remaining; 3323 GLfixed *m = (GLfixed *) 0; 3324 3325 if (!m_buf) { 3326 _exception = 1; 3327 _exceptionType = "java/lang/IllegalArgumentException"; 3328 _exceptionMessage = "m == null"; 3329 goto exit; 3330 } 3331 m = (GLfixed *)getPointer(_env, m_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3332 if (m == NULL) { 3333 char * _mBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 3334 m = (GLfixed *) (_mBase + _bufferOffset); 3335 } 3336 glMultMatrixx( 3337 (GLfixed *)m 3338 ); 3339 3340 exit: 3341 if (_array) { 3342 _env->ReleaseIntArrayElements(_array, (jint*)m, JNI_ABORT); 3343 } 3344 if (_exception) { 3345 jniThrowException(_env, _exceptionType, _exceptionMessage); 3346 } 3347 } 3348 3349 /* void glMultiTexCoord4f ( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q ) */ 3350 static void 3351 android_glMultiTexCoord4f__IFFFF 3352 (JNIEnv *_env, jobject _this, jint target, jfloat s, jfloat t, jfloat r, jfloat q) { 3353 glMultiTexCoord4f( 3354 (GLenum)target, 3355 (GLfloat)s, 3356 (GLfloat)t, 3357 (GLfloat)r, 3358 (GLfloat)q 3359 ); 3360 } 3361 3362 /* void glMultiTexCoord4x ( GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q ) */ 3363 static void 3364 android_glMultiTexCoord4x__IIIII 3365 (JNIEnv *_env, jobject _this, jint target, jint s, jint t, jint r, jint q) { 3366 glMultiTexCoord4x( 3367 (GLenum)target, 3368 (GLfixed)s, 3369 (GLfixed)t, 3370 (GLfixed)r, 3371 (GLfixed)q 3372 ); 3373 } 3374 3375 /* void glNormal3f ( GLfloat nx, GLfloat ny, GLfloat nz ) */ 3376 static void 3377 android_glNormal3f__FFF 3378 (JNIEnv *_env, jobject _this, jfloat nx, jfloat ny, jfloat nz) { 3379 glNormal3f( 3380 (GLfloat)nx, 3381 (GLfloat)ny, 3382 (GLfloat)nz 3383 ); 3384 } 3385 3386 /* void glNormal3x ( GLfixed nx, GLfixed ny, GLfixed nz ) */ 3387 static void 3388 android_glNormal3x__III 3389 (JNIEnv *_env, jobject _this, jint nx, jint ny, jint nz) { 3390 glNormal3x( 3391 (GLfixed)nx, 3392 (GLfixed)ny, 3393 (GLfixed)nz 3394 ); 3395 } 3396 3397 /* void glNormalPointer ( GLenum type, GLsizei stride, const GLvoid *pointer ) */ 3398 static void 3399 android_glNormalPointerBounds__IILjava_nio_Buffer_2I 3400 (JNIEnv *_env, jobject _this, jint type, jint stride, jobject pointer_buf, jint remaining) { 3401 jint _exception = 0; 3402 const char * _exceptionType = NULL; 3403 const char * _exceptionMessage = NULL; 3404 jarray _array = (jarray) 0; 3405 jint _bufferOffset = (jint) 0; 3406 jint _remaining; 3407 GLvoid *pointer = (GLvoid *) 0; 3408 3409 if (pointer_buf) { 3410 pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf); 3411 if ( ! pointer ) { 3412 return; 3413 } 3414 } 3415 glNormalPointerBounds( 3416 (GLenum)type, 3417 (GLsizei)stride, 3418 (GLvoid *)pointer, 3419 (GLsizei)remaining 3420 ); 3421 if (_exception) { 3422 jniThrowException(_env, _exceptionType, _exceptionMessage); 3423 } 3424 } 3425 3426 /* void glOrthof ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */ 3427 static void 3428 android_glOrthof__FFFFFF 3429 (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) { 3430 glOrthof( 3431 (GLfloat)left, 3432 (GLfloat)right, 3433 (GLfloat)bottom, 3434 (GLfloat)top, 3435 (GLfloat)zNear, 3436 (GLfloat)zFar 3437 ); 3438 } 3439 3440 /* void glOrthox ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */ 3441 static void 3442 android_glOrthox__IIIIII 3443 (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) { 3444 glOrthox( 3445 (GLfixed)left, 3446 (GLfixed)right, 3447 (GLfixed)bottom, 3448 (GLfixed)top, 3449 (GLfixed)zNear, 3450 (GLfixed)zFar 3451 ); 3452 } 3453 3454 /* void glPixelStorei ( GLenum pname, GLint param ) */ 3455 static void 3456 android_glPixelStorei__II 3457 (JNIEnv *_env, jobject _this, jint pname, jint param) { 3458 glPixelStorei( 3459 (GLenum)pname, 3460 (GLint)param 3461 ); 3462 } 3463 3464 /* void glPointSize ( GLfloat size ) */ 3465 static void 3466 android_glPointSize__F 3467 (JNIEnv *_env, jobject _this, jfloat size) { 3468 glPointSize( 3469 (GLfloat)size 3470 ); 3471 } 3472 3473 /* void glPointSizex ( GLfixed size ) */ 3474 static void 3475 android_glPointSizex__I 3476 (JNIEnv *_env, jobject _this, jint size) { 3477 glPointSizex( 3478 (GLfixed)size 3479 ); 3480 } 3481 3482 /* void glPolygonOffset ( GLfloat factor, GLfloat units ) */ 3483 static void 3484 android_glPolygonOffset__FF 3485 (JNIEnv *_env, jobject _this, jfloat factor, jfloat units) { 3486 glPolygonOffset( 3487 (GLfloat)factor, 3488 (GLfloat)units 3489 ); 3490 } 3491 3492 /* void glPolygonOffsetx ( GLfixed factor, GLfixed units ) */ 3493 static void 3494 android_glPolygonOffsetx__II 3495 (JNIEnv *_env, jobject _this, jint factor, jint units) { 3496 glPolygonOffsetx( 3497 (GLfixed)factor, 3498 (GLfixed)units 3499 ); 3500 } 3501 3502 /* void glPopMatrix ( void ) */ 3503 static void 3504 android_glPopMatrix__ 3505 (JNIEnv *_env, jobject _this) { 3506 glPopMatrix(); 3507 } 3508 3509 /* void glPushMatrix ( void ) */ 3510 static void 3511 android_glPushMatrix__ 3512 (JNIEnv *_env, jobject _this) { 3513 glPushMatrix(); 3514 } 3515 3516 /* void glReadPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) */ 3517 static void 3518 android_glReadPixels__IIIIIILjava_nio_Buffer_2 3519 (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height, jint format, jint type, jobject pixels_buf) { 3520 jint _exception = 0; 3521 const char * _exceptionType = NULL; 3522 const char * _exceptionMessage = NULL; 3523 jarray _array = (jarray) 0; 3524 jint _bufferOffset = (jint) 0; 3525 jint _remaining; 3526 GLvoid *pixels = (GLvoid *) 0; 3527 3528 if (!pixels_buf) { 3529 _exception = 1; 3530 _exceptionType = "java/lang/IllegalArgumentException"; 3531 _exceptionMessage = "pixels == null"; 3532 goto exit; 3533 } 3534 pixels = (GLvoid *)getPointer(_env, pixels_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3535 if (pixels == NULL) { 3536 char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 3537 pixels = (GLvoid *) (_pixelsBase + _bufferOffset); 3538 } 3539 glReadPixels( 3540 (GLint)x, 3541 (GLint)y, 3542 (GLsizei)width, 3543 (GLsizei)height, 3544 (GLenum)format, 3545 (GLenum)type, 3546 (GLvoid *)pixels 3547 ); 3548 3549 exit: 3550 if (_array) { 3551 releasePointer(_env, _array, pixels, _exception ? JNI_FALSE : JNI_TRUE); 3552 } 3553 if (_exception) { 3554 jniThrowException(_env, _exceptionType, _exceptionMessage); 3555 } 3556 } 3557 3558 /* void glRotatef ( GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) */ 3559 static void 3560 android_glRotatef__FFFF 3561 (JNIEnv *_env, jobject _this, jfloat angle, jfloat x, jfloat y, jfloat z) { 3562 glRotatef( 3563 (GLfloat)angle, 3564 (GLfloat)x, 3565 (GLfloat)y, 3566 (GLfloat)z 3567 ); 3568 } 3569 3570 /* void glRotatex ( GLfixed angle, GLfixed x, GLfixed y, GLfixed z ) */ 3571 static void 3572 android_glRotatex__IIII 3573 (JNIEnv *_env, jobject _this, jint angle, jint x, jint y, jint z) { 3574 glRotatex( 3575 (GLfixed)angle, 3576 (GLfixed)x, 3577 (GLfixed)y, 3578 (GLfixed)z 3579 ); 3580 } 3581 3582 /* void glSampleCoverage ( GLclampf value, GLboolean invert ) */ 3583 static void 3584 android_glSampleCoverage__FZ 3585 (JNIEnv *_env, jobject _this, jfloat value, jboolean invert) { 3586 glSampleCoverage( 3587 (GLclampf)value, 3588 (GLboolean)invert 3589 ); 3590 } 3591 3592 /* void glSampleCoveragex ( GLclampx value, GLboolean invert ) */ 3593 static void 3594 android_glSampleCoveragex__IZ 3595 (JNIEnv *_env, jobject _this, jint value, jboolean invert) { 3596 glSampleCoveragex( 3597 (GLclampx)value, 3598 (GLboolean)invert 3599 ); 3600 } 3601 3602 /* void glScalef ( GLfloat x, GLfloat y, GLfloat z ) */ 3603 static void 3604 android_glScalef__FFF 3605 (JNIEnv *_env, jobject _this, jfloat x, jfloat y, jfloat z) { 3606 glScalef( 3607 (GLfloat)x, 3608 (GLfloat)y, 3609 (GLfloat)z 3610 ); 3611 } 3612 3613 /* void glScalex ( GLfixed x, GLfixed y, GLfixed z ) */ 3614 static void 3615 android_glScalex__III 3616 (JNIEnv *_env, jobject _this, jint x, jint y, jint z) { 3617 glScalex( 3618 (GLfixed)x, 3619 (GLfixed)y, 3620 (GLfixed)z 3621 ); 3622 } 3623 3624 /* void glScissor ( GLint x, GLint y, GLsizei width, GLsizei height ) */ 3625 static void 3626 android_glScissor__IIII 3627 (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height) { 3628 glScissor( 3629 (GLint)x, 3630 (GLint)y, 3631 (GLsizei)width, 3632 (GLsizei)height 3633 ); 3634 } 3635 3636 /* void glShadeModel ( GLenum mode ) */ 3637 static void 3638 android_glShadeModel__I 3639 (JNIEnv *_env, jobject _this, jint mode) { 3640 glShadeModel( 3641 (GLenum)mode 3642 ); 3643 } 3644 3645 /* void glStencilFunc ( GLenum func, GLint ref, GLuint mask ) */ 3646 static void 3647 android_glStencilFunc__III 3648 (JNIEnv *_env, jobject _this, jint func, jint ref, jint mask) { 3649 glStencilFunc( 3650 (GLenum)func, 3651 (GLint)ref, 3652 (GLuint)mask 3653 ); 3654 } 3655 3656 /* void glStencilMask ( GLuint mask ) */ 3657 static void 3658 android_glStencilMask__I 3659 (JNIEnv *_env, jobject _this, jint mask) { 3660 glStencilMask( 3661 (GLuint)mask 3662 ); 3663 } 3664 3665 /* void glStencilOp ( GLenum fail, GLenum zfail, GLenum zpass ) */ 3666 static void 3667 android_glStencilOp__III 3668 (JNIEnv *_env, jobject _this, jint fail, jint zfail, jint zpass) { 3669 glStencilOp( 3670 (GLenum)fail, 3671 (GLenum)zfail, 3672 (GLenum)zpass 3673 ); 3674 } 3675 3676 /* void glTexCoordPointer ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */ 3677 static void 3678 android_glTexCoordPointerBounds__IIILjava_nio_Buffer_2I 3679 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) { 3680 jint _exception = 0; 3681 const char * _exceptionType = NULL; 3682 const char * _exceptionMessage = NULL; 3683 jarray _array = (jarray) 0; 3684 jint _bufferOffset = (jint) 0; 3685 jint _remaining; 3686 GLvoid *pointer = (GLvoid *) 0; 3687 3688 if (pointer_buf) { 3689 pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf); 3690 if ( ! pointer ) { 3691 return; 3692 } 3693 } 3694 glTexCoordPointerBounds( 3695 (GLint)size, 3696 (GLenum)type, 3697 (GLsizei)stride, 3698 (GLvoid *)pointer, 3699 (GLsizei)remaining 3700 ); 3701 if (_exception) { 3702 jniThrowException(_env, _exceptionType, _exceptionMessage); 3703 } 3704 } 3705 3706 /* void glTexEnvf ( GLenum target, GLenum pname, GLfloat param ) */ 3707 static void 3708 android_glTexEnvf__IIF 3709 (JNIEnv *_env, jobject _this, jint target, jint pname, jfloat param) { 3710 glTexEnvf( 3711 (GLenum)target, 3712 (GLenum)pname, 3713 (GLfloat)param 3714 ); 3715 } 3716 3717 /* void glTexEnvfv ( GLenum target, GLenum pname, const GLfloat *params ) */ 3718 static void 3719 android_glTexEnvfv__II_3FI 3720 (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) { 3721 jint _exception = 0; 3722 const char * _exceptionType = NULL; 3723 const char * _exceptionMessage = NULL; 3724 GLfloat *params_base = (GLfloat *) 0; 3725 jint _remaining; 3726 GLfloat *params = (GLfloat *) 0; 3727 3728 if (!params_ref) { 3729 _exception = 1; 3730 _exceptionType = "java/lang/IllegalArgumentException"; 3731 _exceptionMessage = "params == null"; 3732 goto exit; 3733 } 3734 if (offset < 0) { 3735 _exception = 1; 3736 _exceptionType = "java/lang/IllegalArgumentException"; 3737 _exceptionMessage = "offset < 0"; 3738 goto exit; 3739 } 3740 _remaining = _env->GetArrayLength(params_ref) - offset; 3741 int _needed; 3742 switch (pname) { 3743 #if defined(GL_TEXTURE_ENV_MODE) 3744 case GL_TEXTURE_ENV_MODE: 3745 #endif // defined(GL_TEXTURE_ENV_MODE) 3746 #if defined(GL_COMBINE_RGB) 3747 case GL_COMBINE_RGB: 3748 #endif // defined(GL_COMBINE_RGB) 3749 #if defined(GL_COMBINE_ALPHA) 3750 case GL_COMBINE_ALPHA: 3751 #endif // defined(GL_COMBINE_ALPHA) 3752 _needed = 1; 3753 break; 3754 #if defined(GL_TEXTURE_ENV_COLOR) 3755 case GL_TEXTURE_ENV_COLOR: 3756 #endif // defined(GL_TEXTURE_ENV_COLOR) 3757 _needed = 4; 3758 break; 3759 default: 3760 _needed = 1; 3761 break; 3762 } 3763 if (_remaining < _needed) { 3764 _exception = 1; 3765 _exceptionType = "java/lang/IllegalArgumentException"; 3766 _exceptionMessage = "length - offset < needed"; 3767 goto exit; 3768 } 3769 params_base = (GLfloat *) 3770 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 3771 params = params_base + offset; 3772 3773 glTexEnvfv( 3774 (GLenum)target, 3775 (GLenum)pname, 3776 (GLfloat *)params 3777 ); 3778 3779 exit: 3780 if (params_base) { 3781 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 3782 JNI_ABORT); 3783 } 3784 if (_exception) { 3785 jniThrowException(_env, _exceptionType, _exceptionMessage); 3786 } 3787 } 3788 3789 /* void glTexEnvfv ( GLenum target, GLenum pname, const GLfloat *params ) */ 3790 static void 3791 android_glTexEnvfv__IILjava_nio_FloatBuffer_2 3792 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 3793 jint _exception = 0; 3794 const char * _exceptionType = NULL; 3795 const char * _exceptionMessage = NULL; 3796 jfloatArray _array = (jfloatArray) 0; 3797 jint _bufferOffset = (jint) 0; 3798 jint _remaining; 3799 GLfloat *params = (GLfloat *) 0; 3800 3801 if (!params_buf) { 3802 _exception = 1; 3803 _exceptionType = "java/lang/IllegalArgumentException"; 3804 _exceptionMessage = "params == null"; 3805 goto exit; 3806 } 3807 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3808 int _needed; 3809 switch (pname) { 3810 #if defined(GL_TEXTURE_ENV_MODE) 3811 case GL_TEXTURE_ENV_MODE: 3812 #endif // defined(GL_TEXTURE_ENV_MODE) 3813 #if defined(GL_COMBINE_RGB) 3814 case GL_COMBINE_RGB: 3815 #endif // defined(GL_COMBINE_RGB) 3816 #if defined(GL_COMBINE_ALPHA) 3817 case GL_COMBINE_ALPHA: 3818 #endif // defined(GL_COMBINE_ALPHA) 3819 _needed = 1; 3820 break; 3821 #if defined(GL_TEXTURE_ENV_COLOR) 3822 case GL_TEXTURE_ENV_COLOR: 3823 #endif // defined(GL_TEXTURE_ENV_COLOR) 3824 _needed = 4; 3825 break; 3826 default: 3827 _needed = 1; 3828 break; 3829 } 3830 if (_remaining < _needed) { 3831 _exception = 1; 3832 _exceptionType = "java/lang/IllegalArgumentException"; 3833 _exceptionMessage = "remaining() < needed"; 3834 goto exit; 3835 } 3836 if (params == NULL) { 3837 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 3838 params = (GLfloat *) (_paramsBase + _bufferOffset); 3839 } 3840 glTexEnvfv( 3841 (GLenum)target, 3842 (GLenum)pname, 3843 (GLfloat *)params 3844 ); 3845 3846 exit: 3847 if (_array) { 3848 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT); 3849 } 3850 if (_exception) { 3851 jniThrowException(_env, _exceptionType, _exceptionMessage); 3852 } 3853 } 3854 3855 /* void glTexEnvx ( GLenum target, GLenum pname, GLfixed param ) */ 3856 static void 3857 android_glTexEnvx__III 3858 (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) { 3859 glTexEnvx( 3860 (GLenum)target, 3861 (GLenum)pname, 3862 (GLfixed)param 3863 ); 3864 } 3865 3866 /* void glTexEnvxv ( GLenum target, GLenum pname, const GLfixed *params ) */ 3867 static void 3868 android_glTexEnvxv__II_3II 3869 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 3870 jint _exception = 0; 3871 const char * _exceptionType = NULL; 3872 const char * _exceptionMessage = NULL; 3873 GLfixed *params_base = (GLfixed *) 0; 3874 jint _remaining; 3875 GLfixed *params = (GLfixed *) 0; 3876 3877 if (!params_ref) { 3878 _exception = 1; 3879 _exceptionType = "java/lang/IllegalArgumentException"; 3880 _exceptionMessage = "params == null"; 3881 goto exit; 3882 } 3883 if (offset < 0) { 3884 _exception = 1; 3885 _exceptionType = "java/lang/IllegalArgumentException"; 3886 _exceptionMessage = "offset < 0"; 3887 goto exit; 3888 } 3889 _remaining = _env->GetArrayLength(params_ref) - offset; 3890 int _needed; 3891 switch (pname) { 3892 #if defined(GL_TEXTURE_ENV_MODE) 3893 case GL_TEXTURE_ENV_MODE: 3894 #endif // defined(GL_TEXTURE_ENV_MODE) 3895 #if defined(GL_COMBINE_RGB) 3896 case GL_COMBINE_RGB: 3897 #endif // defined(GL_COMBINE_RGB) 3898 #if defined(GL_COMBINE_ALPHA) 3899 case GL_COMBINE_ALPHA: 3900 #endif // defined(GL_COMBINE_ALPHA) 3901 _needed = 1; 3902 break; 3903 #if defined(GL_TEXTURE_ENV_COLOR) 3904 case GL_TEXTURE_ENV_COLOR: 3905 #endif // defined(GL_TEXTURE_ENV_COLOR) 3906 _needed = 4; 3907 break; 3908 default: 3909 _needed = 1; 3910 break; 3911 } 3912 if (_remaining < _needed) { 3913 _exception = 1; 3914 _exceptionType = "java/lang/IllegalArgumentException"; 3915 _exceptionMessage = "length - offset < needed"; 3916 goto exit; 3917 } 3918 params_base = (GLfixed *) 3919 _env->GetIntArrayElements(params_ref, (jboolean *)0); 3920 params = params_base + offset; 3921 3922 glTexEnvxv( 3923 (GLenum)target, 3924 (GLenum)pname, 3925 (GLfixed *)params 3926 ); 3927 3928 exit: 3929 if (params_base) { 3930 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 3931 JNI_ABORT); 3932 } 3933 if (_exception) { 3934 jniThrowException(_env, _exceptionType, _exceptionMessage); 3935 } 3936 } 3937 3938 /* void glTexEnvxv ( GLenum target, GLenum pname, const GLfixed *params ) */ 3939 static void 3940 android_glTexEnvxv__IILjava_nio_IntBuffer_2 3941 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 3942 jint _exception = 0; 3943 const char * _exceptionType = NULL; 3944 const char * _exceptionMessage = NULL; 3945 jintArray _array = (jintArray) 0; 3946 jint _bufferOffset = (jint) 0; 3947 jint _remaining; 3948 GLfixed *params = (GLfixed *) 0; 3949 3950 if (!params_buf) { 3951 _exception = 1; 3952 _exceptionType = "java/lang/IllegalArgumentException"; 3953 _exceptionMessage = "params == null"; 3954 goto exit; 3955 } 3956 params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3957 int _needed; 3958 switch (pname) { 3959 #if defined(GL_TEXTURE_ENV_MODE) 3960 case GL_TEXTURE_ENV_MODE: 3961 #endif // defined(GL_TEXTURE_ENV_MODE) 3962 #if defined(GL_COMBINE_RGB) 3963 case GL_COMBINE_RGB: 3964 #endif // defined(GL_COMBINE_RGB) 3965 #if defined(GL_COMBINE_ALPHA) 3966 case GL_COMBINE_ALPHA: 3967 #endif // defined(GL_COMBINE_ALPHA) 3968 _needed = 1; 3969 break; 3970 #if defined(GL_TEXTURE_ENV_COLOR) 3971 case GL_TEXTURE_ENV_COLOR: 3972 #endif // defined(GL_TEXTURE_ENV_COLOR) 3973 _needed = 4; 3974 break; 3975 default: 3976 _needed = 1; 3977 break; 3978 } 3979 if (_remaining < _needed) { 3980 _exception = 1; 3981 _exceptionType = "java/lang/IllegalArgumentException"; 3982 _exceptionMessage = "remaining() < needed"; 3983 goto exit; 3984 } 3985 if (params == NULL) { 3986 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 3987 params = (GLfixed *) (_paramsBase + _bufferOffset); 3988 } 3989 glTexEnvxv( 3990 (GLenum)target, 3991 (GLenum)pname, 3992 (GLfixed *)params 3993 ); 3994 3995 exit: 3996 if (_array) { 3997 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT); 3998 } 3999 if (_exception) { 4000 jniThrowException(_env, _exceptionType, _exceptionMessage); 4001 } 4002 } 4003 4004 /* void glTexImage2D ( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) */ 4005 static void 4006 android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2 4007 (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint format, jint type, jobject pixels_buf) { 4008 jint _exception = 0; 4009 const char * _exceptionType = NULL; 4010 const char * _exceptionMessage = NULL; 4011 jarray _array = (jarray) 0; 4012 jint _bufferOffset = (jint) 0; 4013 jint _remaining; 4014 GLvoid *pixels = (GLvoid *) 0; 4015 4016 if (pixels_buf) { 4017 pixels = (GLvoid *)getPointer(_env, pixels_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4018 } 4019 if (pixels_buf && pixels == NULL) { 4020 char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 4021 pixels = (GLvoid *) (_pixelsBase + _bufferOffset); 4022 } 4023 glTexImage2D( 4024 (GLenum)target, 4025 (GLint)level, 4026 (GLint)internalformat, 4027 (GLsizei)width, 4028 (GLsizei)height, 4029 (GLint)border, 4030 (GLenum)format, 4031 (GLenum)type, 4032 (GLvoid *)pixels 4033 ); 4034 if (_array) { 4035 releasePointer(_env, _array, pixels, JNI_FALSE); 4036 } 4037 if (_exception) { 4038 jniThrowException(_env, _exceptionType, _exceptionMessage); 4039 } 4040 } 4041 4042 /* void glTexParameterf ( GLenum target, GLenum pname, GLfloat param ) */ 4043 static void 4044 android_glTexParameterf__IIF 4045 (JNIEnv *_env, jobject _this, jint target, jint pname, jfloat param) { 4046 glTexParameterf( 4047 (GLenum)target, 4048 (GLenum)pname, 4049 (GLfloat)param 4050 ); 4051 } 4052 4053 /* void glTexParameterx ( GLenum target, GLenum pname, GLfixed param ) */ 4054 static void 4055 android_glTexParameterx__III 4056 (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) { 4057 glTexParameterx( 4058 (GLenum)target, 4059 (GLenum)pname, 4060 (GLfixed)param 4061 ); 4062 } 4063 4064 /* void glTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels ) */ 4065 static void 4066 android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 4067 (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint type, jobject pixels_buf) { 4068 jint _exception = 0; 4069 const char * _exceptionType = NULL; 4070 const char * _exceptionMessage = NULL; 4071 jarray _array = (jarray) 0; 4072 jint _bufferOffset = (jint) 0; 4073 jint _remaining; 4074 GLvoid *pixels = (GLvoid *) 0; 4075 4076 if (pixels_buf) { 4077 pixels = (GLvoid *)getPointer(_env, pixels_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4078 } 4079 if (pixels_buf && pixels == NULL) { 4080 char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 4081 pixels = (GLvoid *) (_pixelsBase + _bufferOffset); 4082 } 4083 glTexSubImage2D( 4084 (GLenum)target, 4085 (GLint)level, 4086 (GLint)xoffset, 4087 (GLint)yoffset, 4088 (GLsizei)width, 4089 (GLsizei)height, 4090 (GLenum)format, 4091 (GLenum)type, 4092 (GLvoid *)pixels 4093 ); 4094 if (_array) { 4095 releasePointer(_env, _array, pixels, JNI_FALSE); 4096 } 4097 if (_exception) { 4098 jniThrowException(_env, _exceptionType, _exceptionMessage); 4099 } 4100 } 4101 4102 /* void glTranslatef ( GLfloat x, GLfloat y, GLfloat z ) */ 4103 static void 4104 android_glTranslatef__FFF 4105 (JNIEnv *_env, jobject _this, jfloat x, jfloat y, jfloat z) { 4106 glTranslatef( 4107 (GLfloat)x, 4108 (GLfloat)y, 4109 (GLfloat)z 4110 ); 4111 } 4112 4113 /* void glTranslatex ( GLfixed x, GLfixed y, GLfixed z ) */ 4114 static void 4115 android_glTranslatex__III 4116 (JNIEnv *_env, jobject _this, jint x, jint y, jint z) { 4117 glTranslatex( 4118 (GLfixed)x, 4119 (GLfixed)y, 4120 (GLfixed)z 4121 ); 4122 } 4123 4124 /* void glVertexPointer ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */ 4125 static void 4126 android_glVertexPointerBounds__IIILjava_nio_Buffer_2I 4127 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) { 4128 jint _exception = 0; 4129 const char * _exceptionType = NULL; 4130 const char * _exceptionMessage = NULL; 4131 jarray _array = (jarray) 0; 4132 jint _bufferOffset = (jint) 0; 4133 jint _remaining; 4134 GLvoid *pointer = (GLvoid *) 0; 4135 4136 if (pointer_buf) { 4137 pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf); 4138 if ( ! pointer ) { 4139 return; 4140 } 4141 } 4142 glVertexPointerBounds( 4143 (GLint)size, 4144 (GLenum)type, 4145 (GLsizei)stride, 4146 (GLvoid *)pointer, 4147 (GLsizei)remaining 4148 ); 4149 if (_exception) { 4150 jniThrowException(_env, _exceptionType, _exceptionMessage); 4151 } 4152 } 4153 4154 /* void glViewport ( GLint x, GLint y, GLsizei width, GLsizei height ) */ 4155 static void 4156 android_glViewport__IIII 4157 (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height) { 4158 glViewport( 4159 (GLint)x, 4160 (GLint)y, 4161 (GLsizei)width, 4162 (GLsizei)height 4163 ); 4164 } 4165 4166 /* GLbitfield glQueryMatrixxOES ( GLfixed *mantissa, GLint *exponent ) */ 4167 static jint 4168 android_glQueryMatrixxOES___3II_3II 4169 (JNIEnv *_env, jobject _this, jintArray mantissa_ref, jint mantissaOffset, jintArray exponent_ref, jint exponentOffset) { 4170 jint _exception = 0; 4171 const char * _exceptionType = NULL; 4172 const char * _exceptionMessage = NULL; 4173 GLbitfield _returnValue = -1; 4174 GLfixed *mantissa_base = (GLfixed *) 0; 4175 jint _mantissaRemaining; 4176 GLfixed *mantissa = (GLfixed *) 0; 4177 GLint *exponent_base = (GLint *) 0; 4178 jint _exponentRemaining; 4179 GLint *exponent = (GLint *) 0; 4180 4181 if (!mantissa_ref) { 4182 _exception = 1; 4183 _exceptionType = "java/lang/IllegalArgumentException"; 4184 _exceptionMessage = "mantissa == null"; 4185 goto exit; 4186 } 4187 if (mantissaOffset < 0) { 4188 _exception = 1; 4189 _exceptionType = "java/lang/IllegalArgumentException"; 4190 _exceptionMessage = "mantissaOffset < 0"; 4191 goto exit; 4192 } 4193 _mantissaRemaining = _env->GetArrayLength(mantissa_ref) - mantissaOffset; 4194 if (_mantissaRemaining < 16) { 4195 _exception = 1; 4196 _exceptionType = "java/lang/IllegalArgumentException"; 4197 _exceptionMessage = "length - mantissaOffset < 16 < needed"; 4198 goto exit; 4199 } 4200 mantissa_base = (GLfixed *) 4201 _env->GetIntArrayElements(mantissa_ref, (jboolean *)0); 4202 mantissa = mantissa_base + mantissaOffset; 4203 4204 if (!exponent_ref) { 4205 _exception = 1; 4206 _exceptionType = "java/lang/IllegalArgumentException"; 4207 _exceptionMessage = "exponent == null"; 4208 goto exit; 4209 } 4210 if (exponentOffset < 0) { 4211 _exception = 1; 4212 _exceptionType = "java/lang/IllegalArgumentException"; 4213 _exceptionMessage = "exponentOffset < 0"; 4214 goto exit; 4215 } 4216 _exponentRemaining = _env->GetArrayLength(exponent_ref) - exponentOffset; 4217 if (_exponentRemaining < 16) { 4218 _exception = 1; 4219 _exceptionType = "java/lang/IllegalArgumentException"; 4220 _exceptionMessage = "length - exponentOffset < 16 < needed"; 4221 goto exit; 4222 } 4223 exponent_base = (GLint *) 4224 _env->GetIntArrayElements(exponent_ref, (jboolean *)0); 4225 exponent = exponent_base + exponentOffset; 4226 4227 _returnValue = glQueryMatrixxOES( 4228 (GLfixed *)mantissa, 4229 (GLint *)exponent 4230 ); 4231 4232 exit: 4233 if (exponent_base) { 4234 _env->ReleaseIntArrayElements(exponent_ref, (jint*)exponent_base, 4235 _exception ? JNI_ABORT: 0); 4236 } 4237 if (mantissa_base) { 4238 _env->ReleaseIntArrayElements(mantissa_ref, (jint*)mantissa_base, 4239 _exception ? JNI_ABORT: 0); 4240 } 4241 if (_exception) { 4242 jniThrowException(_env, _exceptionType, _exceptionMessage); 4243 } 4244 return (jint)_returnValue; 4245 } 4246 4247 /* GLbitfield glQueryMatrixxOES ( GLfixed *mantissa, GLint *exponent ) */ 4248 static jint 4249 android_glQueryMatrixxOES__Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 4250 (JNIEnv *_env, jobject _this, jobject mantissa_buf, jobject exponent_buf) { 4251 jint _exception = 0; 4252 const char * _exceptionType = NULL; 4253 const char * _exceptionMessage = NULL; 4254 jintArray _mantissaArray = (jintArray) 0; 4255 jint _mantissaBufferOffset = (jint) 0; 4256 jintArray _exponentArray = (jintArray) 0; 4257 jint _exponentBufferOffset = (jint) 0; 4258 GLbitfield _returnValue = -1; 4259 jint _mantissaRemaining; 4260 GLfixed *mantissa = (GLfixed *) 0; 4261 jint _exponentRemaining; 4262 GLint *exponent = (GLint *) 0; 4263 4264 if (!mantissa_buf) { 4265 _exception = 1; 4266 _exceptionType = "java/lang/IllegalArgumentException"; 4267 _exceptionMessage = "mantissa == null"; 4268 goto exit; 4269 } 4270 mantissa = (GLfixed *)getPointer(_env, mantissa_buf, (jarray*)&_mantissaArray, &_mantissaRemaining, &_mantissaBufferOffset); 4271 if (_mantissaRemaining < 16) { 4272 _exception = 1; 4273 _exceptionType = "java/lang/IllegalArgumentException"; 4274 _exceptionMessage = "remaining() < 16 < needed"; 4275 goto exit; 4276 } 4277 if (!exponent_buf) { 4278 _exception = 1; 4279 _exceptionType = "java/lang/IllegalArgumentException"; 4280 _exceptionMessage = "exponent == null"; 4281 goto exit; 4282 } 4283 exponent = (GLint *)getPointer(_env, exponent_buf, (jarray*)&_exponentArray, &_exponentRemaining, &_exponentBufferOffset); 4284 if (_exponentRemaining < 16) { 4285 _exception = 1; 4286 _exceptionType = "java/lang/IllegalArgumentException"; 4287 _exceptionMessage = "remaining() < 16 < needed"; 4288 goto exit; 4289 } 4290 if (mantissa == NULL) { 4291 char * _mantissaBase = (char *)_env->GetIntArrayElements(_mantissaArray, (jboolean *) 0); 4292 mantissa = (GLfixed *) (_mantissaBase + _mantissaBufferOffset); 4293 } 4294 if (exponent == NULL) { 4295 char * _exponentBase = (char *)_env->GetIntArrayElements(_exponentArray, (jboolean *) 0); 4296 exponent = (GLint *) (_exponentBase + _exponentBufferOffset); 4297 } 4298 _returnValue = glQueryMatrixxOES( 4299 (GLfixed *)mantissa, 4300 (GLint *)exponent 4301 ); 4302 4303 exit: 4304 if (_exponentArray) { 4305 _env->ReleaseIntArrayElements(_exponentArray, (jint*)exponent, _exception ? JNI_ABORT : 0); 4306 } 4307 if (_mantissaArray) { 4308 _env->ReleaseIntArrayElements(_mantissaArray, (jint*)mantissa, _exception ? JNI_ABORT : 0); 4309 } 4310 if (_exception) { 4311 jniThrowException(_env, _exceptionType, _exceptionMessage); 4312 } 4313 return (jint)_returnValue; 4314 } 4315 4316 /* void glBindBuffer ( GLenum target, GLuint buffer ) */ 4317 static void 4318 android_glBindBuffer__II 4319 (JNIEnv *_env, jobject _this, jint target, jint buffer) { 4320 glBindBuffer( 4321 (GLenum)target, 4322 (GLuint)buffer 4323 ); 4324 } 4325 4326 /* void glBufferData ( GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage ) */ 4327 static void 4328 android_glBufferData__IILjava_nio_Buffer_2I 4329 (JNIEnv *_env, jobject _this, jint target, jint size, jobject data_buf, jint usage) { 4330 jint _exception = 0; 4331 const char * _exceptionType = NULL; 4332 const char * _exceptionMessage = NULL; 4333 jarray _array = (jarray) 0; 4334 jint _bufferOffset = (jint) 0; 4335 jint _remaining; 4336 GLvoid *data = (GLvoid *) 0; 4337 4338 if (data_buf) { 4339 data = (GLvoid *)getPointer(_env, data_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4340 if (_remaining < size) { 4341 _exception = 1; 4342 _exceptionType = "java/lang/IllegalArgumentException"; 4343 _exceptionMessage = "remaining() < size < needed"; 4344 goto exit; 4345 } 4346 } 4347 if (data_buf && data == NULL) { 4348 char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 4349 data = (GLvoid *) (_dataBase + _bufferOffset); 4350 } 4351 glBufferData( 4352 (GLenum)target, 4353 (GLsizeiptr)size, 4354 (GLvoid *)data, 4355 (GLenum)usage 4356 ); 4357 4358 exit: 4359 if (_array) { 4360 releasePointer(_env, _array, data, JNI_FALSE); 4361 } 4362 if (_exception) { 4363 jniThrowException(_env, _exceptionType, _exceptionMessage); 4364 } 4365 } 4366 4367 /* void glBufferSubData ( GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data ) */ 4368 static void 4369 android_glBufferSubData__IIILjava_nio_Buffer_2 4370 (JNIEnv *_env, jobject _this, jint target, jint offset, jint size, jobject data_buf) { 4371 jint _exception = 0; 4372 const char * _exceptionType = NULL; 4373 const char * _exceptionMessage = NULL; 4374 jarray _array = (jarray) 0; 4375 jint _bufferOffset = (jint) 0; 4376 jint _remaining; 4377 GLvoid *data = (GLvoid *) 0; 4378 4379 if (!data_buf) { 4380 _exception = 1; 4381 _exceptionType = "java/lang/IllegalArgumentException"; 4382 _exceptionMessage = "data == null"; 4383 goto exit; 4384 } 4385 data = (GLvoid *)getPointer(_env, data_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4386 if (_remaining < size) { 4387 _exception = 1; 4388 _exceptionType = "java/lang/IllegalArgumentException"; 4389 _exceptionMessage = "remaining() < size < needed"; 4390 goto exit; 4391 } 4392 if (data == NULL) { 4393 char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 4394 data = (GLvoid *) (_dataBase + _bufferOffset); 4395 } 4396 glBufferSubData( 4397 (GLenum)target, 4398 (GLintptr)offset, 4399 (GLsizeiptr)size, 4400 (GLvoid *)data 4401 ); 4402 4403 exit: 4404 if (_array) { 4405 releasePointer(_env, _array, data, JNI_FALSE); 4406 } 4407 if (_exception) { 4408 jniThrowException(_env, _exceptionType, _exceptionMessage); 4409 } 4410 } 4411 4412 /* void glClipPlanef ( GLenum plane, const GLfloat *equation ) */ 4413 static void 4414 android_glClipPlanef__I_3FI 4415 (JNIEnv *_env, jobject _this, jint plane, jfloatArray equation_ref, jint offset) { 4416 jint _exception = 0; 4417 const char * _exceptionType = NULL; 4418 const char * _exceptionMessage = NULL; 4419 GLfloat *equation_base = (GLfloat *) 0; 4420 jint _remaining; 4421 GLfloat *equation = (GLfloat *) 0; 4422 4423 if (!equation_ref) { 4424 _exception = 1; 4425 _exceptionType = "java/lang/IllegalArgumentException"; 4426 _exceptionMessage = "equation == null"; 4427 goto exit; 4428 } 4429 if (offset < 0) { 4430 _exception = 1; 4431 _exceptionType = "java/lang/IllegalArgumentException"; 4432 _exceptionMessage = "offset < 0"; 4433 goto exit; 4434 } 4435 _remaining = _env->GetArrayLength(equation_ref) - offset; 4436 if (_remaining < 4) { 4437 _exception = 1; 4438 _exceptionType = "java/lang/IllegalArgumentException"; 4439 _exceptionMessage = "length - offset < 4 < needed"; 4440 goto exit; 4441 } 4442 equation_base = (GLfloat *) 4443 _env->GetFloatArrayElements(equation_ref, (jboolean *)0); 4444 equation = equation_base + offset; 4445 4446 glClipPlanef( 4447 (GLenum)plane, 4448 (GLfloat *)equation 4449 ); 4450 4451 exit: 4452 if (equation_base) { 4453 _env->ReleaseFloatArrayElements(equation_ref, (jfloat*)equation_base, 4454 JNI_ABORT); 4455 } 4456 if (_exception) { 4457 jniThrowException(_env, _exceptionType, _exceptionMessage); 4458 } 4459 } 4460 4461 /* void glClipPlanef ( GLenum plane, const GLfloat *equation ) */ 4462 static void 4463 android_glClipPlanef__ILjava_nio_FloatBuffer_2 4464 (JNIEnv *_env, jobject _this, jint plane, jobject equation_buf) { 4465 jint _exception = 0; 4466 const char * _exceptionType = NULL; 4467 const char * _exceptionMessage = NULL; 4468 jfloatArray _array = (jfloatArray) 0; 4469 jint _bufferOffset = (jint) 0; 4470 jint _remaining; 4471 GLfloat *equation = (GLfloat *) 0; 4472 4473 if (!equation_buf) { 4474 _exception = 1; 4475 _exceptionType = "java/lang/IllegalArgumentException"; 4476 _exceptionMessage = "equation == null"; 4477 goto exit; 4478 } 4479 equation = (GLfloat *)getPointer(_env, equation_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4480 if (_remaining < 4) { 4481 _exception = 1; 4482 _exceptionType = "java/lang/IllegalArgumentException"; 4483 _exceptionMessage = "remaining() < 4 < needed"; 4484 goto exit; 4485 } 4486 if (equation == NULL) { 4487 char * _equationBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 4488 equation = (GLfloat *) (_equationBase + _bufferOffset); 4489 } 4490 glClipPlanef( 4491 (GLenum)plane, 4492 (GLfloat *)equation 4493 ); 4494 4495 exit: 4496 if (_array) { 4497 _env->ReleaseFloatArrayElements(_array, (jfloat*)equation, JNI_ABORT); 4498 } 4499 if (_exception) { 4500 jniThrowException(_env, _exceptionType, _exceptionMessage); 4501 } 4502 } 4503 4504 /* void glClipPlanex ( GLenum plane, const GLfixed *equation ) */ 4505 static void 4506 android_glClipPlanex__I_3II 4507 (JNIEnv *_env, jobject _this, jint plane, jintArray equation_ref, jint offset) { 4508 jint _exception = 0; 4509 const char * _exceptionType = NULL; 4510 const char * _exceptionMessage = NULL; 4511 GLfixed *equation_base = (GLfixed *) 0; 4512 jint _remaining; 4513 GLfixed *equation = (GLfixed *) 0; 4514 4515 if (!equation_ref) { 4516 _exception = 1; 4517 _exceptionType = "java/lang/IllegalArgumentException"; 4518 _exceptionMessage = "equation == null"; 4519 goto exit; 4520 } 4521 if (offset < 0) { 4522 _exception = 1; 4523 _exceptionType = "java/lang/IllegalArgumentException"; 4524 _exceptionMessage = "offset < 0"; 4525 goto exit; 4526 } 4527 _remaining = _env->GetArrayLength(equation_ref) - offset; 4528 if (_remaining < 4) { 4529 _exception = 1; 4530 _exceptionType = "java/lang/IllegalArgumentException"; 4531 _exceptionMessage = "length - offset < 4 < needed"; 4532 goto exit; 4533 } 4534 equation_base = (GLfixed *) 4535 _env->GetIntArrayElements(equation_ref, (jboolean *)0); 4536 equation = equation_base + offset; 4537 4538 glClipPlanex( 4539 (GLenum)plane, 4540 (GLfixed *)equation 4541 ); 4542 4543 exit: 4544 if (equation_base) { 4545 _env->ReleaseIntArrayElements(equation_ref, (jint*)equation_base, 4546 JNI_ABORT); 4547 } 4548 if (_exception) { 4549 jniThrowException(_env, _exceptionType, _exceptionMessage); 4550 } 4551 } 4552 4553 /* void glClipPlanex ( GLenum plane, const GLfixed *equation ) */ 4554 static void 4555 android_glClipPlanex__ILjava_nio_IntBuffer_2 4556 (JNIEnv *_env, jobject _this, jint plane, jobject equation_buf) { 4557 jint _exception = 0; 4558 const char * _exceptionType = NULL; 4559 const char * _exceptionMessage = NULL; 4560 jintArray _array = (jintArray) 0; 4561 jint _bufferOffset = (jint) 0; 4562 jint _remaining; 4563 GLfixed *equation = (GLfixed *) 0; 4564 4565 if (!equation_buf) { 4566 _exception = 1; 4567 _exceptionType = "java/lang/IllegalArgumentException"; 4568 _exceptionMessage = "equation == null"; 4569 goto exit; 4570 } 4571 equation = (GLfixed *)getPointer(_env, equation_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4572 if (_remaining < 4) { 4573 _exception = 1; 4574 _exceptionType = "java/lang/IllegalArgumentException"; 4575 _exceptionMessage = "remaining() < 4 < needed"; 4576 goto exit; 4577 } 4578 if (equation == NULL) { 4579 char * _equationBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 4580 equation = (GLfixed *) (_equationBase + _bufferOffset); 4581 } 4582 glClipPlanex( 4583 (GLenum)plane, 4584 (GLfixed *)equation 4585 ); 4586 4587 exit: 4588 if (_array) { 4589 _env->ReleaseIntArrayElements(_array, (jint*)equation, JNI_ABORT); 4590 } 4591 if (_exception) { 4592 jniThrowException(_env, _exceptionType, _exceptionMessage); 4593 } 4594 } 4595 4596 /* void glColor4ub ( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha ) */ 4597 static void 4598 android_glColor4ub__BBBB 4599 (JNIEnv *_env, jobject _this, jbyte red, jbyte green, jbyte blue, jbyte alpha) { 4600 glColor4ub( 4601 (GLubyte)red, 4602 (GLubyte)green, 4603 (GLubyte)blue, 4604 (GLubyte)alpha 4605 ); 4606 } 4607 4608 /* void glColorPointer ( GLint size, GLenum type, GLsizei stride, GLint offset ) */ 4609 static void 4610 android_glColorPointer__IIII 4611 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jint offset) { 4612 glColorPointer( 4613 (GLint)size, 4614 (GLenum)type, 4615 (GLsizei)stride, 4616 reinterpret_cast<GLvoid *>(offset) 4617 ); 4618 } 4619 4620 /* void glDeleteBuffers ( GLsizei n, const GLuint *buffers ) */ 4621 static void 4622 android_glDeleteBuffers__I_3II 4623 (JNIEnv *_env, jobject _this, jint n, jintArray buffers_ref, jint offset) { 4624 jint _exception = 0; 4625 const char * _exceptionType = NULL; 4626 const char * _exceptionMessage = NULL; 4627 GLuint *buffers_base = (GLuint *) 0; 4628 jint _remaining; 4629 GLuint *buffers = (GLuint *) 0; 4630 4631 if (!buffers_ref) { 4632 _exception = 1; 4633 _exceptionType = "java/lang/IllegalArgumentException"; 4634 _exceptionMessage = "buffers == null"; 4635 goto exit; 4636 } 4637 if (offset < 0) { 4638 _exception = 1; 4639 _exceptionType = "java/lang/IllegalArgumentException"; 4640 _exceptionMessage = "offset < 0"; 4641 goto exit; 4642 } 4643 _remaining = _env->GetArrayLength(buffers_ref) - offset; 4644 if (_remaining < n) { 4645 _exception = 1; 4646 _exceptionType = "java/lang/IllegalArgumentException"; 4647 _exceptionMessage = "length - offset < n < needed"; 4648 goto exit; 4649 } 4650 buffers_base = (GLuint *) 4651 _env->GetIntArrayElements(buffers_ref, (jboolean *)0); 4652 buffers = buffers_base + offset; 4653 4654 glDeleteBuffers( 4655 (GLsizei)n, 4656 (GLuint *)buffers 4657 ); 4658 4659 exit: 4660 if (buffers_base) { 4661 _env->ReleaseIntArrayElements(buffers_ref, (jint*)buffers_base, 4662 JNI_ABORT); 4663 } 4664 if (_exception) { 4665 jniThrowException(_env, _exceptionType, _exceptionMessage); 4666 } 4667 } 4668 4669 /* void glDeleteBuffers ( GLsizei n, const GLuint *buffers ) */ 4670 static void 4671 android_glDeleteBuffers__ILjava_nio_IntBuffer_2 4672 (JNIEnv *_env, jobject _this, jint n, jobject buffers_buf) { 4673 jint _exception = 0; 4674 const char * _exceptionType = NULL; 4675 const char * _exceptionMessage = NULL; 4676 jintArray _array = (jintArray) 0; 4677 jint _bufferOffset = (jint) 0; 4678 jint _remaining; 4679 GLuint *buffers = (GLuint *) 0; 4680 4681 if (!buffers_buf) { 4682 _exception = 1; 4683 _exceptionType = "java/lang/IllegalArgumentException"; 4684 _exceptionMessage = "buffers == null"; 4685 goto exit; 4686 } 4687 buffers = (GLuint *)getPointer(_env, buffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4688 if (_remaining < n) { 4689 _exception = 1; 4690 _exceptionType = "java/lang/IllegalArgumentException"; 4691 _exceptionMessage = "remaining() < n < needed"; 4692 goto exit; 4693 } 4694 if (buffers == NULL) { 4695 char * _buffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 4696 buffers = (GLuint *) (_buffersBase + _bufferOffset); 4697 } 4698 glDeleteBuffers( 4699 (GLsizei)n, 4700 (GLuint *)buffers 4701 ); 4702 4703 exit: 4704 if (_array) { 4705 _env->ReleaseIntArrayElements(_array, (jint*)buffers, JNI_ABORT); 4706 } 4707 if (_exception) { 4708 jniThrowException(_env, _exceptionType, _exceptionMessage); 4709 } 4710 } 4711 4712 /* void glDrawElements ( GLenum mode, GLsizei count, GLenum type, GLint offset ) */ 4713 static void 4714 android_glDrawElements__IIII 4715 (JNIEnv *_env, jobject _this, jint mode, jint count, jint type, jint offset) { 4716 jint _exception = 0; 4717 const char * _exceptionType = NULL; 4718 const char * _exceptionMessage = NULL; 4719 glDrawElements( 4720 (GLenum)mode, 4721 (GLsizei)count, 4722 (GLenum)type, 4723 reinterpret_cast<GLvoid *>(offset) 4724 ); 4725 if (_exception) { 4726 jniThrowException(_env, _exceptionType, _exceptionMessage); 4727 } 4728 } 4729 4730 /* void glGenBuffers ( GLsizei n, GLuint *buffers ) */ 4731 static void 4732 android_glGenBuffers__I_3II 4733 (JNIEnv *_env, jobject _this, jint n, jintArray buffers_ref, jint offset) { 4734 jint _exception = 0; 4735 const char * _exceptionType = NULL; 4736 const char * _exceptionMessage = NULL; 4737 GLuint *buffers_base = (GLuint *) 0; 4738 jint _remaining; 4739 GLuint *buffers = (GLuint *) 0; 4740 4741 if (!buffers_ref) { 4742 _exception = 1; 4743 _exceptionType = "java/lang/IllegalArgumentException"; 4744 _exceptionMessage = "buffers == null"; 4745 goto exit; 4746 } 4747 if (offset < 0) { 4748 _exception = 1; 4749 _exceptionType = "java/lang/IllegalArgumentException"; 4750 _exceptionMessage = "offset < 0"; 4751 goto exit; 4752 } 4753 _remaining = _env->GetArrayLength(buffers_ref) - offset; 4754 if (_remaining < n) { 4755 _exception = 1; 4756 _exceptionType = "java/lang/IllegalArgumentException"; 4757 _exceptionMessage = "length - offset < n < needed"; 4758 goto exit; 4759 } 4760 buffers_base = (GLuint *) 4761 _env->GetIntArrayElements(buffers_ref, (jboolean *)0); 4762 buffers = buffers_base + offset; 4763 4764 glGenBuffers( 4765 (GLsizei)n, 4766 (GLuint *)buffers 4767 ); 4768 4769 exit: 4770 if (buffers_base) { 4771 _env->ReleaseIntArrayElements(buffers_ref, (jint*)buffers_base, 4772 _exception ? JNI_ABORT: 0); 4773 } 4774 if (_exception) { 4775 jniThrowException(_env, _exceptionType, _exceptionMessage); 4776 } 4777 } 4778 4779 /* void glGenBuffers ( GLsizei n, GLuint *buffers ) */ 4780 static void 4781 android_glGenBuffers__ILjava_nio_IntBuffer_2 4782 (JNIEnv *_env, jobject _this, jint n, jobject buffers_buf) { 4783 jint _exception = 0; 4784 const char * _exceptionType = NULL; 4785 const char * _exceptionMessage = NULL; 4786 jintArray _array = (jintArray) 0; 4787 jint _bufferOffset = (jint) 0; 4788 jint _remaining; 4789 GLuint *buffers = (GLuint *) 0; 4790 4791 if (!buffers_buf) { 4792 _exception = 1; 4793 _exceptionType = "java/lang/IllegalArgumentException"; 4794 _exceptionMessage = "buffers == null"; 4795 goto exit; 4796 } 4797 buffers = (GLuint *)getPointer(_env, buffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4798 if (_remaining < n) { 4799 _exception = 1; 4800 _exceptionType = "java/lang/IllegalArgumentException"; 4801 _exceptionMessage = "remaining() < n < needed"; 4802 goto exit; 4803 } 4804 if (buffers == NULL) { 4805 char * _buffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 4806 buffers = (GLuint *) (_buffersBase + _bufferOffset); 4807 } 4808 glGenBuffers( 4809 (GLsizei)n, 4810 (GLuint *)buffers 4811 ); 4812 4813 exit: 4814 if (_array) { 4815 _env->ReleaseIntArrayElements(_array, (jint*)buffers, _exception ? JNI_ABORT : 0); 4816 } 4817 if (_exception) { 4818 jniThrowException(_env, _exceptionType, _exceptionMessage); 4819 } 4820 } 4821 4822 /* void glGetBooleanv ( GLenum pname, GLboolean *params ) */ 4823 static void 4824 android_glGetBooleanv__I_3ZI 4825 (JNIEnv *_env, jobject _this, jint pname, jbooleanArray params_ref, jint offset) { 4826 jint _exception = 0; 4827 const char * _exceptionType = NULL; 4828 const char * _exceptionMessage = NULL; 4829 GLboolean *params_base = (GLboolean *) 0; 4830 jint _remaining; 4831 GLboolean *params = (GLboolean *) 0; 4832 4833 if (!params_ref) { 4834 _exception = 1; 4835 _exceptionType = "java/lang/IllegalArgumentException"; 4836 _exceptionMessage = "params == null"; 4837 goto exit; 4838 } 4839 if (offset < 0) { 4840 _exception = 1; 4841 _exceptionType = "java/lang/IllegalArgumentException"; 4842 _exceptionMessage = "offset < 0"; 4843 goto exit; 4844 } 4845 _remaining = _env->GetArrayLength(params_ref) - offset; 4846 params_base = (GLboolean *) 4847 _env->GetBooleanArrayElements(params_ref, (jboolean *)0); 4848 params = params_base + offset; 4849 4850 glGetBooleanv( 4851 (GLenum)pname, 4852 (GLboolean *)params 4853 ); 4854 4855 exit: 4856 if (params_base) { 4857 _env->ReleaseBooleanArrayElements(params_ref, (jboolean*)params_base, 4858 _exception ? JNI_ABORT: 0); 4859 } 4860 if (_exception) { 4861 jniThrowException(_env, _exceptionType, _exceptionMessage); 4862 } 4863 } 4864 4865 /* void glGetBooleanv ( GLenum pname, GLboolean *params ) */ 4866 static void 4867 android_glGetBooleanv__ILjava_nio_IntBuffer_2 4868 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 4869 jint _exception = 0; 4870 const char * _exceptionType = NULL; 4871 const char * _exceptionMessage = NULL; 4872 jintArray _array = (jintArray) 0; 4873 jint _bufferOffset = (jint) 0; 4874 jint _remaining; 4875 GLboolean *params = (GLboolean *) 0; 4876 4877 if (!params_buf) { 4878 _exception = 1; 4879 _exceptionType = "java/lang/IllegalArgumentException"; 4880 _exceptionMessage = "params == null"; 4881 goto exit; 4882 } 4883 params = (GLboolean *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4884 if (params == NULL) { 4885 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 4886 params = (GLboolean *) (_paramsBase + _bufferOffset); 4887 } 4888 glGetBooleanv( 4889 (GLenum)pname, 4890 (GLboolean *)params 4891 ); 4892 4893 exit: 4894 if (_array) { 4895 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 4896 } 4897 if (_exception) { 4898 jniThrowException(_env, _exceptionType, _exceptionMessage); 4899 } 4900 } 4901 4902 /* void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 4903 static void 4904 android_glGetBufferParameteriv__II_3II 4905 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 4906 jniThrowException(_env, "java/lang/UnsupportedOperationException", 4907 "glGetBufferParameteriv"); 4908 } 4909 4910 /* void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 4911 static void 4912 android_glGetBufferParameteriv__IILjava_nio_IntBuffer_2 4913 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 4914 jniThrowException(_env, "java/lang/UnsupportedOperationException", 4915 "glGetBufferParameteriv"); 4916 } 4917 4918 /* void glGetClipPlanef ( GLenum pname, GLfloat *eqn ) */ 4919 static void 4920 android_glGetClipPlanef__I_3FI 4921 (JNIEnv *_env, jobject _this, jint pname, jfloatArray eqn_ref, jint offset) { 4922 jint _exception = 0; 4923 const char * _exceptionType = NULL; 4924 const char * _exceptionMessage = NULL; 4925 GLfloat *eqn_base = (GLfloat *) 0; 4926 jint _remaining; 4927 GLfloat *eqn = (GLfloat *) 0; 4928 4929 if (!eqn_ref) { 4930 _exception = 1; 4931 _exceptionType = "java/lang/IllegalArgumentException"; 4932 _exceptionMessage = "eqn == null"; 4933 goto exit; 4934 } 4935 if (offset < 0) { 4936 _exception = 1; 4937 _exceptionType = "java/lang/IllegalArgumentException"; 4938 _exceptionMessage = "offset < 0"; 4939 goto exit; 4940 } 4941 _remaining = _env->GetArrayLength(eqn_ref) - offset; 4942 eqn_base = (GLfloat *) 4943 _env->GetFloatArrayElements(eqn_ref, (jboolean *)0); 4944 eqn = eqn_base + offset; 4945 4946 glGetClipPlanef( 4947 (GLenum)pname, 4948 (GLfloat *)eqn 4949 ); 4950 4951 exit: 4952 if (eqn_base) { 4953 _env->ReleaseFloatArrayElements(eqn_ref, (jfloat*)eqn_base, 4954 _exception ? JNI_ABORT: 0); 4955 } 4956 if (_exception) { 4957 jniThrowException(_env, _exceptionType, _exceptionMessage); 4958 } 4959 } 4960 4961 /* void glGetClipPlanef ( GLenum pname, GLfloat *eqn ) */ 4962 static void 4963 android_glGetClipPlanef__ILjava_nio_FloatBuffer_2 4964 (JNIEnv *_env, jobject _this, jint pname, jobject eqn_buf) { 4965 jint _exception = 0; 4966 const char * _exceptionType = NULL; 4967 const char * _exceptionMessage = NULL; 4968 jfloatArray _array = (jfloatArray) 0; 4969 jint _bufferOffset = (jint) 0; 4970 jint _remaining; 4971 GLfloat *eqn = (GLfloat *) 0; 4972 4973 if (!eqn_buf) { 4974 _exception = 1; 4975 _exceptionType = "java/lang/IllegalArgumentException"; 4976 _exceptionMessage = "eqn == null"; 4977 goto exit; 4978 } 4979 eqn = (GLfloat *)getPointer(_env, eqn_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4980 if (eqn == NULL) { 4981 char * _eqnBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 4982 eqn = (GLfloat *) (_eqnBase + _bufferOffset); 4983 } 4984 glGetClipPlanef( 4985 (GLenum)pname, 4986 (GLfloat *)eqn 4987 ); 4988 4989 exit: 4990 if (_array) { 4991 _env->ReleaseFloatArrayElements(_array, (jfloat*)eqn, _exception ? JNI_ABORT : 0); 4992 } 4993 if (_exception) { 4994 jniThrowException(_env, _exceptionType, _exceptionMessage); 4995 } 4996 } 4997 4998 /* void glGetClipPlanex ( GLenum pname, GLfixed *eqn ) */ 4999 static void 5000 android_glGetClipPlanex__I_3II 5001 (JNIEnv *_env, jobject _this, jint pname, jintArray eqn_ref, jint offset) { 5002 jint _exception = 0; 5003 const char * _exceptionType = NULL; 5004 const char * _exceptionMessage = NULL; 5005 GLfixed *eqn_base = (GLfixed *) 0; 5006 jint _remaining; 5007 GLfixed *eqn = (GLfixed *) 0; 5008 5009 if (!eqn_ref) { 5010 _exception = 1; 5011 _exceptionType = "java/lang/IllegalArgumentException"; 5012 _exceptionMessage = "eqn == null"; 5013 goto exit; 5014 } 5015 if (offset < 0) { 5016 _exception = 1; 5017 _exceptionType = "java/lang/IllegalArgumentException"; 5018 _exceptionMessage = "offset < 0"; 5019 goto exit; 5020 } 5021 _remaining = _env->GetArrayLength(eqn_ref) - offset; 5022 eqn_base = (GLfixed *) 5023 _env->GetIntArrayElements(eqn_ref, (jboolean *)0); 5024 eqn = eqn_base + offset; 5025 5026 glGetClipPlanex( 5027 (GLenum)pname, 5028 (GLfixed *)eqn 5029 ); 5030 5031 exit: 5032 if (eqn_base) { 5033 _env->ReleaseIntArrayElements(eqn_ref, (jint*)eqn_base, 5034 _exception ? JNI_ABORT: 0); 5035 } 5036 if (_exception) { 5037 jniThrowException(_env, _exceptionType, _exceptionMessage); 5038 } 5039 } 5040 5041 /* void glGetClipPlanex ( GLenum pname, GLfixed *eqn ) */ 5042 static void 5043 android_glGetClipPlanex__ILjava_nio_IntBuffer_2 5044 (JNIEnv *_env, jobject _this, jint pname, jobject eqn_buf) { 5045 jint _exception = 0; 5046 const char * _exceptionType = NULL; 5047 const char * _exceptionMessage = NULL; 5048 jintArray _array = (jintArray) 0; 5049 jint _bufferOffset = (jint) 0; 5050 jint _remaining; 5051 GLfixed *eqn = (GLfixed *) 0; 5052 5053 if (!eqn_buf) { 5054 _exception = 1; 5055 _exceptionType = "java/lang/IllegalArgumentException"; 5056 _exceptionMessage = "eqn == null"; 5057 goto exit; 5058 } 5059 eqn = (GLfixed *)getPointer(_env, eqn_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5060 if (eqn == NULL) { 5061 char * _eqnBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 5062 eqn = (GLfixed *) (_eqnBase + _bufferOffset); 5063 } 5064 glGetClipPlanex( 5065 (GLenum)pname, 5066 (GLfixed *)eqn 5067 ); 5068 5069 exit: 5070 if (_array) { 5071 _env->ReleaseIntArrayElements(_array, (jint*)eqn, _exception ? JNI_ABORT : 0); 5072 } 5073 if (_exception) { 5074 jniThrowException(_env, _exceptionType, _exceptionMessage); 5075 } 5076 } 5077 5078 /* void glGetFixedv ( GLenum pname, GLfixed *params ) */ 5079 static void 5080 android_glGetFixedv__I_3II 5081 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) { 5082 jint _exception = 0; 5083 const char * _exceptionType = NULL; 5084 const char * _exceptionMessage = NULL; 5085 GLfixed *params_base = (GLfixed *) 0; 5086 jint _remaining; 5087 GLfixed *params = (GLfixed *) 0; 5088 5089 if (!params_ref) { 5090 _exception = 1; 5091 _exceptionType = "java/lang/IllegalArgumentException"; 5092 _exceptionMessage = "params == null"; 5093 goto exit; 5094 } 5095 if (offset < 0) { 5096 _exception = 1; 5097 _exceptionType = "java/lang/IllegalArgumentException"; 5098 _exceptionMessage = "offset < 0"; 5099 goto exit; 5100 } 5101 _remaining = _env->GetArrayLength(params_ref) - offset; 5102 params_base = (GLfixed *) 5103 _env->GetIntArrayElements(params_ref, (jboolean *)0); 5104 params = params_base + offset; 5105 5106 glGetFixedv( 5107 (GLenum)pname, 5108 (GLfixed *)params 5109 ); 5110 5111 exit: 5112 if (params_base) { 5113 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 5114 _exception ? JNI_ABORT: 0); 5115 } 5116 if (_exception) { 5117 jniThrowException(_env, _exceptionType, _exceptionMessage); 5118 } 5119 } 5120 5121 /* void glGetFixedv ( GLenum pname, GLfixed *params ) */ 5122 static void 5123 android_glGetFixedv__ILjava_nio_IntBuffer_2 5124 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 5125 jint _exception = 0; 5126 const char * _exceptionType = NULL; 5127 const char * _exceptionMessage = NULL; 5128 jintArray _array = (jintArray) 0; 5129 jint _bufferOffset = (jint) 0; 5130 jint _remaining; 5131 GLfixed *params = (GLfixed *) 0; 5132 5133 if (!params_buf) { 5134 _exception = 1; 5135 _exceptionType = "java/lang/IllegalArgumentException"; 5136 _exceptionMessage = "params == null"; 5137 goto exit; 5138 } 5139 params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5140 if (params == NULL) { 5141 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 5142 params = (GLfixed *) (_paramsBase + _bufferOffset); 5143 } 5144 glGetFixedv( 5145 (GLenum)pname, 5146 (GLfixed *)params 5147 ); 5148 5149 exit: 5150 if (_array) { 5151 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 5152 } 5153 if (_exception) { 5154 jniThrowException(_env, _exceptionType, _exceptionMessage); 5155 } 5156 } 5157 5158 /* void glGetFloatv ( GLenum pname, GLfloat *params ) */ 5159 static void 5160 android_glGetFloatv__I_3FI 5161 (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) { 5162 jint _exception = 0; 5163 const char * _exceptionType = NULL; 5164 const char * _exceptionMessage = NULL; 5165 GLfloat *params_base = (GLfloat *) 0; 5166 jint _remaining; 5167 GLfloat *params = (GLfloat *) 0; 5168 5169 if (!params_ref) { 5170 _exception = 1; 5171 _exceptionType = "java/lang/IllegalArgumentException"; 5172 _exceptionMessage = "params == null"; 5173 goto exit; 5174 } 5175 if (offset < 0) { 5176 _exception = 1; 5177 _exceptionType = "java/lang/IllegalArgumentException"; 5178 _exceptionMessage = "offset < 0"; 5179 goto exit; 5180 } 5181 _remaining = _env->GetArrayLength(params_ref) - offset; 5182 params_base = (GLfloat *) 5183 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 5184 params = params_base + offset; 5185 5186 glGetFloatv( 5187 (GLenum)pname, 5188 (GLfloat *)params 5189 ); 5190 5191 exit: 5192 if (params_base) { 5193 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 5194 _exception ? JNI_ABORT: 0); 5195 } 5196 if (_exception) { 5197 jniThrowException(_env, _exceptionType, _exceptionMessage); 5198 } 5199 } 5200 5201 /* void glGetFloatv ( GLenum pname, GLfloat *params ) */ 5202 static void 5203 android_glGetFloatv__ILjava_nio_FloatBuffer_2 5204 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 5205 jint _exception = 0; 5206 const char * _exceptionType = NULL; 5207 const char * _exceptionMessage = NULL; 5208 jfloatArray _array = (jfloatArray) 0; 5209 jint _bufferOffset = (jint) 0; 5210 jint _remaining; 5211 GLfloat *params = (GLfloat *) 0; 5212 5213 if (!params_buf) { 5214 _exception = 1; 5215 _exceptionType = "java/lang/IllegalArgumentException"; 5216 _exceptionMessage = "params == null"; 5217 goto exit; 5218 } 5219 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5220 if (params == NULL) { 5221 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5222 params = (GLfloat *) (_paramsBase + _bufferOffset); 5223 } 5224 glGetFloatv( 5225 (GLenum)pname, 5226 (GLfloat *)params 5227 ); 5228 5229 exit: 5230 if (_array) { 5231 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0); 5232 } 5233 if (_exception) { 5234 jniThrowException(_env, _exceptionType, _exceptionMessage); 5235 } 5236 } 5237 5238 /* void glGetLightfv ( GLenum light, GLenum pname, GLfloat *params ) */ 5239 static void 5240 android_glGetLightfv__II_3FI 5241 (JNIEnv *_env, jobject _this, jint light, jint pname, jfloatArray params_ref, jint offset) { 5242 jint _exception = 0; 5243 const char * _exceptionType = NULL; 5244 const char * _exceptionMessage = NULL; 5245 GLfloat *params_base = (GLfloat *) 0; 5246 jint _remaining; 5247 GLfloat *params = (GLfloat *) 0; 5248 5249 if (!params_ref) { 5250 _exception = 1; 5251 _exceptionType = "java/lang/IllegalArgumentException"; 5252 _exceptionMessage = "params == null"; 5253 goto exit; 5254 } 5255 if (offset < 0) { 5256 _exception = 1; 5257 _exceptionType = "java/lang/IllegalArgumentException"; 5258 _exceptionMessage = "offset < 0"; 5259 goto exit; 5260 } 5261 _remaining = _env->GetArrayLength(params_ref) - offset; 5262 int _needed; 5263 switch (pname) { 5264 #if defined(GL_SPOT_EXPONENT) 5265 case GL_SPOT_EXPONENT: 5266 #endif // defined(GL_SPOT_EXPONENT) 5267 #if defined(GL_SPOT_CUTOFF) 5268 case GL_SPOT_CUTOFF: 5269 #endif // defined(GL_SPOT_CUTOFF) 5270 #if defined(GL_CONSTANT_ATTENUATION) 5271 case GL_CONSTANT_ATTENUATION: 5272 #endif // defined(GL_CONSTANT_ATTENUATION) 5273 #if defined(GL_LINEAR_ATTENUATION) 5274 case GL_LINEAR_ATTENUATION: 5275 #endif // defined(GL_LINEAR_ATTENUATION) 5276 #if defined(GL_QUADRATIC_ATTENUATION) 5277 case GL_QUADRATIC_ATTENUATION: 5278 #endif // defined(GL_QUADRATIC_ATTENUATION) 5279 _needed = 1; 5280 break; 5281 #if defined(GL_SPOT_DIRECTION) 5282 case GL_SPOT_DIRECTION: 5283 #endif // defined(GL_SPOT_DIRECTION) 5284 _needed = 3; 5285 break; 5286 #if defined(GL_AMBIENT) 5287 case GL_AMBIENT: 5288 #endif // defined(GL_AMBIENT) 5289 #if defined(GL_DIFFUSE) 5290 case GL_DIFFUSE: 5291 #endif // defined(GL_DIFFUSE) 5292 #if defined(GL_SPECULAR) 5293 case GL_SPECULAR: 5294 #endif // defined(GL_SPECULAR) 5295 #if defined(GL_EMISSION) 5296 case GL_EMISSION: 5297 #endif // defined(GL_EMISSION) 5298 _needed = 4; 5299 break; 5300 default: 5301 _needed = 1; 5302 break; 5303 } 5304 if (_remaining < _needed) { 5305 _exception = 1; 5306 _exceptionType = "java/lang/IllegalArgumentException"; 5307 _exceptionMessage = "length - offset < needed"; 5308 goto exit; 5309 } 5310 params_base = (GLfloat *) 5311 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 5312 params = params_base + offset; 5313 5314 glGetLightfv( 5315 (GLenum)light, 5316 (GLenum)pname, 5317 (GLfloat *)params 5318 ); 5319 5320 exit: 5321 if (params_base) { 5322 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 5323 _exception ? JNI_ABORT: 0); 5324 } 5325 if (_exception) { 5326 jniThrowException(_env, _exceptionType, _exceptionMessage); 5327 } 5328 } 5329 5330 /* void glGetLightfv ( GLenum light, GLenum pname, GLfloat *params ) */ 5331 static void 5332 android_glGetLightfv__IILjava_nio_FloatBuffer_2 5333 (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) { 5334 jint _exception = 0; 5335 const char * _exceptionType = NULL; 5336 const char * _exceptionMessage = NULL; 5337 jfloatArray _array = (jfloatArray) 0; 5338 jint _bufferOffset = (jint) 0; 5339 jint _remaining; 5340 GLfloat *params = (GLfloat *) 0; 5341 5342 if (!params_buf) { 5343 _exception = 1; 5344 _exceptionType = "java/lang/IllegalArgumentException"; 5345 _exceptionMessage = "params == null"; 5346 goto exit; 5347 } 5348 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5349 int _needed; 5350 switch (pname) { 5351 #if defined(GL_SPOT_EXPONENT) 5352 case GL_SPOT_EXPONENT: 5353 #endif // defined(GL_SPOT_EXPONENT) 5354 #if defined(GL_SPOT_CUTOFF) 5355 case GL_SPOT_CUTOFF: 5356 #endif // defined(GL_SPOT_CUTOFF) 5357 #if defined(GL_CONSTANT_ATTENUATION) 5358 case GL_CONSTANT_ATTENUATION: 5359 #endif // defined(GL_CONSTANT_ATTENUATION) 5360 #if defined(GL_LINEAR_ATTENUATION) 5361 case GL_LINEAR_ATTENUATION: 5362 #endif // defined(GL_LINEAR_ATTENUATION) 5363 #if defined(GL_QUADRATIC_ATTENUATION) 5364 case GL_QUADRATIC_ATTENUATION: 5365 #endif // defined(GL_QUADRATIC_ATTENUATION) 5366 _needed = 1; 5367 break; 5368 #if defined(GL_SPOT_DIRECTION) 5369 case GL_SPOT_DIRECTION: 5370 #endif // defined(GL_SPOT_DIRECTION) 5371 _needed = 3; 5372 break; 5373 #if defined(GL_AMBIENT) 5374 case GL_AMBIENT: 5375 #endif // defined(GL_AMBIENT) 5376 #if defined(GL_DIFFUSE) 5377 case GL_DIFFUSE: 5378 #endif // defined(GL_DIFFUSE) 5379 #if defined(GL_SPECULAR) 5380 case GL_SPECULAR: 5381 #endif // defined(GL_SPECULAR) 5382 #if defined(GL_EMISSION) 5383 case GL_EMISSION: 5384 #endif // defined(GL_EMISSION) 5385 _needed = 4; 5386 break; 5387 default: 5388 _needed = 1; 5389 break; 5390 } 5391 if (_remaining < _needed) { 5392 _exception = 1; 5393 _exceptionType = "java/lang/IllegalArgumentException"; 5394 _exceptionMessage = "remaining() < needed"; 5395 goto exit; 5396 } 5397 if (params == NULL) { 5398 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5399 params = (GLfloat *) (_paramsBase + _bufferOffset); 5400 } 5401 glGetLightfv( 5402 (GLenum)light, 5403 (GLenum)pname, 5404 (GLfloat *)params 5405 ); 5406 5407 exit: 5408 if (_array) { 5409 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0); 5410 } 5411 if (_exception) { 5412 jniThrowException(_env, _exceptionType, _exceptionMessage); 5413 } 5414 } 5415 5416 /* void glGetLightxv ( GLenum light, GLenum pname, GLfixed *params ) */ 5417 static void 5418 android_glGetLightxv__II_3II 5419 (JNIEnv *_env, jobject _this, jint light, jint pname, jintArray params_ref, jint offset) { 5420 jint _exception = 0; 5421 const char * _exceptionType = NULL; 5422 const char * _exceptionMessage = NULL; 5423 GLfixed *params_base = (GLfixed *) 0; 5424 jint _remaining; 5425 GLfixed *params = (GLfixed *) 0; 5426 5427 if (!params_ref) { 5428 _exception = 1; 5429 _exceptionType = "java/lang/IllegalArgumentException"; 5430 _exceptionMessage = "params == null"; 5431 goto exit; 5432 } 5433 if (offset < 0) { 5434 _exception = 1; 5435 _exceptionType = "java/lang/IllegalArgumentException"; 5436 _exceptionMessage = "offset < 0"; 5437 goto exit; 5438 } 5439 _remaining = _env->GetArrayLength(params_ref) - offset; 5440 int _needed; 5441 switch (pname) { 5442 #if defined(GL_SPOT_EXPONENT) 5443 case GL_SPOT_EXPONENT: 5444 #endif // defined(GL_SPOT_EXPONENT) 5445 #if defined(GL_SPOT_CUTOFF) 5446 case GL_SPOT_CUTOFF: 5447 #endif // defined(GL_SPOT_CUTOFF) 5448 #if defined(GL_CONSTANT_ATTENUATION) 5449 case GL_CONSTANT_ATTENUATION: 5450 #endif // defined(GL_CONSTANT_ATTENUATION) 5451 #if defined(GL_LINEAR_ATTENUATION) 5452 case GL_LINEAR_ATTENUATION: 5453 #endif // defined(GL_LINEAR_ATTENUATION) 5454 #if defined(GL_QUADRATIC_ATTENUATION) 5455 case GL_QUADRATIC_ATTENUATION: 5456 #endif // defined(GL_QUADRATIC_ATTENUATION) 5457 _needed = 1; 5458 break; 5459 #if defined(GL_SPOT_DIRECTION) 5460 case GL_SPOT_DIRECTION: 5461 #endif // defined(GL_SPOT_DIRECTION) 5462 _needed = 3; 5463 break; 5464 #if defined(GL_AMBIENT) 5465 case GL_AMBIENT: 5466 #endif // defined(GL_AMBIENT) 5467 #if defined(GL_DIFFUSE) 5468 case GL_DIFFUSE: 5469 #endif // defined(GL_DIFFUSE) 5470 #if defined(GL_SPECULAR) 5471 case GL_SPECULAR: 5472 #endif // defined(GL_SPECULAR) 5473 #if defined(GL_EMISSION) 5474 case GL_EMISSION: 5475 #endif // defined(GL_EMISSION) 5476 _needed = 4; 5477 break; 5478 default: 5479 _needed = 1; 5480 break; 5481 } 5482 if (_remaining < _needed) { 5483 _exception = 1; 5484 _exceptionType = "java/lang/IllegalArgumentException"; 5485 _exceptionMessage = "length - offset < needed"; 5486 goto exit; 5487 } 5488 params_base = (GLfixed *) 5489 _env->GetIntArrayElements(params_ref, (jboolean *)0); 5490 params = params_base + offset; 5491 5492 glGetLightxv( 5493 (GLenum)light, 5494 (GLenum)pname, 5495 (GLfixed *)params 5496 ); 5497 5498 exit: 5499 if (params_base) { 5500 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 5501 _exception ? JNI_ABORT: 0); 5502 } 5503 if (_exception) { 5504 jniThrowException(_env, _exceptionType, _exceptionMessage); 5505 } 5506 } 5507 5508 /* void glGetLightxv ( GLenum light, GLenum pname, GLfixed *params ) */ 5509 static void 5510 android_glGetLightxv__IILjava_nio_IntBuffer_2 5511 (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) { 5512 jint _exception = 0; 5513 const char * _exceptionType = NULL; 5514 const char * _exceptionMessage = NULL; 5515 jintArray _array = (jintArray) 0; 5516 jint _bufferOffset = (jint) 0; 5517 jint _remaining; 5518 GLfixed *params = (GLfixed *) 0; 5519 5520 if (!params_buf) { 5521 _exception = 1; 5522 _exceptionType = "java/lang/IllegalArgumentException"; 5523 _exceptionMessage = "params == null"; 5524 goto exit; 5525 } 5526 params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5527 int _needed; 5528 switch (pname) { 5529 #if defined(GL_SPOT_EXPONENT) 5530 case GL_SPOT_EXPONENT: 5531 #endif // defined(GL_SPOT_EXPONENT) 5532 #if defined(GL_SPOT_CUTOFF) 5533 case GL_SPOT_CUTOFF: 5534 #endif // defined(GL_SPOT_CUTOFF) 5535 #if defined(GL_CONSTANT_ATTENUATION) 5536 case GL_CONSTANT_ATTENUATION: 5537 #endif // defined(GL_CONSTANT_ATTENUATION) 5538 #if defined(GL_LINEAR_ATTENUATION) 5539 case GL_LINEAR_ATTENUATION: 5540 #endif // defined(GL_LINEAR_ATTENUATION) 5541 #if defined(GL_QUADRATIC_ATTENUATION) 5542 case GL_QUADRATIC_ATTENUATION: 5543 #endif // defined(GL_QUADRATIC_ATTENUATION) 5544 _needed = 1; 5545 break; 5546 #if defined(GL_SPOT_DIRECTION) 5547 case GL_SPOT_DIRECTION: 5548 #endif // defined(GL_SPOT_DIRECTION) 5549 _needed = 3; 5550 break; 5551 #if defined(GL_AMBIENT) 5552 case GL_AMBIENT: 5553 #endif // defined(GL_AMBIENT) 5554 #if defined(GL_DIFFUSE) 5555 case GL_DIFFUSE: 5556 #endif // defined(GL_DIFFUSE) 5557 #if defined(GL_SPECULAR) 5558 case GL_SPECULAR: 5559 #endif // defined(GL_SPECULAR) 5560 #if defined(GL_EMISSION) 5561 case GL_EMISSION: 5562 #endif // defined(GL_EMISSION) 5563 _needed = 4; 5564 break; 5565 default: 5566 _needed = 1; 5567 break; 5568 } 5569 if (_remaining < _needed) { 5570 _exception = 1; 5571 _exceptionType = "java/lang/IllegalArgumentException"; 5572 _exceptionMessage = "remaining() < needed"; 5573 goto exit; 5574 } 5575 if (params == NULL) { 5576 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 5577 params = (GLfixed *) (_paramsBase + _bufferOffset); 5578 } 5579 glGetLightxv( 5580 (GLenum)light, 5581 (GLenum)pname, 5582 (GLfixed *)params 5583 ); 5584 5585 exit: 5586 if (_array) { 5587 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 5588 } 5589 if (_exception) { 5590 jniThrowException(_env, _exceptionType, _exceptionMessage); 5591 } 5592 } 5593 5594 /* void glGetMaterialfv ( GLenum face, GLenum pname, GLfloat *params ) */ 5595 static void 5596 android_glGetMaterialfv__II_3FI 5597 (JNIEnv *_env, jobject _this, jint face, jint pname, jfloatArray params_ref, jint offset) { 5598 jint _exception = 0; 5599 const char * _exceptionType = NULL; 5600 const char * _exceptionMessage = NULL; 5601 GLfloat *params_base = (GLfloat *) 0; 5602 jint _remaining; 5603 GLfloat *params = (GLfloat *) 0; 5604 5605 if (!params_ref) { 5606 _exception = 1; 5607 _exceptionType = "java/lang/IllegalArgumentException"; 5608 _exceptionMessage = "params == null"; 5609 goto exit; 5610 } 5611 if (offset < 0) { 5612 _exception = 1; 5613 _exceptionType = "java/lang/IllegalArgumentException"; 5614 _exceptionMessage = "offset < 0"; 5615 goto exit; 5616 } 5617 _remaining = _env->GetArrayLength(params_ref) - offset; 5618 int _needed; 5619 switch (pname) { 5620 #if defined(GL_SHININESS) 5621 case GL_SHININESS: 5622 #endif // defined(GL_SHININESS) 5623 _needed = 1; 5624 break; 5625 #if defined(GL_AMBIENT) 5626 case GL_AMBIENT: 5627 #endif // defined(GL_AMBIENT) 5628 #if defined(GL_DIFFUSE) 5629 case GL_DIFFUSE: 5630 #endif // defined(GL_DIFFUSE) 5631 #if defined(GL_SPECULAR) 5632 case GL_SPECULAR: 5633 #endif // defined(GL_SPECULAR) 5634 #if defined(GL_EMISSION) 5635 case GL_EMISSION: 5636 #endif // defined(GL_EMISSION) 5637 #if defined(GL_AMBIENT_AND_DIFFUSE) 5638 case GL_AMBIENT_AND_DIFFUSE: 5639 #endif // defined(GL_AMBIENT_AND_DIFFUSE) 5640 _needed = 4; 5641 break; 5642 default: 5643 _needed = 1; 5644 break; 5645 } 5646 if (_remaining < _needed) { 5647 _exception = 1; 5648 _exceptionType = "java/lang/IllegalArgumentException"; 5649 _exceptionMessage = "length - offset < needed"; 5650 goto exit; 5651 } 5652 params_base = (GLfloat *) 5653 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 5654 params = params_base + offset; 5655 5656 glGetMaterialfv( 5657 (GLenum)face, 5658 (GLenum)pname, 5659 (GLfloat *)params 5660 ); 5661 5662 exit: 5663 if (params_base) { 5664 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 5665 _exception ? JNI_ABORT: 0); 5666 } 5667 if (_exception) { 5668 jniThrowException(_env, _exceptionType, _exceptionMessage); 5669 } 5670 } 5671 5672 /* void glGetMaterialfv ( GLenum face, GLenum pname, GLfloat *params ) */ 5673 static void 5674 android_glGetMaterialfv__IILjava_nio_FloatBuffer_2 5675 (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) { 5676 jint _exception = 0; 5677 const char * _exceptionType = NULL; 5678 const char * _exceptionMessage = NULL; 5679 jfloatArray _array = (jfloatArray) 0; 5680 jint _bufferOffset = (jint) 0; 5681 jint _remaining; 5682 GLfloat *params = (GLfloat *) 0; 5683 5684 if (!params_buf) { 5685 _exception = 1; 5686 _exceptionType = "java/lang/IllegalArgumentException"; 5687 _exceptionMessage = "params == null"; 5688 goto exit; 5689 } 5690 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5691 int _needed; 5692 switch (pname) { 5693 #if defined(GL_SHININESS) 5694 case GL_SHININESS: 5695 #endif // defined(GL_SHININESS) 5696 _needed = 1; 5697 break; 5698 #if defined(GL_AMBIENT) 5699 case GL_AMBIENT: 5700 #endif // defined(GL_AMBIENT) 5701 #if defined(GL_DIFFUSE) 5702 case GL_DIFFUSE: 5703 #endif // defined(GL_DIFFUSE) 5704 #if defined(GL_SPECULAR) 5705 case GL_SPECULAR: 5706 #endif // defined(GL_SPECULAR) 5707 #if defined(GL_EMISSION) 5708 case GL_EMISSION: 5709 #endif // defined(GL_EMISSION) 5710 #if defined(GL_AMBIENT_AND_DIFFUSE) 5711 case GL_AMBIENT_AND_DIFFUSE: 5712 #endif // defined(GL_AMBIENT_AND_DIFFUSE) 5713 _needed = 4; 5714 break; 5715 default: 5716 _needed = 1; 5717 break; 5718 } 5719 if (_remaining < _needed) { 5720 _exception = 1; 5721 _exceptionType = "java/lang/IllegalArgumentException"; 5722 _exceptionMessage = "remaining() < needed"; 5723 goto exit; 5724 } 5725 if (params == NULL) { 5726 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5727 params = (GLfloat *) (_paramsBase + _bufferOffset); 5728 } 5729 glGetMaterialfv( 5730 (GLenum)face, 5731 (GLenum)pname, 5732 (GLfloat *)params 5733 ); 5734 5735 exit: 5736 if (_array) { 5737 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0); 5738 } 5739 if (_exception) { 5740 jniThrowException(_env, _exceptionType, _exceptionMessage); 5741 } 5742 } 5743 5744 /* void glGetMaterialxv ( GLenum face, GLenum pname, GLfixed *params ) */ 5745 static void 5746 android_glGetMaterialxv__II_3II 5747 (JNIEnv *_env, jobject _this, jint face, jint pname, jintArray params_ref, jint offset) { 5748 jint _exception = 0; 5749 const char * _exceptionType = NULL; 5750 const char * _exceptionMessage = NULL; 5751 GLfixed *params_base = (GLfixed *) 0; 5752 jint _remaining; 5753 GLfixed *params = (GLfixed *) 0; 5754 5755 if (!params_ref) { 5756 _exception = 1; 5757 _exceptionType = "java/lang/IllegalArgumentException"; 5758 _exceptionMessage = "params == null"; 5759 goto exit; 5760 } 5761 if (offset < 0) { 5762 _exception = 1; 5763 _exceptionType = "java/lang/IllegalArgumentException"; 5764 _exceptionMessage = "offset < 0"; 5765 goto exit; 5766 } 5767 _remaining = _env->GetArrayLength(params_ref) - offset; 5768 int _needed; 5769 switch (pname) { 5770 #if defined(GL_SHININESS) 5771 case GL_SHININESS: 5772 #endif // defined(GL_SHININESS) 5773 _needed = 1; 5774 break; 5775 #if defined(GL_AMBIENT) 5776 case GL_AMBIENT: 5777 #endif // defined(GL_AMBIENT) 5778 #if defined(GL_DIFFUSE) 5779 case GL_DIFFUSE: 5780 #endif // defined(GL_DIFFUSE) 5781 #if defined(GL_SPECULAR) 5782 case GL_SPECULAR: 5783 #endif // defined(GL_SPECULAR) 5784 #if defined(GL_EMISSION) 5785 case GL_EMISSION: 5786 #endif // defined(GL_EMISSION) 5787 #if defined(GL_AMBIENT_AND_DIFFUSE) 5788 case GL_AMBIENT_AND_DIFFUSE: 5789 #endif // defined(GL_AMBIENT_AND_DIFFUSE) 5790 _needed = 4; 5791 break; 5792 default: 5793 _needed = 1; 5794 break; 5795 } 5796 if (_remaining < _needed) { 5797 _exception = 1; 5798 _exceptionType = "java/lang/IllegalArgumentException"; 5799 _exceptionMessage = "length - offset < needed"; 5800 goto exit; 5801 } 5802 params_base = (GLfixed *) 5803 _env->GetIntArrayElements(params_ref, (jboolean *)0); 5804 params = params_base + offset; 5805 5806 glGetMaterialxv( 5807 (GLenum)face, 5808 (GLenum)pname, 5809 (GLfixed *)params 5810 ); 5811 5812 exit: 5813 if (params_base) { 5814 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 5815 _exception ? JNI_ABORT: 0); 5816 } 5817 if (_exception) { 5818 jniThrowException(_env, _exceptionType, _exceptionMessage); 5819 } 5820 } 5821 5822 /* void glGetMaterialxv ( GLenum face, GLenum pname, GLfixed *params ) */ 5823 static void 5824 android_glGetMaterialxv__IILjava_nio_IntBuffer_2 5825 (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) { 5826 jint _exception = 0; 5827 const char * _exceptionType = NULL; 5828 const char * _exceptionMessage = NULL; 5829 jintArray _array = (jintArray) 0; 5830 jint _bufferOffset = (jint) 0; 5831 jint _remaining; 5832 GLfixed *params = (GLfixed *) 0; 5833 5834 if (!params_buf) { 5835 _exception = 1; 5836 _exceptionType = "java/lang/IllegalArgumentException"; 5837 _exceptionMessage = "params == null"; 5838 goto exit; 5839 } 5840 params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5841 int _needed; 5842 switch (pname) { 5843 #if defined(GL_SHININESS) 5844 case GL_SHININESS: 5845 #endif // defined(GL_SHININESS) 5846 _needed = 1; 5847 break; 5848 #if defined(GL_AMBIENT) 5849 case GL_AMBIENT: 5850 #endif // defined(GL_AMBIENT) 5851 #if defined(GL_DIFFUSE) 5852 case GL_DIFFUSE: 5853 #endif // defined(GL_DIFFUSE) 5854 #if defined(GL_SPECULAR) 5855 case GL_SPECULAR: 5856 #endif // defined(GL_SPECULAR) 5857 #if defined(GL_EMISSION) 5858 case GL_EMISSION: 5859 #endif // defined(GL_EMISSION) 5860 #if defined(GL_AMBIENT_AND_DIFFUSE) 5861 case GL_AMBIENT_AND_DIFFUSE: 5862 #endif // defined(GL_AMBIENT_AND_DIFFUSE) 5863 _needed = 4; 5864 break; 5865 default: 5866 _needed = 1; 5867 break; 5868 } 5869 if (_remaining < _needed) { 5870 _exception = 1; 5871 _exceptionType = "java/lang/IllegalArgumentException"; 5872 _exceptionMessage = "remaining() < needed"; 5873 goto exit; 5874 } 5875 if (params == NULL) { 5876 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 5877 params = (GLfixed *) (_paramsBase + _bufferOffset); 5878 } 5879 glGetMaterialxv( 5880 (GLenum)face, 5881 (GLenum)pname, 5882 (GLfixed *)params 5883 ); 5884 5885 exit: 5886 if (_array) { 5887 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 5888 } 5889 if (_exception) { 5890 jniThrowException(_env, _exceptionType, _exceptionMessage); 5891 } 5892 } 5893 5894 /* void glGetTexEnviv ( GLenum env, GLenum pname, GLint *params ) */ 5895 static void 5896 android_glGetTexEnviv__II_3II 5897 (JNIEnv *_env, jobject _this, jint env, jint pname, jintArray params_ref, jint offset) { 5898 jint _exception = 0; 5899 const char * _exceptionType = NULL; 5900 const char * _exceptionMessage = NULL; 5901 GLint *params_base = (GLint *) 0; 5902 jint _remaining; 5903 GLint *params = (GLint *) 0; 5904 5905 if (!params_ref) { 5906 _exception = 1; 5907 _exceptionType = "java/lang/IllegalArgumentException"; 5908 _exceptionMessage = "params == null"; 5909 goto exit; 5910 } 5911 if (offset < 0) { 5912 _exception = 1; 5913 _exceptionType = "java/lang/IllegalArgumentException"; 5914 _exceptionMessage = "offset < 0"; 5915 goto exit; 5916 } 5917 _remaining = _env->GetArrayLength(params_ref) - offset; 5918 int _needed; 5919 switch (pname) { 5920 #if defined(GL_TEXTURE_ENV_MODE) 5921 case GL_TEXTURE_ENV_MODE: 5922 #endif // defined(GL_TEXTURE_ENV_MODE) 5923 #if defined(GL_COMBINE_RGB) 5924 case GL_COMBINE_RGB: 5925 #endif // defined(GL_COMBINE_RGB) 5926 #if defined(GL_COMBINE_ALPHA) 5927 case GL_COMBINE_ALPHA: 5928 #endif // defined(GL_COMBINE_ALPHA) 5929 _needed = 1; 5930 break; 5931 #if defined(GL_TEXTURE_ENV_COLOR) 5932 case GL_TEXTURE_ENV_COLOR: 5933 #endif // defined(GL_TEXTURE_ENV_COLOR) 5934 _needed = 4; 5935 break; 5936 default: 5937 _needed = 1; 5938 break; 5939 } 5940 if (_remaining < _needed) { 5941 _exception = 1; 5942 _exceptionType = "java/lang/IllegalArgumentException"; 5943 _exceptionMessage = "length - offset < needed"; 5944 goto exit; 5945 } 5946 params_base = (GLint *) 5947 _env->GetIntArrayElements(params_ref, (jboolean *)0); 5948 params = params_base + offset; 5949 5950 glGetTexEnviv( 5951 (GLenum)env, 5952 (GLenum)pname, 5953 (GLint *)params 5954 ); 5955 5956 exit: 5957 if (params_base) { 5958 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 5959 _exception ? JNI_ABORT: 0); 5960 } 5961 if (_exception) { 5962 jniThrowException(_env, _exceptionType, _exceptionMessage); 5963 } 5964 } 5965 5966 /* void glGetTexEnviv ( GLenum env, GLenum pname, GLint *params ) */ 5967 static void 5968 android_glGetTexEnviv__IILjava_nio_IntBuffer_2 5969 (JNIEnv *_env, jobject _this, jint env, jint pname, jobject params_buf) { 5970 jint _exception = 0; 5971 const char * _exceptionType = NULL; 5972 const char * _exceptionMessage = NULL; 5973 jintArray _array = (jintArray) 0; 5974 jint _bufferOffset = (jint) 0; 5975 jint _remaining; 5976 GLint *params = (GLint *) 0; 5977 5978 if (!params_buf) { 5979 _exception = 1; 5980 _exceptionType = "java/lang/IllegalArgumentException"; 5981 _exceptionMessage = "params == null"; 5982 goto exit; 5983 } 5984 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5985 int _needed; 5986 switch (pname) { 5987 #if defined(GL_TEXTURE_ENV_MODE) 5988 case GL_TEXTURE_ENV_MODE: 5989 #endif // defined(GL_TEXTURE_ENV_MODE) 5990 #if defined(GL_COMBINE_RGB) 5991 case GL_COMBINE_RGB: 5992 #endif // defined(GL_COMBINE_RGB) 5993 #if defined(GL_COMBINE_ALPHA) 5994 case GL_COMBINE_ALPHA: 5995 #endif // defined(GL_COMBINE_ALPHA) 5996 _needed = 1; 5997 break; 5998 #if defined(GL_TEXTURE_ENV_COLOR) 5999 case GL_TEXTURE_ENV_COLOR: 6000 #endif // defined(GL_TEXTURE_ENV_COLOR) 6001 _needed = 4; 6002 break; 6003 default: 6004 _needed = 1; 6005 break; 6006 } 6007 if (_remaining < _needed) { 6008 _exception = 1; 6009 _exceptionType = "java/lang/IllegalArgumentException"; 6010 _exceptionMessage = "remaining() < needed"; 6011 goto exit; 6012 } 6013 if (params == NULL) { 6014 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 6015 params = (GLint *) (_paramsBase + _bufferOffset); 6016 } 6017 glGetTexEnviv( 6018 (GLenum)env, 6019 (GLenum)pname, 6020 (GLint *)params 6021 ); 6022 6023 exit: 6024 if (_array) { 6025 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 6026 } 6027 if (_exception) { 6028 jniThrowException(_env, _exceptionType, _exceptionMessage); 6029 } 6030 } 6031 6032 /* void glGetTexEnvxv ( GLenum env, GLenum pname, GLfixed *params ) */ 6033 static void 6034 android_glGetTexEnvxv__II_3II 6035 (JNIEnv *_env, jobject _this, jint env, jint pname, jintArray params_ref, jint offset) { 6036 jint _exception = 0; 6037 const char * _exceptionType = NULL; 6038 const char * _exceptionMessage = NULL; 6039 GLfixed *params_base = (GLfixed *) 0; 6040 jint _remaining; 6041 GLfixed *params = (GLfixed *) 0; 6042 6043 if (!params_ref) { 6044 _exception = 1; 6045 _exceptionType = "java/lang/IllegalArgumentException"; 6046 _exceptionMessage = "params == null"; 6047 goto exit; 6048 } 6049 if (offset < 0) { 6050 _exception = 1; 6051 _exceptionType = "java/lang/IllegalArgumentException"; 6052 _exceptionMessage = "offset < 0"; 6053 goto exit; 6054 } 6055 _remaining = _env->GetArrayLength(params_ref) - offset; 6056 int _needed; 6057 switch (pname) { 6058 #if defined(GL_TEXTURE_ENV_MODE) 6059 case GL_TEXTURE_ENV_MODE: 6060 #endif // defined(GL_TEXTURE_ENV_MODE) 6061 #if defined(GL_COMBINE_RGB) 6062 case GL_COMBINE_RGB: 6063 #endif // defined(GL_COMBINE_RGB) 6064 #if defined(GL_COMBINE_ALPHA) 6065 case GL_COMBINE_ALPHA: 6066 #endif // defined(GL_COMBINE_ALPHA) 6067 _needed = 1; 6068 break; 6069 #if defined(GL_TEXTURE_ENV_COLOR) 6070 case GL_TEXTURE_ENV_COLOR: 6071 #endif // defined(GL_TEXTURE_ENV_COLOR) 6072 _needed = 4; 6073 break; 6074 default: 6075 _needed = 1; 6076 break; 6077 } 6078 if (_remaining < _needed) { 6079 _exception = 1; 6080 _exceptionType = "java/lang/IllegalArgumentException"; 6081 _exceptionMessage = "length - offset < needed"; 6082 goto exit; 6083 } 6084 params_base = (GLfixed *) 6085 _env->GetIntArrayElements(params_ref, (jboolean *)0); 6086 params = params_base + offset; 6087 6088 glGetTexEnvxv( 6089 (GLenum)env, 6090 (GLenum)pname, 6091 (GLfixed *)params 6092 ); 6093 6094 exit: 6095 if (params_base) { 6096 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 6097 _exception ? JNI_ABORT: 0); 6098 } 6099 if (_exception) { 6100 jniThrowException(_env, _exceptionType, _exceptionMessage); 6101 } 6102 } 6103 6104 /* void glGetTexEnvxv ( GLenum env, GLenum pname, GLfixed *params ) */ 6105 static void 6106 android_glGetTexEnvxv__IILjava_nio_IntBuffer_2 6107 (JNIEnv *_env, jobject _this, jint env, jint pname, jobject params_buf) { 6108 jint _exception = 0; 6109 const char * _exceptionType = NULL; 6110 const char * _exceptionMessage = NULL; 6111 jintArray _array = (jintArray) 0; 6112 jint _bufferOffset = (jint) 0; 6113 jint _remaining; 6114 GLfixed *params = (GLfixed *) 0; 6115 6116 if (!params_buf) { 6117 _exception = 1; 6118 _exceptionType = "java/lang/IllegalArgumentException"; 6119 _exceptionMessage = "params == null"; 6120 goto exit; 6121 } 6122 params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 6123 int _needed; 6124 switch (pname) { 6125 #if defined(GL_TEXTURE_ENV_MODE) 6126 case GL_TEXTURE_ENV_MODE: 6127 #endif // defined(GL_TEXTURE_ENV_MODE) 6128 #if defined(GL_COMBINE_RGB) 6129 case GL_COMBINE_RGB: 6130 #endif // defined(GL_COMBINE_RGB) 6131 #if defined(GL_COMBINE_ALPHA) 6132 case GL_COMBINE_ALPHA: 6133 #endif // defined(GL_COMBINE_ALPHA) 6134 _needed = 1; 6135 break; 6136 #if defined(GL_TEXTURE_ENV_COLOR) 6137 case GL_TEXTURE_ENV_COLOR: 6138 #endif // defined(GL_TEXTURE_ENV_COLOR) 6139 _needed = 4; 6140 break; 6141 default: 6142 _needed = 1; 6143 break; 6144 } 6145 if (_remaining < _needed) { 6146 _exception = 1; 6147 _exceptionType = "java/lang/IllegalArgumentException"; 6148 _exceptionMessage = "remaining() < needed"; 6149 goto exit; 6150 } 6151 if (params == NULL) { 6152 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 6153 params = (GLfixed *) (_paramsBase + _bufferOffset); 6154 } 6155 glGetTexEnvxv( 6156 (GLenum)env, 6157 (GLenum)pname, 6158 (GLfixed *)params 6159 ); 6160 6161 exit: 6162 if (_array) { 6163 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 6164 } 6165 if (_exception) { 6166 jniThrowException(_env, _exceptionType, _exceptionMessage); 6167 } 6168 } 6169 6170 /* void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) */ 6171 static void 6172 android_glGetTexParameterfv__II_3FI 6173 (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) { 6174 jint _exception = 0; 6175 const char * _exceptionType = NULL; 6176 const char * _exceptionMessage = NULL; 6177 GLfloat *params_base = (GLfloat *) 0; 6178 jint _remaining; 6179 GLfloat *params = (GLfloat *) 0; 6180 6181 if (!params_ref) { 6182 _exception = 1; 6183 _exceptionType = "java/lang/IllegalArgumentException"; 6184 _exceptionMessage = "params == null"; 6185 goto exit; 6186 } 6187 if (offset < 0) { 6188 _exception = 1; 6189 _exceptionType = "java/lang/IllegalArgumentException"; 6190 _exceptionMessage = "offset < 0"; 6191 goto exit; 6192 } 6193 _remaining = _env->GetArrayLength(params_ref) - offset; 6194 if (_remaining < 1) { 6195 _exception = 1; 6196 _exceptionType = "java/lang/IllegalArgumentException"; 6197 _exceptionMessage = "length - offset < 1 < needed"; 6198 goto exit; 6199 } 6200 params_base = (GLfloat *) 6201 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 6202 params = params_base + offset; 6203 6204 glGetTexParameterfv( 6205 (GLenum)target, 6206 (GLenum)pname, 6207 (GLfloat *)params 6208 ); 6209 6210 exit: 6211 if (params_base) { 6212 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 6213 _exception ? JNI_ABORT: 0); 6214 } 6215 if (_exception) { 6216 jniThrowException(_env, _exceptionType, _exceptionMessage); 6217 } 6218 } 6219 6220 /* void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) */ 6221 static void 6222 android_glGetTexParameterfv__IILjava_nio_FloatBuffer_2 6223 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 6224 jint _exception = 0; 6225 const char * _exceptionType = NULL; 6226 const char * _exceptionMessage = NULL; 6227 jfloatArray _array = (jfloatArray) 0; 6228 jint _bufferOffset = (jint) 0; 6229 jint _remaining; 6230 GLfloat *params = (GLfloat *) 0; 6231 6232 if (!params_buf) { 6233 _exception = 1; 6234 _exceptionType = "java/lang/IllegalArgumentException"; 6235 _exceptionMessage = "params == null"; 6236 goto exit; 6237 } 6238 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 6239 if (_remaining < 1) { 6240 _exception = 1; 6241 _exceptionType = "java/lang/IllegalArgumentException"; 6242 _exceptionMessage = "remaining() < 1 < needed"; 6243 goto exit; 6244 } 6245 if (params == NULL) { 6246 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 6247 params = (GLfloat *) (_paramsBase + _bufferOffset); 6248 } 6249 glGetTexParameterfv( 6250 (GLenum)target, 6251 (GLenum)pname, 6252 (GLfloat *)params 6253 ); 6254 6255 exit: 6256 if (_array) { 6257 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0); 6258 } 6259 if (_exception) { 6260 jniThrowException(_env, _exceptionType, _exceptionMessage); 6261 } 6262 } 6263 6264 /* void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 6265 static void 6266 android_glGetTexParameteriv__II_3II 6267 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 6268 jint _exception = 0; 6269 const char * _exceptionType = NULL; 6270 const char * _exceptionMessage = NULL; 6271 GLint *params_base = (GLint *) 0; 6272 jint _remaining; 6273 GLint *params = (GLint *) 0; 6274 6275 if (!params_ref) { 6276 _exception = 1; 6277 _exceptionType = "java/lang/IllegalArgumentException"; 6278 _exceptionMessage = "params == null"; 6279 goto exit; 6280 } 6281 if (offset < 0) { 6282 _exception = 1; 6283 _exceptionType = "java/lang/IllegalArgumentException"; 6284 _exceptionMessage = "offset < 0"; 6285 goto exit; 6286 } 6287 _remaining = _env->GetArrayLength(params_ref) - offset; 6288 if (_remaining < 1) { 6289 _exception = 1; 6290 _exceptionType = "java/lang/IllegalArgumentException"; 6291 _exceptionMessage = "length - offset < 1 < needed"; 6292 goto exit; 6293 } 6294 params_base = (GLint *) 6295 _env->GetIntArrayElements(params_ref, (jboolean *)0); 6296 params = params_base + offset; 6297 6298 glGetTexParameteriv( 6299 (GLenum)target, 6300 (GLenum)pname, 6301 (GLint *)params 6302 ); 6303 6304 exit: 6305 if (params_base) { 6306 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 6307 _exception ? JNI_ABORT: 0); 6308 } 6309 if (_exception) { 6310 jniThrowException(_env, _exceptionType, _exceptionMessage); 6311 } 6312 } 6313 6314 /* void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 6315 static void 6316 android_glGetTexParameteriv__IILjava_nio_IntBuffer_2 6317 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 6318 jint _exception = 0; 6319 const char * _exceptionType = NULL; 6320 const char * _exceptionMessage = NULL; 6321 jintArray _array = (jintArray) 0; 6322 jint _bufferOffset = (jint) 0; 6323 jint _remaining; 6324 GLint *params = (GLint *) 0; 6325 6326 if (!params_buf) { 6327 _exception = 1; 6328 _exceptionType = "java/lang/IllegalArgumentException"; 6329 _exceptionMessage = "params == null"; 6330 goto exit; 6331 } 6332 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 6333 if (_remaining < 1) { 6334 _exception = 1; 6335 _exceptionType = "java/lang/IllegalArgumentException"; 6336 _exceptionMessage = "remaining() < 1 < needed"; 6337 goto exit; 6338 } 6339 if (params == NULL) { 6340 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 6341 params = (GLint *) (_paramsBase + _bufferOffset); 6342 } 6343 glGetTexParameteriv( 6344 (GLenum)target, 6345 (GLenum)pname, 6346 (GLint *)params 6347 ); 6348 6349 exit: 6350 if (_array) { 6351 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 6352 } 6353 if (_exception) { 6354 jniThrowException(_env, _exceptionType, _exceptionMessage); 6355 } 6356 } 6357 6358 /* void glGetTexParameterxv ( GLenum target, GLenum pname, GLfixed *params ) */ 6359 static void 6360 android_glGetTexParameterxv__II_3II 6361 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 6362 jint _exception = 0; 6363 const char * _exceptionType = NULL; 6364 const char * _exceptionMessage = NULL; 6365 GLfixed *params_base = (GLfixed *) 0; 6366 jint _remaining; 6367 GLfixed *params = (GLfixed *) 0; 6368 6369 if (!params_ref) { 6370 _exception = 1; 6371 _exceptionType = "java/lang/IllegalArgumentException"; 6372 _exceptionMessage = "params == null"; 6373 goto exit; 6374 } 6375 if (offset < 0) { 6376 _exception = 1; 6377 _exceptionType = "java/lang/IllegalArgumentException"; 6378 _exceptionMessage = "offset < 0"; 6379 goto exit; 6380 } 6381 _remaining = _env->GetArrayLength(params_ref) - offset; 6382 if (_remaining < 1) { 6383 _exception = 1; 6384 _exceptionType = "java/lang/IllegalArgumentException"; 6385 _exceptionMessage = "length - offset < 1 < needed"; 6386 goto exit; 6387 } 6388 params_base = (GLfixed *) 6389 _env->GetIntArrayElements(params_ref, (jboolean *)0); 6390 params = params_base + offset; 6391 6392 glGetTexParameterxv( 6393 (GLenum)target, 6394 (GLenum)pname, 6395 (GLfixed *)params 6396 ); 6397 6398 exit: 6399 if (params_base) { 6400 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 6401 _exception ? JNI_ABORT: 0); 6402 } 6403 if (_exception) { 6404 jniThrowException(_env, _exceptionType, _exceptionMessage); 6405 } 6406 } 6407 6408 /* void glGetTexParameterxv ( GLenum target, GLenum pname, GLfixed *params ) */ 6409 static void 6410 android_glGetTexParameterxv__IILjava_nio_IntBuffer_2 6411 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 6412 jint _exception = 0; 6413 const char * _exceptionType = NULL; 6414 const char * _exceptionMessage = NULL; 6415 jintArray _array = (jintArray) 0; 6416 jint _bufferOffset = (jint) 0; 6417 jint _remaining; 6418 GLfixed *params = (GLfixed *) 0; 6419 6420 if (!params_buf) { 6421 _exception = 1; 6422 _exceptionType = "java/lang/IllegalArgumentException"; 6423 _exceptionMessage = "params == null"; 6424 goto exit; 6425 } 6426 params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 6427 if (_remaining < 1) { 6428 _exception = 1; 6429 _exceptionType = "java/lang/IllegalArgumentException"; 6430 _exceptionMessage = "remaining() < 1 < needed"; 6431 goto exit; 6432 } 6433 if (params == NULL) { 6434 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 6435 params = (GLfixed *) (_paramsBase + _bufferOffset); 6436 } 6437 glGetTexParameterxv( 6438 (GLenum)target, 6439 (GLenum)pname, 6440 (GLfixed *)params 6441 ); 6442 6443 exit: 6444 if (_array) { 6445 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 6446 } 6447 if (_exception) { 6448 jniThrowException(_env, _exceptionType, _exceptionMessage); 6449 } 6450 } 6451 6452 /* GLboolean glIsBuffer ( GLuint buffer ) */ 6453 static jboolean 6454 android_glIsBuffer__I 6455 (JNIEnv *_env, jobject _this, jint buffer) { 6456 GLboolean _returnValue; 6457 _returnValue = glIsBuffer( 6458 (GLuint)buffer 6459 ); 6460 return (jboolean)_returnValue; 6461 } 6462 6463 /* GLboolean glIsEnabled ( GLenum cap ) */ 6464 static jboolean 6465 android_glIsEnabled__I 6466 (JNIEnv *_env, jobject _this, jint cap) { 6467 GLboolean _returnValue; 6468 _returnValue = glIsEnabled( 6469 (GLenum)cap 6470 ); 6471 return (jboolean)_returnValue; 6472 } 6473 6474 /* GLboolean glIsTexture ( GLuint texture ) */ 6475 static jboolean 6476 android_glIsTexture__I 6477 (JNIEnv *_env, jobject _this, jint texture) { 6478 GLboolean _returnValue; 6479 _returnValue = glIsTexture( 6480 (GLuint)texture 6481 ); 6482 return (jboolean)_returnValue; 6483 } 6484 6485 /* void glNormalPointer ( GLenum type, GLsizei stride, GLint offset ) */ 6486 static void 6487 android_glNormalPointer__III 6488 (JNIEnv *_env, jobject _this, jint type, jint stride, jint offset) { 6489 glNormalPointer( 6490 (GLenum)type, 6491 (GLsizei)stride, 6492 reinterpret_cast<GLvoid *>(offset) 6493 ); 6494 } 6495 6496 /* void glPointParameterf ( GLenum pname, GLfloat param ) */ 6497 static void 6498 android_glPointParameterf__IF 6499 (JNIEnv *_env, jobject _this, jint pname, jfloat param) { 6500 glPointParameterf( 6501 (GLenum)pname, 6502 (GLfloat)param 6503 ); 6504 } 6505 6506 /* void glPointParameterfv ( GLenum pname, const GLfloat *params ) */ 6507 static void 6508 android_glPointParameterfv__I_3FI 6509 (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) { 6510 jint _exception = 0; 6511 const char * _exceptionType = NULL; 6512 const char * _exceptionMessage = NULL; 6513 GLfloat *params_base = (GLfloat *) 0; 6514 jint _remaining; 6515 GLfloat *params = (GLfloat *) 0; 6516 6517 if (!params_ref) { 6518 _exception = 1; 6519 _exceptionType = "java/lang/IllegalArgumentException"; 6520 _exceptionMessage = "params == null"; 6521 goto exit; 6522 } 6523 if (offset < 0) { 6524 _exception = 1; 6525 _exceptionType = "java/lang/IllegalArgumentException"; 6526 _exceptionMessage = "offset < 0"; 6527 goto exit; 6528 } 6529 _remaining = _env->GetArrayLength(params_ref) - offset; 6530 if (_remaining < 1) { 6531 _exception = 1; 6532 _exceptionType = "java/lang/IllegalArgumentException"; 6533 _exceptionMessage = "length - offset < 1 < needed"; 6534 goto exit; 6535 } 6536 params_base = (GLfloat *) 6537 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 6538 params = params_base + offset; 6539 6540 glPointParameterfv( 6541 (GLenum)pname, 6542 (GLfloat *)params 6543 ); 6544 6545 exit: 6546 if (params_base) { 6547 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 6548 JNI_ABORT); 6549 } 6550 if (_exception) { 6551 jniThrowException(_env, _exceptionType, _exceptionMessage); 6552 } 6553 } 6554 6555 /* void glPointParameterfv ( GLenum pname, const GLfloat *params ) */ 6556 static void 6557 android_glPointParameterfv__ILjava_nio_FloatBuffer_2 6558 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 6559 jint _exception = 0; 6560 const char * _exceptionType = NULL; 6561 const char * _exceptionMessage = NULL; 6562 jfloatArray _array = (jfloatArray) 0; 6563 jint _bufferOffset = (jint) 0; 6564 jint _remaining; 6565 GLfloat *params = (GLfloat *) 0; 6566 6567 if (!params_buf) { 6568 _exception = 1; 6569 _exceptionType = "java/lang/IllegalArgumentException"; 6570 _exceptionMessage = "params == null"; 6571 goto exit; 6572 } 6573 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 6574 if (_remaining < 1) { 6575 _exception = 1; 6576 _exceptionType = "java/lang/IllegalArgumentException"; 6577 _exceptionMessage = "remaining() < 1 < needed"; 6578 goto exit; 6579 } 6580 if (params == NULL) { 6581 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 6582 params = (GLfloat *) (_paramsBase + _bufferOffset); 6583 } 6584 glPointParameterfv( 6585 (GLenum)pname, 6586 (GLfloat *)params 6587 ); 6588 6589 exit: 6590 if (_array) { 6591 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT); 6592 } 6593 if (_exception) { 6594 jniThrowException(_env, _exceptionType, _exceptionMessage); 6595 } 6596 } 6597 6598 /* void glPointParameterx ( GLenum pname, GLfixed param ) */ 6599 static void 6600 android_glPointParameterx__II 6601 (JNIEnv *_env, jobject _this, jint pname, jint param) { 6602 glPointParameterx( 6603 (GLenum)pname, 6604 (GLfixed)param 6605 ); 6606 } 6607 6608 /* void glPointParameterxv ( GLenum pname, const GLfixed *params ) */ 6609 static void 6610 android_glPointParameterxv__I_3II 6611 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) { 6612 jint _exception = 0; 6613 const char * _exceptionType = NULL; 6614 const char * _exceptionMessage = NULL; 6615 GLfixed *params_base = (GLfixed *) 0; 6616 jint _remaining; 6617 GLfixed *params = (GLfixed *) 0; 6618 6619 if (!params_ref) { 6620 _exception = 1; 6621 _exceptionType = "java/lang/IllegalArgumentException"; 6622 _exceptionMessage = "params == null"; 6623 goto exit; 6624 } 6625 if (offset < 0) { 6626 _exception = 1; 6627 _exceptionType = "java/lang/IllegalArgumentException"; 6628 _exceptionMessage = "offset < 0"; 6629 goto exit; 6630 } 6631 _remaining = _env->GetArrayLength(params_ref) - offset; 6632 if (_remaining < 1) { 6633 _exception = 1; 6634 _exceptionType = "java/lang/IllegalArgumentException"; 6635 _exceptionMessage = "length - offset < 1 < needed"; 6636 goto exit; 6637 } 6638 params_base = (GLfixed *) 6639 _env->GetIntArrayElements(params_ref, (jboolean *)0); 6640 params = params_base + offset; 6641 6642 glPointParameterxv( 6643 (GLenum)pname, 6644 (GLfixed *)params 6645 ); 6646 6647 exit: 6648 if (params_base) { 6649 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 6650 JNI_ABORT); 6651 } 6652 if (_exception) { 6653 jniThrowException(_env, _exceptionType, _exceptionMessage); 6654 } 6655 } 6656 6657 /* void glPointParameterxv ( GLenum pname, const GLfixed *params ) */ 6658 static void 6659 android_glPointParameterxv__ILjava_nio_IntBuffer_2 6660 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 6661 jint _exception = 0; 6662 const char * _exceptionType = NULL; 6663 const char * _exceptionMessage = NULL; 6664 jintArray _array = (jintArray) 0; 6665 jint _bufferOffset = (jint) 0; 6666 jint _remaining; 6667 GLfixed *params = (GLfixed *) 0; 6668 6669 if (!params_buf) { 6670 _exception = 1; 6671 _exceptionType = "java/lang/IllegalArgumentException"; 6672 _exceptionMessage = "params == null"; 6673 goto exit; 6674 } 6675 params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 6676 if (_remaining < 1) { 6677 _exception = 1; 6678 _exceptionType = "java/lang/IllegalArgumentException"; 6679 _exceptionMessage = "remaining() < 1 < needed"; 6680 goto exit; 6681 } 6682 if (params == NULL) { 6683 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 6684 params = (GLfixed *) (_paramsBase + _bufferOffset); 6685 } 6686 glPointParameterxv( 6687 (GLenum)pname, 6688 (GLfixed *)params 6689 ); 6690 6691 exit: 6692 if (_array) { 6693 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT); 6694 } 6695 if (_exception) { 6696 jniThrowException(_env, _exceptionType, _exceptionMessage); 6697 } 6698 } 6699 6700 /* void glPointSizePointerOES ( GLenum type, GLsizei stride, const GLvoid *pointer ) */ 6701 static void 6702 android_glPointSizePointerOESBounds__IILjava_nio_Buffer_2I 6703 (JNIEnv *_env, jobject _this, jint type, jint stride, jobject pointer_buf, jint remaining) { 6704 jint _exception = 0; 6705 const char * _exceptionType = NULL; 6706 const char * _exceptionMessage = NULL; 6707 jarray _array = (jarray) 0; 6708 jint _bufferOffset = (jint) 0; 6709 jint _remaining; 6710 GLvoid *pointer = (GLvoid *) 0; 6711 6712 if (pointer_buf) { 6713 pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf); 6714 if ( ! pointer ) { 6715 return; 6716 } 6717 } 6718 glPointSizePointerOESBounds( 6719 (GLenum)type, 6720 (GLsizei)stride, 6721 (GLvoid *)pointer, 6722 (GLsizei)remaining 6723 ); 6724 if (_exception) { 6725 jniThrowException(_env, _exceptionType, _exceptionMessage); 6726 } 6727 } 6728 6729 /* void glTexCoordPointer ( GLint size, GLenum type, GLsizei stride, GLint offset ) */ 6730 static void 6731 android_glTexCoordPointer__IIII 6732 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jint offset) { 6733 glTexCoordPointer( 6734 (GLint)size, 6735 (GLenum)type, 6736 (GLsizei)stride, 6737 reinterpret_cast<GLvoid *>(offset) 6738 ); 6739 } 6740 6741 /* void glTexEnvi ( GLenum target, GLenum pname, GLint param ) */ 6742 static void 6743 android_glTexEnvi__III 6744 (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) { 6745 glTexEnvi( 6746 (GLenum)target, 6747 (GLenum)pname, 6748 (GLint)param 6749 ); 6750 } 6751 6752 /* void glTexEnviv ( GLenum target, GLenum pname, const GLint *params ) */ 6753 static void 6754 android_glTexEnviv__II_3II 6755 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 6756 jint _exception = 0; 6757 const char * _exceptionType = NULL; 6758 const char * _exceptionMessage = NULL; 6759 GLint *params_base = (GLint *) 0; 6760 jint _remaining; 6761 GLint *params = (GLint *) 0; 6762 6763 if (!params_ref) { 6764 _exception = 1; 6765 _exceptionType = "java/lang/IllegalArgumentException"; 6766 _exceptionMessage = "params == null"; 6767 goto exit; 6768 } 6769 if (offset < 0) { 6770 _exception = 1; 6771 _exceptionType = "java/lang/IllegalArgumentException"; 6772 _exceptionMessage = "offset < 0"; 6773 goto exit; 6774 } 6775 _remaining = _env->GetArrayLength(params_ref) - offset; 6776 int _needed; 6777 switch (pname) { 6778 #if defined(GL_TEXTURE_ENV_MODE) 6779 case GL_TEXTURE_ENV_MODE: 6780 #endif // defined(GL_TEXTURE_ENV_MODE) 6781 #if defined(GL_COMBINE_RGB) 6782 case GL_COMBINE_RGB: 6783 #endif // defined(GL_COMBINE_RGB) 6784 #if defined(GL_COMBINE_ALPHA) 6785 case GL_COMBINE_ALPHA: 6786 #endif // defined(GL_COMBINE_ALPHA) 6787 _needed = 1; 6788 break; 6789 #if defined(GL_TEXTURE_ENV_COLOR) 6790 case GL_TEXTURE_ENV_COLOR: 6791 #endif // defined(GL_TEXTURE_ENV_COLOR) 6792 _needed = 4; 6793 break; 6794 default: 6795 _needed = 1; 6796 break; 6797 } 6798 if (_remaining < _needed) { 6799 _exception = 1; 6800 _exceptionType = "java/lang/IllegalArgumentException"; 6801 _exceptionMessage = "length - offset < needed"; 6802 goto exit; 6803 } 6804 params_base = (GLint *) 6805 _env->GetIntArrayElements(params_ref, (jboolean *)0); 6806 params = params_base + offset; 6807 6808 glTexEnviv( 6809 (GLenum)target, 6810 (GLenum)pname, 6811 (GLint *)params 6812 ); 6813 6814 exit: 6815 if (params_base) { 6816 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 6817 JNI_ABORT); 6818 } 6819 if (_exception) { 6820 jniThrowException(_env, _exceptionType, _exceptionMessage); 6821 } 6822 } 6823 6824 /* void glTexEnviv ( GLenum target, GLenum pname, const GLint *params ) */ 6825 static void 6826 android_glTexEnviv__IILjava_nio_IntBuffer_2 6827 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 6828 jint _exception = 0; 6829 const char * _exceptionType = NULL; 6830 const char * _exceptionMessage = NULL; 6831 jintArray _array = (jintArray) 0; 6832 jint _bufferOffset = (jint) 0; 6833 jint _remaining; 6834 GLint *params = (GLint *) 0; 6835 6836 if (!params_buf) { 6837 _exception = 1; 6838 _exceptionType = "java/lang/IllegalArgumentException"; 6839 _exceptionMessage = "params == null"; 6840 goto exit; 6841 } 6842 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 6843 int _needed; 6844 switch (pname) { 6845 #if defined(GL_TEXTURE_ENV_MODE) 6846 case GL_TEXTURE_ENV_MODE: 6847 #endif // defined(GL_TEXTURE_ENV_MODE) 6848 #if defined(GL_COMBINE_RGB) 6849 case GL_COMBINE_RGB: 6850 #endif // defined(GL_COMBINE_RGB) 6851 #if defined(GL_COMBINE_ALPHA) 6852 case GL_COMBINE_ALPHA: 6853 #endif // defined(GL_COMBINE_ALPHA) 6854 _needed = 1; 6855 break; 6856 #if defined(GL_TEXTURE_ENV_COLOR) 6857 case GL_TEXTURE_ENV_COLOR: 6858 #endif // defined(GL_TEXTURE_ENV_COLOR) 6859 _needed = 4; 6860 break; 6861 default: 6862 _needed = 1; 6863 break; 6864 } 6865 if (_remaining < _needed) { 6866 _exception = 1; 6867 _exceptionType = "java/lang/IllegalArgumentException"; 6868 _exceptionMessage = "remaining() < needed"; 6869 goto exit; 6870 } 6871 if (params == NULL) { 6872 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 6873 params = (GLint *) (_paramsBase + _bufferOffset); 6874 } 6875 glTexEnviv( 6876 (GLenum)target, 6877 (GLenum)pname, 6878 (GLint *)params 6879 ); 6880 6881 exit: 6882 if (_array) { 6883 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT); 6884 } 6885 if (_exception) { 6886 jniThrowException(_env, _exceptionType, _exceptionMessage); 6887 } 6888 } 6889 6890 /* void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params ) */ 6891 static void 6892 android_glTexParameterfv__II_3FI 6893 (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) { 6894 jint _exception = 0; 6895 const char * _exceptionType = NULL; 6896 const char * _exceptionMessage = NULL; 6897 GLfloat *params_base = (GLfloat *) 0; 6898 jint _remaining; 6899 GLfloat *params = (GLfloat *) 0; 6900 6901 if (!params_ref) { 6902 _exception = 1; 6903 _exceptionType = "java/lang/IllegalArgumentException"; 6904 _exceptionMessage = "params == null"; 6905 goto exit; 6906 } 6907 if (offset < 0) { 6908 _exception = 1; 6909 _exceptionType = "java/lang/IllegalArgumentException"; 6910 _exceptionMessage = "offset < 0"; 6911 goto exit; 6912 } 6913 _remaining = _env->GetArrayLength(params_ref) - offset; 6914 if (_remaining < 1) { 6915 _exception = 1; 6916 _exceptionType = "java/lang/IllegalArgumentException"; 6917 _exceptionMessage = "length - offset < 1 < needed"; 6918 goto exit; 6919 } 6920 params_base = (GLfloat *) 6921 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 6922 params = params_base + offset; 6923 6924 glTexParameterfv( 6925 (GLenum)target, 6926 (GLenum)pname, 6927 (GLfloat *)params 6928 ); 6929 6930 exit: 6931 if (params_base) { 6932 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 6933 JNI_ABORT); 6934 } 6935 if (_exception) { 6936 jniThrowException(_env, _exceptionType, _exceptionMessage); 6937 } 6938 } 6939 6940 /* void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params ) */ 6941 static void 6942 android_glTexParameterfv__IILjava_nio_FloatBuffer_2 6943 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 6944 jint _exception = 0; 6945 const char * _exceptionType = NULL; 6946 const char * _exceptionMessage = NULL; 6947 jfloatArray _array = (jfloatArray) 0; 6948 jint _bufferOffset = (jint) 0; 6949 jint _remaining; 6950 GLfloat *params = (GLfloat *) 0; 6951 6952 if (!params_buf) { 6953 _exception = 1; 6954 _exceptionType = "java/lang/IllegalArgumentException"; 6955 _exceptionMessage = "params == null"; 6956 goto exit; 6957 } 6958 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 6959 if (_remaining < 1) { 6960 _exception = 1; 6961 _exceptionType = "java/lang/IllegalArgumentException"; 6962 _exceptionMessage = "remaining() < 1 < needed"; 6963 goto exit; 6964 } 6965 if (params == NULL) { 6966 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 6967 params = (GLfloat *) (_paramsBase + _bufferOffset); 6968 } 6969 glTexParameterfv( 6970 (GLenum)target, 6971 (GLenum)pname, 6972 (GLfloat *)params 6973 ); 6974 6975 exit: 6976 if (_array) { 6977 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT); 6978 } 6979 if (_exception) { 6980 jniThrowException(_env, _exceptionType, _exceptionMessage); 6981 } 6982 } 6983 6984 /* void glTexParameteri ( GLenum target, GLenum pname, GLint param ) */ 6985 static void 6986 android_glTexParameteri__III 6987 (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) { 6988 glTexParameteri( 6989 (GLenum)target, 6990 (GLenum)pname, 6991 (GLint)param 6992 ); 6993 } 6994 6995 /* void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params ) */ 6996 static void 6997 android_glTexParameteriv__II_3II 6998 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 6999 jint _exception = 0; 7000 const char * _exceptionType = NULL; 7001 const char * _exceptionMessage = NULL; 7002 GLint *params_base = (GLint *) 0; 7003 jint _remaining; 7004 GLint *params = (GLint *) 0; 7005 7006 if (!params_ref) { 7007 _exception = 1; 7008 _exceptionType = "java/lang/IllegalArgumentException"; 7009 _exceptionMessage = "params == null"; 7010 goto exit; 7011 } 7012 if (offset < 0) { 7013 _exception = 1; 7014 _exceptionType = "java/lang/IllegalArgumentException"; 7015 _exceptionMessage = "offset < 0"; 7016 goto exit; 7017 } 7018 _remaining = _env->GetArrayLength(params_ref) - offset; 7019 if (_remaining < 1) { 7020 _exception = 1; 7021 _exceptionType = "java/lang/IllegalArgumentException"; 7022 _exceptionMessage = "length - offset < 1 < needed"; 7023 goto exit; 7024 } 7025 params_base = (GLint *) 7026 _env->GetIntArrayElements(params_ref, (jboolean *)0); 7027 params = params_base + offset; 7028 7029 glTexParameteriv( 7030 (GLenum)target, 7031 (GLenum)pname, 7032 (GLint *)params 7033 ); 7034 7035 exit: 7036 if (params_base) { 7037 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 7038 JNI_ABORT); 7039 } 7040 if (_exception) { 7041 jniThrowException(_env, _exceptionType, _exceptionMessage); 7042 } 7043 } 7044 7045 /* void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params ) */ 7046 static void 7047 android_glTexParameteriv__IILjava_nio_IntBuffer_2 7048 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 7049 jint _exception = 0; 7050 const char * _exceptionType = NULL; 7051 const char * _exceptionMessage = NULL; 7052 jintArray _array = (jintArray) 0; 7053 jint _bufferOffset = (jint) 0; 7054 jint _remaining; 7055 GLint *params = (GLint *) 0; 7056 7057 if (!params_buf) { 7058 _exception = 1; 7059 _exceptionType = "java/lang/IllegalArgumentException"; 7060 _exceptionMessage = "params == null"; 7061 goto exit; 7062 } 7063 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 7064 if (_remaining < 1) { 7065 _exception = 1; 7066 _exceptionType = "java/lang/IllegalArgumentException"; 7067 _exceptionMessage = "remaining() < 1 < needed"; 7068 goto exit; 7069 } 7070 if (params == NULL) { 7071 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 7072 params = (GLint *) (_paramsBase + _bufferOffset); 7073 } 7074 glTexParameteriv( 7075 (GLenum)target, 7076 (GLenum)pname, 7077 (GLint *)params 7078 ); 7079 7080 exit: 7081 if (_array) { 7082 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT); 7083 } 7084 if (_exception) { 7085 jniThrowException(_env, _exceptionType, _exceptionMessage); 7086 } 7087 } 7088 7089 /* void glTexParameterxv ( GLenum target, GLenum pname, const GLfixed *params ) */ 7090 static void 7091 android_glTexParameterxv__II_3II 7092 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 7093 jint _exception = 0; 7094 const char * _exceptionType = NULL; 7095 const char * _exceptionMessage = NULL; 7096 GLfixed *params_base = (GLfixed *) 0; 7097 jint _remaining; 7098 GLfixed *params = (GLfixed *) 0; 7099 7100 if (!params_ref) { 7101 _exception = 1; 7102 _exceptionType = "java/lang/IllegalArgumentException"; 7103 _exceptionMessage = "params == null"; 7104 goto exit; 7105 } 7106 if (offset < 0) { 7107 _exception = 1; 7108 _exceptionType = "java/lang/IllegalArgumentException"; 7109 _exceptionMessage = "offset < 0"; 7110 goto exit; 7111 } 7112 _remaining = _env->GetArrayLength(params_ref) - offset; 7113 if (_remaining < 1) { 7114 _exception = 1; 7115 _exceptionType = "java/lang/IllegalArgumentException"; 7116 _exceptionMessage = "length - offset < 1 < needed"; 7117 goto exit; 7118 } 7119 params_base = (GLfixed *) 7120 _env->GetIntArrayElements(params_ref, (jboolean *)0); 7121 params = params_base + offset; 7122 7123 glTexParameterxv( 7124 (GLenum)target, 7125 (GLenum)pname, 7126 (GLfixed *)params 7127 ); 7128 7129 exit: 7130 if (params_base) { 7131 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 7132 JNI_ABORT); 7133 } 7134 if (_exception) { 7135 jniThrowException(_env, _exceptionType, _exceptionMessage); 7136 } 7137 } 7138 7139 /* void glTexParameterxv ( GLenum target, GLenum pname, const GLfixed *params ) */ 7140 static void 7141 android_glTexParameterxv__IILjava_nio_IntBuffer_2 7142 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 7143 jint _exception = 0; 7144 const char * _exceptionType = NULL; 7145 const char * _exceptionMessage = NULL; 7146 jintArray _array = (jintArray) 0; 7147 jint _bufferOffset = (jint) 0; 7148 jint _remaining; 7149 GLfixed *params = (GLfixed *) 0; 7150 7151 if (!params_buf) { 7152 _exception = 1; 7153 _exceptionType = "java/lang/IllegalArgumentException"; 7154 _exceptionMessage = "params == null"; 7155 goto exit; 7156 } 7157 params = (GLfixed *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 7158 if (_remaining < 1) { 7159 _exception = 1; 7160 _exceptionType = "java/lang/IllegalArgumentException"; 7161 _exceptionMessage = "remaining() < 1 < needed"; 7162 goto exit; 7163 } 7164 if (params == NULL) { 7165 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 7166 params = (GLfixed *) (_paramsBase + _bufferOffset); 7167 } 7168 glTexParameterxv( 7169 (GLenum)target, 7170 (GLenum)pname, 7171 (GLfixed *)params 7172 ); 7173 7174 exit: 7175 if (_array) { 7176 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT); 7177 } 7178 if (_exception) { 7179 jniThrowException(_env, _exceptionType, _exceptionMessage); 7180 } 7181 } 7182 7183 /* void glVertexPointer ( GLint size, GLenum type, GLsizei stride, GLint offset ) */ 7184 static void 7185 android_glVertexPointer__IIII 7186 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jint offset) { 7187 glVertexPointer( 7188 (GLint)size, 7189 (GLenum)type, 7190 (GLsizei)stride, 7191 reinterpret_cast<GLvoid *>(offset) 7192 ); 7193 } 7194 7195 /* void glCurrentPaletteMatrixOES ( GLuint matrixpaletteindex ) */ 7196 static void 7197 android_glCurrentPaletteMatrixOES__I 7198 (JNIEnv *_env, jobject _this, jint matrixpaletteindex) { 7199 glCurrentPaletteMatrixOES( 7200 (GLuint)matrixpaletteindex 7201 ); 7202 } 7203 7204 /* void glDrawTexfOES ( GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height ) */ 7205 static void 7206 android_glDrawTexfOES__FFFFF 7207 (JNIEnv *_env, jobject _this, jfloat x, jfloat y, jfloat z, jfloat width, jfloat height) { 7208 glDrawTexfOES( 7209 (GLfloat)x, 7210 (GLfloat)y, 7211 (GLfloat)z, 7212 (GLfloat)width, 7213 (GLfloat)height 7214 ); 7215 } 7216 7217 /* void glDrawTexfvOES ( const GLfloat *coords ) */ 7218 static void 7219 android_glDrawTexfvOES___3FI 7220 (JNIEnv *_env, jobject _this, jfloatArray coords_ref, jint offset) { 7221 jint _exception = 0; 7222 const char * _exceptionType = NULL; 7223 const char * _exceptionMessage = NULL; 7224 GLfloat *coords_base = (GLfloat *) 0; 7225 jint _remaining; 7226 GLfloat *coords = (GLfloat *) 0; 7227 7228 if (!coords_ref) { 7229 _exception = 1; 7230 _exceptionType = "java/lang/IllegalArgumentException"; 7231 _exceptionMessage = "coords == null"; 7232 goto exit; 7233 } 7234 if (offset < 0) { 7235 _exception = 1; 7236 _exceptionType = "java/lang/IllegalArgumentException"; 7237 _exceptionMessage = "offset < 0"; 7238 goto exit; 7239 } 7240 _remaining = _env->GetArrayLength(coords_ref) - offset; 7241 if (_remaining < 5) { 7242 _exception = 1; 7243 _exceptionType = "java/lang/IllegalArgumentException"; 7244 _exceptionMessage = "length - offset < 5 < needed"; 7245 goto exit; 7246 } 7247 coords_base = (GLfloat *) 7248 _env->GetFloatArrayElements(coords_ref, (jboolean *)0); 7249 coords = coords_base + offset; 7250 7251 glDrawTexfvOES( 7252 (GLfloat *)coords 7253 ); 7254 7255 exit: 7256 if (coords_base) { 7257 _env->ReleaseFloatArrayElements(coords_ref, (jfloat*)coords_base, 7258 JNI_ABORT); 7259 } 7260 if (_exception) { 7261 jniThrowException(_env, _exceptionType, _exceptionMessage); 7262 } 7263 } 7264 7265 /* void glDrawTexfvOES ( const GLfloat *coords ) */ 7266 static void 7267 android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2 7268 (JNIEnv *_env, jobject _this, jobject coords_buf) { 7269 jint _exception = 0; 7270 const char * _exceptionType = NULL; 7271 const char * _exceptionMessage = NULL; 7272 jfloatArray _array = (jfloatArray) 0; 7273 jint _bufferOffset = (jint) 0; 7274 jint _remaining; 7275 GLfloat *coords = (GLfloat *) 0; 7276 7277 if (!coords_buf) { 7278 _exception = 1; 7279 _exceptionType = "java/lang/IllegalArgumentException"; 7280 _exceptionMessage = "coords == null"; 7281 goto exit; 7282 } 7283 coords = (GLfloat *)getPointer(_env, coords_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 7284 if (_remaining < 5) { 7285 _exception = 1; 7286 _exceptionType = "java/lang/IllegalArgumentException"; 7287 _exceptionMessage = "remaining() < 5 < needed"; 7288 goto exit; 7289 } 7290 if (coords == NULL) { 7291 char * _coordsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 7292 coords = (GLfloat *) (_coordsBase + _bufferOffset); 7293 } 7294 glDrawTexfvOES( 7295 (GLfloat *)coords 7296 ); 7297 7298 exit: 7299 if (_array) { 7300 _env->ReleaseFloatArrayElements(_array, (jfloat*)coords, JNI_ABORT); 7301 } 7302 if (_exception) { 7303 jniThrowException(_env, _exceptionType, _exceptionMessage); 7304 } 7305 } 7306 7307 /* void glDrawTexiOES ( GLint x, GLint y, GLint z, GLint width, GLint height ) */ 7308 static void 7309 android_glDrawTexiOES__IIIII 7310 (JNIEnv *_env, jobject _this, jint x, jint y, jint z, jint width, jint height) { 7311 glDrawTexiOES( 7312 (GLint)x, 7313 (GLint)y, 7314 (GLint)z, 7315 (GLint)width, 7316 (GLint)height 7317 ); 7318 } 7319 7320 /* void glDrawTexivOES ( const GLint *coords ) */ 7321 static void 7322 android_glDrawTexivOES___3II 7323 (JNIEnv *_env, jobject _this, jintArray coords_ref, jint offset) { 7324 jint _exception = 0; 7325 const char * _exceptionType = NULL; 7326 const char * _exceptionMessage = NULL; 7327 GLint *coords_base = (GLint *) 0; 7328 jint _remaining; 7329 GLint *coords = (GLint *) 0; 7330 7331 if (!coords_ref) { 7332 _exception = 1; 7333 _exceptionType = "java/lang/IllegalArgumentException"; 7334 _exceptionMessage = "coords == null"; 7335 goto exit; 7336 } 7337 if (offset < 0) { 7338 _exception = 1; 7339 _exceptionType = "java/lang/IllegalArgumentException"; 7340 _exceptionMessage = "offset < 0"; 7341 goto exit; 7342 } 7343 _remaining = _env->GetArrayLength(coords_ref) - offset; 7344 if (_remaining < 5) { 7345 _exception = 1; 7346 _exceptionType = "java/lang/IllegalArgumentException"; 7347 _exceptionMessage = "length - offset < 5 < needed"; 7348 goto exit; 7349 } 7350 coords_base = (GLint *) 7351 _env->GetIntArrayElements(coords_ref, (jboolean *)0); 7352 coords = coords_base + offset; 7353 7354 glDrawTexivOES( 7355 (GLint *)coords 7356 ); 7357 7358 exit: 7359 if (coords_base) { 7360 _env->ReleaseIntArrayElements(coords_ref, (jint*)coords_base, 7361 JNI_ABORT); 7362 } 7363 if (_exception) { 7364 jniThrowException(_env, _exceptionType, _exceptionMessage); 7365 } 7366 } 7367 7368 /* void glDrawTexivOES ( const GLint *coords ) */ 7369 static void 7370 android_glDrawTexivOES__Ljava_nio_IntBuffer_2 7371 (JNIEnv *_env, jobject _this, jobject coords_buf) { 7372 jint _exception = 0; 7373 const char * _exceptionType = NULL; 7374 const char * _exceptionMessage = NULL; 7375 jintArray _array = (jintArray) 0; 7376 jint _bufferOffset = (jint) 0; 7377 jint _remaining; 7378 GLint *coords = (GLint *) 0; 7379 7380 if (!coords_buf) { 7381 _exception = 1; 7382 _exceptionType = "java/lang/IllegalArgumentException"; 7383 _exceptionMessage = "coords == null"; 7384 goto exit; 7385 } 7386 coords = (GLint *)getPointer(_env, coords_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 7387 if (_remaining < 5) { 7388 _exception = 1; 7389 _exceptionType = "java/lang/IllegalArgumentException"; 7390 _exceptionMessage = "remaining() < 5 < needed"; 7391 goto exit; 7392 } 7393 if (coords == NULL) { 7394 char * _coordsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 7395 coords = (GLint *) (_coordsBase + _bufferOffset); 7396 } 7397 glDrawTexivOES( 7398 (GLint *)coords 7399 ); 7400 7401 exit: 7402 if (_array) { 7403 _env->ReleaseIntArrayElements(_array, (jint*)coords, JNI_ABORT); 7404 } 7405 if (_exception) { 7406 jniThrowException(_env, _exceptionType, _exceptionMessage); 7407 } 7408 } 7409 7410 /* void glDrawTexsOES ( GLshort x, GLshort y, GLshort z, GLshort width, GLshort height ) */ 7411 static void 7412 android_glDrawTexsOES__SSSSS 7413 (JNIEnv *_env, jobject _this, jshort x, jshort y, jshort z, jshort width, jshort height) { 7414 glDrawTexsOES( 7415 (GLshort)x, 7416 (GLshort)y, 7417 (GLshort)z, 7418 (GLshort)width, 7419 (GLshort)height 7420 ); 7421 } 7422 7423 /* void glDrawTexsvOES ( const GLshort *coords ) */ 7424 static void 7425 android_glDrawTexsvOES___3SI 7426 (JNIEnv *_env, jobject _this, jshortArray coords_ref, jint offset) { 7427 jint _exception = 0; 7428 const char * _exceptionType = NULL; 7429 const char * _exceptionMessage = NULL; 7430 GLshort *coords_base = (GLshort *) 0; 7431 jint _remaining; 7432 GLshort *coords = (GLshort *) 0; 7433 7434 if (!coords_ref) { 7435 _exception = 1; 7436 _exceptionType = "java/lang/IllegalArgumentException"; 7437 _exceptionMessage = "coords == null"; 7438 goto exit; 7439 } 7440 if (offset < 0) { 7441 _exception = 1; 7442 _exceptionType = "java/lang/IllegalArgumentException"; 7443 _exceptionMessage = "offset < 0"; 7444 goto exit; 7445 } 7446 _remaining = _env->GetArrayLength(coords_ref) - offset; 7447 if (_remaining < 5) { 7448 _exception = 1; 7449 _exceptionType = "java/lang/IllegalArgumentException"; 7450 _exceptionMessage = "length - offset < 5 < needed"; 7451 goto exit; 7452 } 7453 coords_base = (GLshort *) 7454 _env->GetShortArrayElements(coords_ref, (jboolean *)0); 7455 coords = coords_base + offset; 7456 7457 glDrawTexsvOES( 7458 (GLshort *)coords 7459 ); 7460 7461 exit: 7462 if (coords_base) { 7463 _env->ReleaseShortArrayElements(coords_ref, (jshort*)coords_base, 7464 JNI_ABORT); 7465 } 7466 if (_exception) { 7467 jniThrowException(_env, _exceptionType, _exceptionMessage); 7468 } 7469 } 7470 7471 /* void glDrawTexsvOES ( const GLshort *coords ) */ 7472 static void 7473 android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2 7474 (JNIEnv *_env, jobject _this, jobject coords_buf) { 7475 jint _exception = 0; 7476 const char * _exceptionType = NULL; 7477 const char * _exceptionMessage = NULL; 7478 jshortArray _array = (jshortArray) 0; 7479 jint _bufferOffset = (jint) 0; 7480 jint _remaining; 7481 GLshort *coords = (GLshort *) 0; 7482 7483 if (!coords_buf) { 7484 _exception = 1; 7485 _exceptionType = "java/lang/IllegalArgumentException"; 7486 _exceptionMessage = "coords == null"; 7487 goto exit; 7488 } 7489 coords = (GLshort *)getPointer(_env, coords_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 7490 if (_remaining < 5) { 7491 _exception = 1; 7492 _exceptionType = "java/lang/IllegalArgumentException"; 7493 _exceptionMessage = "remaining() < 5 < needed"; 7494 goto exit; 7495 } 7496 if (coords == NULL) { 7497 char * _coordsBase = (char *)_env->GetShortArrayElements(_array, (jboolean *) 0); 7498 coords = (GLshort *) (_coordsBase + _bufferOffset); 7499 } 7500 glDrawTexsvOES( 7501 (GLshort *)coords 7502 ); 7503 7504 exit: 7505 if (_array) { 7506 _env->ReleaseShortArrayElements(_array, (jshort*)coords, JNI_ABORT); 7507 } 7508 if (_exception) { 7509 jniThrowException(_env, _exceptionType, _exceptionMessage); 7510 } 7511 } 7512 7513 /* void glDrawTexxOES ( GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height ) */ 7514 static void 7515 android_glDrawTexxOES__IIIII 7516 (JNIEnv *_env, jobject _this, jint x, jint y, jint z, jint width, jint height) { 7517 glDrawTexxOES( 7518 (GLfixed)x, 7519 (GLfixed)y, 7520 (GLfixed)z, 7521 (GLfixed)width, 7522 (GLfixed)height 7523 ); 7524 } 7525 7526 /* void glDrawTexxvOES ( const GLfixed *coords ) */ 7527 static void 7528 android_glDrawTexxvOES___3II 7529 (JNIEnv *_env, jobject _this, jintArray coords_ref, jint offset) { 7530 jint _exception = 0; 7531 const char * _exceptionType = NULL; 7532 const char * _exceptionMessage = NULL; 7533 GLfixed *coords_base = (GLfixed *) 0; 7534 jint _remaining; 7535 GLfixed *coords = (GLfixed *) 0; 7536 7537 if (!coords_ref) { 7538 _exception = 1; 7539 _exceptionType = "java/lang/IllegalArgumentException"; 7540 _exceptionMessage = "coords == null"; 7541 goto exit; 7542 } 7543 if (offset < 0) { 7544 _exception = 1; 7545 _exceptionType = "java/lang/IllegalArgumentException"; 7546 _exceptionMessage = "offset < 0"; 7547 goto exit; 7548 } 7549 _remaining = _env->GetArrayLength(coords_ref) - offset; 7550 if (_remaining < 5) { 7551 _exception = 1; 7552 _exceptionType = "java/lang/IllegalArgumentException"; 7553 _exceptionMessage = "length - offset < 5 < needed"; 7554 goto exit; 7555 } 7556 coords_base = (GLfixed *) 7557 _env->GetIntArrayElements(coords_ref, (jboolean *)0); 7558 coords = coords_base + offset; 7559 7560 glDrawTexxvOES( 7561 (GLfixed *)coords 7562 ); 7563 7564 exit: 7565 if (coords_base) { 7566 _env->ReleaseIntArrayElements(coords_ref, (jint*)coords_base, 7567 JNI_ABORT); 7568 } 7569 if (_exception) { 7570 jniThrowException(_env, _exceptionType, _exceptionMessage); 7571 } 7572 } 7573 7574 /* void glDrawTexxvOES ( const GLfixed *coords ) */ 7575 static void 7576 android_glDrawTexxvOES__Ljava_nio_IntBuffer_2 7577 (JNIEnv *_env, jobject _this, jobject coords_buf) { 7578 jint _exception = 0; 7579 const char * _exceptionType = NULL; 7580 const char * _exceptionMessage = NULL; 7581 jintArray _array = (jintArray) 0; 7582 jint _bufferOffset = (jint) 0; 7583 jint _remaining; 7584 GLfixed *coords = (GLfixed *) 0; 7585 7586 if (!coords_buf) { 7587 _exception = 1; 7588 _exceptionType = "java/lang/IllegalArgumentException"; 7589 _exceptionMessage = "coords == null"; 7590 goto exit; 7591 } 7592 coords = (GLfixed *)getPointer(_env, coords_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 7593 if (_remaining < 5) { 7594 _exception = 1; 7595 _exceptionType = "java/lang/IllegalArgumentException"; 7596 _exceptionMessage = "remaining() < 5 < needed"; 7597 goto exit; 7598 } 7599 if (coords == NULL) { 7600 char * _coordsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 7601 coords = (GLfixed *) (_coordsBase + _bufferOffset); 7602 } 7603 glDrawTexxvOES( 7604 (GLfixed *)coords 7605 ); 7606 7607 exit: 7608 if (_array) { 7609 _env->ReleaseIntArrayElements(_array, (jint*)coords, JNI_ABORT); 7610 } 7611 if (_exception) { 7612 jniThrowException(_env, _exceptionType, _exceptionMessage); 7613 } 7614 } 7615 7616 /* void glLoadPaletteFromModelViewMatrixOES ( void ) */ 7617 static void 7618 android_glLoadPaletteFromModelViewMatrixOES__ 7619 (JNIEnv *_env, jobject _this) { 7620 glLoadPaletteFromModelViewMatrixOES(); 7621 } 7622 7623 /* void glMatrixIndexPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */ 7624 static void 7625 android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I 7626 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) { 7627 jint _exception = 0; 7628 const char * _exceptionType = NULL; 7629 const char * _exceptionMessage = NULL; 7630 jarray _array = (jarray) 0; 7631 jint _bufferOffset = (jint) 0; 7632 jint _remaining; 7633 GLvoid *pointer = (GLvoid *) 0; 7634 7635 if (pointer_buf) { 7636 pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf); 7637 if ( ! pointer ) { 7638 return; 7639 } 7640 } 7641 glMatrixIndexPointerOESBounds( 7642 (GLint)size, 7643 (GLenum)type, 7644 (GLsizei)stride, 7645 (GLvoid *)pointer, 7646 (GLsizei)remaining 7647 ); 7648 if (_exception) { 7649 jniThrowException(_env, _exceptionType, _exceptionMessage); 7650 } 7651 } 7652 7653 /* void glMatrixIndexPointerOES ( GLint size, GLenum type, GLsizei stride, GLint offset ) */ 7654 static void 7655 android_glMatrixIndexPointerOES__IIII 7656 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jint offset) { 7657 glMatrixIndexPointerOES( 7658 (GLint)size, 7659 (GLenum)type, 7660 (GLsizei)stride, 7661 reinterpret_cast<GLvoid *>(offset) 7662 ); 7663 } 7664 7665 /* void glWeightPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */ 7666 static void 7667 android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I 7668 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) { 7669 jint _exception = 0; 7670 const char * _exceptionType = NULL; 7671 const char * _exceptionMessage = NULL; 7672 jarray _array = (jarray) 0; 7673 jint _bufferOffset = (jint) 0; 7674 jint _remaining; 7675 GLvoid *pointer = (GLvoid *) 0; 7676 7677 if (pointer_buf) { 7678 pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf); 7679 if ( ! pointer ) { 7680 return; 7681 } 7682 } 7683 glWeightPointerOESBounds( 7684 (GLint)size, 7685 (GLenum)type, 7686 (GLsizei)stride, 7687 (GLvoid *)pointer, 7688 (GLsizei)remaining 7689 ); 7690 if (_exception) { 7691 jniThrowException(_env, _exceptionType, _exceptionMessage); 7692 } 7693 } 7694 7695 /* void glWeightPointerOES ( GLint size, GLenum type, GLsizei stride, GLint offset ) */ 7696 static void 7697 android_glWeightPointerOES__IIII 7698 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jint offset) { 7699 glWeightPointerOES( 7700 (GLint)size, 7701 (GLenum)type, 7702 (GLsizei)stride, 7703 reinterpret_cast<GLvoid *>(offset) 7704 ); 7705 } 7706 7707 /* void glBindFramebufferOES ( GLint target, GLint framebuffer ) */ 7708 static void 7709 android_glBindFramebufferOES__II 7710 (JNIEnv *_env, jobject _this, jint target, jint framebuffer) { 7711 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 7712 jniThrowException(_env, "java/lang/UnsupportedOperationException", 7713 "glBindFramebufferOES"); 7714 return; 7715 } 7716 glBindFramebufferOES( 7717 (GLint)target, 7718 (GLint)framebuffer 7719 ); 7720 } 7721 7722 /* void glBindRenderbufferOES ( GLint target, GLint renderbuffer ) */ 7723 static void 7724 android_glBindRenderbufferOES__II 7725 (JNIEnv *_env, jobject _this, jint target, jint renderbuffer) { 7726 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 7727 jniThrowException(_env, "java/lang/UnsupportedOperationException", 7728 "glBindRenderbufferOES"); 7729 return; 7730 } 7731 glBindRenderbufferOES( 7732 (GLint)target, 7733 (GLint)renderbuffer 7734 ); 7735 } 7736 7737 /* void glBlendEquation ( GLint mode ) */ 7738 static void 7739 android_glBlendEquation__I 7740 (JNIEnv *_env, jobject _this, jint mode) { 7741 if (! supportsExtension(_env, _this, have_OES_blend_subtractID)) { 7742 jniThrowException(_env, "java/lang/UnsupportedOperationException", 7743 "glBlendEquation"); 7744 return; 7745 } 7746 glBlendEquation( 7747 (GLint)mode 7748 ); 7749 } 7750 7751 /* void glBlendEquationSeparate ( GLint modeRGB, GLint modeAlpha ) */ 7752 static void 7753 android_glBlendEquationSeparate__II 7754 (JNIEnv *_env, jobject _this, jint modeRGB, jint modeAlpha) { 7755 if (! supportsExtension(_env, _this, have_OES_blend_equation_separateID)) { 7756 jniThrowException(_env, "java/lang/UnsupportedOperationException", 7757 "glBlendEquationSeparate"); 7758 return; 7759 } 7760 glBlendEquationSeparate( 7761 (GLint)modeRGB, 7762 (GLint)modeAlpha 7763 ); 7764 } 7765 7766 /* void glBlendFuncSeparate ( GLint srcRGB, GLint dstRGB, GLint srcAlpha, GLint dstAlpha ) */ 7767 static void 7768 android_glBlendFuncSeparate__IIII 7769 (JNIEnv *_env, jobject _this, jint srcRGB, jint dstRGB, jint srcAlpha, jint dstAlpha) { 7770 if (! supportsExtension(_env, _this, have_OES_blend_equation_separateID)) { 7771 jniThrowException(_env, "java/lang/UnsupportedOperationException", 7772 "glBlendFuncSeparate"); 7773 return; 7774 } 7775 glBlendFuncSeparate( 7776 (GLint)srcRGB, 7777 (GLint)dstRGB, 7778 (GLint)srcAlpha, 7779 (GLint)dstAlpha 7780 ); 7781 } 7782 7783 /* GLint glCheckFramebufferStatusOES ( GLint target ) */ 7784 static jint 7785 android_glCheckFramebufferStatusOES__I 7786 (JNIEnv *_env, jobject _this, jint target) { 7787 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 7788 jniThrowException(_env, "java/lang/UnsupportedOperationException", 7789 "glCheckFramebufferStatusOES"); 7790 return 0; 7791 } 7792 GLint _returnValue = 0; 7793 _returnValue = glCheckFramebufferStatusOES( 7794 (GLint)target 7795 ); 7796 return (jint)_returnValue; 7797 } 7798 7799 /* void glDeleteFramebuffersOES ( GLint n, GLuint *framebuffers ) */ 7800 static void 7801 android_glDeleteFramebuffersOES__I_3II 7802 (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) { 7803 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 7804 jniThrowException(_env, "java/lang/UnsupportedOperationException", 7805 "glDeleteFramebuffersOES"); 7806 return; 7807 } 7808 jint _exception = 0; 7809 const char * _exceptionType = NULL; 7810 const char * _exceptionMessage = NULL; 7811 GLuint *framebuffers_base = (GLuint *) 0; 7812 jint _remaining; 7813 GLuint *framebuffers = (GLuint *) 0; 7814 7815 if (!framebuffers_ref) { 7816 _exception = 1; 7817 _exceptionType = "java/lang/IllegalArgumentException"; 7818 _exceptionMessage = "framebuffers == null"; 7819 goto exit; 7820 } 7821 if (offset < 0) { 7822 _exception = 1; 7823 _exceptionType = "java/lang/IllegalArgumentException"; 7824 _exceptionMessage = "offset < 0"; 7825 goto exit; 7826 } 7827 _remaining = _env->GetArrayLength(framebuffers_ref) - offset; 7828 if (_remaining < n) { 7829 _exception = 1; 7830 _exceptionType = "java/lang/IllegalArgumentException"; 7831 _exceptionMessage = "length - offset < n < needed"; 7832 goto exit; 7833 } 7834 framebuffers_base = (GLuint *) 7835 _env->GetIntArrayElements(framebuffers_ref, (jboolean *)0); 7836 framebuffers = framebuffers_base + offset; 7837 7838 glDeleteFramebuffersOES( 7839 (GLint)n, 7840 (GLuint *)framebuffers 7841 ); 7842 7843 exit: 7844 if (framebuffers_base) { 7845 _env->ReleaseIntArrayElements(framebuffers_ref, (jint*)framebuffers_base, 7846 _exception ? JNI_ABORT: 0); 7847 } 7848 if (_exception) { 7849 jniThrowException(_env, _exceptionType, _exceptionMessage); 7850 } 7851 } 7852 7853 /* void glDeleteFramebuffersOES ( GLint n, GLuint *framebuffers ) */ 7854 static void 7855 android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2 7856 (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) { 7857 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 7858 jniThrowException(_env, "java/lang/UnsupportedOperationException", 7859 "glDeleteFramebuffersOES"); 7860 return; 7861 } 7862 jint _exception = 0; 7863 const char * _exceptionType = NULL; 7864 const char * _exceptionMessage = NULL; 7865 jintArray _array = (jintArray) 0; 7866 jint _bufferOffset = (jint) 0; 7867 jint _remaining; 7868 GLuint *framebuffers = (GLuint *) 0; 7869 7870 if (!framebuffers_buf) { 7871 _exception = 1; 7872 _exceptionType = "java/lang/IllegalArgumentException"; 7873 _exceptionMessage = "framebuffers == null"; 7874 goto exit; 7875 } 7876 framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 7877 if (_remaining < n) { 7878 _exception = 1; 7879 _exceptionType = "java/lang/IllegalArgumentException"; 7880 _exceptionMessage = "remaining() < n < needed"; 7881 goto exit; 7882 } 7883 if (framebuffers == NULL) { 7884 char * _framebuffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 7885 framebuffers = (GLuint *) (_framebuffersBase + _bufferOffset); 7886 } 7887 glDeleteFramebuffersOES( 7888 (GLint)n, 7889 (GLuint *)framebuffers 7890 ); 7891 7892 exit: 7893 if (_array) { 7894 _env->ReleaseIntArrayElements(_array, (jint*)framebuffers, _exception ? JNI_ABORT : 0); 7895 } 7896 if (_exception) { 7897 jniThrowException(_env, _exceptionType, _exceptionMessage); 7898 } 7899 } 7900 7901 /* void glDeleteRenderbuffersOES ( GLint n, GLuint *renderbuffers ) */ 7902 static void 7903 android_glDeleteRenderbuffersOES__I_3II 7904 (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) { 7905 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 7906 jniThrowException(_env, "java/lang/UnsupportedOperationException", 7907 "glDeleteRenderbuffersOES"); 7908 return; 7909 } 7910 jint _exception = 0; 7911 const char * _exceptionType = NULL; 7912 const char * _exceptionMessage = NULL; 7913 GLuint *renderbuffers_base = (GLuint *) 0; 7914 jint _remaining; 7915 GLuint *renderbuffers = (GLuint *) 0; 7916 7917 if (!renderbuffers_ref) { 7918 _exception = 1; 7919 _exceptionType = "java/lang/IllegalArgumentException"; 7920 _exceptionMessage = "renderbuffers == null"; 7921 goto exit; 7922 } 7923 if (offset < 0) { 7924 _exception = 1; 7925 _exceptionType = "java/lang/IllegalArgumentException"; 7926 _exceptionMessage = "offset < 0"; 7927 goto exit; 7928 } 7929 _remaining = _env->GetArrayLength(renderbuffers_ref) - offset; 7930 if (_remaining < n) { 7931 _exception = 1; 7932 _exceptionType = "java/lang/IllegalArgumentException"; 7933 _exceptionMessage = "length - offset < n < needed"; 7934 goto exit; 7935 } 7936 renderbuffers_base = (GLuint *) 7937 _env->GetIntArrayElements(renderbuffers_ref, (jboolean *)0); 7938 renderbuffers = renderbuffers_base + offset; 7939 7940 glDeleteRenderbuffersOES( 7941 (GLint)n, 7942 (GLuint *)renderbuffers 7943 ); 7944 7945 exit: 7946 if (renderbuffers_base) { 7947 _env->ReleaseIntArrayElements(renderbuffers_ref, (jint*)renderbuffers_base, 7948 _exception ? JNI_ABORT: 0); 7949 } 7950 if (_exception) { 7951 jniThrowException(_env, _exceptionType, _exceptionMessage); 7952 } 7953 } 7954 7955 /* void glDeleteRenderbuffersOES ( GLint n, GLuint *renderbuffers ) */ 7956 static void 7957 android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2 7958 (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) { 7959 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 7960 jniThrowException(_env, "java/lang/UnsupportedOperationException", 7961 "glDeleteRenderbuffersOES"); 7962 return; 7963 } 7964 jint _exception = 0; 7965 const char * _exceptionType = NULL; 7966 const char * _exceptionMessage = NULL; 7967 jintArray _array = (jintArray) 0; 7968 jint _bufferOffset = (jint) 0; 7969 jint _remaining; 7970 GLuint *renderbuffers = (GLuint *) 0; 7971 7972 if (!renderbuffers_buf) { 7973 _exception = 1; 7974 _exceptionType = "java/lang/IllegalArgumentException"; 7975 _exceptionMessage = "renderbuffers == null"; 7976 goto exit; 7977 } 7978 renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 7979 if (_remaining < n) { 7980 _exception = 1; 7981 _exceptionType = "java/lang/IllegalArgumentException"; 7982 _exceptionMessage = "remaining() < n < needed"; 7983 goto exit; 7984 } 7985 if (renderbuffers == NULL) { 7986 char * _renderbuffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 7987 renderbuffers = (GLuint *) (_renderbuffersBase + _bufferOffset); 7988 } 7989 glDeleteRenderbuffersOES( 7990 (GLint)n, 7991 (GLuint *)renderbuffers 7992 ); 7993 7994 exit: 7995 if (_array) { 7996 _env->ReleaseIntArrayElements(_array, (jint*)renderbuffers, _exception ? JNI_ABORT : 0); 7997 } 7998 if (_exception) { 7999 jniThrowException(_env, _exceptionType, _exceptionMessage); 8000 } 8001 } 8002 8003 /* void glFramebufferRenderbufferOES ( GLint target, GLint attachment, GLint renderbuffertarget, GLint renderbuffer ) */ 8004 static void 8005 android_glFramebufferRenderbufferOES__IIII 8006 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint renderbuffertarget, jint renderbuffer) { 8007 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 8008 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8009 "glFramebufferRenderbufferOES"); 8010 return; 8011 } 8012 glFramebufferRenderbufferOES( 8013 (GLint)target, 8014 (GLint)attachment, 8015 (GLint)renderbuffertarget, 8016 (GLint)renderbuffer 8017 ); 8018 } 8019 8020 /* void glFramebufferTexture2DOES ( GLint target, GLint attachment, GLint textarget, GLint texture, GLint level ) */ 8021 static void 8022 android_glFramebufferTexture2DOES__IIIII 8023 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint textarget, jint texture, jint level) { 8024 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 8025 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8026 "glFramebufferTexture2DOES"); 8027 return; 8028 } 8029 glFramebufferTexture2DOES( 8030 (GLint)target, 8031 (GLint)attachment, 8032 (GLint)textarget, 8033 (GLint)texture, 8034 (GLint)level 8035 ); 8036 } 8037 8038 /* void glGenerateMipmapOES ( GLint target ) */ 8039 static void 8040 android_glGenerateMipmapOES__I 8041 (JNIEnv *_env, jobject _this, jint target) { 8042 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 8043 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8044 "glGenerateMipmapOES"); 8045 return; 8046 } 8047 glGenerateMipmapOES( 8048 (GLint)target 8049 ); 8050 } 8051 8052 /* void glGenFramebuffersOES ( GLint n, GLuint *framebuffers ) */ 8053 static void 8054 android_glGenFramebuffersOES__I_3II 8055 (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) { 8056 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 8057 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8058 "glGenFramebuffersOES"); 8059 return; 8060 } 8061 jint _exception = 0; 8062 const char * _exceptionType = NULL; 8063 const char * _exceptionMessage = NULL; 8064 GLuint *framebuffers_base = (GLuint *) 0; 8065 jint _remaining; 8066 GLuint *framebuffers = (GLuint *) 0; 8067 8068 if (!framebuffers_ref) { 8069 _exception = 1; 8070 _exceptionType = "java/lang/IllegalArgumentException"; 8071 _exceptionMessage = "framebuffers == null"; 8072 goto exit; 8073 } 8074 if (offset < 0) { 8075 _exception = 1; 8076 _exceptionType = "java/lang/IllegalArgumentException"; 8077 _exceptionMessage = "offset < 0"; 8078 goto exit; 8079 } 8080 _remaining = _env->GetArrayLength(framebuffers_ref) - offset; 8081 if (_remaining < n) { 8082 _exception = 1; 8083 _exceptionType = "java/lang/IllegalArgumentException"; 8084 _exceptionMessage = "length - offset < n < needed"; 8085 goto exit; 8086 } 8087 framebuffers_base = (GLuint *) 8088 _env->GetIntArrayElements(framebuffers_ref, (jboolean *)0); 8089 framebuffers = framebuffers_base + offset; 8090 8091 glGenFramebuffersOES( 8092 (GLint)n, 8093 (GLuint *)framebuffers 8094 ); 8095 8096 exit: 8097 if (framebuffers_base) { 8098 _env->ReleaseIntArrayElements(framebuffers_ref, (jint*)framebuffers_base, 8099 _exception ? JNI_ABORT: 0); 8100 } 8101 if (_exception) { 8102 jniThrowException(_env, _exceptionType, _exceptionMessage); 8103 } 8104 } 8105 8106 /* void glGenFramebuffersOES ( GLint n, GLuint *framebuffers ) */ 8107 static void 8108 android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2 8109 (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) { 8110 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 8111 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8112 "glGenFramebuffersOES"); 8113 return; 8114 } 8115 jint _exception = 0; 8116 const char * _exceptionType = NULL; 8117 const char * _exceptionMessage = NULL; 8118 jintArray _array = (jintArray) 0; 8119 jint _bufferOffset = (jint) 0; 8120 jint _remaining; 8121 GLuint *framebuffers = (GLuint *) 0; 8122 8123 if (!framebuffers_buf) { 8124 _exception = 1; 8125 _exceptionType = "java/lang/IllegalArgumentException"; 8126 _exceptionMessage = "framebuffers == null"; 8127 goto exit; 8128 } 8129 framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 8130 if (_remaining < n) { 8131 _exception = 1; 8132 _exceptionType = "java/lang/IllegalArgumentException"; 8133 _exceptionMessage = "remaining() < n < needed"; 8134 goto exit; 8135 } 8136 if (framebuffers == NULL) { 8137 char * _framebuffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 8138 framebuffers = (GLuint *) (_framebuffersBase + _bufferOffset); 8139 } 8140 glGenFramebuffersOES( 8141 (GLint)n, 8142 (GLuint *)framebuffers 8143 ); 8144 8145 exit: 8146 if (_array) { 8147 _env->ReleaseIntArrayElements(_array, (jint*)framebuffers, _exception ? JNI_ABORT : 0); 8148 } 8149 if (_exception) { 8150 jniThrowException(_env, _exceptionType, _exceptionMessage); 8151 } 8152 } 8153 8154 /* void glGenRenderbuffersOES ( GLint n, GLuint *renderbuffers ) */ 8155 static void 8156 android_glGenRenderbuffersOES__I_3II 8157 (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) { 8158 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 8159 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8160 "glGenRenderbuffersOES"); 8161 return; 8162 } 8163 jint _exception = 0; 8164 const char * _exceptionType = NULL; 8165 const char * _exceptionMessage = NULL; 8166 GLuint *renderbuffers_base = (GLuint *) 0; 8167 jint _remaining; 8168 GLuint *renderbuffers = (GLuint *) 0; 8169 8170 if (!renderbuffers_ref) { 8171 _exception = 1; 8172 _exceptionType = "java/lang/IllegalArgumentException"; 8173 _exceptionMessage = "renderbuffers == null"; 8174 goto exit; 8175 } 8176 if (offset < 0) { 8177 _exception = 1; 8178 _exceptionType = "java/lang/IllegalArgumentException"; 8179 _exceptionMessage = "offset < 0"; 8180 goto exit; 8181 } 8182 _remaining = _env->GetArrayLength(renderbuffers_ref) - offset; 8183 if (_remaining < n) { 8184 _exception = 1; 8185 _exceptionType = "java/lang/IllegalArgumentException"; 8186 _exceptionMessage = "length - offset < n < needed"; 8187 goto exit; 8188 } 8189 renderbuffers_base = (GLuint *) 8190 _env->GetIntArrayElements(renderbuffers_ref, (jboolean *)0); 8191 renderbuffers = renderbuffers_base + offset; 8192 8193 glGenRenderbuffersOES( 8194 (GLint)n, 8195 (GLuint *)renderbuffers 8196 ); 8197 8198 exit: 8199 if (renderbuffers_base) { 8200 _env->ReleaseIntArrayElements(renderbuffers_ref, (jint*)renderbuffers_base, 8201 _exception ? JNI_ABORT: 0); 8202 } 8203 if (_exception) { 8204 jniThrowException(_env, _exceptionType, _exceptionMessage); 8205 } 8206 } 8207 8208 /* void glGenRenderbuffersOES ( GLint n, GLuint *renderbuffers ) */ 8209 static void 8210 android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2 8211 (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) { 8212 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 8213 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8214 "glGenRenderbuffersOES"); 8215 return; 8216 } 8217 jint _exception = 0; 8218 const char * _exceptionType = NULL; 8219 const char * _exceptionMessage = NULL; 8220 jintArray _array = (jintArray) 0; 8221 jint _bufferOffset = (jint) 0; 8222 jint _remaining; 8223 GLuint *renderbuffers = (GLuint *) 0; 8224 8225 if (!renderbuffers_buf) { 8226 _exception = 1; 8227 _exceptionType = "java/lang/IllegalArgumentException"; 8228 _exceptionMessage = "renderbuffers == null"; 8229 goto exit; 8230 } 8231 renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 8232 if (_remaining < n) { 8233 _exception = 1; 8234 _exceptionType = "java/lang/IllegalArgumentException"; 8235 _exceptionMessage = "remaining() < n < needed"; 8236 goto exit; 8237 } 8238 if (renderbuffers == NULL) { 8239 char * _renderbuffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 8240 renderbuffers = (GLuint *) (_renderbuffersBase + _bufferOffset); 8241 } 8242 glGenRenderbuffersOES( 8243 (GLint)n, 8244 (GLuint *)renderbuffers 8245 ); 8246 8247 exit: 8248 if (_array) { 8249 _env->ReleaseIntArrayElements(_array, (jint*)renderbuffers, _exception ? JNI_ABORT : 0); 8250 } 8251 if (_exception) { 8252 jniThrowException(_env, _exceptionType, _exceptionMessage); 8253 } 8254 } 8255 8256 /* void glGetFramebufferAttachmentParameterivOES ( GLint target, GLint attachment, GLint pname, GLint *params ) */ 8257 static void 8258 android_glGetFramebufferAttachmentParameterivOES__III_3II 8259 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jintArray params_ref, jint offset) { 8260 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 8261 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8262 "glGetFramebufferAttachmentParameterivOES"); 8263 return; 8264 } 8265 jint _exception = 0; 8266 const char * _exceptionType = NULL; 8267 const char * _exceptionMessage = NULL; 8268 GLint *params_base = (GLint *) 0; 8269 jint _remaining; 8270 GLint *params = (GLint *) 0; 8271 8272 if (!params_ref) { 8273 _exception = 1; 8274 _exceptionType = "java/lang/IllegalArgumentException"; 8275 _exceptionMessage = "params == null"; 8276 goto exit; 8277 } 8278 if (offset < 0) { 8279 _exception = 1; 8280 _exceptionType = "java/lang/IllegalArgumentException"; 8281 _exceptionMessage = "offset < 0"; 8282 goto exit; 8283 } 8284 _remaining = _env->GetArrayLength(params_ref) - offset; 8285 params_base = (GLint *) 8286 _env->GetIntArrayElements(params_ref, (jboolean *)0); 8287 params = params_base + offset; 8288 8289 glGetFramebufferAttachmentParameterivOES( 8290 (GLint)target, 8291 (GLint)attachment, 8292 (GLint)pname, 8293 (GLint *)params 8294 ); 8295 8296 exit: 8297 if (params_base) { 8298 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 8299 _exception ? JNI_ABORT: 0); 8300 } 8301 if (_exception) { 8302 jniThrowException(_env, _exceptionType, _exceptionMessage); 8303 } 8304 } 8305 8306 /* void glGetFramebufferAttachmentParameterivOES ( GLint target, GLint attachment, GLint pname, GLint *params ) */ 8307 static void 8308 android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2 8309 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jobject params_buf) { 8310 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 8311 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8312 "glGetFramebufferAttachmentParameterivOES"); 8313 return; 8314 } 8315 jint _exception = 0; 8316 const char * _exceptionType = NULL; 8317 const char * _exceptionMessage = NULL; 8318 jintArray _array = (jintArray) 0; 8319 jint _bufferOffset = (jint) 0; 8320 jint _remaining; 8321 GLint *params = (GLint *) 0; 8322 8323 if (!params_buf) { 8324 _exception = 1; 8325 _exceptionType = "java/lang/IllegalArgumentException"; 8326 _exceptionMessage = "params == null"; 8327 goto exit; 8328 } 8329 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 8330 if (params == NULL) { 8331 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 8332 params = (GLint *) (_paramsBase + _bufferOffset); 8333 } 8334 glGetFramebufferAttachmentParameterivOES( 8335 (GLint)target, 8336 (GLint)attachment, 8337 (GLint)pname, 8338 (GLint *)params 8339 ); 8340 8341 exit: 8342 if (_array) { 8343 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 8344 } 8345 if (_exception) { 8346 jniThrowException(_env, _exceptionType, _exceptionMessage); 8347 } 8348 } 8349 8350 /* void glGetRenderbufferParameterivOES ( GLint target, GLint pname, GLint *params ) */ 8351 static void 8352 android_glGetRenderbufferParameterivOES__II_3II 8353 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 8354 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 8355 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8356 "glGetRenderbufferParameterivOES"); 8357 return; 8358 } 8359 jint _exception = 0; 8360 const char * _exceptionType = NULL; 8361 const char * _exceptionMessage = NULL; 8362 GLint *params_base = (GLint *) 0; 8363 jint _remaining; 8364 GLint *params = (GLint *) 0; 8365 8366 if (!params_ref) { 8367 _exception = 1; 8368 _exceptionType = "java/lang/IllegalArgumentException"; 8369 _exceptionMessage = "params == null"; 8370 goto exit; 8371 } 8372 if (offset < 0) { 8373 _exception = 1; 8374 _exceptionType = "java/lang/IllegalArgumentException"; 8375 _exceptionMessage = "offset < 0"; 8376 goto exit; 8377 } 8378 _remaining = _env->GetArrayLength(params_ref) - offset; 8379 params_base = (GLint *) 8380 _env->GetIntArrayElements(params_ref, (jboolean *)0); 8381 params = params_base + offset; 8382 8383 glGetRenderbufferParameterivOES( 8384 (GLint)target, 8385 (GLint)pname, 8386 (GLint *)params 8387 ); 8388 8389 exit: 8390 if (params_base) { 8391 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 8392 _exception ? JNI_ABORT: 0); 8393 } 8394 if (_exception) { 8395 jniThrowException(_env, _exceptionType, _exceptionMessage); 8396 } 8397 } 8398 8399 /* void glGetRenderbufferParameterivOES ( GLint target, GLint pname, GLint *params ) */ 8400 static void 8401 android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2 8402 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 8403 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 8404 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8405 "glGetRenderbufferParameterivOES"); 8406 return; 8407 } 8408 jint _exception = 0; 8409 const char * _exceptionType = NULL; 8410 const char * _exceptionMessage = NULL; 8411 jintArray _array = (jintArray) 0; 8412 jint _bufferOffset = (jint) 0; 8413 jint _remaining; 8414 GLint *params = (GLint *) 0; 8415 8416 if (!params_buf) { 8417 _exception = 1; 8418 _exceptionType = "java/lang/IllegalArgumentException"; 8419 _exceptionMessage = "params == null"; 8420 goto exit; 8421 } 8422 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 8423 if (params == NULL) { 8424 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 8425 params = (GLint *) (_paramsBase + _bufferOffset); 8426 } 8427 glGetRenderbufferParameterivOES( 8428 (GLint)target, 8429 (GLint)pname, 8430 (GLint *)params 8431 ); 8432 8433 exit: 8434 if (_array) { 8435 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 8436 } 8437 if (_exception) { 8438 jniThrowException(_env, _exceptionType, _exceptionMessage); 8439 } 8440 } 8441 8442 /* void glGetTexGenfv ( GLint coord, GLint pname, GLfloat *params ) */ 8443 static void 8444 android_glGetTexGenfv__II_3FI 8445 (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) { 8446 if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) { 8447 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8448 "glGetTexGenfv"); 8449 return; 8450 } 8451 jint _exception = 0; 8452 const char * _exceptionType = NULL; 8453 const char * _exceptionMessage = NULL; 8454 GLfloat *params_base = (GLfloat *) 0; 8455 jint _remaining; 8456 GLfloat *params = (GLfloat *) 0; 8457 8458 if (!params_ref) { 8459 _exception = 1; 8460 _exceptionType = "java/lang/IllegalArgumentException"; 8461 _exceptionMessage = "params == null"; 8462 goto exit; 8463 } 8464 if (offset < 0) { 8465 _exception = 1; 8466 _exceptionType = "java/lang/IllegalArgumentException"; 8467 _exceptionMessage = "offset < 0"; 8468 goto exit; 8469 } 8470 _remaining = _env->GetArrayLength(params_ref) - offset; 8471 params_base = (GLfloat *) 8472 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 8473 params = params_base + offset; 8474 8475 glGetTexGenfv( 8476 (GLint)coord, 8477 (GLint)pname, 8478 (GLfloat *)params 8479 ); 8480 8481 exit: 8482 if (params_base) { 8483 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 8484 _exception ? JNI_ABORT: 0); 8485 } 8486 if (_exception) { 8487 jniThrowException(_env, _exceptionType, _exceptionMessage); 8488 } 8489 } 8490 8491 /* void glGetTexGenfv ( GLint coord, GLint pname, GLfloat *params ) */ 8492 static void 8493 android_glGetTexGenfv__IILjava_nio_FloatBuffer_2 8494 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { 8495 if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) { 8496 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8497 "glGetTexGenfv"); 8498 return; 8499 } 8500 jint _exception = 0; 8501 const char * _exceptionType = NULL; 8502 const char * _exceptionMessage = NULL; 8503 jfloatArray _array = (jfloatArray) 0; 8504 jint _bufferOffset = (jint) 0; 8505 jint _remaining; 8506 GLfloat *params = (GLfloat *) 0; 8507 8508 if (!params_buf) { 8509 _exception = 1; 8510 _exceptionType = "java/lang/IllegalArgumentException"; 8511 _exceptionMessage = "params == null"; 8512 goto exit; 8513 } 8514 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 8515 if (params == NULL) { 8516 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 8517 params = (GLfloat *) (_paramsBase + _bufferOffset); 8518 } 8519 glGetTexGenfv( 8520 (GLint)coord, 8521 (GLint)pname, 8522 (GLfloat *)params 8523 ); 8524 8525 exit: 8526 if (_array) { 8527 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0); 8528 } 8529 if (_exception) { 8530 jniThrowException(_env, _exceptionType, _exceptionMessage); 8531 } 8532 } 8533 8534 /* void glGetTexGeniv ( GLint coord, GLint pname, GLint *params ) */ 8535 static void 8536 android_glGetTexGeniv__II_3II 8537 (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) { 8538 if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) { 8539 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8540 "glGetTexGeniv"); 8541 return; 8542 } 8543 jint _exception = 0; 8544 const char * _exceptionType = NULL; 8545 const char * _exceptionMessage = NULL; 8546 GLint *params_base = (GLint *) 0; 8547 jint _remaining; 8548 GLint *params = (GLint *) 0; 8549 8550 if (!params_ref) { 8551 _exception = 1; 8552 _exceptionType = "java/lang/IllegalArgumentException"; 8553 _exceptionMessage = "params == null"; 8554 goto exit; 8555 } 8556 if (offset < 0) { 8557 _exception = 1; 8558 _exceptionType = "java/lang/IllegalArgumentException"; 8559 _exceptionMessage = "offset < 0"; 8560 goto exit; 8561 } 8562 _remaining = _env->GetArrayLength(params_ref) - offset; 8563 params_base = (GLint *) 8564 _env->GetIntArrayElements(params_ref, (jboolean *)0); 8565 params = params_base + offset; 8566 8567 glGetTexGeniv( 8568 (GLint)coord, 8569 (GLint)pname, 8570 (GLint *)params 8571 ); 8572 8573 exit: 8574 if (params_base) { 8575 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 8576 _exception ? JNI_ABORT: 0); 8577 } 8578 if (_exception) { 8579 jniThrowException(_env, _exceptionType, _exceptionMessage); 8580 } 8581 } 8582 8583 /* void glGetTexGeniv ( GLint coord, GLint pname, GLint *params ) */ 8584 static void 8585 android_glGetTexGeniv__IILjava_nio_IntBuffer_2 8586 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { 8587 if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) { 8588 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8589 "glGetTexGeniv"); 8590 return; 8591 } 8592 jint _exception = 0; 8593 const char * _exceptionType = NULL; 8594 const char * _exceptionMessage = NULL; 8595 jintArray _array = (jintArray) 0; 8596 jint _bufferOffset = (jint) 0; 8597 jint _remaining; 8598 GLint *params = (GLint *) 0; 8599 8600 if (!params_buf) { 8601 _exception = 1; 8602 _exceptionType = "java/lang/IllegalArgumentException"; 8603 _exceptionMessage = "params == null"; 8604 goto exit; 8605 } 8606 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 8607 if (params == NULL) { 8608 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 8609 params = (GLint *) (_paramsBase + _bufferOffset); 8610 } 8611 glGetTexGeniv( 8612 (GLint)coord, 8613 (GLint)pname, 8614 (GLint *)params 8615 ); 8616 8617 exit: 8618 if (_array) { 8619 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 8620 } 8621 if (_exception) { 8622 jniThrowException(_env, _exceptionType, _exceptionMessage); 8623 } 8624 } 8625 8626 /* void glGetTexGenxv ( GLint coord, GLint pname, GLint *params ) */ 8627 static void 8628 android_glGetTexGenxv__II_3II 8629 (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) { 8630 if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) { 8631 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8632 "glGetTexGenxv"); 8633 return; 8634 } 8635 jint _exception = 0; 8636 const char * _exceptionType = NULL; 8637 const char * _exceptionMessage = NULL; 8638 GLint *params_base = (GLint *) 0; 8639 jint _remaining; 8640 GLint *params = (GLint *) 0; 8641 8642 if (!params_ref) { 8643 _exception = 1; 8644 _exceptionType = "java/lang/IllegalArgumentException"; 8645 _exceptionMessage = "params == null"; 8646 goto exit; 8647 } 8648 if (offset < 0) { 8649 _exception = 1; 8650 _exceptionType = "java/lang/IllegalArgumentException"; 8651 _exceptionMessage = "offset < 0"; 8652 goto exit; 8653 } 8654 _remaining = _env->GetArrayLength(params_ref) - offset; 8655 params_base = (GLint *) 8656 _env->GetIntArrayElements(params_ref, (jboolean *)0); 8657 params = params_base + offset; 8658 8659 glGetTexGenxv( 8660 (GLint)coord, 8661 (GLint)pname, 8662 (GLint *)params 8663 ); 8664 8665 exit: 8666 if (params_base) { 8667 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 8668 _exception ? JNI_ABORT: 0); 8669 } 8670 if (_exception) { 8671 jniThrowException(_env, _exceptionType, _exceptionMessage); 8672 } 8673 } 8674 8675 /* void glGetTexGenxv ( GLint coord, GLint pname, GLint *params ) */ 8676 static void 8677 android_glGetTexGenxv__IILjava_nio_IntBuffer_2 8678 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { 8679 if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) { 8680 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8681 "glGetTexGenxv"); 8682 return; 8683 } 8684 jint _exception = 0; 8685 const char * _exceptionType = NULL; 8686 const char * _exceptionMessage = NULL; 8687 jintArray _array = (jintArray) 0; 8688 jint _bufferOffset = (jint) 0; 8689 jint _remaining; 8690 GLint *params = (GLint *) 0; 8691 8692 if (!params_buf) { 8693 _exception = 1; 8694 _exceptionType = "java/lang/IllegalArgumentException"; 8695 _exceptionMessage = "params == null"; 8696 goto exit; 8697 } 8698 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 8699 if (params == NULL) { 8700 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 8701 params = (GLint *) (_paramsBase + _bufferOffset); 8702 } 8703 glGetTexGenxv( 8704 (GLint)coord, 8705 (GLint)pname, 8706 (GLint *)params 8707 ); 8708 8709 exit: 8710 if (_array) { 8711 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 8712 } 8713 if (_exception) { 8714 jniThrowException(_env, _exceptionType, _exceptionMessage); 8715 } 8716 } 8717 8718 /* GLboolean glIsFramebufferOES ( GLint framebuffer ) */ 8719 static jboolean 8720 android_glIsFramebufferOES__I 8721 (JNIEnv *_env, jobject _this, jint framebuffer) { 8722 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 8723 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8724 "glIsFramebufferOES"); 8725 return JNI_FALSE; 8726 } 8727 GLboolean _returnValue = JNI_FALSE; 8728 _returnValue = glIsFramebufferOES( 8729 (GLint)framebuffer 8730 ); 8731 return (jboolean)_returnValue; 8732 } 8733 8734 /* GLboolean glIsRenderbufferOES ( GLint renderbuffer ) */ 8735 static jboolean 8736 android_glIsRenderbufferOES__I 8737 (JNIEnv *_env, jobject _this, jint renderbuffer) { 8738 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 8739 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8740 "glIsRenderbufferOES"); 8741 return JNI_FALSE; 8742 } 8743 GLboolean _returnValue = JNI_FALSE; 8744 _returnValue = glIsRenderbufferOES( 8745 (GLint)renderbuffer 8746 ); 8747 return (jboolean)_returnValue; 8748 } 8749 8750 /* void glRenderbufferStorageOES ( GLint target, GLint internalformat, GLint width, GLint height ) */ 8751 static void 8752 android_glRenderbufferStorageOES__IIII 8753 (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint width, jint height) { 8754 if (! supportsExtension(_env, _this, have_OES_framebuffer_objectID)) { 8755 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8756 "glRenderbufferStorageOES"); 8757 return; 8758 } 8759 glRenderbufferStorageOES( 8760 (GLint)target, 8761 (GLint)internalformat, 8762 (GLint)width, 8763 (GLint)height 8764 ); 8765 } 8766 8767 /* void glTexGenf ( GLint coord, GLint pname, GLfloat param ) */ 8768 static void 8769 android_glTexGenf__IIF 8770 (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloat param) { 8771 if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) { 8772 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8773 "glTexGenf"); 8774 return; 8775 } 8776 glTexGenf( 8777 (GLint)coord, 8778 (GLint)pname, 8779 (GLfloat)param 8780 ); 8781 } 8782 8783 /* void glTexGenfv ( GLint coord, GLint pname, GLfloat *params ) */ 8784 static void 8785 android_glTexGenfv__II_3FI 8786 (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) { 8787 if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) { 8788 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8789 "glTexGenfv"); 8790 return; 8791 } 8792 jint _exception = 0; 8793 const char * _exceptionType = NULL; 8794 const char * _exceptionMessage = NULL; 8795 GLfloat *params_base = (GLfloat *) 0; 8796 jint _remaining; 8797 GLfloat *params = (GLfloat *) 0; 8798 8799 if (!params_ref) { 8800 _exception = 1; 8801 _exceptionType = "java/lang/IllegalArgumentException"; 8802 _exceptionMessage = "params == null"; 8803 goto exit; 8804 } 8805 if (offset < 0) { 8806 _exception = 1; 8807 _exceptionType = "java/lang/IllegalArgumentException"; 8808 _exceptionMessage = "offset < 0"; 8809 goto exit; 8810 } 8811 _remaining = _env->GetArrayLength(params_ref) - offset; 8812 params_base = (GLfloat *) 8813 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 8814 params = params_base + offset; 8815 8816 glTexGenfv( 8817 (GLint)coord, 8818 (GLint)pname, 8819 (GLfloat *)params 8820 ); 8821 8822 exit: 8823 if (params_base) { 8824 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 8825 _exception ? JNI_ABORT: 0); 8826 } 8827 if (_exception) { 8828 jniThrowException(_env, _exceptionType, _exceptionMessage); 8829 } 8830 } 8831 8832 /* void glTexGenfv ( GLint coord, GLint pname, GLfloat *params ) */ 8833 static void 8834 android_glTexGenfv__IILjava_nio_FloatBuffer_2 8835 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { 8836 if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) { 8837 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8838 "glTexGenfv"); 8839 return; 8840 } 8841 jint _exception = 0; 8842 const char * _exceptionType = NULL; 8843 const char * _exceptionMessage = NULL; 8844 jfloatArray _array = (jfloatArray) 0; 8845 jint _bufferOffset = (jint) 0; 8846 jint _remaining; 8847 GLfloat *params = (GLfloat *) 0; 8848 8849 if (!params_buf) { 8850 _exception = 1; 8851 _exceptionType = "java/lang/IllegalArgumentException"; 8852 _exceptionMessage = "params == null"; 8853 goto exit; 8854 } 8855 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 8856 if (params == NULL) { 8857 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 8858 params = (GLfloat *) (_paramsBase + _bufferOffset); 8859 } 8860 glTexGenfv( 8861 (GLint)coord, 8862 (GLint)pname, 8863 (GLfloat *)params 8864 ); 8865 8866 exit: 8867 if (_array) { 8868 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0); 8869 } 8870 if (_exception) { 8871 jniThrowException(_env, _exceptionType, _exceptionMessage); 8872 } 8873 } 8874 8875 /* void glTexGeni ( GLint coord, GLint pname, GLint param ) */ 8876 static void 8877 android_glTexGeni__III 8878 (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) { 8879 if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) { 8880 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8881 "glTexGeni"); 8882 return; 8883 } 8884 glTexGeni( 8885 (GLint)coord, 8886 (GLint)pname, 8887 (GLint)param 8888 ); 8889 } 8890 8891 /* void glTexGeniv ( GLint coord, GLint pname, GLint *params ) */ 8892 static void 8893 android_glTexGeniv__II_3II 8894 (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) { 8895 if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) { 8896 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8897 "glTexGeniv"); 8898 return; 8899 } 8900 jint _exception = 0; 8901 const char * _exceptionType = NULL; 8902 const char * _exceptionMessage = NULL; 8903 GLint *params_base = (GLint *) 0; 8904 jint _remaining; 8905 GLint *params = (GLint *) 0; 8906 8907 if (!params_ref) { 8908 _exception = 1; 8909 _exceptionType = "java/lang/IllegalArgumentException"; 8910 _exceptionMessage = "params == null"; 8911 goto exit; 8912 } 8913 if (offset < 0) { 8914 _exception = 1; 8915 _exceptionType = "java/lang/IllegalArgumentException"; 8916 _exceptionMessage = "offset < 0"; 8917 goto exit; 8918 } 8919 _remaining = _env->GetArrayLength(params_ref) - offset; 8920 params_base = (GLint *) 8921 _env->GetIntArrayElements(params_ref, (jboolean *)0); 8922 params = params_base + offset; 8923 8924 glTexGeniv( 8925 (GLint)coord, 8926 (GLint)pname, 8927 (GLint *)params 8928 ); 8929 8930 exit: 8931 if (params_base) { 8932 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 8933 _exception ? JNI_ABORT: 0); 8934 } 8935 if (_exception) { 8936 jniThrowException(_env, _exceptionType, _exceptionMessage); 8937 } 8938 } 8939 8940 /* void glTexGeniv ( GLint coord, GLint pname, GLint *params ) */ 8941 static void 8942 android_glTexGeniv__IILjava_nio_IntBuffer_2 8943 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { 8944 if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) { 8945 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8946 "glTexGeniv"); 8947 return; 8948 } 8949 jint _exception = 0; 8950 const char * _exceptionType = NULL; 8951 const char * _exceptionMessage = NULL; 8952 jintArray _array = (jintArray) 0; 8953 jint _bufferOffset = (jint) 0; 8954 jint _remaining; 8955 GLint *params = (GLint *) 0; 8956 8957 if (!params_buf) { 8958 _exception = 1; 8959 _exceptionType = "java/lang/IllegalArgumentException"; 8960 _exceptionMessage = "params == null"; 8961 goto exit; 8962 } 8963 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 8964 if (params == NULL) { 8965 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 8966 params = (GLint *) (_paramsBase + _bufferOffset); 8967 } 8968 glTexGeniv( 8969 (GLint)coord, 8970 (GLint)pname, 8971 (GLint *)params 8972 ); 8973 8974 exit: 8975 if (_array) { 8976 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 8977 } 8978 if (_exception) { 8979 jniThrowException(_env, _exceptionType, _exceptionMessage); 8980 } 8981 } 8982 8983 /* void glTexGenx ( GLint coord, GLint pname, GLint param ) */ 8984 static void 8985 android_glTexGenx__III 8986 (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) { 8987 if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) { 8988 jniThrowException(_env, "java/lang/UnsupportedOperationException", 8989 "glTexGenx"); 8990 return; 8991 } 8992 glTexGenx( 8993 (GLint)coord, 8994 (GLint)pname, 8995 (GLint)param 8996 ); 8997 } 8998 8999 /* void glTexGenxv ( GLint coord, GLint pname, GLint *params ) */ 9000 static void 9001 android_glTexGenxv__II_3II 9002 (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) { 9003 if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) { 9004 jniThrowException(_env, "java/lang/UnsupportedOperationException", 9005 "glTexGenxv"); 9006 return; 9007 } 9008 jint _exception = 0; 9009 const char * _exceptionType = NULL; 9010 const char * _exceptionMessage = NULL; 9011 GLint *params_base = (GLint *) 0; 9012 jint _remaining; 9013 GLint *params = (GLint *) 0; 9014 9015 if (!params_ref) { 9016 _exception = 1; 9017 _exceptionType = "java/lang/IllegalArgumentException"; 9018 _exceptionMessage = "params == null"; 9019 goto exit; 9020 } 9021 if (offset < 0) { 9022 _exception = 1; 9023 _exceptionType = "java/lang/IllegalArgumentException"; 9024 _exceptionMessage = "offset < 0"; 9025 goto exit; 9026 } 9027 _remaining = _env->GetArrayLength(params_ref) - offset; 9028 params_base = (GLint *) 9029 _env->GetIntArrayElements(params_ref, (jboolean *)0); 9030 params = params_base + offset; 9031 9032 glTexGenxv( 9033 (GLint)coord, 9034 (GLint)pname, 9035 (GLint *)params 9036 ); 9037 9038 exit: 9039 if (params_base) { 9040 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 9041 _exception ? JNI_ABORT: 0); 9042 } 9043 if (_exception) { 9044 jniThrowException(_env, _exceptionType, _exceptionMessage); 9045 } 9046 } 9047 9048 /* void glTexGenxv ( GLint coord, GLint pname, GLint *params ) */ 9049 static void 9050 android_glTexGenxv__IILjava_nio_IntBuffer_2 9051 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { 9052 if (! supportsExtension(_env, _this, have_OES_texture_cube_mapID)) { 9053 jniThrowException(_env, "java/lang/UnsupportedOperationException", 9054 "glTexGenxv"); 9055 return; 9056 } 9057 jint _exception = 0; 9058 const char * _exceptionType = NULL; 9059 const char * _exceptionMessage = NULL; 9060 jintArray _array = (jintArray) 0; 9061 jint _bufferOffset = (jint) 0; 9062 jint _remaining; 9063 GLint *params = (GLint *) 0; 9064 9065 if (!params_buf) { 9066 _exception = 1; 9067 _exceptionType = "java/lang/IllegalArgumentException"; 9068 _exceptionMessage = "params == null"; 9069 goto exit; 9070 } 9071 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 9072 if (params == NULL) { 9073 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 9074 params = (GLint *) (_paramsBase + _bufferOffset); 9075 } 9076 glTexGenxv( 9077 (GLint)coord, 9078 (GLint)pname, 9079 (GLint *)params 9080 ); 9081 9082 exit: 9083 if (_array) { 9084 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 9085 } 9086 if (_exception) { 9087 jniThrowException(_env, _exceptionType, _exceptionMessage); 9088 } 9089 } 9090 9091 static const char *classPathName = "com/google/android/gles_jni/GLImpl"; 9092 9093 static const JNINativeMethod methods[] = { 9094 {"_nativeClassInit", "()V", (void*)nativeClassInit }, 9095 {"glActiveTexture", "(I)V", (void *) android_glActiveTexture__I }, 9096 {"glAlphaFunc", "(IF)V", (void *) android_glAlphaFunc__IF }, 9097 {"glAlphaFuncx", "(II)V", (void *) android_glAlphaFuncx__II }, 9098 {"glBindTexture", "(II)V", (void *) android_glBindTexture__II }, 9099 {"glBlendFunc", "(II)V", (void *) android_glBlendFunc__II }, 9100 {"glClear", "(I)V", (void *) android_glClear__I }, 9101 {"glClearColor", "(FFFF)V", (void *) android_glClearColor__FFFF }, 9102 {"glClearColorx", "(IIII)V", (void *) android_glClearColorx__IIII }, 9103 {"glClearDepthf", "(F)V", (void *) android_glClearDepthf__F }, 9104 {"glClearDepthx", "(I)V", (void *) android_glClearDepthx__I }, 9105 {"glClearStencil", "(I)V", (void *) android_glClearStencil__I }, 9106 {"glClientActiveTexture", "(I)V", (void *) android_glClientActiveTexture__I }, 9107 {"glColor4f", "(FFFF)V", (void *) android_glColor4f__FFFF }, 9108 {"glColor4x", "(IIII)V", (void *) android_glColor4x__IIII }, 9109 {"glColorMask", "(ZZZZ)V", (void *) android_glColorMask__ZZZZ }, 9110 {"glColorPointerBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glColorPointerBounds__IIILjava_nio_Buffer_2I }, 9111 {"glCompressedTexImage2D", "(IIIIIIILjava/nio/Buffer;)V", (void *) android_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2 }, 9112 {"glCompressedTexSubImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 }, 9113 {"glCopyTexImage2D", "(IIIIIIII)V", (void *) android_glCopyTexImage2D__IIIIIIII }, 9114 {"glCopyTexSubImage2D", "(IIIIIIII)V", (void *) android_glCopyTexSubImage2D__IIIIIIII }, 9115 {"glCullFace", "(I)V", (void *) android_glCullFace__I }, 9116 {"glDeleteTextures", "(I[II)V", (void *) android_glDeleteTextures__I_3II }, 9117 {"glDeleteTextures", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteTextures__ILjava_nio_IntBuffer_2 }, 9118 {"glDepthFunc", "(I)V", (void *) android_glDepthFunc__I }, 9119 {"glDepthMask", "(Z)V", (void *) android_glDepthMask__Z }, 9120 {"glDepthRangef", "(FF)V", (void *) android_glDepthRangef__FF }, 9121 {"glDepthRangex", "(II)V", (void *) android_glDepthRangex__II }, 9122 {"glDisable", "(I)V", (void *) android_glDisable__I }, 9123 {"glDisableClientState", "(I)V", (void *) android_glDisableClientState__I }, 9124 {"glDrawArrays", "(III)V", (void *) android_glDrawArrays__III }, 9125 {"glDrawElements", "(IIILjava/nio/Buffer;)V", (void *) android_glDrawElements__IIILjava_nio_Buffer_2 }, 9126 {"glEnable", "(I)V", (void *) android_glEnable__I }, 9127 {"glEnableClientState", "(I)V", (void *) android_glEnableClientState__I }, 9128 {"glFinish", "()V", (void *) android_glFinish__ }, 9129 {"glFlush", "()V", (void *) android_glFlush__ }, 9130 {"glFogf", "(IF)V", (void *) android_glFogf__IF }, 9131 {"glFogfv", "(I[FI)V", (void *) android_glFogfv__I_3FI }, 9132 {"glFogfv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glFogfv__ILjava_nio_FloatBuffer_2 }, 9133 {"glFogx", "(II)V", (void *) android_glFogx__II }, 9134 {"glFogxv", "(I[II)V", (void *) android_glFogxv__I_3II }, 9135 {"glFogxv", "(ILjava/nio/IntBuffer;)V", (void *) android_glFogxv__ILjava_nio_IntBuffer_2 }, 9136 {"glFrontFace", "(I)V", (void *) android_glFrontFace__I }, 9137 {"glFrustumf", "(FFFFFF)V", (void *) android_glFrustumf__FFFFFF }, 9138 {"glFrustumx", "(IIIIII)V", (void *) android_glFrustumx__IIIIII }, 9139 {"glGenTextures", "(I[II)V", (void *) android_glGenTextures__I_3II }, 9140 {"glGenTextures", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenTextures__ILjava_nio_IntBuffer_2 }, 9141 {"glGetError", "()I", (void *) android_glGetError__ }, 9142 {"glGetIntegerv", "(I[II)V", (void *) android_glGetIntegerv__I_3II }, 9143 {"glGetIntegerv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetIntegerv__ILjava_nio_IntBuffer_2 }, 9144 {"_glGetString", "(I)Ljava/lang/String;", (void *) android_glGetString }, 9145 {"glHint", "(II)V", (void *) android_glHint__II }, 9146 {"glLightModelf", "(IF)V", (void *) android_glLightModelf__IF }, 9147 {"glLightModelfv", "(I[FI)V", (void *) android_glLightModelfv__I_3FI }, 9148 {"glLightModelfv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glLightModelfv__ILjava_nio_FloatBuffer_2 }, 9149 {"glLightModelx", "(II)V", (void *) android_glLightModelx__II }, 9150 {"glLightModelxv", "(I[II)V", (void *) android_glLightModelxv__I_3II }, 9151 {"glLightModelxv", "(ILjava/nio/IntBuffer;)V", (void *) android_glLightModelxv__ILjava_nio_IntBuffer_2 }, 9152 {"glLightf", "(IIF)V", (void *) android_glLightf__IIF }, 9153 {"glLightfv", "(II[FI)V", (void *) android_glLightfv__II_3FI }, 9154 {"glLightfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glLightfv__IILjava_nio_FloatBuffer_2 }, 9155 {"glLightx", "(III)V", (void *) android_glLightx__III }, 9156 {"glLightxv", "(II[II)V", (void *) android_glLightxv__II_3II }, 9157 {"glLightxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glLightxv__IILjava_nio_IntBuffer_2 }, 9158 {"glLineWidth", "(F)V", (void *) android_glLineWidth__F }, 9159 {"glLineWidthx", "(I)V", (void *) android_glLineWidthx__I }, 9160 {"glLoadIdentity", "()V", (void *) android_glLoadIdentity__ }, 9161 {"glLoadMatrixf", "([FI)V", (void *) android_glLoadMatrixf___3FI }, 9162 {"glLoadMatrixf", "(Ljava/nio/FloatBuffer;)V", (void *) android_glLoadMatrixf__Ljava_nio_FloatBuffer_2 }, 9163 {"glLoadMatrixx", "([II)V", (void *) android_glLoadMatrixx___3II }, 9164 {"glLoadMatrixx", "(Ljava/nio/IntBuffer;)V", (void *) android_glLoadMatrixx__Ljava_nio_IntBuffer_2 }, 9165 {"glLogicOp", "(I)V", (void *) android_glLogicOp__I }, 9166 {"glMaterialf", "(IIF)V", (void *) android_glMaterialf__IIF }, 9167 {"glMaterialfv", "(II[FI)V", (void *) android_glMaterialfv__II_3FI }, 9168 {"glMaterialfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glMaterialfv__IILjava_nio_FloatBuffer_2 }, 9169 {"glMaterialx", "(III)V", (void *) android_glMaterialx__III }, 9170 {"glMaterialxv", "(II[II)V", (void *) android_glMaterialxv__II_3II }, 9171 {"glMaterialxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glMaterialxv__IILjava_nio_IntBuffer_2 }, 9172 {"glMatrixMode", "(I)V", (void *) android_glMatrixMode__I }, 9173 {"glMultMatrixf", "([FI)V", (void *) android_glMultMatrixf___3FI }, 9174 {"glMultMatrixf", "(Ljava/nio/FloatBuffer;)V", (void *) android_glMultMatrixf__Ljava_nio_FloatBuffer_2 }, 9175 {"glMultMatrixx", "([II)V", (void *) android_glMultMatrixx___3II }, 9176 {"glMultMatrixx", "(Ljava/nio/IntBuffer;)V", (void *) android_glMultMatrixx__Ljava_nio_IntBuffer_2 }, 9177 {"glMultiTexCoord4f", "(IFFFF)V", (void *) android_glMultiTexCoord4f__IFFFF }, 9178 {"glMultiTexCoord4x", "(IIIII)V", (void *) android_glMultiTexCoord4x__IIIII }, 9179 {"glNormal3f", "(FFF)V", (void *) android_glNormal3f__FFF }, 9180 {"glNormal3x", "(III)V", (void *) android_glNormal3x__III }, 9181 {"glNormalPointerBounds", "(IILjava/nio/Buffer;I)V", (void *) android_glNormalPointerBounds__IILjava_nio_Buffer_2I }, 9182 {"glOrthof", "(FFFFFF)V", (void *) android_glOrthof__FFFFFF }, 9183 {"glOrthox", "(IIIIII)V", (void *) android_glOrthox__IIIIII }, 9184 {"glPixelStorei", "(II)V", (void *) android_glPixelStorei__II }, 9185 {"glPointSize", "(F)V", (void *) android_glPointSize__F }, 9186 {"glPointSizex", "(I)V", (void *) android_glPointSizex__I }, 9187 {"glPolygonOffset", "(FF)V", (void *) android_glPolygonOffset__FF }, 9188 {"glPolygonOffsetx", "(II)V", (void *) android_glPolygonOffsetx__II }, 9189 {"glPopMatrix", "()V", (void *) android_glPopMatrix__ }, 9190 {"glPushMatrix", "()V", (void *) android_glPushMatrix__ }, 9191 {"glReadPixels", "(IIIIIILjava/nio/Buffer;)V", (void *) android_glReadPixels__IIIIIILjava_nio_Buffer_2 }, 9192 {"glRotatef", "(FFFF)V", (void *) android_glRotatef__FFFF }, 9193 {"glRotatex", "(IIII)V", (void *) android_glRotatex__IIII }, 9194 {"glSampleCoverage", "(FZ)V", (void *) android_glSampleCoverage__FZ }, 9195 {"glSampleCoveragex", "(IZ)V", (void *) android_glSampleCoveragex__IZ }, 9196 {"glScalef", "(FFF)V", (void *) android_glScalef__FFF }, 9197 {"glScalex", "(III)V", (void *) android_glScalex__III }, 9198 {"glScissor", "(IIII)V", (void *) android_glScissor__IIII }, 9199 {"glShadeModel", "(I)V", (void *) android_glShadeModel__I }, 9200 {"glStencilFunc", "(III)V", (void *) android_glStencilFunc__III }, 9201 {"glStencilMask", "(I)V", (void *) android_glStencilMask__I }, 9202 {"glStencilOp", "(III)V", (void *) android_glStencilOp__III }, 9203 {"glTexCoordPointerBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glTexCoordPointerBounds__IIILjava_nio_Buffer_2I }, 9204 {"glTexEnvf", "(IIF)V", (void *) android_glTexEnvf__IIF }, 9205 {"glTexEnvfv", "(II[FI)V", (void *) android_glTexEnvfv__II_3FI }, 9206 {"glTexEnvfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexEnvfv__IILjava_nio_FloatBuffer_2 }, 9207 {"glTexEnvx", "(III)V", (void *) android_glTexEnvx__III }, 9208 {"glTexEnvxv", "(II[II)V", (void *) android_glTexEnvxv__II_3II }, 9209 {"glTexEnvxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexEnvxv__IILjava_nio_IntBuffer_2 }, 9210 {"glTexImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2 }, 9211 {"glTexParameterf", "(IIF)V", (void *) android_glTexParameterf__IIF }, 9212 {"glTexParameterx", "(III)V", (void *) android_glTexParameterx__III }, 9213 {"glTexSubImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 }, 9214 {"glTranslatef", "(FFF)V", (void *) android_glTranslatef__FFF }, 9215 {"glTranslatex", "(III)V", (void *) android_glTranslatex__III }, 9216 {"glVertexPointerBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glVertexPointerBounds__IIILjava_nio_Buffer_2I }, 9217 {"glViewport", "(IIII)V", (void *) android_glViewport__IIII }, 9218 {"glQueryMatrixxOES", "([II[II)I", (void *) android_glQueryMatrixxOES___3II_3II }, 9219 {"glQueryMatrixxOES", "(Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;)I", (void *) android_glQueryMatrixxOES__Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 }, 9220 {"glBindBuffer", "(II)V", (void *) android_glBindBuffer__II }, 9221 {"glBufferData", "(IILjava/nio/Buffer;I)V", (void *) android_glBufferData__IILjava_nio_Buffer_2I }, 9222 {"glBufferSubData", "(IIILjava/nio/Buffer;)V", (void *) android_glBufferSubData__IIILjava_nio_Buffer_2 }, 9223 {"glClipPlanef", "(I[FI)V", (void *) android_glClipPlanef__I_3FI }, 9224 {"glClipPlanef", "(ILjava/nio/FloatBuffer;)V", (void *) android_glClipPlanef__ILjava_nio_FloatBuffer_2 }, 9225 {"glClipPlanex", "(I[II)V", (void *) android_glClipPlanex__I_3II }, 9226 {"glClipPlanex", "(ILjava/nio/IntBuffer;)V", (void *) android_glClipPlanex__ILjava_nio_IntBuffer_2 }, 9227 {"glColor4ub", "(BBBB)V", (void *) android_glColor4ub__BBBB }, 9228 {"glColorPointer", "(IIII)V", (void *) android_glColorPointer__IIII }, 9229 {"glDeleteBuffers", "(I[II)V", (void *) android_glDeleteBuffers__I_3II }, 9230 {"glDeleteBuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteBuffers__ILjava_nio_IntBuffer_2 }, 9231 {"glDrawElements", "(IIII)V", (void *) android_glDrawElements__IIII }, 9232 {"glGenBuffers", "(I[II)V", (void *) android_glGenBuffers__I_3II }, 9233 {"glGenBuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenBuffers__ILjava_nio_IntBuffer_2 }, 9234 {"glGetBooleanv", "(I[ZI)V", (void *) android_glGetBooleanv__I_3ZI }, 9235 {"glGetBooleanv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetBooleanv__ILjava_nio_IntBuffer_2 }, 9236 {"glGetBufferParameteriv", "(II[II)V", (void *) android_glGetBufferParameteriv__II_3II }, 9237 {"glGetBufferParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetBufferParameteriv__IILjava_nio_IntBuffer_2 }, 9238 {"glGetClipPlanef", "(I[FI)V", (void *) android_glGetClipPlanef__I_3FI }, 9239 {"glGetClipPlanef", "(ILjava/nio/FloatBuffer;)V", (void *) android_glGetClipPlanef__ILjava_nio_FloatBuffer_2 }, 9240 {"glGetClipPlanex", "(I[II)V", (void *) android_glGetClipPlanex__I_3II }, 9241 {"glGetClipPlanex", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetClipPlanex__ILjava_nio_IntBuffer_2 }, 9242 {"glGetFixedv", "(I[II)V", (void *) android_glGetFixedv__I_3II }, 9243 {"glGetFixedv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetFixedv__ILjava_nio_IntBuffer_2 }, 9244 {"glGetFloatv", "(I[FI)V", (void *) android_glGetFloatv__I_3FI }, 9245 {"glGetFloatv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glGetFloatv__ILjava_nio_FloatBuffer_2 }, 9246 {"glGetLightfv", "(II[FI)V", (void *) android_glGetLightfv__II_3FI }, 9247 {"glGetLightfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetLightfv__IILjava_nio_FloatBuffer_2 }, 9248 {"glGetLightxv", "(II[II)V", (void *) android_glGetLightxv__II_3II }, 9249 {"glGetLightxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetLightxv__IILjava_nio_IntBuffer_2 }, 9250 {"glGetMaterialfv", "(II[FI)V", (void *) android_glGetMaterialfv__II_3FI }, 9251 {"glGetMaterialfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetMaterialfv__IILjava_nio_FloatBuffer_2 }, 9252 {"glGetMaterialxv", "(II[II)V", (void *) android_glGetMaterialxv__II_3II }, 9253 {"glGetMaterialxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetMaterialxv__IILjava_nio_IntBuffer_2 }, 9254 {"glGetTexEnviv", "(II[II)V", (void *) android_glGetTexEnviv__II_3II }, 9255 {"glGetTexEnviv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexEnviv__IILjava_nio_IntBuffer_2 }, 9256 {"glGetTexEnvxv", "(II[II)V", (void *) android_glGetTexEnvxv__II_3II }, 9257 {"glGetTexEnvxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexEnvxv__IILjava_nio_IntBuffer_2 }, 9258 {"glGetTexParameterfv", "(II[FI)V", (void *) android_glGetTexParameterfv__II_3FI }, 9259 {"glGetTexParameterfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetTexParameterfv__IILjava_nio_FloatBuffer_2 }, 9260 {"glGetTexParameteriv", "(II[II)V", (void *) android_glGetTexParameteriv__II_3II }, 9261 {"glGetTexParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameteriv__IILjava_nio_IntBuffer_2 }, 9262 {"glGetTexParameterxv", "(II[II)V", (void *) android_glGetTexParameterxv__II_3II }, 9263 {"glGetTexParameterxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameterxv__IILjava_nio_IntBuffer_2 }, 9264 {"glIsBuffer", "(I)Z", (void *) android_glIsBuffer__I }, 9265 {"glIsEnabled", "(I)Z", (void *) android_glIsEnabled__I }, 9266 {"glIsTexture", "(I)Z", (void *) android_glIsTexture__I }, 9267 {"glNormalPointer", "(III)V", (void *) android_glNormalPointer__III }, 9268 {"glPointParameterf", "(IF)V", (void *) android_glPointParameterf__IF }, 9269 {"glPointParameterfv", "(I[FI)V", (void *) android_glPointParameterfv__I_3FI }, 9270 {"glPointParameterfv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glPointParameterfv__ILjava_nio_FloatBuffer_2 }, 9271 {"glPointParameterx", "(II)V", (void *) android_glPointParameterx__II }, 9272 {"glPointParameterxv", "(I[II)V", (void *) android_glPointParameterxv__I_3II }, 9273 {"glPointParameterxv", "(ILjava/nio/IntBuffer;)V", (void *) android_glPointParameterxv__ILjava_nio_IntBuffer_2 }, 9274 {"glPointSizePointerOESBounds", "(IILjava/nio/Buffer;I)V", (void *) android_glPointSizePointerOESBounds__IILjava_nio_Buffer_2I }, 9275 {"glTexCoordPointer", "(IIII)V", (void *) android_glTexCoordPointer__IIII }, 9276 {"glTexEnvi", "(III)V", (void *) android_glTexEnvi__III }, 9277 {"glTexEnviv", "(II[II)V", (void *) android_glTexEnviv__II_3II }, 9278 {"glTexEnviv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexEnviv__IILjava_nio_IntBuffer_2 }, 9279 {"glTexParameterfv", "(II[FI)V", (void *) android_glTexParameterfv__II_3FI }, 9280 {"glTexParameterfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexParameterfv__IILjava_nio_FloatBuffer_2 }, 9281 {"glTexParameteri", "(III)V", (void *) android_glTexParameteri__III }, 9282 {"glTexParameteriv", "(II[II)V", (void *) android_glTexParameteriv__II_3II }, 9283 {"glTexParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameteriv__IILjava_nio_IntBuffer_2 }, 9284 {"glTexParameterxv", "(II[II)V", (void *) android_glTexParameterxv__II_3II }, 9285 {"glTexParameterxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameterxv__IILjava_nio_IntBuffer_2 }, 9286 {"glVertexPointer", "(IIII)V", (void *) android_glVertexPointer__IIII }, 9287 {"glCurrentPaletteMatrixOES", "(I)V", (void *) android_glCurrentPaletteMatrixOES__I }, 9288 {"glDrawTexfOES", "(FFFFF)V", (void *) android_glDrawTexfOES__FFFFF }, 9289 {"glDrawTexfvOES", "([FI)V", (void *) android_glDrawTexfvOES___3FI }, 9290 {"glDrawTexfvOES", "(Ljava/nio/FloatBuffer;)V", (void *) android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2 }, 9291 {"glDrawTexiOES", "(IIIII)V", (void *) android_glDrawTexiOES__IIIII }, 9292 {"glDrawTexivOES", "([II)V", (void *) android_glDrawTexivOES___3II }, 9293 {"glDrawTexivOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexivOES__Ljava_nio_IntBuffer_2 }, 9294 {"glDrawTexsOES", "(SSSSS)V", (void *) android_glDrawTexsOES__SSSSS }, 9295 {"glDrawTexsvOES", "([SI)V", (void *) android_glDrawTexsvOES___3SI }, 9296 {"glDrawTexsvOES", "(Ljava/nio/ShortBuffer;)V", (void *) android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2 }, 9297 {"glDrawTexxOES", "(IIIII)V", (void *) android_glDrawTexxOES__IIIII }, 9298 {"glDrawTexxvOES", "([II)V", (void *) android_glDrawTexxvOES___3II }, 9299 {"glDrawTexxvOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexxvOES__Ljava_nio_IntBuffer_2 }, 9300 {"glLoadPaletteFromModelViewMatrixOES", "()V", (void *) android_glLoadPaletteFromModelViewMatrixOES__ }, 9301 {"glMatrixIndexPointerOESBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I }, 9302 {"glMatrixIndexPointerOES", "(IIII)V", (void *) android_glMatrixIndexPointerOES__IIII }, 9303 {"glWeightPointerOESBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I }, 9304 {"glWeightPointerOES", "(IIII)V", (void *) android_glWeightPointerOES__IIII }, 9305 {"glBindFramebufferOES", "(II)V", (void *) android_glBindFramebufferOES__II }, 9306 {"glBindRenderbufferOES", "(II)V", (void *) android_glBindRenderbufferOES__II }, 9307 {"glBlendEquation", "(I)V", (void *) android_glBlendEquation__I }, 9308 {"glBlendEquationSeparate", "(II)V", (void *) android_glBlendEquationSeparate__II }, 9309 {"glBlendFuncSeparate", "(IIII)V", (void *) android_glBlendFuncSeparate__IIII }, 9310 {"glCheckFramebufferStatusOES", "(I)I", (void *) android_glCheckFramebufferStatusOES__I }, 9311 {"glDeleteFramebuffersOES", "(I[II)V", (void *) android_glDeleteFramebuffersOES__I_3II }, 9312 {"glDeleteFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2 }, 9313 {"glDeleteRenderbuffersOES", "(I[II)V", (void *) android_glDeleteRenderbuffersOES__I_3II }, 9314 {"glDeleteRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2 }, 9315 {"glFramebufferRenderbufferOES", "(IIII)V", (void *) android_glFramebufferRenderbufferOES__IIII }, 9316 {"glFramebufferTexture2DOES", "(IIIII)V", (void *) android_glFramebufferTexture2DOES__IIIII }, 9317 {"glGenerateMipmapOES", "(I)V", (void *) android_glGenerateMipmapOES__I }, 9318 {"glGenFramebuffersOES", "(I[II)V", (void *) android_glGenFramebuffersOES__I_3II }, 9319 {"glGenFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2 }, 9320 {"glGenRenderbuffersOES", "(I[II)V", (void *) android_glGenRenderbuffersOES__I_3II }, 9321 {"glGenRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2 }, 9322 {"glGetFramebufferAttachmentParameterivOES", "(III[II)V", (void *) android_glGetFramebufferAttachmentParameterivOES__III_3II }, 9323 {"glGetFramebufferAttachmentParameterivOES", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2 }, 9324 {"glGetRenderbufferParameterivOES", "(II[II)V", (void *) android_glGetRenderbufferParameterivOES__II_3II }, 9325 {"glGetRenderbufferParameterivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2 }, 9326 {"glGetTexGenfv", "(II[FI)V", (void *) android_glGetTexGenfv__II_3FI }, 9327 {"glGetTexGenfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetTexGenfv__IILjava_nio_FloatBuffer_2 }, 9328 {"glGetTexGeniv", "(II[II)V", (void *) android_glGetTexGeniv__II_3II }, 9329 {"glGetTexGeniv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGeniv__IILjava_nio_IntBuffer_2 }, 9330 {"glGetTexGenxv", "(II[II)V", (void *) android_glGetTexGenxv__II_3II }, 9331 {"glGetTexGenxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGenxv__IILjava_nio_IntBuffer_2 }, 9332 {"glIsFramebufferOES", "(I)Z", (void *) android_glIsFramebufferOES__I }, 9333 {"glIsRenderbufferOES", "(I)Z", (void *) android_glIsRenderbufferOES__I }, 9334 {"glRenderbufferStorageOES", "(IIII)V", (void *) android_glRenderbufferStorageOES__IIII }, 9335 {"glTexGenf", "(IIF)V", (void *) android_glTexGenf__IIF }, 9336 {"glTexGenfv", "(II[FI)V", (void *) android_glTexGenfv__II_3FI }, 9337 {"glTexGenfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexGenfv__IILjava_nio_FloatBuffer_2 }, 9338 {"glTexGeni", "(III)V", (void *) android_glTexGeni__III }, 9339 {"glTexGeniv", "(II[II)V", (void *) android_glTexGeniv__II_3II }, 9340 {"glTexGeniv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGeniv__IILjava_nio_IntBuffer_2 }, 9341 {"glTexGenx", "(III)V", (void *) android_glTexGenx__III }, 9342 {"glTexGenxv", "(II[II)V", (void *) android_glTexGenxv__II_3II }, 9343 {"glTexGenxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGenxv__IILjava_nio_IntBuffer_2 }, 9344 }; 9345 9346 int register_com_google_android_gles_jni_GLImpl(JNIEnv *_env) 9347 { 9348 int err; 9349 err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods)); 9350 return err; 9351 } 9352
