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 "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 */ 52extern "C" { 53GL_API void GL_APIENTRY glColorPointerBounds(GLint size, GLenum type, GLsizei stride, 54 const GLvoid *ptr, GLsizei count); 55GL_API void GL_APIENTRY glNormalPointerBounds(GLenum type, GLsizei stride, 56 const GLvoid *pointer, GLsizei count); 57GL_API void GL_APIENTRY glTexCoordPointerBounds(GLint size, GLenum type, 58 GLsizei stride, const GLvoid *pointer, GLsizei count); 59GL_API void GL_APIENTRY glVertexPointerBounds(GLint size, GLenum type, 60 GLsizei stride, const GLvoid *pointer, GLsizei count); 61GL_API void GL_APIENTRY glPointSizePointerOESBounds(GLenum type, 62 GLsizei stride, const GLvoid *pointer, GLsizei count); 63GL_API void GL_APIENTRY glMatrixIndexPointerOESBounds(GLint size, GLenum type, 64 GLsizei stride, const GLvoid *pointer, GLsizei count); 65GL_API void GL_APIENTRY glWeightPointerOESBounds(GLint size, GLenum type, 66 GLsizei stride, const GLvoid *pointer, GLsizei count); 67} 68 69static int initialized = 0; 70 71static jclass nioAccessClass; 72static jclass bufferClass; 73static jclass G11ImplClass; 74static jmethodID getBasePointerID; 75static jmethodID getBaseArrayID; 76static jmethodID getBaseArrayOffsetID; 77static jmethodID allowIndirectBuffersID; 78static jfieldID positionID; 79static jfieldID limitID; 80static jfieldID elementSizeShiftID; 81static jfieldID haveCheckedExtensionsID; 82static jfieldID have_OES_blend_equation_separateID; 83static jfieldID have_OES_blend_subtractID; 84static jfieldID have_OES_framebuffer_objectID; 85static jfieldID have_OES_texture_cube_mapID; 86 87/* Cache method IDs each time the class is loaded. */ 88 89static void 90nativeClassInit(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 120static void * 121getPointer(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 152static void 153releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit) 154{ 155 _env->ReleasePrimitiveArrayCritical(array, data, 156 commit ? 0 : JNI_ABORT); 157} 158 159extern "C" { 160extern char* __progname; 161} 162 163static bool 164allowIndirectBuffers(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 173static void * 174getDirectBufferPointer(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 201static int 202getNumCompressedTextureFormats() { 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 211static bool 212extensionEqual(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 227static const GLubyte* 228nextExtension(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 239static bool 240checkForExtension(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 249static bool 250supportsExtension(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 ) */ 268static void 269android_glActiveTexture__I 270 (JNIEnv *_env, jobject _this, jint texture) { 271 glActiveTexture( 272 (GLenum)texture 273 ); 274} 275 276/* void glAlphaFunc ( GLenum func, GLclampf ref ) */ 277static void 278android_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 ) */ 287static void 288android_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 ) */ 297static void 298android_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 ) */ 307static void 308android_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 ) */ 317static void 318android_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 ) */ 326static void 327android_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 ) */ 338static void 339android_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 ) */ 350static void 351android_glClearDepthf__F 352 (JNIEnv *_env, jobject _this, jfloat depth) { 353 glClearDepthf( 354 (GLclampf)depth 355 ); 356} 357 358/* void glClearDepthx ( GLclampx depth ) */ 359static void 360android_glClearDepthx__I 361 (JNIEnv *_env, jobject _this, jint depth) { 362 glClearDepthx( 363 (GLclampx)depth 364 ); 365} 366 367/* void glClearStencil ( GLint s ) */ 368static void 369android_glClearStencil__I 370 (JNIEnv *_env, jobject _this, jint s) { 371 glClearStencil( 372 (GLint)s 373 ); 374} 375 376/* void glClientActiveTexture ( GLenum texture ) */ 377static void 378android_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 ) */ 386static void 387android_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 ) */ 398static void 399android_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 ) */ 410static void 411android_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 ) */ 422static void 423android_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 ) */ 452static void 453android_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 485exit: 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 ) */ 495static void 496android_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 529exit: 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 ) */ 539static void 540android_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 ) */ 555static void 556android_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 ) */ 571static void 572android_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 ) */ 580static void 581android_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 618exit: 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 ) */ 629static void 630android_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 662exit: 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 ) */ 672static void 673android_glDepthFunc__I 674 (JNIEnv *_env, jobject _this, jint func) { 675 glDepthFunc( 676 (GLenum)func 677 ); 678} 679 680/* void glDepthMask ( GLboolean flag ) */ 681static void 682android_glDepthMask__Z 683 (JNIEnv *_env, jobject _this, jboolean flag) { 684 glDepthMask( 685 (GLboolean)flag 686 ); 687} 688 689/* void glDepthRangef ( GLclampf zNear, GLclampf zFar ) */ 690static void 691android_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 ) */ 700static void 701android_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 ) */ 710static void 711android_glDisable__I 712 (JNIEnv *_env, jobject _this, jint cap) { 713 glDisable( 714 (GLenum)cap 715 ); 716} 717 718/* void glDisableClientState ( GLenum array ) */ 719static void 720android_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 ) */ 728static void 729android_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 ) */ 739static void 740android_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 774exit: 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 ) */ 784static void 785android_glEnable__I 786 (JNIEnv *_env, jobject _this, jint cap) { 787 glEnable( 788 (GLenum)cap 789 ); 790} 791 792/* void glEnableClientState ( GLenum array ) */ 793static void 794android_glEnableClientState__I 795 (JNIEnv *_env, jobject _this, jint array) { 796 glEnableClientState( 797 (GLenum)array 798 ); 799} 800 801/* void glFinish ( void ) */ 802static void 803android_glFinish__ 804 (JNIEnv *_env, jobject _this) { 805 glFinish(); 806} 807 808/* void glFlush ( void ) */ 809static void 810android_glFlush__ 811 (JNIEnv *_env, jobject _this) { 812 glFlush(); 813} 814 815/* void glFogf ( GLenum pname, GLfloat param ) */ 816static void 817android_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 ) */ 826static void 827android_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 889exit: 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 ) */ 900static void 901android_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 958exit: 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 ) */ 968static void 969android_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 ) */ 978static void 979android_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 1041exit: 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 ) */ 1052static void 1053android_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 1110exit: 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 ) */ 1120static void 1121android_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 ) */ 1129static void 1130android_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 ) */ 1143static void 1144android_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 ) */ 1157static void 1158android_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 1195exit: 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 ) */ 1206static void 1207android_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 1239exit: 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 ) */ 1249static jint 1250android_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 ) */ 1258static void 1259android_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 1627exit: 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 ) */ 1638static void 1639android_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 2002exit: 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 ) */ 2012static 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 ) */ 2017static void 2018android_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 ) */ 2027static void 2028android_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 ) */ 2037static void 2038android_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 2091exit: 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 ) */ 2102static void 2103android_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 2151exit: 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 ) */ 2161static void 2162android_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 ) */ 2171static void 2172android_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 2225exit: 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 ) */ 2236static void 2237android_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 2285exit: 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 ) */ 2295static void 2296android_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 ) */ 2306static void 2307android_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 2387exit: 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 ) */ 2398static void 2399android_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 2474exit: 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 ) */ 2484static void 2485android_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 ) */ 2495static void 2496android_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 2576exit: 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 ) */ 2587static void 2588android_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 2663exit: 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 ) */ 2673static void 2674android_glLineWidth__F 2675 (JNIEnv *_env, jobject _this, jfloat width) { 2676 glLineWidth( 2677 (GLfloat)width 2678 ); 2679} 2680 2681/* void glLineWidthx ( GLfixed width ) */ 2682static void 2683android_glLineWidthx__I 2684 (JNIEnv *_env, jobject _this, jint width) { 2685 glLineWidthx( 2686 (GLfixed)width 2687 ); 2688} 2689 2690/* void glLoadIdentity ( void ) */ 2691static void 2692android_glLoadIdentity__ 2693 (JNIEnv *_env, jobject _this) { 2694 glLoadIdentity(); 2695} 2696 2697/* void glLoadMatrixf ( const GLfloat *m ) */ 2698static void 2699android_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 2729exit: 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 ) */ 2740static void 2741android_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 2766exit: 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 ) */ 2776static void 2777android_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 2807exit: 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 ) */ 2818static void 2819android_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 2844exit: 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 ) */ 2854static void 2855android_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 ) */ 2863static void 2864android_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 ) */ 2874static void 2875android_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 2941exit: 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 ) */ 2952static void 2953android_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 3014exit: 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 ) */ 3024static void 3025android_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 ) */ 3035static void 3036android_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 3102exit: 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 ) */ 3113static void 3114android_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 3175exit: 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 ) */ 3185static void 3186android_glMatrixMode__I 3187 (JNIEnv *_env, jobject _this, jint mode) { 3188 glMatrixMode( 3189 (GLenum)mode 3190 ); 3191} 3192 3193/* void glMultMatrixf ( const GLfloat *m ) */ 3194static void 3195android_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 3225exit: 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 ) */ 3236static void 3237android_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 3262exit: 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 ) */ 3272static void 3273android_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 3303exit: 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 ) */ 3314static void 3315android_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 3340exit: 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 ) */ 3350static void 3351android_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 ) */ 3363static void 3364android_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 ) */ 3376static void 3377android_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 ) */ 3387static void 3388android_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 ) */ 3398static void 3399android_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 ) */ 3427static void 3428android_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 ) */ 3441static void 3442android_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 ) */ 3455static void 3456android_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 ) */ 3465static void 3466android_glPointSize__F 3467 (JNIEnv *_env, jobject _this, jfloat size) { 3468 glPointSize( 3469 (GLfloat)size 3470 ); 3471} 3472 3473/* void glPointSizex ( GLfixed size ) */ 3474static void 3475android_glPointSizex__I 3476 (JNIEnv *_env, jobject _this, jint size) { 3477 glPointSizex( 3478 (GLfixed)size 3479 ); 3480} 3481 3482/* void glPolygonOffset ( GLfloat factor, GLfloat units ) */ 3483static void 3484android_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 ) */ 3493static void 3494android_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 ) */ 3503static void 3504android_glPopMatrix__ 3505 (JNIEnv *_env, jobject _this) { 3506 glPopMatrix(); 3507} 3508 3509/* void glPushMatrix ( void ) */ 3510static void 3511android_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 ) */ 3517static void 3518android_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 3549exit: 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 ) */ 3559static void 3560android_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 ) */ 3571static void 3572android_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 ) */ 3583static void 3584android_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 ) */ 3593static void 3594android_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 ) */ 3603static void 3604android_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 ) */ 3614static void 3615android_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 ) */ 3625static void 3626android_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 ) */ 3637static void 3638android_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 ) */ 3646static void 3647android_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 ) */ 3657static void 3658android_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 ) */ 3666static void 3667android_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 ) */ 3677static void 3678android_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 ) */ 3707static void 3708android_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 ) */ 3718static void 3719android_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 3779exit: 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 ) */ 3790static void 3791android_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 3846exit: 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 ) */ 3856static void 3857android_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 ) */ 3867static void 3868android_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 3928exit: 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 ) */ 3939static void 3940android_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 3995exit: 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 ) */ 4005static void 4006android_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 ) */ 4043static void 4044android_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 ) */ 4054static void 4055android_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 ) */ 4065static void 4066android_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 ) */ 4103static void 4104android_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 ) */ 4114static void 4115android_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 ) */ 4125static void 4126android_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 ) */ 4155static void 4156android_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 ) */ 4167static jint 4168android_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 4232exit: 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 ) */ 4248static jint 4249android_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 4303exit: 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 ) */ 4317static void 4318android_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 ) */ 4327static void 4328android_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 4358exit: 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 ) */ 4368static void 4369android_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 4403exit: 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 ) */ 4413static void 4414android_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 4451exit: 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 ) */ 4462static void 4463android_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 4495exit: 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 ) */ 4505static void 4506android_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 4543exit: 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 ) */ 4554static void 4555android_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 4587exit: 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 ) */ 4597static void 4598android_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 ) */ 4609static void 4610android_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 ) */ 4621static void 4622android_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 4659exit: 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 ) */ 4670static void 4671android_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 4703exit: 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 ) */ 4713static void 4714android_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 ) */ 4731static void 4732android_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 4769exit: 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 ) */ 4780static void 4781android_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 4813exit: 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 ) */ 4823static void 4824android_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 4855exit: 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 ) */ 4866static void 4867android_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 4893exit: 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 ) */ 4903static void 4904android_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 ) */ 4911static void 4912android_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 ) */ 4919static void 4920android_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 4951exit: 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 ) */ 4962static void 4963android_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 4989exit: 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 ) */ 4999static void 5000android_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 5031exit: 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 ) */ 5042static void 5043android_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 5069exit: 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 ) */ 5079static void 5080android_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 5111exit: 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 ) */ 5122static void 5123android_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 5149exit: 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 ) */ 5159static void 5160android_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 5191exit: 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 ) */ 5202static void 5203android_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 5229exit: 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 ) */ 5239static void 5240android_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 5320exit: 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 ) */ 5331static void 5332android_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 5407exit: 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 ) */ 5417static void 5418android_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 5498exit: 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 ) */ 5509static void 5510android_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 5585exit: 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 ) */ 5595static void 5596android_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 5662exit: 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 ) */ 5673static void 5674android_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 5735exit: 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 ) */ 5745static void 5746android_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 5812exit: 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 ) */ 5823static void 5824android_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 5885exit: 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 ) */ 5895static void 5896android_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 5956exit: 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 ) */ 5967static void 5968android_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 6023exit: 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 ) */ 6033static void 6034android_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 6094exit: 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 ) */ 6105static void 6106android_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 6161exit: 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 ) */ 6171static void 6172android_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 6210exit: 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 ) */ 6221static void 6222android_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 6255exit: 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 ) */ 6265static void 6266android_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 6304exit: 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 ) */ 6315static void 6316android_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 6349exit: 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 ) */ 6359static void 6360android_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 6398exit: 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 ) */ 6409static void 6410android_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 6443exit: 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 ) */ 6453static jboolean 6454android_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 ) */ 6464static jboolean 6465android_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 ) */ 6475static jboolean 6476android_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 ) */ 6486static void 6487android_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 ) */ 6497static void 6498android_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 ) */ 6507static void 6508android_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 6545exit: 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 ) */ 6556static void 6557android_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 6589exit: 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 ) */ 6599static void 6600android_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 ) */ 6609static void 6610android_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 6647exit: 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 ) */ 6658static void 6659android_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 6691exit: 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 ) */ 6701static void 6702android_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 ) */ 6730static void 6731android_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 ) */ 6742static void 6743android_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 ) */ 6753static void 6754android_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 6814exit: 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 ) */ 6825static void 6826android_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 6881exit: 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 ) */ 6891static void 6892android_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 6930exit: 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 ) */ 6941static void 6942android_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 6975exit: 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 ) */ 6985static void 6986android_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 ) */ 6996static void 6997android_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 7035exit: 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 ) */ 7046static void 7047android_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 7080exit: 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 ) */ 7090static void 7091android_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 7129exit: 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 ) */ 7140static void 7141android_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 7174exit: 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 ) */ 7184static void 7185android_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 ) */ 7196static void 7197android_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 ) */ 7205static void 7206android_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 ) */ 7218static void 7219android_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 7255exit: 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 ) */ 7266static void 7267android_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 7298exit: 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 ) */ 7308static void 7309android_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 ) */ 7321static void 7322android_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 7358exit: 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 ) */ 7369static void 7370android_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 7401exit: 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 ) */ 7411static void 7412android_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 ) */ 7424static void 7425android_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 7461exit: 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 ) */ 7472static void 7473android_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 7504exit: 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 ) */ 7514static void 7515android_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 ) */ 7527static void 7528android_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 7564exit: 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 ) */ 7575static void 7576android_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 7607exit: 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 ) */ 7617static void 7618android_glLoadPaletteFromModelViewMatrixOES__ 7619 (JNIEnv *_env, jobject _this) { 7620 glLoadPaletteFromModelViewMatrixOES(); 7621} 7622 7623/* void glMatrixIndexPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */ 7624static void 7625android_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 ) */ 7654static void 7655android_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 ) */ 7666static void 7667android_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 ) */ 7696static void 7697android_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 ) */ 7708static void 7709android_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 ) */ 7723static void 7724android_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 ) */ 7738static void 7739android_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 ) */ 7752static void 7753android_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 ) */ 7767static void 7768android_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 ) */ 7784static jint 7785android_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 ) */ 7800static void 7801android_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 7843exit: 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 ) */ 7854static void 7855android_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 7892exit: 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 ) */ 7902static void 7903android_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 7945exit: 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 ) */ 7956static void 7957android_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 7994exit: 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 ) */ 8004static void 8005android_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 ) */ 8021static void 8022android_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 ) */ 8039static void 8040android_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 ) */ 8053static void 8054android_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 8096exit: 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 ) */ 8107static void 8108android_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 8145exit: 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 ) */ 8155static void 8156android_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 8198exit: 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 ) */ 8209static void 8210android_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 8247exit: 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 ) */ 8257static void 8258android_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 8296exit: 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 ) */ 8307static void 8308android_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 8341exit: 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 ) */ 8351static void 8352android_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 8389exit: 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 ) */ 8400static void 8401android_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 8433exit: 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 ) */ 8443static void 8444android_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 8481exit: 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 ) */ 8492static void 8493android_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 8525exit: 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 ) */ 8535static void 8536android_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 8573exit: 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 ) */ 8584static void 8585android_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 8617exit: 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 ) */ 8627static void 8628android_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 8665exit: 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 ) */ 8676static void 8677android_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 8709exit: 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 ) */ 8719static jboolean 8720android_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 ) */ 8735static jboolean 8736android_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 ) */ 8751static void 8752android_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 ) */ 8768static void 8769android_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 ) */ 8784static void 8785android_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 8822exit: 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 ) */ 8833static void 8834android_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 8866exit: 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 ) */ 8876static void 8877android_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 ) */ 8892static void 8893android_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 8930exit: 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 ) */ 8941static void 8942android_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 8974exit: 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 ) */ 8984static void 8985android_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 ) */ 9000static void 9001android_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 9038exit: 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 ) */ 9049static void 9050android_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 9082exit: 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 9091static const char *classPathName = "com/google/android/gles_jni/GLImpl"; 9092 9093static 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 9346int 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