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 "jni.h" 21 #include "JNIHelp.h" 22 #include <android_runtime/AndroidRuntime.h> 23 #include <utils/misc.h> 24 25 #include <assert.h> 26 #include <GLES/gl.h> 27 #include <GLES/glext.h> 28 29 /* special calls implemented in Android's GLES wrapper used to more 30 * efficiently bound-check passed arrays */ 31 extern "C" { 32 GL_API void GL_APIENTRY glMatrixIndexPointerOESBounds(GLint size, GLenum type, GLsizei stride, 33 const GLvoid *ptr, GLsizei count); 34 GL_API void GL_APIENTRY glWeightPointerOESBounds(GLint size, GLenum type, GLsizei stride, 35 const GLvoid *ptr, GLsizei count); 36 } 37 38 static int initialized = 0; 39 40 static jclass nioAccessClass; 41 static jclass bufferClass; 42 static jmethodID getBasePointerID; 43 static jmethodID getBaseArrayID; 44 static jmethodID getBaseArrayOffsetID; 45 static jfieldID positionID; 46 static jfieldID limitID; 47 static jfieldID elementSizeShiftID; 48 49 /* Cache method IDs each time the class is loaded. */ 50 51 static void 52 nativeClassInit(JNIEnv *_env, jclass glImplClass) 53 { 54 jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess"); 55 nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal); 56 57 jclass bufferClassLocal = _env->FindClass("java/nio/Buffer"); 58 bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal); 59 60 getBasePointerID = _env->GetStaticMethodID(nioAccessClass, 61 "getBasePointer", "(Ljava/nio/Buffer;)J"); 62 getBaseArrayID = _env->GetStaticMethodID(nioAccessClass, 63 "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;"); 64 getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass, 65 "getBaseArrayOffset", "(Ljava/nio/Buffer;)I"); 66 67 positionID = _env->GetFieldID(bufferClass, "position", "I"); 68 limitID = _env->GetFieldID(bufferClass, "limit", "I"); 69 elementSizeShiftID = 70 _env->GetFieldID(bufferClass, "_elementSizeShift", "I"); 71 } 72 73 74 static void * 75 getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining) 76 { 77 jint position; 78 jint limit; 79 jint elementSizeShift; 80 jlong pointer; 81 jint offset; 82 void *data; 83 84 position = _env->GetIntField(buffer, positionID); 85 limit = _env->GetIntField(buffer, limitID); 86 elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID); 87 *remaining = (limit - position) << elementSizeShift; 88 pointer = _env->CallStaticLongMethod(nioAccessClass, 89 getBasePointerID, buffer); 90 if (pointer != 0L) { 91 *array = NULL; 92 return (void *) (jint) pointer; 93 } 94 95 *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass, 96 getBaseArrayID, buffer); 97 offset = _env->CallStaticIntMethod(nioAccessClass, 98 getBaseArrayOffsetID, buffer); 99 data = _env->GetPrimitiveArrayCritical(*array, (jboolean *) 0); 100 101 return (void *) ((char *) data + offset); 102 } 103 104 105 static void 106 releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit) 107 { 108 _env->ReleasePrimitiveArrayCritical(array, data, 109 commit ? 0 : JNI_ABORT); 110 } 111 112 static void * 113 getDirectBufferPointer(JNIEnv *_env, jobject buffer) { 114 char* buf = (char*) _env->GetDirectBufferAddress(buffer); 115 if (buf) { 116 jint position = _env->GetIntField(buffer, positionID); 117 jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID); 118 buf += position << elementSizeShift; 119 } else { 120 jniThrowException(_env, "java/lang/IllegalArgumentException", 121 "Must use a native order direct Buffer"); 122 } 123 return (void*) buf; 124 } 125 // -------------------------------------------------------------------------- 126 /* void glBlendEquationSeparateOES ( GLenum modeRGB, GLenum modeAlpha ) */ 127 static void 128 android_glBlendEquationSeparateOES__II 129 (JNIEnv *_env, jobject _this, jint modeRGB, jint modeAlpha) { 130 glBlendEquationSeparateOES( 131 (GLenum)modeRGB, 132 (GLenum)modeAlpha 133 ); 134 } 135 136 /* void glBlendFuncSeparateOES ( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) */ 137 static void 138 android_glBlendFuncSeparateOES__IIII 139 (JNIEnv *_env, jobject _this, jint srcRGB, jint dstRGB, jint srcAlpha, jint dstAlpha) { 140 glBlendFuncSeparateOES( 141 (GLenum)srcRGB, 142 (GLenum)dstRGB, 143 (GLenum)srcAlpha, 144 (GLenum)dstAlpha 145 ); 146 } 147 148 /* void glBlendEquationOES ( GLenum mode ) */ 149 static void 150 android_glBlendEquationOES__I 151 (JNIEnv *_env, jobject _this, jint mode) { 152 glBlendEquationOES( 153 (GLenum)mode 154 ); 155 } 156 157 /* void glDrawTexsOES ( GLshort x, GLshort y, GLshort z, GLshort width, GLshort height ) */ 158 static void 159 android_glDrawTexsOES__SSSSS 160 (JNIEnv *_env, jobject _this, jshort x, jshort y, jshort z, jshort width, jshort height) { 161 glDrawTexsOES( 162 (GLshort)x, 163 (GLshort)y, 164 (GLshort)z, 165 (GLshort)width, 166 (GLshort)height 167 ); 168 } 169 170 /* void glDrawTexiOES ( GLint x, GLint y, GLint z, GLint width, GLint height ) */ 171 static void 172 android_glDrawTexiOES__IIIII 173 (JNIEnv *_env, jobject _this, jint x, jint y, jint z, jint width, jint height) { 174 glDrawTexiOES( 175 (GLint)x, 176 (GLint)y, 177 (GLint)z, 178 (GLint)width, 179 (GLint)height 180 ); 181 } 182 183 /* void glDrawTexxOES ( GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height ) */ 184 static void 185 android_glDrawTexxOES__IIIII 186 (JNIEnv *_env, jobject _this, jint x, jint y, jint z, jint width, jint height) { 187 glDrawTexxOES( 188 (GLfixed)x, 189 (GLfixed)y, 190 (GLfixed)z, 191 (GLfixed)width, 192 (GLfixed)height 193 ); 194 } 195 196 /* void glDrawTexsvOES ( const GLshort *coords ) */ 197 static void 198 android_glDrawTexsvOES___3SI 199 (JNIEnv *_env, jobject _this, jshortArray coords_ref, jint offset) { 200 GLshort *coords_base = (GLshort *) 0; 201 jint _remaining; 202 GLshort *coords = (GLshort *) 0; 203 204 if (!coords_ref) { 205 jniThrowException(_env, "java/lang/IllegalArgumentException", "coords == null"); 206 goto exit; 207 } 208 if (offset < 0) { 209 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 210 goto exit; 211 } 212 _remaining = _env->GetArrayLength(coords_ref) - offset; 213 if (_remaining < 5) { 214 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < 5"); 215 goto exit; 216 } 217 coords_base = (GLshort *) 218 _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0); 219 coords = coords_base + offset; 220 221 glDrawTexsvOES( 222 (GLshort *)coords 223 ); 224 225 exit: 226 if (coords_base) { 227 _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base, 228 JNI_ABORT); 229 } 230 } 231 232 /* void glDrawTexsvOES ( const GLshort *coords ) */ 233 static void 234 android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2 235 (JNIEnv *_env, jobject _this, jobject coords_buf) { 236 jarray _array = (jarray) 0; 237 jint _remaining; 238 GLshort *coords = (GLshort *) 0; 239 240 coords = (GLshort *)getPointer(_env, coords_buf, &_array, &_remaining); 241 if (_remaining < 5) { 242 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < 5"); 243 goto exit; 244 } 245 glDrawTexsvOES( 246 (GLshort *)coords 247 ); 248 249 exit: 250 if (_array) { 251 releasePointer(_env, _array, coords, JNI_FALSE); 252 } 253 } 254 255 /* void glDrawTexivOES ( const GLint *coords ) */ 256 static void 257 android_glDrawTexivOES___3II 258 (JNIEnv *_env, jobject _this, jintArray coords_ref, jint offset) { 259 GLint *coords_base = (GLint *) 0; 260 jint _remaining; 261 GLint *coords = (GLint *) 0; 262 263 if (!coords_ref) { 264 jniThrowException(_env, "java/lang/IllegalArgumentException", "coords == null"); 265 goto exit; 266 } 267 if (offset < 0) { 268 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 269 goto exit; 270 } 271 _remaining = _env->GetArrayLength(coords_ref) - offset; 272 if (_remaining < 5) { 273 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < 5"); 274 goto exit; 275 } 276 coords_base = (GLint *) 277 _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0); 278 coords = coords_base + offset; 279 280 glDrawTexivOES( 281 (GLint *)coords 282 ); 283 284 exit: 285 if (coords_base) { 286 _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base, 287 JNI_ABORT); 288 } 289 } 290 291 /* void glDrawTexivOES ( const GLint *coords ) */ 292 static void 293 android_glDrawTexivOES__Ljava_nio_IntBuffer_2 294 (JNIEnv *_env, jobject _this, jobject coords_buf) { 295 jarray _array = (jarray) 0; 296 jint _remaining; 297 GLint *coords = (GLint *) 0; 298 299 coords = (GLint *)getPointer(_env, coords_buf, &_array, &_remaining); 300 if (_remaining < 5) { 301 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < 5"); 302 goto exit; 303 } 304 glDrawTexivOES( 305 (GLint *)coords 306 ); 307 308 exit: 309 if (_array) { 310 releasePointer(_env, _array, coords, JNI_FALSE); 311 } 312 } 313 314 /* void glDrawTexxvOES ( const GLfixed *coords ) */ 315 static void 316 android_glDrawTexxvOES___3II 317 (JNIEnv *_env, jobject _this, jintArray coords_ref, jint offset) { 318 GLfixed *coords_base = (GLfixed *) 0; 319 jint _remaining; 320 GLfixed *coords = (GLfixed *) 0; 321 322 if (!coords_ref) { 323 jniThrowException(_env, "java/lang/IllegalArgumentException", "coords == null"); 324 goto exit; 325 } 326 if (offset < 0) { 327 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 328 goto exit; 329 } 330 _remaining = _env->GetArrayLength(coords_ref) - offset; 331 if (_remaining < 5) { 332 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < 5"); 333 goto exit; 334 } 335 coords_base = (GLfixed *) 336 _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0); 337 coords = coords_base + offset; 338 339 glDrawTexxvOES( 340 (GLfixed *)coords 341 ); 342 343 exit: 344 if (coords_base) { 345 _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base, 346 JNI_ABORT); 347 } 348 } 349 350 /* void glDrawTexxvOES ( const GLfixed *coords ) */ 351 static void 352 android_glDrawTexxvOES__Ljava_nio_IntBuffer_2 353 (JNIEnv *_env, jobject _this, jobject coords_buf) { 354 jarray _array = (jarray) 0; 355 jint _remaining; 356 GLfixed *coords = (GLfixed *) 0; 357 358 coords = (GLfixed *)getPointer(_env, coords_buf, &_array, &_remaining); 359 if (_remaining < 5) { 360 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < 5"); 361 goto exit; 362 } 363 glDrawTexxvOES( 364 (GLfixed *)coords 365 ); 366 367 exit: 368 if (_array) { 369 releasePointer(_env, _array, coords, JNI_FALSE); 370 } 371 } 372 373 /* void glDrawTexfOES ( GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height ) */ 374 static void 375 android_glDrawTexfOES__FFFFF 376 (JNIEnv *_env, jobject _this, jfloat x, jfloat y, jfloat z, jfloat width, jfloat height) { 377 glDrawTexfOES( 378 (GLfloat)x, 379 (GLfloat)y, 380 (GLfloat)z, 381 (GLfloat)width, 382 (GLfloat)height 383 ); 384 } 385 386 /* void glDrawTexfvOES ( const GLfloat *coords ) */ 387 static void 388 android_glDrawTexfvOES___3FI 389 (JNIEnv *_env, jobject _this, jfloatArray coords_ref, jint offset) { 390 GLfloat *coords_base = (GLfloat *) 0; 391 jint _remaining; 392 GLfloat *coords = (GLfloat *) 0; 393 394 if (!coords_ref) { 395 jniThrowException(_env, "java/lang/IllegalArgumentException", "coords == null"); 396 goto exit; 397 } 398 if (offset < 0) { 399 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 400 goto exit; 401 } 402 _remaining = _env->GetArrayLength(coords_ref) - offset; 403 if (_remaining < 5) { 404 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < 5"); 405 goto exit; 406 } 407 coords_base = (GLfloat *) 408 _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0); 409 coords = coords_base + offset; 410 411 glDrawTexfvOES( 412 (GLfloat *)coords 413 ); 414 415 exit: 416 if (coords_base) { 417 _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base, 418 JNI_ABORT); 419 } 420 } 421 422 /* void glDrawTexfvOES ( const GLfloat *coords ) */ 423 static void 424 android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2 425 (JNIEnv *_env, jobject _this, jobject coords_buf) { 426 jarray _array = (jarray) 0; 427 jint _remaining; 428 GLfloat *coords = (GLfloat *) 0; 429 430 coords = (GLfloat *)getPointer(_env, coords_buf, &_array, &_remaining); 431 if (_remaining < 5) { 432 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < 5"); 433 goto exit; 434 } 435 glDrawTexfvOES( 436 (GLfloat *)coords 437 ); 438 439 exit: 440 if (_array) { 441 releasePointer(_env, _array, coords, JNI_FALSE); 442 } 443 } 444 445 /* void glEGLImageTargetTexture2DOES ( GLenum target, GLeglImageOES image ) */ 446 static void 447 android_glEGLImageTargetTexture2DOES__ILjava_nio_Buffer_2 448 (JNIEnv *_env, jobject _this, jint target, jobject image_buf) { 449 jint _exception = 0; 450 jarray _array = (jarray) 0; 451 jint _remaining; 452 GLeglImageOES image = (GLeglImageOES) 0; 453 454 image = (GLeglImageOES)getPointer(_env, image_buf, &_array, &_remaining); 455 glEGLImageTargetTexture2DOES( 456 (GLenum)target, 457 (GLeglImageOES)image 458 ); 459 if (_array) { 460 releasePointer(_env, _array, image, _exception ? JNI_FALSE : JNI_TRUE); 461 } 462 } 463 464 /* void glEGLImageTargetRenderbufferStorageOES ( GLenum target, GLeglImageOES image ) */ 465 static void 466 android_glEGLImageTargetRenderbufferStorageOES__ILjava_nio_Buffer_2 467 (JNIEnv *_env, jobject _this, jint target, jobject image_buf) { 468 jint _exception = 0; 469 jarray _array = (jarray) 0; 470 jint _remaining; 471 GLeglImageOES image = (GLeglImageOES) 0; 472 473 image = (GLeglImageOES)getPointer(_env, image_buf, &_array, &_remaining); 474 glEGLImageTargetRenderbufferStorageOES( 475 (GLenum)target, 476 (GLeglImageOES)image 477 ); 478 if (_array) { 479 releasePointer(_env, _array, image, _exception ? JNI_FALSE : JNI_TRUE); 480 } 481 } 482 483 /* void glAlphaFuncxOES ( GLenum func, GLclampx ref ) */ 484 static void 485 android_glAlphaFuncxOES__II 486 (JNIEnv *_env, jobject _this, jint func, jint ref) { 487 glAlphaFuncxOES( 488 (GLenum)func, 489 (GLclampx)ref 490 ); 491 } 492 493 /* void glClearColorxOES ( GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha ) */ 494 static void 495 android_glClearColorxOES__IIII 496 (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) { 497 glClearColorxOES( 498 (GLclampx)red, 499 (GLclampx)green, 500 (GLclampx)blue, 501 (GLclampx)alpha 502 ); 503 } 504 505 /* void glClearDepthxOES ( GLclampx depth ) */ 506 static void 507 android_glClearDepthxOES__I 508 (JNIEnv *_env, jobject _this, jint depth) { 509 glClearDepthxOES( 510 (GLclampx)depth 511 ); 512 } 513 514 /* void glClipPlanexOES ( GLenum plane, const GLfixed *equation ) */ 515 static void 516 android_glClipPlanexOES__I_3II 517 (JNIEnv *_env, jobject _this, jint plane, jintArray equation_ref, jint offset) { 518 GLfixed *equation_base = (GLfixed *) 0; 519 jint _remaining; 520 GLfixed *equation = (GLfixed *) 0; 521 522 if (!equation_ref) { 523 jniThrowException(_env, "java/lang/IllegalArgumentException", "equation == null"); 524 goto exit; 525 } 526 if (offset < 0) { 527 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 528 goto exit; 529 } 530 _remaining = _env->GetArrayLength(equation_ref) - offset; 531 equation_base = (GLfixed *) 532 _env->GetPrimitiveArrayCritical(equation_ref, (jboolean *)0); 533 equation = equation_base + offset; 534 535 glClipPlanexOES( 536 (GLenum)plane, 537 (GLfixed *)equation 538 ); 539 540 exit: 541 if (equation_base) { 542 _env->ReleasePrimitiveArrayCritical(equation_ref, equation_base, 543 JNI_ABORT); 544 } 545 } 546 547 /* void glClipPlanexOES ( GLenum plane, const GLfixed *equation ) */ 548 static void 549 android_glClipPlanexOES__ILjava_nio_IntBuffer_2 550 (JNIEnv *_env, jobject _this, jint plane, jobject equation_buf) { 551 jarray _array = (jarray) 0; 552 jint _remaining; 553 GLfixed *equation = (GLfixed *) 0; 554 555 equation = (GLfixed *)getPointer(_env, equation_buf, &_array, &_remaining); 556 glClipPlanexOES( 557 (GLenum)plane, 558 (GLfixed *)equation 559 ); 560 if (_array) { 561 releasePointer(_env, _array, equation, JNI_FALSE); 562 } 563 } 564 565 /* void glColor4xOES ( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) */ 566 static void 567 android_glColor4xOES__IIII 568 (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) { 569 glColor4xOES( 570 (GLfixed)red, 571 (GLfixed)green, 572 (GLfixed)blue, 573 (GLfixed)alpha 574 ); 575 } 576 577 /* void glDepthRangexOES ( GLclampx zNear, GLclampx zFar ) */ 578 static void 579 android_glDepthRangexOES__II 580 (JNIEnv *_env, jobject _this, jint zNear, jint zFar) { 581 glDepthRangexOES( 582 (GLclampx)zNear, 583 (GLclampx)zFar 584 ); 585 } 586 587 /* void glFogxOES ( GLenum pname, GLfixed param ) */ 588 static void 589 android_glFogxOES__II 590 (JNIEnv *_env, jobject _this, jint pname, jint param) { 591 glFogxOES( 592 (GLenum)pname, 593 (GLfixed)param 594 ); 595 } 596 597 /* void glFogxvOES ( GLenum pname, const GLfixed *params ) */ 598 static void 599 android_glFogxvOES__I_3II 600 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) { 601 GLfixed *params_base = (GLfixed *) 0; 602 jint _remaining; 603 GLfixed *params = (GLfixed *) 0; 604 605 if (!params_ref) { 606 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 607 goto exit; 608 } 609 if (offset < 0) { 610 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 611 goto exit; 612 } 613 _remaining = _env->GetArrayLength(params_ref) - offset; 614 params_base = (GLfixed *) 615 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 616 params = params_base + offset; 617 618 glFogxvOES( 619 (GLenum)pname, 620 (GLfixed *)params 621 ); 622 623 exit: 624 if (params_base) { 625 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 626 JNI_ABORT); 627 } 628 } 629 630 /* void glFogxvOES ( GLenum pname, const GLfixed *params ) */ 631 static void 632 android_glFogxvOES__ILjava_nio_IntBuffer_2 633 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 634 jarray _array = (jarray) 0; 635 jint _remaining; 636 GLfixed *params = (GLfixed *) 0; 637 638 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); 639 glFogxvOES( 640 (GLenum)pname, 641 (GLfixed *)params 642 ); 643 if (_array) { 644 releasePointer(_env, _array, params, JNI_FALSE); 645 } 646 } 647 648 /* void glFrustumxOES ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */ 649 static void 650 android_glFrustumxOES__IIIIII 651 (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) { 652 glFrustumxOES( 653 (GLfixed)left, 654 (GLfixed)right, 655 (GLfixed)bottom, 656 (GLfixed)top, 657 (GLfixed)zNear, 658 (GLfixed)zFar 659 ); 660 } 661 662 /* void glGetClipPlanexOES ( GLenum pname, GLfixed *eqn ) */ 663 static void 664 android_glGetClipPlanexOES__I_3II 665 (JNIEnv *_env, jobject _this, jint pname, jintArray eqn_ref, jint offset) { 666 jint _exception = 0; 667 GLfixed *eqn_base = (GLfixed *) 0; 668 jint _remaining; 669 GLfixed *eqn = (GLfixed *) 0; 670 671 if (!eqn_ref) { 672 _exception = 1; 673 jniThrowException(_env, "java/lang/IllegalArgumentException", "eqn == null"); 674 goto exit; 675 } 676 if (offset < 0) { 677 _exception = 1; 678 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 679 goto exit; 680 } 681 _remaining = _env->GetArrayLength(eqn_ref) - offset; 682 if (_remaining < 4) { 683 _exception = 1; 684 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < 4"); 685 goto exit; 686 } 687 eqn_base = (GLfixed *) 688 _env->GetPrimitiveArrayCritical(eqn_ref, (jboolean *)0); 689 eqn = eqn_base + offset; 690 691 glGetClipPlanexOES( 692 (GLenum)pname, 693 (GLfixed *)eqn 694 ); 695 696 exit: 697 if (eqn_base) { 698 _env->ReleasePrimitiveArrayCritical(eqn_ref, eqn_base, 699 _exception ? JNI_ABORT: 0); 700 } 701 } 702 703 /* void glGetClipPlanexOES ( GLenum pname, GLfixed *eqn ) */ 704 static void 705 android_glGetClipPlanexOES__ILjava_nio_IntBuffer_2 706 (JNIEnv *_env, jobject _this, jint pname, jobject eqn_buf) { 707 jint _exception = 0; 708 jarray _array = (jarray) 0; 709 jint _remaining; 710 GLfixed *eqn = (GLfixed *) 0; 711 712 eqn = (GLfixed *)getPointer(_env, eqn_buf, &_array, &_remaining); 713 if (_remaining < 4) { 714 _exception = 1; 715 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < 4"); 716 goto exit; 717 } 718 glGetClipPlanexOES( 719 (GLenum)pname, 720 (GLfixed *)eqn 721 ); 722 723 exit: 724 if (_array) { 725 releasePointer(_env, _array, eqn, _exception ? JNI_FALSE : JNI_TRUE); 726 } 727 } 728 729 /* void glGetFixedvOES ( GLenum pname, GLfixed *params ) */ 730 static void 731 android_glGetFixedvOES__I_3II 732 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) { 733 jint _exception = 0; 734 GLfixed *params_base = (GLfixed *) 0; 735 jint _remaining; 736 GLfixed *params = (GLfixed *) 0; 737 738 if (!params_ref) { 739 _exception = 1; 740 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 741 goto exit; 742 } 743 if (offset < 0) { 744 _exception = 1; 745 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 746 goto exit; 747 } 748 _remaining = _env->GetArrayLength(params_ref) - offset; 749 params_base = (GLfixed *) 750 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 751 params = params_base + offset; 752 753 glGetFixedvOES( 754 (GLenum)pname, 755 (GLfixed *)params 756 ); 757 758 exit: 759 if (params_base) { 760 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 761 _exception ? JNI_ABORT: 0); 762 } 763 } 764 765 /* void glGetFixedvOES ( GLenum pname, GLfixed *params ) */ 766 static void 767 android_glGetFixedvOES__ILjava_nio_IntBuffer_2 768 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 769 jint _exception = 0; 770 jarray _array = (jarray) 0; 771 jint _remaining; 772 GLfixed *params = (GLfixed *) 0; 773 774 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); 775 glGetFixedvOES( 776 (GLenum)pname, 777 (GLfixed *)params 778 ); 779 if (_array) { 780 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); 781 } 782 } 783 784 /* void glGetLightxvOES ( GLenum light, GLenum pname, GLfixed *params ) */ 785 static void 786 android_glGetLightxvOES__II_3II 787 (JNIEnv *_env, jobject _this, jint light, jint pname, jintArray params_ref, jint offset) { 788 jint _exception = 0; 789 GLfixed *params_base = (GLfixed *) 0; 790 jint _remaining; 791 GLfixed *params = (GLfixed *) 0; 792 793 if (!params_ref) { 794 _exception = 1; 795 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 796 goto exit; 797 } 798 if (offset < 0) { 799 _exception = 1; 800 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 801 goto exit; 802 } 803 _remaining = _env->GetArrayLength(params_ref) - offset; 804 params_base = (GLfixed *) 805 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 806 params = params_base + offset; 807 808 glGetLightxvOES( 809 (GLenum)light, 810 (GLenum)pname, 811 (GLfixed *)params 812 ); 813 814 exit: 815 if (params_base) { 816 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 817 _exception ? JNI_ABORT: 0); 818 } 819 } 820 821 /* void glGetLightxvOES ( GLenum light, GLenum pname, GLfixed *params ) */ 822 static void 823 android_glGetLightxvOES__IILjava_nio_IntBuffer_2 824 (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) { 825 jint _exception = 0; 826 jarray _array = (jarray) 0; 827 jint _remaining; 828 GLfixed *params = (GLfixed *) 0; 829 830 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); 831 glGetLightxvOES( 832 (GLenum)light, 833 (GLenum)pname, 834 (GLfixed *)params 835 ); 836 if (_array) { 837 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); 838 } 839 } 840 841 /* void glGetMaterialxvOES ( GLenum face, GLenum pname, GLfixed *params ) */ 842 static void 843 android_glGetMaterialxvOES__II_3II 844 (JNIEnv *_env, jobject _this, jint face, jint pname, jintArray params_ref, jint offset) { 845 jint _exception = 0; 846 GLfixed *params_base = (GLfixed *) 0; 847 jint _remaining; 848 GLfixed *params = (GLfixed *) 0; 849 850 if (!params_ref) { 851 _exception = 1; 852 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 853 goto exit; 854 } 855 if (offset < 0) { 856 _exception = 1; 857 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 858 goto exit; 859 } 860 _remaining = _env->GetArrayLength(params_ref) - offset; 861 params_base = (GLfixed *) 862 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 863 params = params_base + offset; 864 865 glGetMaterialxvOES( 866 (GLenum)face, 867 (GLenum)pname, 868 (GLfixed *)params 869 ); 870 871 exit: 872 if (params_base) { 873 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 874 _exception ? JNI_ABORT: 0); 875 } 876 } 877 878 /* void glGetMaterialxvOES ( GLenum face, GLenum pname, GLfixed *params ) */ 879 static void 880 android_glGetMaterialxvOES__IILjava_nio_IntBuffer_2 881 (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) { 882 jint _exception = 0; 883 jarray _array = (jarray) 0; 884 jint _remaining; 885 GLfixed *params = (GLfixed *) 0; 886 887 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); 888 glGetMaterialxvOES( 889 (GLenum)face, 890 (GLenum)pname, 891 (GLfixed *)params 892 ); 893 if (_array) { 894 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); 895 } 896 } 897 898 /* void glGetTexEnvxvOES ( GLenum env, GLenum pname, GLfixed *params ) */ 899 static void 900 android_glGetTexEnvxvOES__II_3II 901 (JNIEnv *_env, jobject _this, jint env, jint pname, jintArray params_ref, jint offset) { 902 jint _exception = 0; 903 GLfixed *params_base = (GLfixed *) 0; 904 jint _remaining; 905 GLfixed *params = (GLfixed *) 0; 906 907 if (!params_ref) { 908 _exception = 1; 909 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 910 goto exit; 911 } 912 if (offset < 0) { 913 _exception = 1; 914 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 915 goto exit; 916 } 917 _remaining = _env->GetArrayLength(params_ref) - offset; 918 params_base = (GLfixed *) 919 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 920 params = params_base + offset; 921 922 glGetTexEnvxvOES( 923 (GLenum)env, 924 (GLenum)pname, 925 (GLfixed *)params 926 ); 927 928 exit: 929 if (params_base) { 930 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 931 _exception ? JNI_ABORT: 0); 932 } 933 } 934 935 /* void glGetTexEnvxvOES ( GLenum env, GLenum pname, GLfixed *params ) */ 936 static void 937 android_glGetTexEnvxvOES__IILjava_nio_IntBuffer_2 938 (JNIEnv *_env, jobject _this, jint env, jint pname, jobject params_buf) { 939 jint _exception = 0; 940 jarray _array = (jarray) 0; 941 jint _remaining; 942 GLfixed *params = (GLfixed *) 0; 943 944 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); 945 glGetTexEnvxvOES( 946 (GLenum)env, 947 (GLenum)pname, 948 (GLfixed *)params 949 ); 950 if (_array) { 951 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); 952 } 953 } 954 955 /* void glGetTexParameterxvOES ( GLenum target, GLenum pname, GLfixed *params ) */ 956 static void 957 android_glGetTexParameterxvOES__II_3II 958 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 959 jint _exception = 0; 960 GLfixed *params_base = (GLfixed *) 0; 961 jint _remaining; 962 GLfixed *params = (GLfixed *) 0; 963 964 if (!params_ref) { 965 _exception = 1; 966 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 967 goto exit; 968 } 969 if (offset < 0) { 970 _exception = 1; 971 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 972 goto exit; 973 } 974 _remaining = _env->GetArrayLength(params_ref) - offset; 975 params_base = (GLfixed *) 976 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 977 params = params_base + offset; 978 979 glGetTexParameterxvOES( 980 (GLenum)target, 981 (GLenum)pname, 982 (GLfixed *)params 983 ); 984 985 exit: 986 if (params_base) { 987 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 988 _exception ? JNI_ABORT: 0); 989 } 990 } 991 992 /* void glGetTexParameterxvOES ( GLenum target, GLenum pname, GLfixed *params ) */ 993 static void 994 android_glGetTexParameterxvOES__IILjava_nio_IntBuffer_2 995 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 996 jint _exception = 0; 997 jarray _array = (jarray) 0; 998 jint _remaining; 999 GLfixed *params = (GLfixed *) 0; 1000 1001 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); 1002 glGetTexParameterxvOES( 1003 (GLenum)target, 1004 (GLenum)pname, 1005 (GLfixed *)params 1006 ); 1007 if (_array) { 1008 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); 1009 } 1010 } 1011 1012 /* void glLightModelxOES ( GLenum pname, GLfixed param ) */ 1013 static void 1014 android_glLightModelxOES__II 1015 (JNIEnv *_env, jobject _this, jint pname, jint param) { 1016 glLightModelxOES( 1017 (GLenum)pname, 1018 (GLfixed)param 1019 ); 1020 } 1021 1022 /* void glLightModelxvOES ( GLenum pname, const GLfixed *params ) */ 1023 static void 1024 android_glLightModelxvOES__I_3II 1025 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) { 1026 GLfixed *params_base = (GLfixed *) 0; 1027 jint _remaining; 1028 GLfixed *params = (GLfixed *) 0; 1029 1030 if (!params_ref) { 1031 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 1032 goto exit; 1033 } 1034 if (offset < 0) { 1035 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 1036 goto exit; 1037 } 1038 _remaining = _env->GetArrayLength(params_ref) - offset; 1039 params_base = (GLfixed *) 1040 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 1041 params = params_base + offset; 1042 1043 glLightModelxvOES( 1044 (GLenum)pname, 1045 (GLfixed *)params 1046 ); 1047 1048 exit: 1049 if (params_base) { 1050 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 1051 JNI_ABORT); 1052 } 1053 } 1054 1055 /* void glLightModelxvOES ( GLenum pname, const GLfixed *params ) */ 1056 static void 1057 android_glLightModelxvOES__ILjava_nio_IntBuffer_2 1058 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 1059 jarray _array = (jarray) 0; 1060 jint _remaining; 1061 GLfixed *params = (GLfixed *) 0; 1062 1063 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); 1064 glLightModelxvOES( 1065 (GLenum)pname, 1066 (GLfixed *)params 1067 ); 1068 if (_array) { 1069 releasePointer(_env, _array, params, JNI_FALSE); 1070 } 1071 } 1072 1073 /* void glLightxOES ( GLenum light, GLenum pname, GLfixed param ) */ 1074 static void 1075 android_glLightxOES__III 1076 (JNIEnv *_env, jobject _this, jint light, jint pname, jint param) { 1077 glLightxOES( 1078 (GLenum)light, 1079 (GLenum)pname, 1080 (GLfixed)param 1081 ); 1082 } 1083 1084 /* void glLightxvOES ( GLenum light, GLenum pname, const GLfixed *params ) */ 1085 static void 1086 android_glLightxvOES__II_3II 1087 (JNIEnv *_env, jobject _this, jint light, jint pname, jintArray params_ref, jint offset) { 1088 GLfixed *params_base = (GLfixed *) 0; 1089 jint _remaining; 1090 GLfixed *params = (GLfixed *) 0; 1091 1092 if (!params_ref) { 1093 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 1094 goto exit; 1095 } 1096 if (offset < 0) { 1097 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 1098 goto exit; 1099 } 1100 _remaining = _env->GetArrayLength(params_ref) - offset; 1101 params_base = (GLfixed *) 1102 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 1103 params = params_base + offset; 1104 1105 glLightxvOES( 1106 (GLenum)light, 1107 (GLenum)pname, 1108 (GLfixed *)params 1109 ); 1110 1111 exit: 1112 if (params_base) { 1113 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 1114 JNI_ABORT); 1115 } 1116 } 1117 1118 /* void glLightxvOES ( GLenum light, GLenum pname, const GLfixed *params ) */ 1119 static void 1120 android_glLightxvOES__IILjava_nio_IntBuffer_2 1121 (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) { 1122 jarray _array = (jarray) 0; 1123 jint _remaining; 1124 GLfixed *params = (GLfixed *) 0; 1125 1126 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); 1127 glLightxvOES( 1128 (GLenum)light, 1129 (GLenum)pname, 1130 (GLfixed *)params 1131 ); 1132 if (_array) { 1133 releasePointer(_env, _array, params, JNI_FALSE); 1134 } 1135 } 1136 1137 /* void glLineWidthxOES ( GLfixed width ) */ 1138 static void 1139 android_glLineWidthxOES__I 1140 (JNIEnv *_env, jobject _this, jint width) { 1141 glLineWidthxOES( 1142 (GLfixed)width 1143 ); 1144 } 1145 1146 /* void glLoadMatrixxOES ( const GLfixed *m ) */ 1147 static void 1148 android_glLoadMatrixxOES___3II 1149 (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) { 1150 GLfixed *m_base = (GLfixed *) 0; 1151 jint _remaining; 1152 GLfixed *m = (GLfixed *) 0; 1153 1154 if (!m_ref) { 1155 jniThrowException(_env, "java/lang/IllegalArgumentException", "m == null"); 1156 goto exit; 1157 } 1158 if (offset < 0) { 1159 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 1160 goto exit; 1161 } 1162 _remaining = _env->GetArrayLength(m_ref) - offset; 1163 m_base = (GLfixed *) 1164 _env->GetPrimitiveArrayCritical(m_ref, (jboolean *)0); 1165 m = m_base + offset; 1166 1167 glLoadMatrixxOES( 1168 (GLfixed *)m 1169 ); 1170 1171 exit: 1172 if (m_base) { 1173 _env->ReleasePrimitiveArrayCritical(m_ref, m_base, 1174 JNI_ABORT); 1175 } 1176 } 1177 1178 /* void glLoadMatrixxOES ( const GLfixed *m ) */ 1179 static void 1180 android_glLoadMatrixxOES__Ljava_nio_IntBuffer_2 1181 (JNIEnv *_env, jobject _this, jobject m_buf) { 1182 jarray _array = (jarray) 0; 1183 jint _remaining; 1184 GLfixed *m = (GLfixed *) 0; 1185 1186 m = (GLfixed *)getPointer(_env, m_buf, &_array, &_remaining); 1187 glLoadMatrixxOES( 1188 (GLfixed *)m 1189 ); 1190 if (_array) { 1191 releasePointer(_env, _array, m, JNI_FALSE); 1192 } 1193 } 1194 1195 /* void glMaterialxOES ( GLenum face, GLenum pname, GLfixed param ) */ 1196 static void 1197 android_glMaterialxOES__III 1198 (JNIEnv *_env, jobject _this, jint face, jint pname, jint param) { 1199 glMaterialxOES( 1200 (GLenum)face, 1201 (GLenum)pname, 1202 (GLfixed)param 1203 ); 1204 } 1205 1206 /* void glMaterialxvOES ( GLenum face, GLenum pname, const GLfixed *params ) */ 1207 static void 1208 android_glMaterialxvOES__II_3II 1209 (JNIEnv *_env, jobject _this, jint face, jint pname, jintArray params_ref, jint offset) { 1210 GLfixed *params_base = (GLfixed *) 0; 1211 jint _remaining; 1212 GLfixed *params = (GLfixed *) 0; 1213 1214 if (!params_ref) { 1215 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 1216 goto exit; 1217 } 1218 if (offset < 0) { 1219 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 1220 goto exit; 1221 } 1222 _remaining = _env->GetArrayLength(params_ref) - offset; 1223 params_base = (GLfixed *) 1224 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 1225 params = params_base + offset; 1226 1227 glMaterialxvOES( 1228 (GLenum)face, 1229 (GLenum)pname, 1230 (GLfixed *)params 1231 ); 1232 1233 exit: 1234 if (params_base) { 1235 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 1236 JNI_ABORT); 1237 } 1238 } 1239 1240 /* void glMaterialxvOES ( GLenum face, GLenum pname, const GLfixed *params ) */ 1241 static void 1242 android_glMaterialxvOES__IILjava_nio_IntBuffer_2 1243 (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) { 1244 jarray _array = (jarray) 0; 1245 jint _remaining; 1246 GLfixed *params = (GLfixed *) 0; 1247 1248 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); 1249 glMaterialxvOES( 1250 (GLenum)face, 1251 (GLenum)pname, 1252 (GLfixed *)params 1253 ); 1254 if (_array) { 1255 releasePointer(_env, _array, params, JNI_FALSE); 1256 } 1257 } 1258 1259 /* void glMultMatrixxOES ( const GLfixed *m ) */ 1260 static void 1261 android_glMultMatrixxOES___3II 1262 (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) { 1263 GLfixed *m_base = (GLfixed *) 0; 1264 jint _remaining; 1265 GLfixed *m = (GLfixed *) 0; 1266 1267 if (!m_ref) { 1268 jniThrowException(_env, "java/lang/IllegalArgumentException", "m == null"); 1269 goto exit; 1270 } 1271 if (offset < 0) { 1272 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 1273 goto exit; 1274 } 1275 _remaining = _env->GetArrayLength(m_ref) - offset; 1276 m_base = (GLfixed *) 1277 _env->GetPrimitiveArrayCritical(m_ref, (jboolean *)0); 1278 m = m_base + offset; 1279 1280 glMultMatrixxOES( 1281 (GLfixed *)m 1282 ); 1283 1284 exit: 1285 if (m_base) { 1286 _env->ReleasePrimitiveArrayCritical(m_ref, m_base, 1287 JNI_ABORT); 1288 } 1289 } 1290 1291 /* void glMultMatrixxOES ( const GLfixed *m ) */ 1292 static void 1293 android_glMultMatrixxOES__Ljava_nio_IntBuffer_2 1294 (JNIEnv *_env, jobject _this, jobject m_buf) { 1295 jarray _array = (jarray) 0; 1296 jint _remaining; 1297 GLfixed *m = (GLfixed *) 0; 1298 1299 m = (GLfixed *)getPointer(_env, m_buf, &_array, &_remaining); 1300 glMultMatrixxOES( 1301 (GLfixed *)m 1302 ); 1303 if (_array) { 1304 releasePointer(_env, _array, m, JNI_FALSE); 1305 } 1306 } 1307 1308 /* void glMultiTexCoord4xOES ( GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q ) */ 1309 static void 1310 android_glMultiTexCoord4xOES__IIIII 1311 (JNIEnv *_env, jobject _this, jint target, jint s, jint t, jint r, jint q) { 1312 glMultiTexCoord4xOES( 1313 (GLenum)target, 1314 (GLfixed)s, 1315 (GLfixed)t, 1316 (GLfixed)r, 1317 (GLfixed)q 1318 ); 1319 } 1320 1321 /* void glNormal3xOES ( GLfixed nx, GLfixed ny, GLfixed nz ) */ 1322 static void 1323 android_glNormal3xOES__III 1324 (JNIEnv *_env, jobject _this, jint nx, jint ny, jint nz) { 1325 glNormal3xOES( 1326 (GLfixed)nx, 1327 (GLfixed)ny, 1328 (GLfixed)nz 1329 ); 1330 } 1331 1332 /* void glOrthoxOES ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */ 1333 static void 1334 android_glOrthoxOES__IIIIII 1335 (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) { 1336 glOrthoxOES( 1337 (GLfixed)left, 1338 (GLfixed)right, 1339 (GLfixed)bottom, 1340 (GLfixed)top, 1341 (GLfixed)zNear, 1342 (GLfixed)zFar 1343 ); 1344 } 1345 1346 /* void glPointParameterxOES ( GLenum pname, GLfixed param ) */ 1347 static void 1348 android_glPointParameterxOES__II 1349 (JNIEnv *_env, jobject _this, jint pname, jint param) { 1350 glPointParameterxOES( 1351 (GLenum)pname, 1352 (GLfixed)param 1353 ); 1354 } 1355 1356 /* void glPointParameterxvOES ( GLenum pname, const GLfixed *params ) */ 1357 static void 1358 android_glPointParameterxvOES__I_3II 1359 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) { 1360 GLfixed *params_base = (GLfixed *) 0; 1361 jint _remaining; 1362 GLfixed *params = (GLfixed *) 0; 1363 1364 if (!params_ref) { 1365 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 1366 goto exit; 1367 } 1368 if (offset < 0) { 1369 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 1370 goto exit; 1371 } 1372 _remaining = _env->GetArrayLength(params_ref) - offset; 1373 params_base = (GLfixed *) 1374 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 1375 params = params_base + offset; 1376 1377 glPointParameterxvOES( 1378 (GLenum)pname, 1379 (GLfixed *)params 1380 ); 1381 1382 exit: 1383 if (params_base) { 1384 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 1385 JNI_ABORT); 1386 } 1387 } 1388 1389 /* void glPointParameterxvOES ( GLenum pname, const GLfixed *params ) */ 1390 static void 1391 android_glPointParameterxvOES__ILjava_nio_IntBuffer_2 1392 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 1393 jarray _array = (jarray) 0; 1394 jint _remaining; 1395 GLfixed *params = (GLfixed *) 0; 1396 1397 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); 1398 glPointParameterxvOES( 1399 (GLenum)pname, 1400 (GLfixed *)params 1401 ); 1402 if (_array) { 1403 releasePointer(_env, _array, params, JNI_FALSE); 1404 } 1405 } 1406 1407 /* void glPointSizexOES ( GLfixed size ) */ 1408 static void 1409 android_glPointSizexOES__I 1410 (JNIEnv *_env, jobject _this, jint size) { 1411 glPointSizexOES( 1412 (GLfixed)size 1413 ); 1414 } 1415 1416 /* void glPolygonOffsetxOES ( GLfixed factor, GLfixed units ) */ 1417 static void 1418 android_glPolygonOffsetxOES__II 1419 (JNIEnv *_env, jobject _this, jint factor, jint units) { 1420 glPolygonOffsetxOES( 1421 (GLfixed)factor, 1422 (GLfixed)units 1423 ); 1424 } 1425 1426 /* void glRotatexOES ( GLfixed angle, GLfixed x, GLfixed y, GLfixed z ) */ 1427 static void 1428 android_glRotatexOES__IIII 1429 (JNIEnv *_env, jobject _this, jint angle, jint x, jint y, jint z) { 1430 glRotatexOES( 1431 (GLfixed)angle, 1432 (GLfixed)x, 1433 (GLfixed)y, 1434 (GLfixed)z 1435 ); 1436 } 1437 1438 /* void glSampleCoveragexOES ( GLclampx value, GLboolean invert ) */ 1439 static void 1440 android_glSampleCoveragexOES__IZ 1441 (JNIEnv *_env, jobject _this, jint value, jboolean invert) { 1442 glSampleCoveragexOES( 1443 (GLclampx)value, 1444 (GLboolean)invert 1445 ); 1446 } 1447 1448 /* void glScalexOES ( GLfixed x, GLfixed y, GLfixed z ) */ 1449 static void 1450 android_glScalexOES__III 1451 (JNIEnv *_env, jobject _this, jint x, jint y, jint z) { 1452 glScalexOES( 1453 (GLfixed)x, 1454 (GLfixed)y, 1455 (GLfixed)z 1456 ); 1457 } 1458 1459 /* void glTexEnvxOES ( GLenum target, GLenum pname, GLfixed param ) */ 1460 static void 1461 android_glTexEnvxOES__III 1462 (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) { 1463 glTexEnvxOES( 1464 (GLenum)target, 1465 (GLenum)pname, 1466 (GLfixed)param 1467 ); 1468 } 1469 1470 /* void glTexEnvxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */ 1471 static void 1472 android_glTexEnvxvOES__II_3II 1473 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 1474 GLfixed *params_base = (GLfixed *) 0; 1475 jint _remaining; 1476 GLfixed *params = (GLfixed *) 0; 1477 1478 if (!params_ref) { 1479 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 1480 goto exit; 1481 } 1482 if (offset < 0) { 1483 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 1484 goto exit; 1485 } 1486 _remaining = _env->GetArrayLength(params_ref) - offset; 1487 params_base = (GLfixed *) 1488 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 1489 params = params_base + offset; 1490 1491 glTexEnvxvOES( 1492 (GLenum)target, 1493 (GLenum)pname, 1494 (GLfixed *)params 1495 ); 1496 1497 exit: 1498 if (params_base) { 1499 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 1500 JNI_ABORT); 1501 } 1502 } 1503 1504 /* void glTexEnvxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */ 1505 static void 1506 android_glTexEnvxvOES__IILjava_nio_IntBuffer_2 1507 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 1508 jarray _array = (jarray) 0; 1509 jint _remaining; 1510 GLfixed *params = (GLfixed *) 0; 1511 1512 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); 1513 glTexEnvxvOES( 1514 (GLenum)target, 1515 (GLenum)pname, 1516 (GLfixed *)params 1517 ); 1518 if (_array) { 1519 releasePointer(_env, _array, params, JNI_FALSE); 1520 } 1521 } 1522 1523 /* void glTexParameterxOES ( GLenum target, GLenum pname, GLfixed param ) */ 1524 static void 1525 android_glTexParameterxOES__III 1526 (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) { 1527 glTexParameterxOES( 1528 (GLenum)target, 1529 (GLenum)pname, 1530 (GLfixed)param 1531 ); 1532 } 1533 1534 /* void glTexParameterxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */ 1535 static void 1536 android_glTexParameterxvOES__II_3II 1537 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 1538 GLfixed *params_base = (GLfixed *) 0; 1539 jint _remaining; 1540 GLfixed *params = (GLfixed *) 0; 1541 1542 if (!params_ref) { 1543 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 1544 goto exit; 1545 } 1546 if (offset < 0) { 1547 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 1548 goto exit; 1549 } 1550 _remaining = _env->GetArrayLength(params_ref) - offset; 1551 params_base = (GLfixed *) 1552 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 1553 params = params_base + offset; 1554 1555 glTexParameterxvOES( 1556 (GLenum)target, 1557 (GLenum)pname, 1558 (GLfixed *)params 1559 ); 1560 1561 exit: 1562 if (params_base) { 1563 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 1564 JNI_ABORT); 1565 } 1566 } 1567 1568 /* void glTexParameterxvOES ( GLenum target, GLenum pname, const GLfixed *params ) */ 1569 static void 1570 android_glTexParameterxvOES__IILjava_nio_IntBuffer_2 1571 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 1572 jarray _array = (jarray) 0; 1573 jint _remaining; 1574 GLfixed *params = (GLfixed *) 0; 1575 1576 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); 1577 glTexParameterxvOES( 1578 (GLenum)target, 1579 (GLenum)pname, 1580 (GLfixed *)params 1581 ); 1582 if (_array) { 1583 releasePointer(_env, _array, params, JNI_FALSE); 1584 } 1585 } 1586 1587 /* void glTranslatexOES ( GLfixed x, GLfixed y, GLfixed z ) */ 1588 static void 1589 android_glTranslatexOES__III 1590 (JNIEnv *_env, jobject _this, jint x, jint y, jint z) { 1591 glTranslatexOES( 1592 (GLfixed)x, 1593 (GLfixed)y, 1594 (GLfixed)z 1595 ); 1596 } 1597 1598 /* GLboolean glIsRenderbufferOES ( GLuint renderbuffer ) */ 1599 static jboolean 1600 android_glIsRenderbufferOES__I 1601 (JNIEnv *_env, jobject _this, jint renderbuffer) { 1602 GLboolean _returnValue; 1603 _returnValue = glIsRenderbufferOES( 1604 (GLuint)renderbuffer 1605 ); 1606 return _returnValue; 1607 } 1608 1609 /* void glBindRenderbufferOES ( GLenum target, GLuint renderbuffer ) */ 1610 static void 1611 android_glBindRenderbufferOES__II 1612 (JNIEnv *_env, jobject _this, jint target, jint renderbuffer) { 1613 glBindRenderbufferOES( 1614 (GLenum)target, 1615 (GLuint)renderbuffer 1616 ); 1617 } 1618 1619 /* void glDeleteRenderbuffersOES ( GLsizei n, const GLuint *renderbuffers ) */ 1620 static void 1621 android_glDeleteRenderbuffersOES__I_3II 1622 (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) { 1623 GLuint *renderbuffers_base = (GLuint *) 0; 1624 jint _remaining; 1625 GLuint *renderbuffers = (GLuint *) 0; 1626 1627 if (!renderbuffers_ref) { 1628 jniThrowException(_env, "java/lang/IllegalArgumentException", "renderbuffers == null"); 1629 goto exit; 1630 } 1631 if (offset < 0) { 1632 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 1633 goto exit; 1634 } 1635 _remaining = _env->GetArrayLength(renderbuffers_ref) - offset; 1636 if (_remaining < n) { 1637 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < n"); 1638 goto exit; 1639 } 1640 renderbuffers_base = (GLuint *) 1641 _env->GetPrimitiveArrayCritical(renderbuffers_ref, (jboolean *)0); 1642 renderbuffers = renderbuffers_base + offset; 1643 1644 glDeleteRenderbuffersOES( 1645 (GLsizei)n, 1646 (GLuint *)renderbuffers 1647 ); 1648 1649 exit: 1650 if (renderbuffers_base) { 1651 _env->ReleasePrimitiveArrayCritical(renderbuffers_ref, renderbuffers_base, 1652 JNI_ABORT); 1653 } 1654 } 1655 1656 /* void glDeleteRenderbuffersOES ( GLsizei n, const GLuint *renderbuffers ) */ 1657 static void 1658 android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2 1659 (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) { 1660 jarray _array = (jarray) 0; 1661 jint _remaining; 1662 GLuint *renderbuffers = (GLuint *) 0; 1663 1664 renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, &_array, &_remaining); 1665 if (_remaining < n) { 1666 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < n"); 1667 goto exit; 1668 } 1669 glDeleteRenderbuffersOES( 1670 (GLsizei)n, 1671 (GLuint *)renderbuffers 1672 ); 1673 1674 exit: 1675 if (_array) { 1676 releasePointer(_env, _array, renderbuffers, JNI_FALSE); 1677 } 1678 } 1679 1680 /* void glGenRenderbuffersOES ( GLsizei n, GLuint *renderbuffers ) */ 1681 static void 1682 android_glGenRenderbuffersOES__I_3II 1683 (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) { 1684 jint _exception = 0; 1685 GLuint *renderbuffers_base = (GLuint *) 0; 1686 jint _remaining; 1687 GLuint *renderbuffers = (GLuint *) 0; 1688 1689 if (!renderbuffers_ref) { 1690 _exception = 1; 1691 jniThrowException(_env, "java/lang/IllegalArgumentException", "renderbuffers == null"); 1692 goto exit; 1693 } 1694 if (offset < 0) { 1695 _exception = 1; 1696 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 1697 goto exit; 1698 } 1699 _remaining = _env->GetArrayLength(renderbuffers_ref) - offset; 1700 if (_remaining < n) { 1701 _exception = 1; 1702 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < n"); 1703 goto exit; 1704 } 1705 renderbuffers_base = (GLuint *) 1706 _env->GetPrimitiveArrayCritical(renderbuffers_ref, (jboolean *)0); 1707 renderbuffers = renderbuffers_base + offset; 1708 1709 glGenRenderbuffersOES( 1710 (GLsizei)n, 1711 (GLuint *)renderbuffers 1712 ); 1713 1714 exit: 1715 if (renderbuffers_base) { 1716 _env->ReleasePrimitiveArrayCritical(renderbuffers_ref, renderbuffers_base, 1717 _exception ? JNI_ABORT: 0); 1718 } 1719 } 1720 1721 /* void glGenRenderbuffersOES ( GLsizei n, GLuint *renderbuffers ) */ 1722 static void 1723 android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2 1724 (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) { 1725 jint _exception = 0; 1726 jarray _array = (jarray) 0; 1727 jint _remaining; 1728 GLuint *renderbuffers = (GLuint *) 0; 1729 1730 renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, &_array, &_remaining); 1731 if (_remaining < n) { 1732 _exception = 1; 1733 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < n"); 1734 goto exit; 1735 } 1736 glGenRenderbuffersOES( 1737 (GLsizei)n, 1738 (GLuint *)renderbuffers 1739 ); 1740 1741 exit: 1742 if (_array) { 1743 releasePointer(_env, _array, renderbuffers, _exception ? JNI_FALSE : JNI_TRUE); 1744 } 1745 } 1746 1747 /* void glRenderbufferStorageOES ( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) */ 1748 static void 1749 android_glRenderbufferStorageOES__IIII 1750 (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint width, jint height) { 1751 glRenderbufferStorageOES( 1752 (GLenum)target, 1753 (GLenum)internalformat, 1754 (GLsizei)width, 1755 (GLsizei)height 1756 ); 1757 } 1758 1759 /* void glGetRenderbufferParameterivOES ( GLenum target, GLenum pname, GLint *params ) */ 1760 static void 1761 android_glGetRenderbufferParameterivOES__II_3II 1762 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 1763 jint _exception = 0; 1764 GLint *params_base = (GLint *) 0; 1765 jint _remaining; 1766 GLint *params = (GLint *) 0; 1767 1768 if (!params_ref) { 1769 _exception = 1; 1770 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 1771 goto exit; 1772 } 1773 if (offset < 0) { 1774 _exception = 1; 1775 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 1776 goto exit; 1777 } 1778 _remaining = _env->GetArrayLength(params_ref) - offset; 1779 if (_remaining < 1) { 1780 _exception = 1; 1781 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < 1"); 1782 goto exit; 1783 } 1784 params_base = (GLint *) 1785 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 1786 params = params_base + offset; 1787 1788 glGetRenderbufferParameterivOES( 1789 (GLenum)target, 1790 (GLenum)pname, 1791 (GLint *)params 1792 ); 1793 1794 exit: 1795 if (params_base) { 1796 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 1797 _exception ? JNI_ABORT: 0); 1798 } 1799 } 1800 1801 /* void glGetRenderbufferParameterivOES ( GLenum target, GLenum pname, GLint *params ) */ 1802 static void 1803 android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2 1804 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 1805 jint _exception = 0; 1806 jarray _array = (jarray) 0; 1807 jint _remaining; 1808 GLint *params = (GLint *) 0; 1809 1810 params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining); 1811 if (_remaining < 1) { 1812 _exception = 1; 1813 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < 1"); 1814 goto exit; 1815 } 1816 glGetRenderbufferParameterivOES( 1817 (GLenum)target, 1818 (GLenum)pname, 1819 (GLint *)params 1820 ); 1821 1822 exit: 1823 if (_array) { 1824 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); 1825 } 1826 } 1827 1828 /* GLboolean glIsFramebufferOES ( GLuint framebuffer ) */ 1829 static jboolean 1830 android_glIsFramebufferOES__I 1831 (JNIEnv *_env, jobject _this, jint framebuffer) { 1832 GLboolean _returnValue; 1833 _returnValue = glIsFramebufferOES( 1834 (GLuint)framebuffer 1835 ); 1836 return _returnValue; 1837 } 1838 1839 /* void glBindFramebufferOES ( GLenum target, GLuint framebuffer ) */ 1840 static void 1841 android_glBindFramebufferOES__II 1842 (JNIEnv *_env, jobject _this, jint target, jint framebuffer) { 1843 glBindFramebufferOES( 1844 (GLenum)target, 1845 (GLuint)framebuffer 1846 ); 1847 } 1848 1849 /* void glDeleteFramebuffersOES ( GLsizei n, const GLuint *framebuffers ) */ 1850 static void 1851 android_glDeleteFramebuffersOES__I_3II 1852 (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) { 1853 GLuint *framebuffers_base = (GLuint *) 0; 1854 jint _remaining; 1855 GLuint *framebuffers = (GLuint *) 0; 1856 1857 if (!framebuffers_ref) { 1858 jniThrowException(_env, "java/lang/IllegalArgumentException", "framebuffers == null"); 1859 goto exit; 1860 } 1861 if (offset < 0) { 1862 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 1863 goto exit; 1864 } 1865 _remaining = _env->GetArrayLength(framebuffers_ref) - offset; 1866 if (_remaining < n) { 1867 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < n"); 1868 goto exit; 1869 } 1870 framebuffers_base = (GLuint *) 1871 _env->GetPrimitiveArrayCritical(framebuffers_ref, (jboolean *)0); 1872 framebuffers = framebuffers_base + offset; 1873 1874 glDeleteFramebuffersOES( 1875 (GLsizei)n, 1876 (GLuint *)framebuffers 1877 ); 1878 1879 exit: 1880 if (framebuffers_base) { 1881 _env->ReleasePrimitiveArrayCritical(framebuffers_ref, framebuffers_base, 1882 JNI_ABORT); 1883 } 1884 } 1885 1886 /* void glDeleteFramebuffersOES ( GLsizei n, const GLuint *framebuffers ) */ 1887 static void 1888 android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2 1889 (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) { 1890 jarray _array = (jarray) 0; 1891 jint _remaining; 1892 GLuint *framebuffers = (GLuint *) 0; 1893 1894 framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, &_array, &_remaining); 1895 if (_remaining < n) { 1896 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < n"); 1897 goto exit; 1898 } 1899 glDeleteFramebuffersOES( 1900 (GLsizei)n, 1901 (GLuint *)framebuffers 1902 ); 1903 1904 exit: 1905 if (_array) { 1906 releasePointer(_env, _array, framebuffers, JNI_FALSE); 1907 } 1908 } 1909 1910 /* void glGenFramebuffersOES ( GLsizei n, GLuint *framebuffers ) */ 1911 static void 1912 android_glGenFramebuffersOES__I_3II 1913 (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) { 1914 jint _exception = 0; 1915 GLuint *framebuffers_base = (GLuint *) 0; 1916 jint _remaining; 1917 GLuint *framebuffers = (GLuint *) 0; 1918 1919 if (!framebuffers_ref) { 1920 _exception = 1; 1921 jniThrowException(_env, "java/lang/IllegalArgumentException", "framebuffers == null"); 1922 goto exit; 1923 } 1924 if (offset < 0) { 1925 _exception = 1; 1926 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 1927 goto exit; 1928 } 1929 _remaining = _env->GetArrayLength(framebuffers_ref) - offset; 1930 if (_remaining < n) { 1931 _exception = 1; 1932 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < n"); 1933 goto exit; 1934 } 1935 framebuffers_base = (GLuint *) 1936 _env->GetPrimitiveArrayCritical(framebuffers_ref, (jboolean *)0); 1937 framebuffers = framebuffers_base + offset; 1938 1939 glGenFramebuffersOES( 1940 (GLsizei)n, 1941 (GLuint *)framebuffers 1942 ); 1943 1944 exit: 1945 if (framebuffers_base) { 1946 _env->ReleasePrimitiveArrayCritical(framebuffers_ref, framebuffers_base, 1947 _exception ? JNI_ABORT: 0); 1948 } 1949 } 1950 1951 /* void glGenFramebuffersOES ( GLsizei n, GLuint *framebuffers ) */ 1952 static void 1953 android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2 1954 (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) { 1955 jint _exception = 0; 1956 jarray _array = (jarray) 0; 1957 jint _remaining; 1958 GLuint *framebuffers = (GLuint *) 0; 1959 1960 framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, &_array, &_remaining); 1961 if (_remaining < n) { 1962 _exception = 1; 1963 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < n"); 1964 goto exit; 1965 } 1966 glGenFramebuffersOES( 1967 (GLsizei)n, 1968 (GLuint *)framebuffers 1969 ); 1970 1971 exit: 1972 if (_array) { 1973 releasePointer(_env, _array, framebuffers, _exception ? JNI_FALSE : JNI_TRUE); 1974 } 1975 } 1976 1977 /* GLenum glCheckFramebufferStatusOES ( GLenum target ) */ 1978 static jint 1979 android_glCheckFramebufferStatusOES__I 1980 (JNIEnv *_env, jobject _this, jint target) { 1981 GLenum _returnValue; 1982 _returnValue = glCheckFramebufferStatusOES( 1983 (GLenum)target 1984 ); 1985 return _returnValue; 1986 } 1987 1988 /* void glFramebufferRenderbufferOES ( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) */ 1989 static void 1990 android_glFramebufferRenderbufferOES__IIII 1991 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint renderbuffertarget, jint renderbuffer) { 1992 glFramebufferRenderbufferOES( 1993 (GLenum)target, 1994 (GLenum)attachment, 1995 (GLenum)renderbuffertarget, 1996 (GLuint)renderbuffer 1997 ); 1998 } 1999 2000 /* void glFramebufferTexture2DOES ( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) */ 2001 static void 2002 android_glFramebufferTexture2DOES__IIIII 2003 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint textarget, jint texture, jint level) { 2004 glFramebufferTexture2DOES( 2005 (GLenum)target, 2006 (GLenum)attachment, 2007 (GLenum)textarget, 2008 (GLuint)texture, 2009 (GLint)level 2010 ); 2011 } 2012 2013 /* void glGetFramebufferAttachmentParameterivOES ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */ 2014 static void 2015 android_glGetFramebufferAttachmentParameterivOES__III_3II 2016 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jintArray params_ref, jint offset) { 2017 jint _exception = 0; 2018 GLint *params_base = (GLint *) 0; 2019 jint _remaining; 2020 GLint *params = (GLint *) 0; 2021 2022 if (!params_ref) { 2023 _exception = 1; 2024 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 2025 goto exit; 2026 } 2027 if (offset < 0) { 2028 _exception = 1; 2029 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 2030 goto exit; 2031 } 2032 _remaining = _env->GetArrayLength(params_ref) - offset; 2033 if (_remaining < 1) { 2034 _exception = 1; 2035 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < 1"); 2036 goto exit; 2037 } 2038 params_base = (GLint *) 2039 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 2040 params = params_base + offset; 2041 2042 glGetFramebufferAttachmentParameterivOES( 2043 (GLenum)target, 2044 (GLenum)attachment, 2045 (GLenum)pname, 2046 (GLint *)params 2047 ); 2048 2049 exit: 2050 if (params_base) { 2051 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 2052 _exception ? JNI_ABORT: 0); 2053 } 2054 } 2055 2056 /* void glGetFramebufferAttachmentParameterivOES ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */ 2057 static void 2058 android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2 2059 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jobject params_buf) { 2060 jint _exception = 0; 2061 jarray _array = (jarray) 0; 2062 jint _remaining; 2063 GLint *params = (GLint *) 0; 2064 2065 params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining); 2066 if (_remaining < 1) { 2067 _exception = 1; 2068 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < 1"); 2069 goto exit; 2070 } 2071 glGetFramebufferAttachmentParameterivOES( 2072 (GLenum)target, 2073 (GLenum)attachment, 2074 (GLenum)pname, 2075 (GLint *)params 2076 ); 2077 2078 exit: 2079 if (_array) { 2080 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); 2081 } 2082 } 2083 2084 /* void glGenerateMipmapOES ( GLenum target ) */ 2085 static void 2086 android_glGenerateMipmapOES__I 2087 (JNIEnv *_env, jobject _this, jint target) { 2088 glGenerateMipmapOES( 2089 (GLenum)target 2090 ); 2091 } 2092 2093 /* void glCurrentPaletteMatrixOES ( GLuint matrixpaletteindex ) */ 2094 static void 2095 android_glCurrentPaletteMatrixOES__I 2096 (JNIEnv *_env, jobject _this, jint matrixpaletteindex) { 2097 glCurrentPaletteMatrixOES( 2098 (GLuint)matrixpaletteindex 2099 ); 2100 } 2101 2102 /* void glLoadPaletteFromModelViewMatrixOES ( void ) */ 2103 static void 2104 android_glLoadPaletteFromModelViewMatrixOES__ 2105 (JNIEnv *_env, jobject _this) { 2106 glLoadPaletteFromModelViewMatrixOES(); 2107 } 2108 2109 /* void glMatrixIndexPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */ 2110 static void 2111 android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I 2112 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) { 2113 jarray _array = (jarray) 0; 2114 jint _remaining; 2115 GLvoid *pointer = (GLvoid *) 0; 2116 2117 if (pointer_buf) { 2118 pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf); 2119 if ( ! pointer ) { 2120 return; 2121 } 2122 } 2123 glMatrixIndexPointerOESBounds( 2124 (GLint)size, 2125 (GLenum)type, 2126 (GLsizei)stride, 2127 (GLvoid *)pointer, 2128 (GLsizei)remaining 2129 ); 2130 } 2131 2132 /* void glWeightPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */ 2133 static void 2134 android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I 2135 (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) { 2136 jarray _array = (jarray) 0; 2137 jint _remaining; 2138 GLvoid *pointer = (GLvoid *) 0; 2139 2140 if (pointer_buf) { 2141 pointer = (GLvoid *) getDirectBufferPointer(_env, pointer_buf); 2142 if ( ! pointer ) { 2143 return; 2144 } 2145 } 2146 glWeightPointerOESBounds( 2147 (GLint)size, 2148 (GLenum)type, 2149 (GLsizei)stride, 2150 (GLvoid *)pointer, 2151 (GLsizei)remaining 2152 ); 2153 } 2154 2155 /* void glDepthRangefOES ( GLclampf zNear, GLclampf zFar ) */ 2156 static void 2157 android_glDepthRangefOES__FF 2158 (JNIEnv *_env, jobject _this, jfloat zNear, jfloat zFar) { 2159 glDepthRangefOES( 2160 (GLclampf)zNear, 2161 (GLclampf)zFar 2162 ); 2163 } 2164 2165 /* void glFrustumfOES ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */ 2166 static void 2167 android_glFrustumfOES__FFFFFF 2168 (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) { 2169 glFrustumfOES( 2170 (GLfloat)left, 2171 (GLfloat)right, 2172 (GLfloat)bottom, 2173 (GLfloat)top, 2174 (GLfloat)zNear, 2175 (GLfloat)zFar 2176 ); 2177 } 2178 2179 /* void glOrthofOES ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */ 2180 static void 2181 android_glOrthofOES__FFFFFF 2182 (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) { 2183 glOrthofOES( 2184 (GLfloat)left, 2185 (GLfloat)right, 2186 (GLfloat)bottom, 2187 (GLfloat)top, 2188 (GLfloat)zNear, 2189 (GLfloat)zFar 2190 ); 2191 } 2192 2193 /* void glClipPlanefOES ( GLenum plane, const GLfloat *equation ) */ 2194 static void 2195 android_glClipPlanefOES__I_3FI 2196 (JNIEnv *_env, jobject _this, jint plane, jfloatArray equation_ref, jint offset) { 2197 GLfloat *equation_base = (GLfloat *) 0; 2198 jint _remaining; 2199 GLfloat *equation = (GLfloat *) 0; 2200 2201 if (!equation_ref) { 2202 jniThrowException(_env, "java/lang/IllegalArgumentException", "equation == null"); 2203 goto exit; 2204 } 2205 if (offset < 0) { 2206 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 2207 goto exit; 2208 } 2209 _remaining = _env->GetArrayLength(equation_ref) - offset; 2210 equation_base = (GLfloat *) 2211 _env->GetPrimitiveArrayCritical(equation_ref, (jboolean *)0); 2212 equation = equation_base + offset; 2213 2214 glClipPlanefOES( 2215 (GLenum)plane, 2216 (GLfloat *)equation 2217 ); 2218 2219 exit: 2220 if (equation_base) { 2221 _env->ReleasePrimitiveArrayCritical(equation_ref, equation_base, 2222 JNI_ABORT); 2223 } 2224 } 2225 2226 /* void glClipPlanefOES ( GLenum plane, const GLfloat *equation ) */ 2227 static void 2228 android_glClipPlanefOES__ILjava_nio_FloatBuffer_2 2229 (JNIEnv *_env, jobject _this, jint plane, jobject equation_buf) { 2230 jarray _array = (jarray) 0; 2231 jint _remaining; 2232 GLfloat *equation = (GLfloat *) 0; 2233 2234 equation = (GLfloat *)getPointer(_env, equation_buf, &_array, &_remaining); 2235 glClipPlanefOES( 2236 (GLenum)plane, 2237 (GLfloat *)equation 2238 ); 2239 if (_array) { 2240 releasePointer(_env, _array, equation, JNI_FALSE); 2241 } 2242 } 2243 2244 /* void glGetClipPlanefOES ( GLenum pname, GLfloat *eqn ) */ 2245 static void 2246 android_glGetClipPlanefOES__I_3FI 2247 (JNIEnv *_env, jobject _this, jint pname, jfloatArray eqn_ref, jint offset) { 2248 jint _exception = 0; 2249 GLfloat *eqn_base = (GLfloat *) 0; 2250 jint _remaining; 2251 GLfloat *eqn = (GLfloat *) 0; 2252 2253 if (!eqn_ref) { 2254 _exception = 1; 2255 jniThrowException(_env, "java/lang/IllegalArgumentException", "eqn == null"); 2256 goto exit; 2257 } 2258 if (offset < 0) { 2259 _exception = 1; 2260 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 2261 goto exit; 2262 } 2263 _remaining = _env->GetArrayLength(eqn_ref) - offset; 2264 if (_remaining < 4) { 2265 _exception = 1; 2266 jniThrowException(_env, "java/lang/IllegalArgumentException", "length - offset < 4"); 2267 goto exit; 2268 } 2269 eqn_base = (GLfloat *) 2270 _env->GetPrimitiveArrayCritical(eqn_ref, (jboolean *)0); 2271 eqn = eqn_base + offset; 2272 2273 glGetClipPlanefOES( 2274 (GLenum)pname, 2275 (GLfloat *)eqn 2276 ); 2277 2278 exit: 2279 if (eqn_base) { 2280 _env->ReleasePrimitiveArrayCritical(eqn_ref, eqn_base, 2281 _exception ? JNI_ABORT: 0); 2282 } 2283 } 2284 2285 /* void glGetClipPlanefOES ( GLenum pname, GLfloat *eqn ) */ 2286 static void 2287 android_glGetClipPlanefOES__ILjava_nio_FloatBuffer_2 2288 (JNIEnv *_env, jobject _this, jint pname, jobject eqn_buf) { 2289 jint _exception = 0; 2290 jarray _array = (jarray) 0; 2291 jint _remaining; 2292 GLfloat *eqn = (GLfloat *) 0; 2293 2294 eqn = (GLfloat *)getPointer(_env, eqn_buf, &_array, &_remaining); 2295 if (_remaining < 4) { 2296 _exception = 1; 2297 jniThrowException(_env, "java/lang/IllegalArgumentException", "remaining() < 4"); 2298 goto exit; 2299 } 2300 glGetClipPlanefOES( 2301 (GLenum)pname, 2302 (GLfloat *)eqn 2303 ); 2304 2305 exit: 2306 if (_array) { 2307 releasePointer(_env, _array, eqn, _exception ? JNI_FALSE : JNI_TRUE); 2308 } 2309 } 2310 2311 /* void glClearDepthfOES ( GLclampf depth ) */ 2312 static void 2313 android_glClearDepthfOES__F 2314 (JNIEnv *_env, jobject _this, jfloat depth) { 2315 glClearDepthfOES( 2316 (GLclampf)depth 2317 ); 2318 } 2319 2320 /* void glTexGenfOES ( GLenum coord, GLenum pname, GLfloat param ) */ 2321 static void 2322 android_glTexGenfOES__IIF 2323 (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloat param) { 2324 glTexGenfOES( 2325 (GLenum)coord, 2326 (GLenum)pname, 2327 (GLfloat)param 2328 ); 2329 } 2330 2331 /* void glTexGenfvOES ( GLenum coord, GLenum pname, const GLfloat *params ) */ 2332 static void 2333 android_glTexGenfvOES__II_3FI 2334 (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) { 2335 GLfloat *params_base = (GLfloat *) 0; 2336 jint _remaining; 2337 GLfloat *params = (GLfloat *) 0; 2338 2339 if (!params_ref) { 2340 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 2341 goto exit; 2342 } 2343 if (offset < 0) { 2344 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 2345 goto exit; 2346 } 2347 _remaining = _env->GetArrayLength(params_ref) - offset; 2348 params_base = (GLfloat *) 2349 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 2350 params = params_base + offset; 2351 2352 glTexGenfvOES( 2353 (GLenum)coord, 2354 (GLenum)pname, 2355 (GLfloat *)params 2356 ); 2357 2358 exit: 2359 if (params_base) { 2360 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 2361 JNI_ABORT); 2362 } 2363 } 2364 2365 /* void glTexGenfvOES ( GLenum coord, GLenum pname, const GLfloat *params ) */ 2366 static void 2367 android_glTexGenfvOES__IILjava_nio_FloatBuffer_2 2368 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { 2369 jarray _array = (jarray) 0; 2370 jint _remaining; 2371 GLfloat *params = (GLfloat *) 0; 2372 2373 params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining); 2374 glTexGenfvOES( 2375 (GLenum)coord, 2376 (GLenum)pname, 2377 (GLfloat *)params 2378 ); 2379 if (_array) { 2380 releasePointer(_env, _array, params, JNI_FALSE); 2381 } 2382 } 2383 2384 /* void glTexGeniOES ( GLenum coord, GLenum pname, GLint param ) */ 2385 static void 2386 android_glTexGeniOES__III 2387 (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) { 2388 glTexGeniOES( 2389 (GLenum)coord, 2390 (GLenum)pname, 2391 (GLint)param 2392 ); 2393 } 2394 2395 /* void glTexGenivOES ( GLenum coord, GLenum pname, const GLint *params ) */ 2396 static void 2397 android_glTexGenivOES__II_3II 2398 (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) { 2399 GLint *params_base = (GLint *) 0; 2400 jint _remaining; 2401 GLint *params = (GLint *) 0; 2402 2403 if (!params_ref) { 2404 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 2405 goto exit; 2406 } 2407 if (offset < 0) { 2408 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 2409 goto exit; 2410 } 2411 _remaining = _env->GetArrayLength(params_ref) - offset; 2412 params_base = (GLint *) 2413 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 2414 params = params_base + offset; 2415 2416 glTexGenivOES( 2417 (GLenum)coord, 2418 (GLenum)pname, 2419 (GLint *)params 2420 ); 2421 2422 exit: 2423 if (params_base) { 2424 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 2425 JNI_ABORT); 2426 } 2427 } 2428 2429 /* void glTexGenivOES ( GLenum coord, GLenum pname, const GLint *params ) */ 2430 static void 2431 android_glTexGenivOES__IILjava_nio_IntBuffer_2 2432 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { 2433 jarray _array = (jarray) 0; 2434 jint _remaining; 2435 GLint *params = (GLint *) 0; 2436 2437 params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining); 2438 glTexGenivOES( 2439 (GLenum)coord, 2440 (GLenum)pname, 2441 (GLint *)params 2442 ); 2443 if (_array) { 2444 releasePointer(_env, _array, params, JNI_FALSE); 2445 } 2446 } 2447 2448 /* void glTexGenxOES ( GLenum coord, GLenum pname, GLfixed param ) */ 2449 static void 2450 android_glTexGenxOES__III 2451 (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) { 2452 glTexGenxOES( 2453 (GLenum)coord, 2454 (GLenum)pname, 2455 (GLfixed)param 2456 ); 2457 } 2458 2459 /* void glTexGenxvOES ( GLenum coord, GLenum pname, const GLfixed *params ) */ 2460 static void 2461 android_glTexGenxvOES__II_3II 2462 (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) { 2463 GLfixed *params_base = (GLfixed *) 0; 2464 jint _remaining; 2465 GLfixed *params = (GLfixed *) 0; 2466 2467 if (!params_ref) { 2468 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 2469 goto exit; 2470 } 2471 if (offset < 0) { 2472 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 2473 goto exit; 2474 } 2475 _remaining = _env->GetArrayLength(params_ref) - offset; 2476 params_base = (GLfixed *) 2477 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 2478 params = params_base + offset; 2479 2480 glTexGenxvOES( 2481 (GLenum)coord, 2482 (GLenum)pname, 2483 (GLfixed *)params 2484 ); 2485 2486 exit: 2487 if (params_base) { 2488 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 2489 JNI_ABORT); 2490 } 2491 } 2492 2493 /* void glTexGenxvOES ( GLenum coord, GLenum pname, const GLfixed *params ) */ 2494 static void 2495 android_glTexGenxvOES__IILjava_nio_IntBuffer_2 2496 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { 2497 jarray _array = (jarray) 0; 2498 jint _remaining; 2499 GLfixed *params = (GLfixed *) 0; 2500 2501 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); 2502 glTexGenxvOES( 2503 (GLenum)coord, 2504 (GLenum)pname, 2505 (GLfixed *)params 2506 ); 2507 if (_array) { 2508 releasePointer(_env, _array, params, JNI_FALSE); 2509 } 2510 } 2511 2512 /* void glGetTexGenfvOES ( GLenum coord, GLenum pname, GLfloat *params ) */ 2513 static void 2514 android_glGetTexGenfvOES__II_3FI 2515 (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) { 2516 jint _exception = 0; 2517 GLfloat *params_base = (GLfloat *) 0; 2518 jint _remaining; 2519 GLfloat *params = (GLfloat *) 0; 2520 2521 if (!params_ref) { 2522 _exception = 1; 2523 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 2524 goto exit; 2525 } 2526 if (offset < 0) { 2527 _exception = 1; 2528 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 2529 goto exit; 2530 } 2531 _remaining = _env->GetArrayLength(params_ref) - offset; 2532 params_base = (GLfloat *) 2533 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 2534 params = params_base + offset; 2535 2536 glGetTexGenfvOES( 2537 (GLenum)coord, 2538 (GLenum)pname, 2539 (GLfloat *)params 2540 ); 2541 2542 exit: 2543 if (params_base) { 2544 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 2545 _exception ? JNI_ABORT: 0); 2546 } 2547 } 2548 2549 /* void glGetTexGenfvOES ( GLenum coord, GLenum pname, GLfloat *params ) */ 2550 static void 2551 android_glGetTexGenfvOES__IILjava_nio_FloatBuffer_2 2552 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { 2553 jint _exception = 0; 2554 jarray _array = (jarray) 0; 2555 jint _remaining; 2556 GLfloat *params = (GLfloat *) 0; 2557 2558 params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining); 2559 glGetTexGenfvOES( 2560 (GLenum)coord, 2561 (GLenum)pname, 2562 (GLfloat *)params 2563 ); 2564 if (_array) { 2565 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); 2566 } 2567 } 2568 2569 /* void glGetTexGenivOES ( GLenum coord, GLenum pname, GLint *params ) */ 2570 static void 2571 android_glGetTexGenivOES__II_3II 2572 (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) { 2573 jint _exception = 0; 2574 GLint *params_base = (GLint *) 0; 2575 jint _remaining; 2576 GLint *params = (GLint *) 0; 2577 2578 if (!params_ref) { 2579 _exception = 1; 2580 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 2581 goto exit; 2582 } 2583 if (offset < 0) { 2584 _exception = 1; 2585 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 2586 goto exit; 2587 } 2588 _remaining = _env->GetArrayLength(params_ref) - offset; 2589 params_base = (GLint *) 2590 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 2591 params = params_base + offset; 2592 2593 glGetTexGenivOES( 2594 (GLenum)coord, 2595 (GLenum)pname, 2596 (GLint *)params 2597 ); 2598 2599 exit: 2600 if (params_base) { 2601 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 2602 _exception ? JNI_ABORT: 0); 2603 } 2604 } 2605 2606 /* void glGetTexGenivOES ( GLenum coord, GLenum pname, GLint *params ) */ 2607 static void 2608 android_glGetTexGenivOES__IILjava_nio_IntBuffer_2 2609 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { 2610 jint _exception = 0; 2611 jarray _array = (jarray) 0; 2612 jint _remaining; 2613 GLint *params = (GLint *) 0; 2614 2615 params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining); 2616 glGetTexGenivOES( 2617 (GLenum)coord, 2618 (GLenum)pname, 2619 (GLint *)params 2620 ); 2621 if (_array) { 2622 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); 2623 } 2624 } 2625 2626 /* void glGetTexGenxvOES ( GLenum coord, GLenum pname, GLfixed *params ) */ 2627 static void 2628 android_glGetTexGenxvOES__II_3II 2629 (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) { 2630 jint _exception = 0; 2631 GLfixed *params_base = (GLfixed *) 0; 2632 jint _remaining; 2633 GLfixed *params = (GLfixed *) 0; 2634 2635 if (!params_ref) { 2636 _exception = 1; 2637 jniThrowException(_env, "java/lang/IllegalArgumentException", "params == null"); 2638 goto exit; 2639 } 2640 if (offset < 0) { 2641 _exception = 1; 2642 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset < 0"); 2643 goto exit; 2644 } 2645 _remaining = _env->GetArrayLength(params_ref) - offset; 2646 params_base = (GLfixed *) 2647 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); 2648 params = params_base + offset; 2649 2650 glGetTexGenxvOES( 2651 (GLenum)coord, 2652 (GLenum)pname, 2653 (GLfixed *)params 2654 ); 2655 2656 exit: 2657 if (params_base) { 2658 _env->ReleasePrimitiveArrayCritical(params_ref, params_base, 2659 _exception ? JNI_ABORT: 0); 2660 } 2661 } 2662 2663 /* void glGetTexGenxvOES ( GLenum coord, GLenum pname, GLfixed *params ) */ 2664 static void 2665 android_glGetTexGenxvOES__IILjava_nio_IntBuffer_2 2666 (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { 2667 jint _exception = 0; 2668 jarray _array = (jarray) 0; 2669 jint _remaining; 2670 GLfixed *params = (GLfixed *) 0; 2671 2672 params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); 2673 glGetTexGenxvOES( 2674 (GLenum)coord, 2675 (GLenum)pname, 2676 (GLfixed *)params 2677 ); 2678 if (_array) { 2679 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); 2680 } 2681 } 2682 2683 static const char *classPathName = "android/opengl/GLES11Ext"; 2684 2685 static JNINativeMethod methods[] = { 2686 {"_nativeClassInit", "()V", (void*)nativeClassInit }, 2687 {"glBlendEquationSeparateOES", "(II)V", (void *) android_glBlendEquationSeparateOES__II }, 2688 {"glBlendFuncSeparateOES", "(IIII)V", (void *) android_glBlendFuncSeparateOES__IIII }, 2689 {"glBlendEquationOES", "(I)V", (void *) android_glBlendEquationOES__I }, 2690 {"glDrawTexsOES", "(SSSSS)V", (void *) android_glDrawTexsOES__SSSSS }, 2691 {"glDrawTexiOES", "(IIIII)V", (void *) android_glDrawTexiOES__IIIII }, 2692 {"glDrawTexxOES", "(IIIII)V", (void *) android_glDrawTexxOES__IIIII }, 2693 {"glDrawTexsvOES", "([SI)V", (void *) android_glDrawTexsvOES___3SI }, 2694 {"glDrawTexsvOES", "(Ljava/nio/ShortBuffer;)V", (void *) android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2 }, 2695 {"glDrawTexivOES", "([II)V", (void *) android_glDrawTexivOES___3II }, 2696 {"glDrawTexivOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexivOES__Ljava_nio_IntBuffer_2 }, 2697 {"glDrawTexxvOES", "([II)V", (void *) android_glDrawTexxvOES___3II }, 2698 {"glDrawTexxvOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexxvOES__Ljava_nio_IntBuffer_2 }, 2699 {"glDrawTexfOES", "(FFFFF)V", (void *) android_glDrawTexfOES__FFFFF }, 2700 {"glDrawTexfvOES", "([FI)V", (void *) android_glDrawTexfvOES___3FI }, 2701 {"glDrawTexfvOES", "(Ljava/nio/FloatBuffer;)V", (void *) android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2 }, 2702 {"glEGLImageTargetTexture2DOES", "(ILjava/nio/Buffer;)V", (void *) android_glEGLImageTargetTexture2DOES__ILjava_nio_Buffer_2 }, 2703 {"glEGLImageTargetRenderbufferStorageOES", "(ILjava/nio/Buffer;)V", (void *) android_glEGLImageTargetRenderbufferStorageOES__ILjava_nio_Buffer_2 }, 2704 {"glAlphaFuncxOES", "(II)V", (void *) android_glAlphaFuncxOES__II }, 2705 {"glClearColorxOES", "(IIII)V", (void *) android_glClearColorxOES__IIII }, 2706 {"glClearDepthxOES", "(I)V", (void *) android_glClearDepthxOES__I }, 2707 {"glClipPlanexOES", "(I[II)V", (void *) android_glClipPlanexOES__I_3II }, 2708 {"glClipPlanexOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glClipPlanexOES__ILjava_nio_IntBuffer_2 }, 2709 {"glColor4xOES", "(IIII)V", (void *) android_glColor4xOES__IIII }, 2710 {"glDepthRangexOES", "(II)V", (void *) android_glDepthRangexOES__II }, 2711 {"glFogxOES", "(II)V", (void *) android_glFogxOES__II }, 2712 {"glFogxvOES", "(I[II)V", (void *) android_glFogxvOES__I_3II }, 2713 {"glFogxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glFogxvOES__ILjava_nio_IntBuffer_2 }, 2714 {"glFrustumxOES", "(IIIIII)V", (void *) android_glFrustumxOES__IIIIII }, 2715 {"glGetClipPlanexOES", "(I[II)V", (void *) android_glGetClipPlanexOES__I_3II }, 2716 {"glGetClipPlanexOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetClipPlanexOES__ILjava_nio_IntBuffer_2 }, 2717 {"glGetFixedvOES", "(I[II)V", (void *) android_glGetFixedvOES__I_3II }, 2718 {"glGetFixedvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetFixedvOES__ILjava_nio_IntBuffer_2 }, 2719 {"glGetLightxvOES", "(II[II)V", (void *) android_glGetLightxvOES__II_3II }, 2720 {"glGetLightxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetLightxvOES__IILjava_nio_IntBuffer_2 }, 2721 {"glGetMaterialxvOES", "(II[II)V", (void *) android_glGetMaterialxvOES__II_3II }, 2722 {"glGetMaterialxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetMaterialxvOES__IILjava_nio_IntBuffer_2 }, 2723 {"glGetTexEnvxvOES", "(II[II)V", (void *) android_glGetTexEnvxvOES__II_3II }, 2724 {"glGetTexEnvxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexEnvxvOES__IILjava_nio_IntBuffer_2 }, 2725 {"glGetTexParameterxvOES", "(II[II)V", (void *) android_glGetTexParameterxvOES__II_3II }, 2726 {"glGetTexParameterxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameterxvOES__IILjava_nio_IntBuffer_2 }, 2727 {"glLightModelxOES", "(II)V", (void *) android_glLightModelxOES__II }, 2728 {"glLightModelxvOES", "(I[II)V", (void *) android_glLightModelxvOES__I_3II }, 2729 {"glLightModelxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glLightModelxvOES__ILjava_nio_IntBuffer_2 }, 2730 {"glLightxOES", "(III)V", (void *) android_glLightxOES__III }, 2731 {"glLightxvOES", "(II[II)V", (void *) android_glLightxvOES__II_3II }, 2732 {"glLightxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glLightxvOES__IILjava_nio_IntBuffer_2 }, 2733 {"glLineWidthxOES", "(I)V", (void *) android_glLineWidthxOES__I }, 2734 {"glLoadMatrixxOES", "([II)V", (void *) android_glLoadMatrixxOES___3II }, 2735 {"glLoadMatrixxOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glLoadMatrixxOES__Ljava_nio_IntBuffer_2 }, 2736 {"glMaterialxOES", "(III)V", (void *) android_glMaterialxOES__III }, 2737 {"glMaterialxvOES", "(II[II)V", (void *) android_glMaterialxvOES__II_3II }, 2738 {"glMaterialxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glMaterialxvOES__IILjava_nio_IntBuffer_2 }, 2739 {"glMultMatrixxOES", "([II)V", (void *) android_glMultMatrixxOES___3II }, 2740 {"glMultMatrixxOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glMultMatrixxOES__Ljava_nio_IntBuffer_2 }, 2741 {"glMultiTexCoord4xOES", "(IIIII)V", (void *) android_glMultiTexCoord4xOES__IIIII }, 2742 {"glNormal3xOES", "(III)V", (void *) android_glNormal3xOES__III }, 2743 {"glOrthoxOES", "(IIIIII)V", (void *) android_glOrthoxOES__IIIIII }, 2744 {"glPointParameterxOES", "(II)V", (void *) android_glPointParameterxOES__II }, 2745 {"glPointParameterxvOES", "(I[II)V", (void *) android_glPointParameterxvOES__I_3II }, 2746 {"glPointParameterxvOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glPointParameterxvOES__ILjava_nio_IntBuffer_2 }, 2747 {"glPointSizexOES", "(I)V", (void *) android_glPointSizexOES__I }, 2748 {"glPolygonOffsetxOES", "(II)V", (void *) android_glPolygonOffsetxOES__II }, 2749 {"glRotatexOES", "(IIII)V", (void *) android_glRotatexOES__IIII }, 2750 {"glSampleCoveragexOES", "(IZ)V", (void *) android_glSampleCoveragexOES__IZ }, 2751 {"glScalexOES", "(III)V", (void *) android_glScalexOES__III }, 2752 {"glTexEnvxOES", "(III)V", (void *) android_glTexEnvxOES__III }, 2753 {"glTexEnvxvOES", "(II[II)V", (void *) android_glTexEnvxvOES__II_3II }, 2754 {"glTexEnvxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexEnvxvOES__IILjava_nio_IntBuffer_2 }, 2755 {"glTexParameterxOES", "(III)V", (void *) android_glTexParameterxOES__III }, 2756 {"glTexParameterxvOES", "(II[II)V", (void *) android_glTexParameterxvOES__II_3II }, 2757 {"glTexParameterxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameterxvOES__IILjava_nio_IntBuffer_2 }, 2758 {"glTranslatexOES", "(III)V", (void *) android_glTranslatexOES__III }, 2759 {"glIsRenderbufferOES", "(I)Z", (void *) android_glIsRenderbufferOES__I }, 2760 {"glBindRenderbufferOES", "(II)V", (void *) android_glBindRenderbufferOES__II }, 2761 {"glDeleteRenderbuffersOES", "(I[II)V", (void *) android_glDeleteRenderbuffersOES__I_3II }, 2762 {"glDeleteRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2 }, 2763 {"glGenRenderbuffersOES", "(I[II)V", (void *) android_glGenRenderbuffersOES__I_3II }, 2764 {"glGenRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2 }, 2765 {"glRenderbufferStorageOES", "(IIII)V", (void *) android_glRenderbufferStorageOES__IIII }, 2766 {"glGetRenderbufferParameterivOES", "(II[II)V", (void *) android_glGetRenderbufferParameterivOES__II_3II }, 2767 {"glGetRenderbufferParameterivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2 }, 2768 {"glIsFramebufferOES", "(I)Z", (void *) android_glIsFramebufferOES__I }, 2769 {"glBindFramebufferOES", "(II)V", (void *) android_glBindFramebufferOES__II }, 2770 {"glDeleteFramebuffersOES", "(I[II)V", (void *) android_glDeleteFramebuffersOES__I_3II }, 2771 {"glDeleteFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2 }, 2772 {"glGenFramebuffersOES", "(I[II)V", (void *) android_glGenFramebuffersOES__I_3II }, 2773 {"glGenFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2 }, 2774 {"glCheckFramebufferStatusOES", "(I)I", (void *) android_glCheckFramebufferStatusOES__I }, 2775 {"glFramebufferRenderbufferOES", "(IIII)V", (void *) android_glFramebufferRenderbufferOES__IIII }, 2776 {"glFramebufferTexture2DOES", "(IIIII)V", (void *) android_glFramebufferTexture2DOES__IIIII }, 2777 {"glGetFramebufferAttachmentParameterivOES", "(III[II)V", (void *) android_glGetFramebufferAttachmentParameterivOES__III_3II }, 2778 {"glGetFramebufferAttachmentParameterivOES", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2 }, 2779 {"glGenerateMipmapOES", "(I)V", (void *) android_glGenerateMipmapOES__I }, 2780 {"glCurrentPaletteMatrixOES", "(I)V", (void *) android_glCurrentPaletteMatrixOES__I }, 2781 {"glLoadPaletteFromModelViewMatrixOES", "()V", (void *) android_glLoadPaletteFromModelViewMatrixOES__ }, 2782 {"glMatrixIndexPointerOESBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glMatrixIndexPointerOESBounds__IIILjava_nio_Buffer_2I }, 2783 {"glWeightPointerOESBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glWeightPointerOESBounds__IIILjava_nio_Buffer_2I }, 2784 {"glDepthRangefOES", "(FF)V", (void *) android_glDepthRangefOES__FF }, 2785 {"glFrustumfOES", "(FFFFFF)V", (void *) android_glFrustumfOES__FFFFFF }, 2786 {"glOrthofOES", "(FFFFFF)V", (void *) android_glOrthofOES__FFFFFF }, 2787 {"glClipPlanefOES", "(I[FI)V", (void *) android_glClipPlanefOES__I_3FI }, 2788 {"glClipPlanefOES", "(ILjava/nio/FloatBuffer;)V", (void *) android_glClipPlanefOES__ILjava_nio_FloatBuffer_2 }, 2789 {"glGetClipPlanefOES", "(I[FI)V", (void *) android_glGetClipPlanefOES__I_3FI }, 2790 {"glGetClipPlanefOES", "(ILjava/nio/FloatBuffer;)V", (void *) android_glGetClipPlanefOES__ILjava_nio_FloatBuffer_2 }, 2791 {"glClearDepthfOES", "(F)V", (void *) android_glClearDepthfOES__F }, 2792 {"glTexGenfOES", "(IIF)V", (void *) android_glTexGenfOES__IIF }, 2793 {"glTexGenfvOES", "(II[FI)V", (void *) android_glTexGenfvOES__II_3FI }, 2794 {"glTexGenfvOES", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexGenfvOES__IILjava_nio_FloatBuffer_2 }, 2795 {"glTexGeniOES", "(III)V", (void *) android_glTexGeniOES__III }, 2796 {"glTexGenivOES", "(II[II)V", (void *) android_glTexGenivOES__II_3II }, 2797 {"glTexGenivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGenivOES__IILjava_nio_IntBuffer_2 }, 2798 {"glTexGenxOES", "(III)V", (void *) android_glTexGenxOES__III }, 2799 {"glTexGenxvOES", "(II[II)V", (void *) android_glTexGenxvOES__II_3II }, 2800 {"glTexGenxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGenxvOES__IILjava_nio_IntBuffer_2 }, 2801 {"glGetTexGenfvOES", "(II[FI)V", (void *) android_glGetTexGenfvOES__II_3FI }, 2802 {"glGetTexGenfvOES", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetTexGenfvOES__IILjava_nio_FloatBuffer_2 }, 2803 {"glGetTexGenivOES", "(II[II)V", (void *) android_glGetTexGenivOES__II_3II }, 2804 {"glGetTexGenivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGenivOES__IILjava_nio_IntBuffer_2 }, 2805 {"glGetTexGenxvOES", "(II[II)V", (void *) android_glGetTexGenxvOES__II_3II }, 2806 {"glGetTexGenxvOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGenxvOES__IILjava_nio_IntBuffer_2 }, 2807 }; 2808 2809 int register_android_opengl_jni_GLES11Ext(JNIEnv *_env) 2810 { 2811 int err; 2812 err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods)); 2813 return err; 2814 } 2815
