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