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