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