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