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