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