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