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