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