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