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 <GLES2/gl2.h> 25#include <GLES2/gl2ext.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_2_0 276 // GLES 2.x pnames 277 switch (pname) { 278 case GL_ALIASED_LINE_WIDTH_RANGE: 279 case GL_ALIASED_POINT_SIZE_RANGE: 280 needed = 2; 281 break; 282 283 case GL_BLEND_COLOR: 284 case GL_COLOR_CLEAR_VALUE: 285 case GL_COLOR_WRITEMASK: 286 case GL_SCISSOR_BOX: 287 case GL_VIEWPORT: 288 needed = 4; 289 break; 290 291 case GL_COMPRESSED_TEXTURE_FORMATS: 292 glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed); 293 break; 294 295 case GL_SHADER_BINARY_FORMATS: 296 glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &needed); 297 break; 298 } 299#endif 300 301#ifdef GL_VERSION_ES_CM_1_1 302 // GLES 1.x pnames 303 switch (pname) { 304 case GL_ALIASED_LINE_WIDTH_RANGE: 305 case GL_ALIASED_POINT_SIZE_RANGE: 306 case GL_DEPTH_RANGE: 307 case GL_SMOOTH_LINE_WIDTH_RANGE: 308 case GL_SMOOTH_POINT_SIZE_RANGE: 309 needed = 2; 310 break; 311 312 case GL_CURRENT_NORMAL: 313 case GL_POINT_DISTANCE_ATTENUATION: 314 needed = 3; 315 break; 316 317 case GL_COLOR_CLEAR_VALUE: 318 case GL_COLOR_WRITEMASK: 319 case GL_CURRENT_COLOR: 320 case GL_CURRENT_TEXTURE_COORDS: 321 case GL_FOG_COLOR: 322 case GL_LIGHT_MODEL_AMBIENT: 323 case GL_SCISSOR_BOX: 324 case GL_VIEWPORT: 325 needed = 4; 326 break; 327 328 case GL_MODELVIEW_MATRIX: 329 case GL_PROJECTION_MATRIX: 330 case GL_TEXTURE_MATRIX: 331 needed = 16; 332 break; 333 334 case GL_COMPRESSED_TEXTURE_FORMATS: 335 glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed); 336 break; 337 } 338#endif 339 return needed; 340} 341 342template <typename JTYPEARRAY, typename ARRAYGETTER, typename NTYPEARRAY, 343 typename ARRAYRELEASER, typename CTYPE, void GET(GLenum, CTYPE*)> 344static void 345get 346 (JNIEnv *_env, jobject _this, jint pname, JTYPEARRAY params_ref, jint offset) { 347 jint _exception = 0; 348 const char * _exceptionType; 349 const char * _exceptionMessage; 350 CTYPE *params_base = (CTYPE *) 0; 351 jint _remaining; 352 CTYPE *params = (CTYPE *) 0; 353 int _needed = 0; 354 355 if (!params_ref) { 356 _exception = 1; 357 _exceptionType = "java/lang/IllegalArgumentException"; 358 _exceptionMessage = "params == null"; 359 goto exit; 360 } 361 if (offset < 0) { 362 _exception = 1; 363 _exceptionType = "java/lang/IllegalArgumentException"; 364 _exceptionMessage = "offset < 0"; 365 goto exit; 366 } 367 _remaining = _env->GetArrayLength(params_ref) - offset; 368 _needed = getNeededCount(pname); 369 // if we didn't find this pname, we just assume the user passed 370 // an array of the right size -- this might happen with extensions 371 // or if we forget an enum here. 372 if (_remaining < _needed) { 373 _exception = 1; 374 _exceptionType = "java/lang/IllegalArgumentException"; 375 _exceptionMessage = "length - offset < needed"; 376 goto exit; 377 } 378 params_base = (CTYPE *) getArrayPointer<JTYPEARRAY, ARRAYGETTER>( 379 _env, params_ref, (jboolean *)0); 380 params = params_base + offset; 381 382 GET( 383 (GLenum)pname, 384 (CTYPE *)params 385 ); 386 387exit: 388 if (params_base) { 389 releaseArrayPointer<JTYPEARRAY, NTYPEARRAY, ARRAYRELEASER>( 390 _env, params_ref, params_base, !_exception); 391 } 392 if (_exception) { 393 jniThrowException(_env, _exceptionType, _exceptionMessage); 394 } 395} 396 397 398template <typename CTYPE, typename JTYPEARRAY, typename ARRAYGETTER, typename NTYPEARRAY, 399 typename ARRAYRELEASER, void GET(GLenum, CTYPE*)> 400static void 401getarray 402 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 403 jint _exception = 0; 404 const char * _exceptionType; 405 const char * _exceptionMessage; 406 JTYPEARRAY _array = (JTYPEARRAY) 0; 407 jint _bufferOffset = (jint) 0; 408 jint _remaining; 409 CTYPE *params = (CTYPE *) 0; 410 int _needed = 0; 411 412 params = (CTYPE *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 413 _remaining /= sizeof(CTYPE); // convert from bytes to item count 414 _needed = getNeededCount(pname); 415 // if we didn't find this pname, we just assume the user passed 416 // an array of the right size -- this might happen with extensions 417 // or if we forget an enum here. 418 if (_needed>0 && _remaining < _needed) { 419 _exception = 1; 420 _exceptionType = "java/lang/IllegalArgumentException"; 421 _exceptionMessage = "remaining() < needed"; 422 goto exit; 423 } 424 if (params == NULL) { 425 char * _paramsBase = (char *) getArrayPointer<JTYPEARRAY, ARRAYGETTER>( 426 _env, _array, (jboolean *) 0); 427 params = (CTYPE *) (_paramsBase + _bufferOffset); 428 } 429 GET( 430 (GLenum)pname, 431 (CTYPE *)params 432 ); 433 434exit: 435 if (_array) { 436 releaseArrayPointer<JTYPEARRAY, NTYPEARRAY, ARRAYRELEASER>( 437 _env, _array, (NTYPEARRAY)params, _exception ? JNI_FALSE : JNI_TRUE); 438 } 439 if (_exception) { 440 jniThrowException(_env, _exceptionType, _exceptionMessage); 441 } 442} 443 444// -------------------------------------------------------------------------- 445/* void glActiveTexture ( GLenum texture ) */ 446static void 447android_glActiveTexture__I 448 (JNIEnv *_env, jobject _this, jint texture) { 449 glActiveTexture( 450 (GLenum)texture 451 ); 452} 453 454/* void glAttachShader ( GLuint program, GLuint shader ) */ 455static void 456android_glAttachShader__II 457 (JNIEnv *_env, jobject _this, jint program, jint shader) { 458 glAttachShader( 459 (GLuint)program, 460 (GLuint)shader 461 ); 462} 463 464/* void glBindAttribLocation ( GLuint program, GLuint index, const char *name ) */ 465static void 466android_glBindAttribLocation__IILjava_lang_String_2 467 (JNIEnv *_env, jobject _this, jint program, jint index, jstring name) { 468 jint _exception = 0; 469 const char * _exceptionType = NULL; 470 const char * _exceptionMessage = NULL; 471 const char* _nativename = 0; 472 473 if (!name) { 474 _exception = 1; 475 _exceptionType = "java/lang/IllegalArgumentException"; 476 _exceptionMessage = "name == null"; 477 goto exit; 478 } 479 _nativename = _env->GetStringUTFChars(name, 0); 480 481 glBindAttribLocation( 482 (GLuint)program, 483 (GLuint)index, 484 (char *)_nativename 485 ); 486 487exit: 488 if (_nativename) { 489 _env->ReleaseStringUTFChars(name, _nativename); 490 } 491 492 if (_exception) { 493 jniThrowException(_env, _exceptionType, _exceptionMessage); 494 } 495} 496 497/* void glBindBuffer ( GLenum target, GLuint buffer ) */ 498static void 499android_glBindBuffer__II 500 (JNIEnv *_env, jobject _this, jint target, jint buffer) { 501 glBindBuffer( 502 (GLenum)target, 503 (GLuint)buffer 504 ); 505} 506 507/* void glBindFramebuffer ( GLenum target, GLuint framebuffer ) */ 508static void 509android_glBindFramebuffer__II 510 (JNIEnv *_env, jobject _this, jint target, jint framebuffer) { 511 glBindFramebuffer( 512 (GLenum)target, 513 (GLuint)framebuffer 514 ); 515} 516 517/* void glBindRenderbuffer ( GLenum target, GLuint renderbuffer ) */ 518static void 519android_glBindRenderbuffer__II 520 (JNIEnv *_env, jobject _this, jint target, jint renderbuffer) { 521 glBindRenderbuffer( 522 (GLenum)target, 523 (GLuint)renderbuffer 524 ); 525} 526 527/* void glBindTexture ( GLenum target, GLuint texture ) */ 528static void 529android_glBindTexture__II 530 (JNIEnv *_env, jobject _this, jint target, jint texture) { 531 glBindTexture( 532 (GLenum)target, 533 (GLuint)texture 534 ); 535} 536 537/* void glBlendColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) */ 538static void 539android_glBlendColor__FFFF 540 (JNIEnv *_env, jobject _this, jfloat red, jfloat green, jfloat blue, jfloat alpha) { 541 glBlendColor( 542 (GLclampf)red, 543 (GLclampf)green, 544 (GLclampf)blue, 545 (GLclampf)alpha 546 ); 547} 548 549/* void glBlendEquation ( GLenum mode ) */ 550static void 551android_glBlendEquation__I 552 (JNIEnv *_env, jobject _this, jint mode) { 553 glBlendEquation( 554 (GLenum)mode 555 ); 556} 557 558/* void glBlendEquationSeparate ( GLenum modeRGB, GLenum modeAlpha ) */ 559static void 560android_glBlendEquationSeparate__II 561 (JNIEnv *_env, jobject _this, jint modeRGB, jint modeAlpha) { 562 glBlendEquationSeparate( 563 (GLenum)modeRGB, 564 (GLenum)modeAlpha 565 ); 566} 567 568/* void glBlendFunc ( GLenum sfactor, GLenum dfactor ) */ 569static void 570android_glBlendFunc__II 571 (JNIEnv *_env, jobject _this, jint sfactor, jint dfactor) { 572 glBlendFunc( 573 (GLenum)sfactor, 574 (GLenum)dfactor 575 ); 576} 577 578/* void glBlendFuncSeparate ( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) */ 579static void 580android_glBlendFuncSeparate__IIII 581 (JNIEnv *_env, jobject _this, jint srcRGB, jint dstRGB, jint srcAlpha, jint dstAlpha) { 582 glBlendFuncSeparate( 583 (GLenum)srcRGB, 584 (GLenum)dstRGB, 585 (GLenum)srcAlpha, 586 (GLenum)dstAlpha 587 ); 588} 589 590/* void glBufferData ( GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage ) */ 591static void 592android_glBufferData__IILjava_nio_Buffer_2I 593 (JNIEnv *_env, jobject _this, jint target, jint size, jobject data_buf, jint usage) { 594 jint _exception = 0; 595 const char * _exceptionType = NULL; 596 const char * _exceptionMessage = NULL; 597 jarray _array = (jarray) 0; 598 jint _bufferOffset = (jint) 0; 599 jint _remaining; 600 GLvoid *data = (GLvoid *) 0; 601 602 if (data_buf) { 603 data = (GLvoid *)getPointer(_env, data_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 604 if (_remaining < size) { 605 _exception = 1; 606 _exceptionType = "java/lang/IllegalArgumentException"; 607 _exceptionMessage = "remaining() < size < needed"; 608 goto exit; 609 } 610 } 611 if (data_buf && data == NULL) { 612 char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 613 data = (GLvoid *) (_dataBase + _bufferOffset); 614 } 615 glBufferData( 616 (GLenum)target, 617 (GLsizeiptr)size, 618 (GLvoid *)data, 619 (GLenum)usage 620 ); 621 622exit: 623 if (_array) { 624 releasePointer(_env, _array, data, JNI_FALSE); 625 } 626 if (_exception) { 627 jniThrowException(_env, _exceptionType, _exceptionMessage); 628 } 629} 630 631/* void glBufferSubData ( GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data ) */ 632static void 633android_glBufferSubData__IIILjava_nio_Buffer_2 634 (JNIEnv *_env, jobject _this, jint target, jint offset, jint size, jobject data_buf) { 635 jint _exception = 0; 636 const char * _exceptionType = NULL; 637 const char * _exceptionMessage = NULL; 638 jarray _array = (jarray) 0; 639 jint _bufferOffset = (jint) 0; 640 jint _remaining; 641 GLvoid *data = (GLvoid *) 0; 642 643 data = (GLvoid *)getPointer(_env, data_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 644 if (_remaining < size) { 645 _exception = 1; 646 _exceptionType = "java/lang/IllegalArgumentException"; 647 _exceptionMessage = "remaining() < size < needed"; 648 goto exit; 649 } 650 if (data == NULL) { 651 char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 652 data = (GLvoid *) (_dataBase + _bufferOffset); 653 } 654 glBufferSubData( 655 (GLenum)target, 656 (GLintptr)offset, 657 (GLsizeiptr)size, 658 (GLvoid *)data 659 ); 660 661exit: 662 if (_array) { 663 releasePointer(_env, _array, data, JNI_FALSE); 664 } 665 if (_exception) { 666 jniThrowException(_env, _exceptionType, _exceptionMessage); 667 } 668} 669 670/* GLenum glCheckFramebufferStatus ( GLenum target ) */ 671static jint 672android_glCheckFramebufferStatus__I 673 (JNIEnv *_env, jobject _this, jint target) { 674 GLenum _returnValue; 675 _returnValue = glCheckFramebufferStatus( 676 (GLenum)target 677 ); 678 return (jint)_returnValue; 679} 680 681/* void glClear ( GLbitfield mask ) */ 682static void 683android_glClear__I 684 (JNIEnv *_env, jobject _this, jint mask) { 685 glClear( 686 (GLbitfield)mask 687 ); 688} 689 690/* void glClearColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) */ 691static void 692android_glClearColor__FFFF 693 (JNIEnv *_env, jobject _this, jfloat red, jfloat green, jfloat blue, jfloat alpha) { 694 glClearColor( 695 (GLclampf)red, 696 (GLclampf)green, 697 (GLclampf)blue, 698 (GLclampf)alpha 699 ); 700} 701 702/* void glClearDepthf ( GLclampf depth ) */ 703static void 704android_glClearDepthf__F 705 (JNIEnv *_env, jobject _this, jfloat depth) { 706 glClearDepthf( 707 (GLclampf)depth 708 ); 709} 710 711/* void glClearStencil ( GLint s ) */ 712static void 713android_glClearStencil__I 714 (JNIEnv *_env, jobject _this, jint s) { 715 glClearStencil( 716 (GLint)s 717 ); 718} 719 720/* void glColorMask ( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) */ 721static void 722android_glColorMask__ZZZZ 723 (JNIEnv *_env, jobject _this, jboolean red, jboolean green, jboolean blue, jboolean alpha) { 724 glColorMask( 725 (GLboolean)red, 726 (GLboolean)green, 727 (GLboolean)blue, 728 (GLboolean)alpha 729 ); 730} 731 732/* void glCompileShader ( GLuint shader ) */ 733static void 734android_glCompileShader__I 735 (JNIEnv *_env, jobject _this, jint shader) { 736 glCompileShader( 737 (GLuint)shader 738 ); 739} 740 741/* void glCompressedTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data ) */ 742static void 743android_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2 744 (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint imageSize, jobject data_buf) { 745 jarray _array = (jarray) 0; 746 jint _bufferOffset = (jint) 0; 747 jint _remaining; 748 GLvoid *data = (GLvoid *) 0; 749 750 data = (GLvoid *)getPointer(_env, data_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 751 if (data == NULL) { 752 char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 753 data = (GLvoid *) (_dataBase + _bufferOffset); 754 } 755 glCompressedTexImage2D( 756 (GLenum)target, 757 (GLint)level, 758 (GLenum)internalformat, 759 (GLsizei)width, 760 (GLsizei)height, 761 (GLint)border, 762 (GLsizei)imageSize, 763 (GLvoid *)data 764 ); 765 if (_array) { 766 releasePointer(_env, _array, data, JNI_FALSE); 767 } 768} 769 770/* void glCompressedTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data ) */ 771static void 772android_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 773 (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint imageSize, jobject data_buf) { 774 jarray _array = (jarray) 0; 775 jint _bufferOffset = (jint) 0; 776 jint _remaining; 777 GLvoid *data = (GLvoid *) 0; 778 779 data = (GLvoid *)getPointer(_env, data_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 780 if (data == NULL) { 781 char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 782 data = (GLvoid *) (_dataBase + _bufferOffset); 783 } 784 glCompressedTexSubImage2D( 785 (GLenum)target, 786 (GLint)level, 787 (GLint)xoffset, 788 (GLint)yoffset, 789 (GLsizei)width, 790 (GLsizei)height, 791 (GLenum)format, 792 (GLsizei)imageSize, 793 (GLvoid *)data 794 ); 795 if (_array) { 796 releasePointer(_env, _array, data, JNI_FALSE); 797 } 798} 799 800/* void glCopyTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) */ 801static void 802android_glCopyTexImage2D__IIIIIIII 803 (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint x, jint y, jint width, jint height, jint border) { 804 glCopyTexImage2D( 805 (GLenum)target, 806 (GLint)level, 807 (GLenum)internalformat, 808 (GLint)x, 809 (GLint)y, 810 (GLsizei)width, 811 (GLsizei)height, 812 (GLint)border 813 ); 814} 815 816/* void glCopyTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) */ 817static void 818android_glCopyTexSubImage2D__IIIIIIII 819 (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint x, jint y, jint width, jint height) { 820 glCopyTexSubImage2D( 821 (GLenum)target, 822 (GLint)level, 823 (GLint)xoffset, 824 (GLint)yoffset, 825 (GLint)x, 826 (GLint)y, 827 (GLsizei)width, 828 (GLsizei)height 829 ); 830} 831 832/* GLuint glCreateProgram ( void ) */ 833static jint 834android_glCreateProgram__ 835 (JNIEnv *_env, jobject _this) { 836 GLuint _returnValue; 837 _returnValue = glCreateProgram(); 838 return (jint)_returnValue; 839} 840 841/* GLuint glCreateShader ( GLenum type ) */ 842static jint 843android_glCreateShader__I 844 (JNIEnv *_env, jobject _this, jint type) { 845 GLuint _returnValue; 846 _returnValue = glCreateShader( 847 (GLenum)type 848 ); 849 return (jint)_returnValue; 850} 851 852/* void glCullFace ( GLenum mode ) */ 853static void 854android_glCullFace__I 855 (JNIEnv *_env, jobject _this, jint mode) { 856 glCullFace( 857 (GLenum)mode 858 ); 859} 860 861/* void glDeleteBuffers ( GLsizei n, const GLuint *buffers ) */ 862static void 863android_glDeleteBuffers__I_3II 864 (JNIEnv *_env, jobject _this, jint n, jintArray buffers_ref, jint offset) { 865 jint _exception = 0; 866 const char * _exceptionType = NULL; 867 const char * _exceptionMessage = NULL; 868 GLuint *buffers_base = (GLuint *) 0; 869 jint _remaining; 870 GLuint *buffers = (GLuint *) 0; 871 872 if (!buffers_ref) { 873 _exception = 1; 874 _exceptionType = "java/lang/IllegalArgumentException"; 875 _exceptionMessage = "buffers == null"; 876 goto exit; 877 } 878 if (offset < 0) { 879 _exception = 1; 880 _exceptionType = "java/lang/IllegalArgumentException"; 881 _exceptionMessage = "offset < 0"; 882 goto exit; 883 } 884 _remaining = _env->GetArrayLength(buffers_ref) - offset; 885 if (_remaining < n) { 886 _exception = 1; 887 _exceptionType = "java/lang/IllegalArgumentException"; 888 _exceptionMessage = "length - offset < n < needed"; 889 goto exit; 890 } 891 buffers_base = (GLuint *) 892 _env->GetIntArrayElements(buffers_ref, (jboolean *)0); 893 buffers = buffers_base + offset; 894 895 glDeleteBuffers( 896 (GLsizei)n, 897 (GLuint *)buffers 898 ); 899 900exit: 901 if (buffers_base) { 902 _env->ReleaseIntArrayElements(buffers_ref, (jint*)buffers_base, 903 JNI_ABORT); 904 } 905 if (_exception) { 906 jniThrowException(_env, _exceptionType, _exceptionMessage); 907 } 908} 909 910/* void glDeleteBuffers ( GLsizei n, const GLuint *buffers ) */ 911static void 912android_glDeleteBuffers__ILjava_nio_IntBuffer_2 913 (JNIEnv *_env, jobject _this, jint n, jobject buffers_buf) { 914 jint _exception = 0; 915 const char * _exceptionType = NULL; 916 const char * _exceptionMessage = NULL; 917 jintArray _array = (jintArray) 0; 918 jint _bufferOffset = (jint) 0; 919 jint _remaining; 920 GLuint *buffers = (GLuint *) 0; 921 922 buffers = (GLuint *)getPointer(_env, buffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 923 if (_remaining < n) { 924 _exception = 1; 925 _exceptionType = "java/lang/IllegalArgumentException"; 926 _exceptionMessage = "remaining() < n < needed"; 927 goto exit; 928 } 929 if (buffers == NULL) { 930 char * _buffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 931 buffers = (GLuint *) (_buffersBase + _bufferOffset); 932 } 933 glDeleteBuffers( 934 (GLsizei)n, 935 (GLuint *)buffers 936 ); 937 938exit: 939 if (_array) { 940 _env->ReleaseIntArrayElements(_array, (jint*)buffers, JNI_ABORT); 941 } 942 if (_exception) { 943 jniThrowException(_env, _exceptionType, _exceptionMessage); 944 } 945} 946 947/* void glDeleteFramebuffers ( GLsizei n, const GLuint *framebuffers ) */ 948static void 949android_glDeleteFramebuffers__I_3II 950 (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) { 951 jint _exception = 0; 952 const char * _exceptionType = NULL; 953 const char * _exceptionMessage = NULL; 954 GLuint *framebuffers_base = (GLuint *) 0; 955 jint _remaining; 956 GLuint *framebuffers = (GLuint *) 0; 957 958 if (!framebuffers_ref) { 959 _exception = 1; 960 _exceptionType = "java/lang/IllegalArgumentException"; 961 _exceptionMessage = "framebuffers == null"; 962 goto exit; 963 } 964 if (offset < 0) { 965 _exception = 1; 966 _exceptionType = "java/lang/IllegalArgumentException"; 967 _exceptionMessage = "offset < 0"; 968 goto exit; 969 } 970 _remaining = _env->GetArrayLength(framebuffers_ref) - offset; 971 if (_remaining < n) { 972 _exception = 1; 973 _exceptionType = "java/lang/IllegalArgumentException"; 974 _exceptionMessage = "length - offset < n < needed"; 975 goto exit; 976 } 977 framebuffers_base = (GLuint *) 978 _env->GetIntArrayElements(framebuffers_ref, (jboolean *)0); 979 framebuffers = framebuffers_base + offset; 980 981 glDeleteFramebuffers( 982 (GLsizei)n, 983 (GLuint *)framebuffers 984 ); 985 986exit: 987 if (framebuffers_base) { 988 _env->ReleaseIntArrayElements(framebuffers_ref, (jint*)framebuffers_base, 989 JNI_ABORT); 990 } 991 if (_exception) { 992 jniThrowException(_env, _exceptionType, _exceptionMessage); 993 } 994} 995 996/* void glDeleteFramebuffers ( GLsizei n, const GLuint *framebuffers ) */ 997static void 998android_glDeleteFramebuffers__ILjava_nio_IntBuffer_2 999 (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) { 1000 jint _exception = 0; 1001 const char * _exceptionType = NULL; 1002 const char * _exceptionMessage = NULL; 1003 jintArray _array = (jintArray) 0; 1004 jint _bufferOffset = (jint) 0; 1005 jint _remaining; 1006 GLuint *framebuffers = (GLuint *) 0; 1007 1008 framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1009 if (_remaining < n) { 1010 _exception = 1; 1011 _exceptionType = "java/lang/IllegalArgumentException"; 1012 _exceptionMessage = "remaining() < n < needed"; 1013 goto exit; 1014 } 1015 if (framebuffers == NULL) { 1016 char * _framebuffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1017 framebuffers = (GLuint *) (_framebuffersBase + _bufferOffset); 1018 } 1019 glDeleteFramebuffers( 1020 (GLsizei)n, 1021 (GLuint *)framebuffers 1022 ); 1023 1024exit: 1025 if (_array) { 1026 _env->ReleaseIntArrayElements(_array, (jint*)framebuffers, JNI_ABORT); 1027 } 1028 if (_exception) { 1029 jniThrowException(_env, _exceptionType, _exceptionMessage); 1030 } 1031} 1032 1033/* void glDeleteProgram ( GLuint program ) */ 1034static void 1035android_glDeleteProgram__I 1036 (JNIEnv *_env, jobject _this, jint program) { 1037 glDeleteProgram( 1038 (GLuint)program 1039 ); 1040} 1041 1042/* void glDeleteRenderbuffers ( GLsizei n, const GLuint *renderbuffers ) */ 1043static void 1044android_glDeleteRenderbuffers__I_3II 1045 (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) { 1046 jint _exception = 0; 1047 const char * _exceptionType = NULL; 1048 const char * _exceptionMessage = NULL; 1049 GLuint *renderbuffers_base = (GLuint *) 0; 1050 jint _remaining; 1051 GLuint *renderbuffers = (GLuint *) 0; 1052 1053 if (!renderbuffers_ref) { 1054 _exception = 1; 1055 _exceptionType = "java/lang/IllegalArgumentException"; 1056 _exceptionMessage = "renderbuffers == null"; 1057 goto exit; 1058 } 1059 if (offset < 0) { 1060 _exception = 1; 1061 _exceptionType = "java/lang/IllegalArgumentException"; 1062 _exceptionMessage = "offset < 0"; 1063 goto exit; 1064 } 1065 _remaining = _env->GetArrayLength(renderbuffers_ref) - offset; 1066 if (_remaining < n) { 1067 _exception = 1; 1068 _exceptionType = "java/lang/IllegalArgumentException"; 1069 _exceptionMessage = "length - offset < n < needed"; 1070 goto exit; 1071 } 1072 renderbuffers_base = (GLuint *) 1073 _env->GetIntArrayElements(renderbuffers_ref, (jboolean *)0); 1074 renderbuffers = renderbuffers_base + offset; 1075 1076 glDeleteRenderbuffers( 1077 (GLsizei)n, 1078 (GLuint *)renderbuffers 1079 ); 1080 1081exit: 1082 if (renderbuffers_base) { 1083 _env->ReleaseIntArrayElements(renderbuffers_ref, (jint*)renderbuffers_base, 1084 JNI_ABORT); 1085 } 1086 if (_exception) { 1087 jniThrowException(_env, _exceptionType, _exceptionMessage); 1088 } 1089} 1090 1091/* void glDeleteRenderbuffers ( GLsizei n, const GLuint *renderbuffers ) */ 1092static void 1093android_glDeleteRenderbuffers__ILjava_nio_IntBuffer_2 1094 (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) { 1095 jint _exception = 0; 1096 const char * _exceptionType = NULL; 1097 const char * _exceptionMessage = NULL; 1098 jintArray _array = (jintArray) 0; 1099 jint _bufferOffset = (jint) 0; 1100 jint _remaining; 1101 GLuint *renderbuffers = (GLuint *) 0; 1102 1103 renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1104 if (_remaining < n) { 1105 _exception = 1; 1106 _exceptionType = "java/lang/IllegalArgumentException"; 1107 _exceptionMessage = "remaining() < n < needed"; 1108 goto exit; 1109 } 1110 if (renderbuffers == NULL) { 1111 char * _renderbuffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1112 renderbuffers = (GLuint *) (_renderbuffersBase + _bufferOffset); 1113 } 1114 glDeleteRenderbuffers( 1115 (GLsizei)n, 1116 (GLuint *)renderbuffers 1117 ); 1118 1119exit: 1120 if (_array) { 1121 _env->ReleaseIntArrayElements(_array, (jint*)renderbuffers, JNI_ABORT); 1122 } 1123 if (_exception) { 1124 jniThrowException(_env, _exceptionType, _exceptionMessage); 1125 } 1126} 1127 1128/* void glDeleteShader ( GLuint shader ) */ 1129static void 1130android_glDeleteShader__I 1131 (JNIEnv *_env, jobject _this, jint shader) { 1132 glDeleteShader( 1133 (GLuint)shader 1134 ); 1135} 1136 1137/* void glDeleteTextures ( GLsizei n, const GLuint *textures ) */ 1138static void 1139android_glDeleteTextures__I_3II 1140 (JNIEnv *_env, jobject _this, jint n, jintArray textures_ref, jint offset) { 1141 jint _exception = 0; 1142 const char * _exceptionType = NULL; 1143 const char * _exceptionMessage = NULL; 1144 GLuint *textures_base = (GLuint *) 0; 1145 jint _remaining; 1146 GLuint *textures = (GLuint *) 0; 1147 1148 if (!textures_ref) { 1149 _exception = 1; 1150 _exceptionType = "java/lang/IllegalArgumentException"; 1151 _exceptionMessage = "textures == null"; 1152 goto exit; 1153 } 1154 if (offset < 0) { 1155 _exception = 1; 1156 _exceptionType = "java/lang/IllegalArgumentException"; 1157 _exceptionMessage = "offset < 0"; 1158 goto exit; 1159 } 1160 _remaining = _env->GetArrayLength(textures_ref) - offset; 1161 if (_remaining < n) { 1162 _exception = 1; 1163 _exceptionType = "java/lang/IllegalArgumentException"; 1164 _exceptionMessage = "length - offset < n < needed"; 1165 goto exit; 1166 } 1167 textures_base = (GLuint *) 1168 _env->GetIntArrayElements(textures_ref, (jboolean *)0); 1169 textures = textures_base + offset; 1170 1171 glDeleteTextures( 1172 (GLsizei)n, 1173 (GLuint *)textures 1174 ); 1175 1176exit: 1177 if (textures_base) { 1178 _env->ReleaseIntArrayElements(textures_ref, (jint*)textures_base, 1179 JNI_ABORT); 1180 } 1181 if (_exception) { 1182 jniThrowException(_env, _exceptionType, _exceptionMessage); 1183 } 1184} 1185 1186/* void glDeleteTextures ( GLsizei n, const GLuint *textures ) */ 1187static void 1188android_glDeleteTextures__ILjava_nio_IntBuffer_2 1189 (JNIEnv *_env, jobject _this, jint n, jobject textures_buf) { 1190 jint _exception = 0; 1191 const char * _exceptionType = NULL; 1192 const char * _exceptionMessage = NULL; 1193 jintArray _array = (jintArray) 0; 1194 jint _bufferOffset = (jint) 0; 1195 jint _remaining; 1196 GLuint *textures = (GLuint *) 0; 1197 1198 textures = (GLuint *)getPointer(_env, textures_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1199 if (_remaining < n) { 1200 _exception = 1; 1201 _exceptionType = "java/lang/IllegalArgumentException"; 1202 _exceptionMessage = "remaining() < n < needed"; 1203 goto exit; 1204 } 1205 if (textures == NULL) { 1206 char * _texturesBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1207 textures = (GLuint *) (_texturesBase + _bufferOffset); 1208 } 1209 glDeleteTextures( 1210 (GLsizei)n, 1211 (GLuint *)textures 1212 ); 1213 1214exit: 1215 if (_array) { 1216 _env->ReleaseIntArrayElements(_array, (jint*)textures, JNI_ABORT); 1217 } 1218 if (_exception) { 1219 jniThrowException(_env, _exceptionType, _exceptionMessage); 1220 } 1221} 1222 1223/* void glDepthFunc ( GLenum func ) */ 1224static void 1225android_glDepthFunc__I 1226 (JNIEnv *_env, jobject _this, jint func) { 1227 glDepthFunc( 1228 (GLenum)func 1229 ); 1230} 1231 1232/* void glDepthMask ( GLboolean flag ) */ 1233static void 1234android_glDepthMask__Z 1235 (JNIEnv *_env, jobject _this, jboolean flag) { 1236 glDepthMask( 1237 (GLboolean)flag 1238 ); 1239} 1240 1241/* void glDepthRangef ( GLclampf zNear, GLclampf zFar ) */ 1242static void 1243android_glDepthRangef__FF 1244 (JNIEnv *_env, jobject _this, jfloat zNear, jfloat zFar) { 1245 glDepthRangef( 1246 (GLclampf)zNear, 1247 (GLclampf)zFar 1248 ); 1249} 1250 1251/* void glDetachShader ( GLuint program, GLuint shader ) */ 1252static void 1253android_glDetachShader__II 1254 (JNIEnv *_env, jobject _this, jint program, jint shader) { 1255 glDetachShader( 1256 (GLuint)program, 1257 (GLuint)shader 1258 ); 1259} 1260 1261/* void glDisable ( GLenum cap ) */ 1262static void 1263android_glDisable__I 1264 (JNIEnv *_env, jobject _this, jint cap) { 1265 glDisable( 1266 (GLenum)cap 1267 ); 1268} 1269 1270/* void glDisableVertexAttribArray ( GLuint index ) */ 1271static void 1272android_glDisableVertexAttribArray__I 1273 (JNIEnv *_env, jobject _this, jint index) { 1274 glDisableVertexAttribArray( 1275 (GLuint)index 1276 ); 1277} 1278 1279/* void glDrawArrays ( GLenum mode, GLint first, GLsizei count ) */ 1280static void 1281android_glDrawArrays__III 1282 (JNIEnv *_env, jobject _this, jint mode, jint first, jint count) { 1283 glDrawArrays( 1284 (GLenum)mode, 1285 (GLint)first, 1286 (GLsizei)count 1287 ); 1288} 1289 1290/* void glDrawElements ( GLenum mode, GLsizei count, GLenum type, GLint offset ) */ 1291static void 1292android_glDrawElements__IIII 1293 (JNIEnv *_env, jobject _this, jint mode, jint count, jint type, jint offset) { 1294 jint _exception = 0; 1295 const char * _exceptionType = NULL; 1296 const char * _exceptionMessage = NULL; 1297 glDrawElements( 1298 (GLenum)mode, 1299 (GLsizei)count, 1300 (GLenum)type, 1301 reinterpret_cast<GLvoid *>(offset) 1302 ); 1303 if (_exception) { 1304 jniThrowException(_env, _exceptionType, _exceptionMessage); 1305 } 1306} 1307 1308/* void glDrawElements ( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices ) */ 1309static void 1310android_glDrawElements__IIILjava_nio_Buffer_2 1311 (JNIEnv *_env, jobject _this, jint mode, jint count, jint type, jobject indices_buf) { 1312 jint _exception = 0; 1313 const char * _exceptionType = NULL; 1314 const char * _exceptionMessage = NULL; 1315 jarray _array = (jarray) 0; 1316 jint _bufferOffset = (jint) 0; 1317 jint _remaining; 1318 GLvoid *indices = (GLvoid *) 0; 1319 1320 indices = (GLvoid *)getPointer(_env, indices_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1321 if (_remaining < count) { 1322 _exception = 1; 1323 _exceptionType = "java/lang/ArrayIndexOutOfBoundsException"; 1324 _exceptionMessage = "remaining() < count < needed"; 1325 goto exit; 1326 } 1327 if (indices == NULL) { 1328 char * _indicesBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 1329 indices = (GLvoid *) (_indicesBase + _bufferOffset); 1330 } 1331 glDrawElements( 1332 (GLenum)mode, 1333 (GLsizei)count, 1334 (GLenum)type, 1335 (GLvoid *)indices 1336 ); 1337 1338exit: 1339 if (_array) { 1340 releasePointer(_env, _array, indices, JNI_FALSE); 1341 } 1342 if (_exception) { 1343 jniThrowException(_env, _exceptionType, _exceptionMessage); 1344 } 1345} 1346 1347/* void glEnable ( GLenum cap ) */ 1348static void 1349android_glEnable__I 1350 (JNIEnv *_env, jobject _this, jint cap) { 1351 glEnable( 1352 (GLenum)cap 1353 ); 1354} 1355 1356/* void glEnableVertexAttribArray ( GLuint index ) */ 1357static void 1358android_glEnableVertexAttribArray__I 1359 (JNIEnv *_env, jobject _this, jint index) { 1360 glEnableVertexAttribArray( 1361 (GLuint)index 1362 ); 1363} 1364 1365/* void glFinish ( void ) */ 1366static void 1367android_glFinish__ 1368 (JNIEnv *_env, jobject _this) { 1369 glFinish(); 1370} 1371 1372/* void glFlush ( void ) */ 1373static void 1374android_glFlush__ 1375 (JNIEnv *_env, jobject _this) { 1376 glFlush(); 1377} 1378 1379/* void glFramebufferRenderbuffer ( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) */ 1380static void 1381android_glFramebufferRenderbuffer__IIII 1382 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint renderbuffertarget, jint renderbuffer) { 1383 glFramebufferRenderbuffer( 1384 (GLenum)target, 1385 (GLenum)attachment, 1386 (GLenum)renderbuffertarget, 1387 (GLuint)renderbuffer 1388 ); 1389} 1390 1391/* void glFramebufferTexture2D ( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) */ 1392static void 1393android_glFramebufferTexture2D__IIIII 1394 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint textarget, jint texture, jint level) { 1395 glFramebufferTexture2D( 1396 (GLenum)target, 1397 (GLenum)attachment, 1398 (GLenum)textarget, 1399 (GLuint)texture, 1400 (GLint)level 1401 ); 1402} 1403 1404/* void glFrontFace ( GLenum mode ) */ 1405static void 1406android_glFrontFace__I 1407 (JNIEnv *_env, jobject _this, jint mode) { 1408 glFrontFace( 1409 (GLenum)mode 1410 ); 1411} 1412 1413/* void glGenBuffers ( GLsizei n, GLuint *buffers ) */ 1414static void 1415android_glGenBuffers__I_3II 1416 (JNIEnv *_env, jobject _this, jint n, jintArray buffers_ref, jint offset) { 1417 jint _exception = 0; 1418 const char * _exceptionType = NULL; 1419 const char * _exceptionMessage = NULL; 1420 GLuint *buffers_base = (GLuint *) 0; 1421 jint _remaining; 1422 GLuint *buffers = (GLuint *) 0; 1423 1424 if (!buffers_ref) { 1425 _exception = 1; 1426 _exceptionType = "java/lang/IllegalArgumentException"; 1427 _exceptionMessage = "buffers == null"; 1428 goto exit; 1429 } 1430 if (offset < 0) { 1431 _exception = 1; 1432 _exceptionType = "java/lang/IllegalArgumentException"; 1433 _exceptionMessage = "offset < 0"; 1434 goto exit; 1435 } 1436 _remaining = _env->GetArrayLength(buffers_ref) - offset; 1437 if (_remaining < n) { 1438 _exception = 1; 1439 _exceptionType = "java/lang/IllegalArgumentException"; 1440 _exceptionMessage = "length - offset < n < needed"; 1441 goto exit; 1442 } 1443 buffers_base = (GLuint *) 1444 _env->GetIntArrayElements(buffers_ref, (jboolean *)0); 1445 buffers = buffers_base + offset; 1446 1447 glGenBuffers( 1448 (GLsizei)n, 1449 (GLuint *)buffers 1450 ); 1451 1452exit: 1453 if (buffers_base) { 1454 _env->ReleaseIntArrayElements(buffers_ref, (jint*)buffers_base, 1455 _exception ? JNI_ABORT: 0); 1456 } 1457 if (_exception) { 1458 jniThrowException(_env, _exceptionType, _exceptionMessage); 1459 } 1460} 1461 1462/* void glGenBuffers ( GLsizei n, GLuint *buffers ) */ 1463static void 1464android_glGenBuffers__ILjava_nio_IntBuffer_2 1465 (JNIEnv *_env, jobject _this, jint n, jobject buffers_buf) { 1466 jint _exception = 0; 1467 const char * _exceptionType = NULL; 1468 const char * _exceptionMessage = NULL; 1469 jintArray _array = (jintArray) 0; 1470 jint _bufferOffset = (jint) 0; 1471 jint _remaining; 1472 GLuint *buffers = (GLuint *) 0; 1473 1474 buffers = (GLuint *)getPointer(_env, buffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1475 if (_remaining < n) { 1476 _exception = 1; 1477 _exceptionType = "java/lang/IllegalArgumentException"; 1478 _exceptionMessage = "remaining() < n < needed"; 1479 goto exit; 1480 } 1481 if (buffers == NULL) { 1482 char * _buffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1483 buffers = (GLuint *) (_buffersBase + _bufferOffset); 1484 } 1485 glGenBuffers( 1486 (GLsizei)n, 1487 (GLuint *)buffers 1488 ); 1489 1490exit: 1491 if (_array) { 1492 _env->ReleaseIntArrayElements(_array, (jint*)buffers, _exception ? JNI_ABORT : 0); 1493 } 1494 if (_exception) { 1495 jniThrowException(_env, _exceptionType, _exceptionMessage); 1496 } 1497} 1498 1499/* void glGenerateMipmap ( GLenum target ) */ 1500static void 1501android_glGenerateMipmap__I 1502 (JNIEnv *_env, jobject _this, jint target) { 1503 glGenerateMipmap( 1504 (GLenum)target 1505 ); 1506} 1507 1508/* void glGenFramebuffers ( GLsizei n, GLuint *framebuffers ) */ 1509static void 1510android_glGenFramebuffers__I_3II 1511 (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) { 1512 jint _exception = 0; 1513 const char * _exceptionType = NULL; 1514 const char * _exceptionMessage = NULL; 1515 GLuint *framebuffers_base = (GLuint *) 0; 1516 jint _remaining; 1517 GLuint *framebuffers = (GLuint *) 0; 1518 1519 if (!framebuffers_ref) { 1520 _exception = 1; 1521 _exceptionType = "java/lang/IllegalArgumentException"; 1522 _exceptionMessage = "framebuffers == null"; 1523 goto exit; 1524 } 1525 if (offset < 0) { 1526 _exception = 1; 1527 _exceptionType = "java/lang/IllegalArgumentException"; 1528 _exceptionMessage = "offset < 0"; 1529 goto exit; 1530 } 1531 _remaining = _env->GetArrayLength(framebuffers_ref) - offset; 1532 if (_remaining < n) { 1533 _exception = 1; 1534 _exceptionType = "java/lang/IllegalArgumentException"; 1535 _exceptionMessage = "length - offset < n < needed"; 1536 goto exit; 1537 } 1538 framebuffers_base = (GLuint *) 1539 _env->GetIntArrayElements(framebuffers_ref, (jboolean *)0); 1540 framebuffers = framebuffers_base + offset; 1541 1542 glGenFramebuffers( 1543 (GLsizei)n, 1544 (GLuint *)framebuffers 1545 ); 1546 1547exit: 1548 if (framebuffers_base) { 1549 _env->ReleaseIntArrayElements(framebuffers_ref, (jint*)framebuffers_base, 1550 _exception ? JNI_ABORT: 0); 1551 } 1552 if (_exception) { 1553 jniThrowException(_env, _exceptionType, _exceptionMessage); 1554 } 1555} 1556 1557/* void glGenFramebuffers ( GLsizei n, GLuint *framebuffers ) */ 1558static void 1559android_glGenFramebuffers__ILjava_nio_IntBuffer_2 1560 (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) { 1561 jint _exception = 0; 1562 const char * _exceptionType = NULL; 1563 const char * _exceptionMessage = NULL; 1564 jintArray _array = (jintArray) 0; 1565 jint _bufferOffset = (jint) 0; 1566 jint _remaining; 1567 GLuint *framebuffers = (GLuint *) 0; 1568 1569 framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1570 if (_remaining < n) { 1571 _exception = 1; 1572 _exceptionType = "java/lang/IllegalArgumentException"; 1573 _exceptionMessage = "remaining() < n < needed"; 1574 goto exit; 1575 } 1576 if (framebuffers == NULL) { 1577 char * _framebuffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1578 framebuffers = (GLuint *) (_framebuffersBase + _bufferOffset); 1579 } 1580 glGenFramebuffers( 1581 (GLsizei)n, 1582 (GLuint *)framebuffers 1583 ); 1584 1585exit: 1586 if (_array) { 1587 _env->ReleaseIntArrayElements(_array, (jint*)framebuffers, _exception ? JNI_ABORT : 0); 1588 } 1589 if (_exception) { 1590 jniThrowException(_env, _exceptionType, _exceptionMessage); 1591 } 1592} 1593 1594/* void glGenRenderbuffers ( GLsizei n, GLuint *renderbuffers ) */ 1595static void 1596android_glGenRenderbuffers__I_3II 1597 (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) { 1598 jint _exception = 0; 1599 const char * _exceptionType = NULL; 1600 const char * _exceptionMessage = NULL; 1601 GLuint *renderbuffers_base = (GLuint *) 0; 1602 jint _remaining; 1603 GLuint *renderbuffers = (GLuint *) 0; 1604 1605 if (!renderbuffers_ref) { 1606 _exception = 1; 1607 _exceptionType = "java/lang/IllegalArgumentException"; 1608 _exceptionMessage = "renderbuffers == null"; 1609 goto exit; 1610 } 1611 if (offset < 0) { 1612 _exception = 1; 1613 _exceptionType = "java/lang/IllegalArgumentException"; 1614 _exceptionMessage = "offset < 0"; 1615 goto exit; 1616 } 1617 _remaining = _env->GetArrayLength(renderbuffers_ref) - offset; 1618 if (_remaining < n) { 1619 _exception = 1; 1620 _exceptionType = "java/lang/IllegalArgumentException"; 1621 _exceptionMessage = "length - offset < n < needed"; 1622 goto exit; 1623 } 1624 renderbuffers_base = (GLuint *) 1625 _env->GetIntArrayElements(renderbuffers_ref, (jboolean *)0); 1626 renderbuffers = renderbuffers_base + offset; 1627 1628 glGenRenderbuffers( 1629 (GLsizei)n, 1630 (GLuint *)renderbuffers 1631 ); 1632 1633exit: 1634 if (renderbuffers_base) { 1635 _env->ReleaseIntArrayElements(renderbuffers_ref, (jint*)renderbuffers_base, 1636 _exception ? JNI_ABORT: 0); 1637 } 1638 if (_exception) { 1639 jniThrowException(_env, _exceptionType, _exceptionMessage); 1640 } 1641} 1642 1643/* void glGenRenderbuffers ( GLsizei n, GLuint *renderbuffers ) */ 1644static void 1645android_glGenRenderbuffers__ILjava_nio_IntBuffer_2 1646 (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) { 1647 jint _exception = 0; 1648 const char * _exceptionType = NULL; 1649 const char * _exceptionMessage = NULL; 1650 jintArray _array = (jintArray) 0; 1651 jint _bufferOffset = (jint) 0; 1652 jint _remaining; 1653 GLuint *renderbuffers = (GLuint *) 0; 1654 1655 renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1656 if (_remaining < n) { 1657 _exception = 1; 1658 _exceptionType = "java/lang/IllegalArgumentException"; 1659 _exceptionMessage = "remaining() < n < needed"; 1660 goto exit; 1661 } 1662 if (renderbuffers == NULL) { 1663 char * _renderbuffersBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1664 renderbuffers = (GLuint *) (_renderbuffersBase + _bufferOffset); 1665 } 1666 glGenRenderbuffers( 1667 (GLsizei)n, 1668 (GLuint *)renderbuffers 1669 ); 1670 1671exit: 1672 if (_array) { 1673 _env->ReleaseIntArrayElements(_array, (jint*)renderbuffers, _exception ? JNI_ABORT : 0); 1674 } 1675 if (_exception) { 1676 jniThrowException(_env, _exceptionType, _exceptionMessage); 1677 } 1678} 1679 1680/* void glGenTextures ( GLsizei n, GLuint *textures ) */ 1681static void 1682android_glGenTextures__I_3II 1683 (JNIEnv *_env, jobject _this, jint n, jintArray textures_ref, jint offset) { 1684 jint _exception = 0; 1685 const char * _exceptionType = NULL; 1686 const char * _exceptionMessage = NULL; 1687 GLuint *textures_base = (GLuint *) 0; 1688 jint _remaining; 1689 GLuint *textures = (GLuint *) 0; 1690 1691 if (!textures_ref) { 1692 _exception = 1; 1693 _exceptionType = "java/lang/IllegalArgumentException"; 1694 _exceptionMessage = "textures == null"; 1695 goto exit; 1696 } 1697 if (offset < 0) { 1698 _exception = 1; 1699 _exceptionType = "java/lang/IllegalArgumentException"; 1700 _exceptionMessage = "offset < 0"; 1701 goto exit; 1702 } 1703 _remaining = _env->GetArrayLength(textures_ref) - offset; 1704 if (_remaining < n) { 1705 _exception = 1; 1706 _exceptionType = "java/lang/IllegalArgumentException"; 1707 _exceptionMessage = "length - offset < n < needed"; 1708 goto exit; 1709 } 1710 textures_base = (GLuint *) 1711 _env->GetIntArrayElements(textures_ref, (jboolean *)0); 1712 textures = textures_base + offset; 1713 1714 glGenTextures( 1715 (GLsizei)n, 1716 (GLuint *)textures 1717 ); 1718 1719exit: 1720 if (textures_base) { 1721 _env->ReleaseIntArrayElements(textures_ref, (jint*)textures_base, 1722 _exception ? JNI_ABORT: 0); 1723 } 1724 if (_exception) { 1725 jniThrowException(_env, _exceptionType, _exceptionMessage); 1726 } 1727} 1728 1729/* void glGenTextures ( GLsizei n, GLuint *textures ) */ 1730static void 1731android_glGenTextures__ILjava_nio_IntBuffer_2 1732 (JNIEnv *_env, jobject _this, jint n, jobject textures_buf) { 1733 jint _exception = 0; 1734 const char * _exceptionType = NULL; 1735 const char * _exceptionMessage = NULL; 1736 jintArray _array = (jintArray) 0; 1737 jint _bufferOffset = (jint) 0; 1738 jint _remaining; 1739 GLuint *textures = (GLuint *) 0; 1740 1741 textures = (GLuint *)getPointer(_env, textures_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1742 if (_remaining < n) { 1743 _exception = 1; 1744 _exceptionType = "java/lang/IllegalArgumentException"; 1745 _exceptionMessage = "remaining() < n < needed"; 1746 goto exit; 1747 } 1748 if (textures == NULL) { 1749 char * _texturesBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1750 textures = (GLuint *) (_texturesBase + _bufferOffset); 1751 } 1752 glGenTextures( 1753 (GLsizei)n, 1754 (GLuint *)textures 1755 ); 1756 1757exit: 1758 if (_array) { 1759 _env->ReleaseIntArrayElements(_array, (jint*)textures, _exception ? JNI_ABORT : 0); 1760 } 1761 if (_exception) { 1762 jniThrowException(_env, _exceptionType, _exceptionMessage); 1763 } 1764} 1765 1766/* void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */ 1767static void 1768android_glGetActiveAttrib__III_3II_3II_3II_3BI 1769 (JNIEnv *_env, jobject _this, jint program, jint index, jint bufsize, jintArray length_ref, jint lengthOffset, jintArray size_ref, jint sizeOffset, jintArray type_ref, jint typeOffset, jbyteArray name_ref, jint nameOffset) { 1770 jint _exception = 0; 1771 const char * _exceptionType; 1772 const char * _exceptionMessage; 1773 GLsizei *length_base = (GLsizei *) 0; 1774 jint _lengthRemaining; 1775 GLsizei *length = (GLsizei *) 0; 1776 GLint *size_base = (GLint *) 0; 1777 jint _sizeRemaining; 1778 GLint *size = (GLint *) 0; 1779 GLenum *type_base = (GLenum *) 0; 1780 jint _typeRemaining; 1781 GLenum *type = (GLenum *) 0; 1782 char *name_base = (char *) 0; 1783 jint _nameRemaining; 1784 char *name = (char *) 0; 1785 1786 if (length_ref) { 1787 if (lengthOffset < 0) { 1788 _exception = 1; 1789 _exceptionType = "java/lang/IllegalArgumentException"; 1790 _exceptionMessage = "lengthOffset < 0"; 1791 goto exit; 1792 } 1793 _lengthRemaining = _env->GetArrayLength(length_ref) - lengthOffset; 1794 length_base = (GLsizei *) 1795 _env->GetIntArrayElements(length_ref, (jboolean *)0); 1796 length = length_base + lengthOffset; 1797 } 1798 1799 if (!size_ref) { 1800 _exception = 1; 1801 _exceptionType = "java/lang/IllegalArgumentException"; 1802 _exceptionMessage = "size == null"; 1803 goto exit; 1804 } 1805 if (sizeOffset < 0) { 1806 _exception = 1; 1807 _exceptionType = "java/lang/IllegalArgumentException"; 1808 _exceptionMessage = "sizeOffset < 0"; 1809 goto exit; 1810 } 1811 _sizeRemaining = _env->GetArrayLength(size_ref) - sizeOffset; 1812 size_base = (GLint *) 1813 _env->GetIntArrayElements(size_ref, (jboolean *)0); 1814 size = size_base + sizeOffset; 1815 1816 if (!type_ref) { 1817 _exception = 1; 1818 _exceptionType = "java/lang/IllegalArgumentException"; 1819 _exceptionMessage = "type == null"; 1820 goto exit; 1821 } 1822 if (typeOffset < 0) { 1823 _exception = 1; 1824 _exceptionType = "java/lang/IllegalArgumentException"; 1825 _exceptionMessage = "typeOffset < 0"; 1826 goto exit; 1827 } 1828 _typeRemaining = _env->GetArrayLength(type_ref) - typeOffset; 1829 type_base = (GLenum *) 1830 _env->GetIntArrayElements(type_ref, (jboolean *)0); 1831 type = type_base + typeOffset; 1832 1833 if (!name_ref) { 1834 _exception = 1; 1835 _exceptionType = "java/lang/IllegalArgumentException"; 1836 _exceptionMessage = "name == null"; 1837 goto exit; 1838 } 1839 if (nameOffset < 0) { 1840 _exception = 1; 1841 _exceptionType = "java/lang/IllegalArgumentException"; 1842 _exceptionMessage = "nameOffset < 0"; 1843 goto exit; 1844 } 1845 _nameRemaining = _env->GetArrayLength(name_ref) - nameOffset; 1846 name_base = (char *) 1847 _env->GetByteArrayElements(name_ref, (jboolean *)0); 1848 name = name_base + nameOffset; 1849 1850 glGetActiveAttrib( 1851 (GLuint)program, 1852 (GLuint)index, 1853 (GLsizei)bufsize, 1854 (GLsizei *)length, 1855 (GLint *)size, 1856 (GLenum *)type, 1857 (char *)name 1858 ); 1859 1860exit: 1861 if (name_base) { 1862 _env->ReleaseByteArrayElements(name_ref, (jbyte*)name_base, 1863 _exception ? JNI_ABORT: 0); 1864 } 1865 if (type_base) { 1866 _env->ReleaseIntArrayElements(type_ref, (jint*)type_base, 1867 _exception ? JNI_ABORT: 0); 1868 } 1869 if (size_base) { 1870 _env->ReleaseIntArrayElements(size_ref, (jint*)size_base, 1871 _exception ? JNI_ABORT: 0); 1872 } 1873 if (length_base) { 1874 _env->ReleaseIntArrayElements(length_ref, (jint*)length_base, 1875 _exception ? JNI_ABORT: 0); 1876 } 1877 if (_exception) { 1878 jniThrowException(_env, _exceptionType, _exceptionMessage); 1879 } 1880} 1881 1882/* void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */ 1883static void 1884android_glGetActiveAttrib__IIILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2B 1885 (JNIEnv *_env, jobject _this, jint program, jint index, jint bufsize, jobject length_buf, jobject size_buf, jobject type_buf, jbyte name) { 1886 jintArray _lengthArray = (jintArray) 0; 1887 jint _lengthBufferOffset = (jint) 0; 1888 jintArray _sizeArray = (jintArray) 0; 1889 jint _sizeBufferOffset = (jint) 0; 1890 jintArray _typeArray = (jintArray) 0; 1891 jint _typeBufferOffset = (jint) 0; 1892 jint _lengthRemaining; 1893 GLsizei *length = (GLsizei *) 0; 1894 jint _sizeRemaining; 1895 GLint *size = (GLint *) 0; 1896 jint _typeRemaining; 1897 GLenum *type = (GLenum *) 0; 1898 1899 length = (GLsizei *)getPointer(_env, length_buf, (jarray*)&_lengthArray, &_lengthRemaining, &_lengthBufferOffset); 1900 size = (GLint *)getPointer(_env, size_buf, (jarray*)&_sizeArray, &_sizeRemaining, &_sizeBufferOffset); 1901 type = (GLenum *)getPointer(_env, type_buf, (jarray*)&_typeArray, &_typeRemaining, &_typeBufferOffset); 1902 if (length == NULL) { 1903 char * _lengthBase = (char *)_env->GetIntArrayElements(_lengthArray, (jboolean *) 0); 1904 length = (GLsizei *) (_lengthBase + _lengthBufferOffset); 1905 } 1906 if (size == NULL) { 1907 char * _sizeBase = (char *)_env->GetIntArrayElements(_sizeArray, (jboolean *) 0); 1908 size = (GLint *) (_sizeBase + _sizeBufferOffset); 1909 } 1910 if (type == NULL) { 1911 char * _typeBase = (char *)_env->GetIntArrayElements(_typeArray, (jboolean *) 0); 1912 type = (GLenum *) (_typeBase + _typeBufferOffset); 1913 } 1914 glGetActiveAttrib( 1915 (GLuint)program, 1916 (GLuint)index, 1917 (GLsizei)bufsize, 1918 (GLsizei *)length, 1919 (GLint *)size, 1920 (GLenum *)type, 1921 reinterpret_cast<char *>(name) 1922 ); 1923 if (_typeArray) { 1924 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _typeArray, (jint*)type, JNI_TRUE); 1925 } 1926 if (_sizeArray) { 1927 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _sizeArray, (jint*)size, JNI_TRUE); 1928 } 1929 if (_lengthArray) { 1930 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _lengthArray, (jint*)length, JNI_TRUE); 1931 } 1932} 1933 1934/* void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */ 1935static jstring 1936android_glGetActiveAttrib1 1937 (JNIEnv *_env, jobject _this, jint program, jint index, jintArray size_ref, jint sizeOffset, jintArray type_ref, jint typeOffset) { 1938 jint _exception = 0; 1939 const char * _exceptionType; 1940 const char * _exceptionMessage; 1941 GLint *size_base = (GLint *) 0; 1942 jint _sizeRemaining; 1943 GLint *size = (GLint *) 0; 1944 GLenum *type_base = (GLenum *) 0; 1945 jint _typeRemaining; 1946 GLenum *type = (GLenum *) 0; 1947 1948 jstring result = 0; 1949 1950 GLint len = 0; 1951 glGetProgramiv((GLuint)program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &len); 1952 if (!len) { 1953 return _env->NewStringUTF(""); 1954 } 1955 char* buf = (char*) malloc(len); 1956 1957 if (buf == NULL) { 1958 jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory"); 1959 return NULL; 1960 } 1961 if (!size_ref) { 1962 _exception = 1; 1963 _exceptionType = "java/lang/IllegalArgumentException"; 1964 _exceptionMessage = "size == null"; 1965 goto exit; 1966 } 1967 if (sizeOffset < 0) { 1968 _exception = 1; 1969 _exceptionType = "java/lang/IllegalArgumentException"; 1970 _exceptionMessage = "sizeOffset < 0"; 1971 goto exit; 1972 } 1973 _sizeRemaining = _env->GetArrayLength(size_ref) - sizeOffset; 1974 size_base = (GLint *) 1975 _env->GetIntArrayElements(size_ref, (jboolean *)0); 1976 size = size_base + sizeOffset; 1977 1978 if (!type_ref) { 1979 _exception = 1; 1980 _exceptionType = "java/lang/IllegalArgumentException"; 1981 _exceptionMessage = "type == null"; 1982 goto exit; 1983 } 1984 if (typeOffset < 0) { 1985 _exception = 1; 1986 _exceptionType = "java/lang/IllegalArgumentException"; 1987 _exceptionMessage = "typeOffset < 0"; 1988 goto exit; 1989 } 1990 _typeRemaining = _env->GetArrayLength(type_ref) - typeOffset; 1991 type_base = (GLenum *) 1992 _env->GetIntArrayElements(type_ref, (jboolean *)0); 1993 type = type_base + typeOffset; 1994 1995 glGetActiveAttrib( 1996 (GLuint)program, 1997 (GLuint)index, 1998 (GLsizei)len, 1999 NULL, 2000 (GLint *)size, 2001 (GLenum *)type, 2002 (char *)buf 2003 ); 2004exit: 2005 if (type_base) { 2006 _env->ReleaseIntArrayElements(type_ref, (jint*)type_base, 2007 _exception ? JNI_ABORT: 0); 2008 } 2009 if (size_base) { 2010 _env->ReleaseIntArrayElements(size_ref, (jint*)size_base, 2011 _exception ? JNI_ABORT: 0); 2012 } 2013 if (_exception != 1) { 2014 result = _env->NewStringUTF(buf); 2015 } 2016 if (buf) { 2017 free(buf); 2018 } 2019 if (_exception) { 2020 jniThrowException(_env, _exceptionType, _exceptionMessage); 2021 } 2022 if (result == 0) { 2023 result = _env->NewStringUTF(""); 2024 } 2025 2026 return result; 2027} 2028 2029/* void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */ 2030static jstring 2031android_glGetActiveAttrib2 2032 (JNIEnv *_env, jobject _this, jint program, jint index, jobject size_buf, jobject type_buf) { 2033 jintArray _sizeArray = (jintArray) 0; 2034 jint _sizeBufferOffset = (jint) 0; 2035 jintArray _typeArray = (jintArray) 0; 2036 jint _typeBufferOffset = (jint) 0; 2037 jint _lengthRemaining; 2038 GLsizei *length = (GLsizei *) 0; 2039 jint _sizeRemaining; 2040 GLint *size = (GLint *) 0; 2041 jint _typeRemaining; 2042 GLenum *type = (GLenum *) 0; 2043 2044 jstring result = 0; 2045 2046 GLint len = 0; 2047 glGetProgramiv((GLuint)program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &len); 2048 if (!len) { 2049 return _env->NewStringUTF(""); 2050 } 2051 char* buf = (char*) malloc(len); 2052 2053 if (buf == NULL) { 2054 jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory"); 2055 return NULL; 2056 } 2057 2058 size = (GLint *)getPointer(_env, size_buf, (jarray*)&_sizeArray, &_sizeRemaining, &_sizeBufferOffset); 2059 type = (GLenum *)getPointer(_env, type_buf, (jarray*)&_typeArray, &_typeRemaining, &_typeBufferOffset); 2060 if (size == NULL) { 2061 char * _sizeBase = (char *)_env->GetIntArrayElements(_sizeArray, (jboolean *) 0); 2062 size = (GLint *) (_sizeBase + _sizeBufferOffset); 2063 } 2064 if (type == NULL) { 2065 char * _typeBase = (char *)_env->GetIntArrayElements(_typeArray, (jboolean *) 0); 2066 type = (GLenum *) (_typeBase + _typeBufferOffset); 2067 } 2068 glGetActiveAttrib( 2069 (GLuint)program, 2070 (GLuint)index, 2071 (GLsizei)len, 2072 NULL, 2073 (GLint *)size, 2074 (GLenum *)type, 2075 (char *)buf 2076 ); 2077 2078 if (_typeArray) { 2079 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _typeArray, (jint*)type, JNI_TRUE); 2080 } 2081 if (_sizeArray) { 2082 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _sizeArray, (jint*)size, JNI_TRUE); 2083 } 2084 result = _env->NewStringUTF(buf); 2085 if (buf) { 2086 free(buf); 2087 } 2088 return result; 2089} 2090/* void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */ 2091static void 2092android_glGetActiveUniform__III_3II_3II_3II_3BI 2093 (JNIEnv *_env, jobject _this, jint program, jint index, jint bufsize, jintArray length_ref, jint lengthOffset, jintArray size_ref, jint sizeOffset, jintArray type_ref, jint typeOffset, jbyteArray name_ref, jint nameOffset) { 2094 jint _exception = 0; 2095 const char * _exceptionType; 2096 const char * _exceptionMessage; 2097 GLsizei *length_base = (GLsizei *) 0; 2098 jint _lengthRemaining; 2099 GLsizei *length = (GLsizei *) 0; 2100 GLint *size_base = (GLint *) 0; 2101 jint _sizeRemaining; 2102 GLint *size = (GLint *) 0; 2103 GLenum *type_base = (GLenum *) 0; 2104 jint _typeRemaining; 2105 GLenum *type = (GLenum *) 0; 2106 char *name_base = (char *) 0; 2107 jint _nameRemaining; 2108 char *name = (char *) 0; 2109 2110 if (length_ref) { 2111 if (lengthOffset < 0) { 2112 _exception = 1; 2113 _exceptionType = "java/lang/IllegalArgumentException"; 2114 _exceptionMessage = "lengthOffset < 0"; 2115 goto exit; 2116 } 2117 _lengthRemaining = _env->GetArrayLength(length_ref) - lengthOffset; 2118 length_base = (GLsizei *) 2119 _env->GetIntArrayElements(length_ref, (jboolean *)0); 2120 length = length_base + lengthOffset; 2121 } 2122 2123 if (!size_ref) { 2124 _exception = 1; 2125 _exceptionType = "java/lang/IllegalArgumentException"; 2126 _exceptionMessage = "size == null"; 2127 goto exit; 2128 } 2129 if (sizeOffset < 0) { 2130 _exception = 1; 2131 _exceptionType = "java/lang/IllegalArgumentException"; 2132 _exceptionMessage = "sizeOffset < 0"; 2133 goto exit; 2134 } 2135 _sizeRemaining = _env->GetArrayLength(size_ref) - sizeOffset; 2136 size_base = (GLint *) 2137 _env->GetIntArrayElements(size_ref, (jboolean *)0); 2138 size = size_base + sizeOffset; 2139 2140 if (!type_ref) { 2141 _exception = 1; 2142 _exceptionType = "java/lang/IllegalArgumentException"; 2143 _exceptionMessage = "type == null"; 2144 goto exit; 2145 } 2146 if (typeOffset < 0) { 2147 _exception = 1; 2148 _exceptionType = "java/lang/IllegalArgumentException"; 2149 _exceptionMessage = "typeOffset < 0"; 2150 goto exit; 2151 } 2152 _typeRemaining = _env->GetArrayLength(type_ref) - typeOffset; 2153 type_base = (GLenum *) 2154 _env->GetIntArrayElements(type_ref, (jboolean *)0); 2155 type = type_base + typeOffset; 2156 2157 if (!name_ref) { 2158 _exception = 1; 2159 _exceptionType = "java/lang/IllegalArgumentException"; 2160 _exceptionMessage = "name == null"; 2161 goto exit; 2162 } 2163 if (nameOffset < 0) { 2164 _exception = 1; 2165 _exceptionType = "java/lang/IllegalArgumentException"; 2166 _exceptionMessage = "nameOffset < 0"; 2167 goto exit; 2168 } 2169 _nameRemaining = _env->GetArrayLength(name_ref) - nameOffset; 2170 name_base = (char *) 2171 _env->GetByteArrayElements(name_ref, (jboolean *)0); 2172 name = name_base + nameOffset; 2173 2174 glGetActiveUniform( 2175 (GLuint)program, 2176 (GLuint)index, 2177 (GLsizei)bufsize, 2178 (GLsizei *)length, 2179 (GLint *)size, 2180 (GLenum *)type, 2181 (char *)name 2182 ); 2183 2184exit: 2185 if (name_base) { 2186 _env->ReleaseByteArrayElements(name_ref, (jbyte*)name_base, 2187 _exception ? JNI_ABORT: 0); 2188 } 2189 if (type_base) { 2190 _env->ReleaseIntArrayElements(type_ref, (jint*)type_base, 2191 _exception ? JNI_ABORT: 0); 2192 } 2193 if (size_base) { 2194 _env->ReleaseIntArrayElements(size_ref, (jint*)size_base, 2195 _exception ? JNI_ABORT: 0); 2196 } 2197 if (length_base) { 2198 _env->ReleaseIntArrayElements(length_ref, (jint*)length_base, 2199 _exception ? JNI_ABORT: 0); 2200 } 2201 if (_exception) { 2202 jniThrowException(_env, _exceptionType, _exceptionMessage); 2203 } 2204} 2205 2206/* void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */ 2207static void 2208android_glGetActiveUniform__IIILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2B 2209 (JNIEnv *_env, jobject _this, jint program, jint index, jint bufsize, jobject length_buf, jobject size_buf, jobject type_buf, jbyte name) { 2210 jintArray _lengthArray = (jintArray) 0; 2211 jint _lengthBufferOffset = (jint) 0; 2212 jintArray _sizeArray = (jintArray) 0; 2213 jint _sizeBufferOffset = (jint) 0; 2214 jintArray _typeArray = (jintArray) 0; 2215 jint _typeBufferOffset = (jint) 0; 2216 jint _lengthRemaining; 2217 GLsizei *length = (GLsizei *) 0; 2218 jint _sizeRemaining; 2219 GLint *size = (GLint *) 0; 2220 jint _typeRemaining; 2221 GLenum *type = (GLenum *) 0; 2222 2223 length = (GLsizei *)getPointer(_env, length_buf, (jarray*)&_lengthArray, &_lengthRemaining, &_lengthBufferOffset); 2224 size = (GLint *)getPointer(_env, size_buf, (jarray*)&_sizeArray, &_sizeRemaining, &_sizeBufferOffset); 2225 type = (GLenum *)getPointer(_env, type_buf, (jarray*)&_typeArray, &_typeRemaining, &_typeBufferOffset); 2226 if (length == NULL) { 2227 char * _lengthBase = (char *)_env->GetIntArrayElements(_lengthArray, (jboolean *) 0); 2228 length = (GLsizei *) (_lengthBase + _lengthBufferOffset); 2229 } 2230 if (size == NULL) { 2231 char * _sizeBase = (char *)_env->GetIntArrayElements(_sizeArray, (jboolean *) 0); 2232 size = (GLint *) (_sizeBase + _sizeBufferOffset); 2233 } 2234 if (type == NULL) { 2235 char * _typeBase = (char *)_env->GetIntArrayElements(_typeArray, (jboolean *) 0); 2236 type = (GLenum *) (_typeBase + _typeBufferOffset); 2237 } 2238 glGetActiveUniform( 2239 (GLuint)program, 2240 (GLuint)index, 2241 (GLsizei)bufsize, 2242 (GLsizei *)length, 2243 (GLint *)size, 2244 (GLenum *)type, 2245 reinterpret_cast<char *>(name) 2246 ); 2247 if (_typeArray) { 2248 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _typeArray, (jint*)type, JNI_TRUE); 2249 } 2250 if (_sizeArray) { 2251 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _sizeArray, (jint*)size, JNI_TRUE); 2252 } 2253 if (_lengthArray) { 2254 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _lengthArray, (jint*)length, JNI_TRUE); 2255 } 2256} 2257 2258/* void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */ 2259static jstring 2260android_glGetActiveUniform1 2261 (JNIEnv *_env, jobject _this, jint program, jint index, jintArray size_ref, jint sizeOffset, jintArray type_ref, jint typeOffset) { 2262 jint _exception = 0; 2263 const char * _exceptionType; 2264 const char * _exceptionMessage; 2265 2266 GLint *size_base = (GLint *) 0; 2267 jint _sizeRemaining; 2268 GLint *size = (GLint *) 0; 2269 2270 GLenum *type_base = (GLenum *) 0; 2271 jint _typeRemaining; 2272 GLenum *type = (GLenum *) 0; 2273 2274 jstring result = 0; 2275 2276 GLint len = 0; 2277 glGetProgramiv((GLuint)program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &len); 2278 if (!len) { 2279 return _env->NewStringUTF(""); 2280 } 2281 char* buf = (char*) malloc(len); 2282 2283 if (buf == NULL) { 2284 jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory"); 2285 return NULL; 2286 } 2287 2288 if (!size_ref) { 2289 _exception = 1; 2290 _exceptionType = "java/lang/IllegalArgumentException"; 2291 _exceptionMessage = "size == null"; 2292 goto exit; 2293 } 2294 if (sizeOffset < 0) { 2295 _exception = 1; 2296 _exceptionType = "java/lang/IllegalArgumentException"; 2297 _exceptionMessage = "sizeOffset < 0"; 2298 goto exit; 2299 } 2300 _sizeRemaining = _env->GetArrayLength(size_ref) - sizeOffset; 2301 size_base = (GLint *) 2302 _env->GetIntArrayElements(size_ref, (jboolean *)0); 2303 size = size_base + sizeOffset; 2304 2305 if (!type_ref) { 2306 _exception = 1; 2307 _exceptionType = "java/lang/IllegalArgumentException"; 2308 _exceptionMessage = "type == null"; 2309 goto exit; 2310 } 2311 if (typeOffset < 0) { 2312 _exception = 1; 2313 _exceptionType = "java/lang/IllegalArgumentException"; 2314 _exceptionMessage = "typeOffset < 0"; 2315 goto exit; 2316 } 2317 _typeRemaining = _env->GetArrayLength(type_ref) - typeOffset; 2318 type_base = (GLenum *) 2319 _env->GetIntArrayElements(type_ref, (jboolean *)0); 2320 type = type_base + typeOffset; 2321 2322 glGetActiveUniform( 2323 (GLuint)program, 2324 (GLuint)index, 2325 (GLsizei)len, 2326 NULL, 2327 (GLint *)size, 2328 (GLenum *)type, 2329 (char *)buf 2330 ); 2331 2332exit: 2333 if (type_base) { 2334 _env->ReleaseIntArrayElements(type_ref, (jint*)type_base, 2335 _exception ? JNI_ABORT: 0); 2336 } 2337 if (size_base) { 2338 _env->ReleaseIntArrayElements(size_ref, (jint*)size_base, 2339 _exception ? JNI_ABORT: 0); 2340 } 2341 if (_exception != 1) { 2342 result = _env->NewStringUTF(buf); 2343 } 2344 if (buf) { 2345 free(buf); 2346 } 2347 if (_exception) { 2348 jniThrowException(_env, _exceptionType, _exceptionMessage); 2349 } 2350 if (result == 0) { 2351 result = _env->NewStringUTF(""); 2352 } 2353 return result; 2354} 2355 2356/* void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */ 2357static jstring 2358android_glGetActiveUniform2 2359 (JNIEnv *_env, jobject _this, jint program, jint index, jobject size_buf, jobject type_buf) { 2360 jintArray _sizeArray = (jintArray) 0; 2361 jint _sizeBufferOffset = (jint) 0; 2362 jintArray _typeArray = (jintArray) 0; 2363 jint _typeBufferOffset = (jint) 0; 2364 jint _sizeRemaining; 2365 GLint *size = (GLint *) 0; 2366 jint _typeRemaining; 2367 GLenum *type = (GLenum *) 0; 2368 2369 jstring result = 0; 2370 GLint len = 0; 2371 glGetProgramiv((GLuint)program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &len); 2372 if (!len) { 2373 return _env->NewStringUTF(""); 2374 } 2375 char* buf = (char*) malloc(len); 2376 2377 if (buf == NULL) { 2378 jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory"); 2379 return NULL; 2380 } 2381 2382 size = (GLint *)getPointer(_env, size_buf, (jarray*)&_sizeArray, &_sizeRemaining, &_sizeBufferOffset); 2383 type = (GLenum *)getPointer(_env, type_buf, (jarray*)&_typeArray, &_typeRemaining, &_typeBufferOffset); 2384 2385 if (size == NULL) { 2386 char * _sizeBase = (char *)_env->GetIntArrayElements(_sizeArray, (jboolean *) 0); 2387 size = (GLint *) (_sizeBase + _sizeBufferOffset); 2388 } 2389 if (type == NULL) { 2390 char * _typeBase = (char *)_env->GetIntArrayElements(_typeArray, (jboolean *) 0); 2391 type = (GLenum *) (_typeBase + _typeBufferOffset); 2392 } 2393 glGetActiveUniform( 2394 (GLuint)program, 2395 (GLuint)index, 2396 len, 2397 NULL, 2398 (GLint *)size, 2399 (GLenum *)type, 2400 (char *)buf 2401 ); 2402 2403 if (_typeArray) { 2404 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _typeArray, (jint*)type, JNI_TRUE); 2405 } 2406 if (_sizeArray) { 2407 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _sizeArray, (jint*)size, JNI_TRUE); 2408 } 2409 result = _env->NewStringUTF(buf); 2410 if (buf) { 2411 free(buf); 2412 } 2413 return result; 2414} 2415/* void glGetAttachedShaders ( GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders ) */ 2416static void 2417android_glGetAttachedShaders__II_3II_3II 2418 (JNIEnv *_env, jobject _this, jint program, jint maxcount, jintArray count_ref, jint countOffset, jintArray shaders_ref, jint shadersOffset) { 2419 jint _exception = 0; 2420 const char * _exceptionType = NULL; 2421 const char * _exceptionMessage = NULL; 2422 GLsizei *count_base = (GLsizei *) 0; 2423 jint _countRemaining; 2424 GLsizei *count = (GLsizei *) 0; 2425 GLuint *shaders_base = (GLuint *) 0; 2426 jint _shadersRemaining; 2427 GLuint *shaders = (GLuint *) 0; 2428 2429 if (count_ref) { 2430 if (countOffset < 0) { 2431 _exception = 1; 2432 _exceptionType = "java/lang/IllegalArgumentException"; 2433 _exceptionMessage = "countOffset < 0"; 2434 goto exit; 2435 } 2436 _countRemaining = _env->GetArrayLength(count_ref) - countOffset; 2437 if (_countRemaining < 1) { 2438 _exception = 1; 2439 _exceptionType = "java/lang/IllegalArgumentException"; 2440 _exceptionMessage = "length - countOffset < 1 < needed"; 2441 goto exit; 2442 } 2443 count_base = (GLsizei *) 2444 _env->GetIntArrayElements(count_ref, (jboolean *)0); 2445 count = count_base + countOffset; 2446 } 2447 2448 if (!shaders_ref) { 2449 _exception = 1; 2450 _exceptionType = "java/lang/IllegalArgumentException"; 2451 _exceptionMessage = "shaders == null"; 2452 goto exit; 2453 } 2454 if (shadersOffset < 0) { 2455 _exception = 1; 2456 _exceptionType = "java/lang/IllegalArgumentException"; 2457 _exceptionMessage = "shadersOffset < 0"; 2458 goto exit; 2459 } 2460 _shadersRemaining = _env->GetArrayLength(shaders_ref) - shadersOffset; 2461 if (_shadersRemaining < maxcount) { 2462 _exception = 1; 2463 _exceptionType = "java/lang/IllegalArgumentException"; 2464 _exceptionMessage = "length - shadersOffset < maxcount < needed"; 2465 goto exit; 2466 } 2467 shaders_base = (GLuint *) 2468 _env->GetIntArrayElements(shaders_ref, (jboolean *)0); 2469 shaders = shaders_base + shadersOffset; 2470 2471 glGetAttachedShaders( 2472 (GLuint)program, 2473 (GLsizei)maxcount, 2474 (GLsizei *)count, 2475 (GLuint *)shaders 2476 ); 2477 2478exit: 2479 if (shaders_base) { 2480 _env->ReleaseIntArrayElements(shaders_ref, (jint*)shaders_base, 2481 _exception ? JNI_ABORT: 0); 2482 } 2483 if (count_base) { 2484 _env->ReleaseIntArrayElements(count_ref, (jint*)count_base, 2485 _exception ? JNI_ABORT: 0); 2486 } 2487 if (_exception) { 2488 jniThrowException(_env, _exceptionType, _exceptionMessage); 2489 } 2490} 2491 2492/* void glGetAttachedShaders ( GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders ) */ 2493static void 2494android_glGetAttachedShaders__IILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 2495 (JNIEnv *_env, jobject _this, jint program, jint maxcount, jobject count_buf, jobject shaders_buf) { 2496 jint _exception = 0; 2497 const char * _exceptionType = NULL; 2498 const char * _exceptionMessage = NULL; 2499 jintArray _countArray = (jintArray) 0; 2500 jint _countBufferOffset = (jint) 0; 2501 jintArray _shadersArray = (jintArray) 0; 2502 jint _shadersBufferOffset = (jint) 0; 2503 jint _countRemaining; 2504 GLsizei *count = (GLsizei *) 0; 2505 jint _shadersRemaining; 2506 GLuint *shaders = (GLuint *) 0; 2507 2508 if (count_buf) { 2509 count = (GLsizei *)getPointer(_env, count_buf, (jarray*)&_countArray, &_countRemaining, &_countBufferOffset); 2510 if (_countRemaining < 1) { 2511 _exception = 1; 2512 _exceptionType = "java/lang/IllegalArgumentException"; 2513 _exceptionMessage = "remaining() < 1 < needed"; 2514 goto exit; 2515 } 2516 } 2517 shaders = (GLuint *)getPointer(_env, shaders_buf, (jarray*)&_shadersArray, &_shadersRemaining, &_shadersBufferOffset); 2518 if (_shadersRemaining < maxcount) { 2519 _exception = 1; 2520 _exceptionType = "java/lang/IllegalArgumentException"; 2521 _exceptionMessage = "remaining() < maxcount < needed"; 2522 goto exit; 2523 } 2524 if (count_buf && count == NULL) { 2525 char * _countBase = (char *)_env->GetIntArrayElements(_countArray, (jboolean *) 0); 2526 count = (GLsizei *) (_countBase + _countBufferOffset); 2527 } 2528 if (shaders == NULL) { 2529 char * _shadersBase = (char *)_env->GetIntArrayElements(_shadersArray, (jboolean *) 0); 2530 shaders = (GLuint *) (_shadersBase + _shadersBufferOffset); 2531 } 2532 glGetAttachedShaders( 2533 (GLuint)program, 2534 (GLsizei)maxcount, 2535 (GLsizei *)count, 2536 (GLuint *)shaders 2537 ); 2538 2539exit: 2540 if (_shadersArray) { 2541 _env->ReleaseIntArrayElements(_shadersArray, (jint*)shaders, _exception ? JNI_ABORT : 0); 2542 } 2543 if (_countArray) { 2544 _env->ReleaseIntArrayElements(_countArray, (jint*)count, _exception ? JNI_ABORT : 0); 2545 } 2546 if (_exception) { 2547 jniThrowException(_env, _exceptionType, _exceptionMessage); 2548 } 2549} 2550 2551/* GLint glGetAttribLocation ( GLuint program, const char *name ) */ 2552static jint 2553android_glGetAttribLocation__ILjava_lang_String_2 2554 (JNIEnv *_env, jobject _this, jint program, jstring name) { 2555 jint _exception = 0; 2556 const char * _exceptionType = NULL; 2557 const char * _exceptionMessage = NULL; 2558 GLint _returnValue = 0; 2559 const char* _nativename = 0; 2560 2561 if (!name) { 2562 _exception = 1; 2563 _exceptionType = "java/lang/IllegalArgumentException"; 2564 _exceptionMessage = "name == null"; 2565 goto exit; 2566 } 2567 _nativename = _env->GetStringUTFChars(name, 0); 2568 2569 _returnValue = glGetAttribLocation( 2570 (GLuint)program, 2571 (char *)_nativename 2572 ); 2573 2574exit: 2575 if (_nativename) { 2576 _env->ReleaseStringUTFChars(name, _nativename); 2577 } 2578 2579 if (_exception) { 2580 jniThrowException(_env, _exceptionType, _exceptionMessage); 2581 } 2582 return (jint)_returnValue; 2583} 2584 2585/* void glGetBooleanv ( GLenum pname, GLboolean *params ) */ 2586static void 2587android_glGetBooleanv__I_3ZI 2588 (JNIEnv *_env, jobject _this, jint pname, jbooleanArray params_ref, jint offset) { 2589 get<jbooleanArray, BooleanArrayGetter, jboolean*, BooleanArrayReleaser, GLboolean, glGetBooleanv>( 2590 _env, _this, pname, params_ref, offset); 2591} 2592 2593/* void glGetBooleanv ( GLenum pname, GLboolean *params ) */ 2594static void 2595android_glGetBooleanv__ILjava_nio_IntBuffer_2 2596 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 2597 getarray<GLboolean, jintArray, IntArrayGetter, jint*, IntArrayReleaser, glGetBooleanv>( 2598 _env, _this, pname, params_buf); 2599} 2600/* void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 2601static void 2602android_glGetBufferParameteriv__II_3II 2603 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 2604 jint _exception = 0; 2605 const char * _exceptionType = NULL; 2606 const char * _exceptionMessage = NULL; 2607 GLint *params_base = (GLint *) 0; 2608 jint _remaining; 2609 GLint *params = (GLint *) 0; 2610 2611 if (!params_ref) { 2612 _exception = 1; 2613 _exceptionType = "java/lang/IllegalArgumentException"; 2614 _exceptionMessage = "params == null"; 2615 goto exit; 2616 } 2617 if (offset < 0) { 2618 _exception = 1; 2619 _exceptionType = "java/lang/IllegalArgumentException"; 2620 _exceptionMessage = "offset < 0"; 2621 goto exit; 2622 } 2623 _remaining = _env->GetArrayLength(params_ref) - offset; 2624 if (_remaining < 1) { 2625 _exception = 1; 2626 _exceptionType = "java/lang/IllegalArgumentException"; 2627 _exceptionMessage = "length - offset < 1 < needed"; 2628 goto exit; 2629 } 2630 params_base = (GLint *) 2631 _env->GetIntArrayElements(params_ref, (jboolean *)0); 2632 params = params_base + offset; 2633 2634 glGetBufferParameteriv( 2635 (GLenum)target, 2636 (GLenum)pname, 2637 (GLint *)params 2638 ); 2639 2640exit: 2641 if (params_base) { 2642 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 2643 _exception ? JNI_ABORT: 0); 2644 } 2645 if (_exception) { 2646 jniThrowException(_env, _exceptionType, _exceptionMessage); 2647 } 2648} 2649 2650/* void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 2651static void 2652android_glGetBufferParameteriv__IILjava_nio_IntBuffer_2 2653 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 2654 jint _exception = 0; 2655 const char * _exceptionType = NULL; 2656 const char * _exceptionMessage = NULL; 2657 jintArray _array = (jintArray) 0; 2658 jint _bufferOffset = (jint) 0; 2659 jint _remaining; 2660 GLint *params = (GLint *) 0; 2661 2662 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2663 if (_remaining < 1) { 2664 _exception = 1; 2665 _exceptionType = "java/lang/IllegalArgumentException"; 2666 _exceptionMessage = "remaining() < 1 < needed"; 2667 goto exit; 2668 } 2669 if (params == NULL) { 2670 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 2671 params = (GLint *) (_paramsBase + _bufferOffset); 2672 } 2673 glGetBufferParameteriv( 2674 (GLenum)target, 2675 (GLenum)pname, 2676 (GLint *)params 2677 ); 2678 2679exit: 2680 if (_array) { 2681 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 2682 } 2683 if (_exception) { 2684 jniThrowException(_env, _exceptionType, _exceptionMessage); 2685 } 2686} 2687 2688/* GLenum glGetError ( void ) */ 2689static jint 2690android_glGetError__ 2691 (JNIEnv *_env, jobject _this) { 2692 GLenum _returnValue; 2693 _returnValue = glGetError(); 2694 return (jint)_returnValue; 2695} 2696 2697/* void glGetFloatv ( GLenum pname, GLfloat *params ) */ 2698static void 2699android_glGetFloatv__I_3FI 2700 (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) { 2701 get<jfloatArray, FloatArrayGetter, jfloat*, FloatArrayReleaser, GLfloat, glGetFloatv>( 2702 _env, _this, pname, params_ref, offset); 2703} 2704 2705/* void glGetFloatv ( GLenum pname, GLfloat *params ) */ 2706static void 2707android_glGetFloatv__ILjava_nio_FloatBuffer_2 2708 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 2709 getarray<GLfloat, jfloatArray, FloatArrayGetter, jfloat*, FloatArrayReleaser, glGetFloatv>( 2710 _env, _this, pname, params_buf); 2711} 2712/* void glGetFramebufferAttachmentParameteriv ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */ 2713static void 2714android_glGetFramebufferAttachmentParameteriv__III_3II 2715 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jintArray params_ref, jint offset) { 2716 jint _exception = 0; 2717 const char * _exceptionType = NULL; 2718 const char * _exceptionMessage = NULL; 2719 GLint *params_base = (GLint *) 0; 2720 jint _remaining; 2721 GLint *params = (GLint *) 0; 2722 2723 if (!params_ref) { 2724 _exception = 1; 2725 _exceptionType = "java/lang/IllegalArgumentException"; 2726 _exceptionMessage = "params == null"; 2727 goto exit; 2728 } 2729 if (offset < 0) { 2730 _exception = 1; 2731 _exceptionType = "java/lang/IllegalArgumentException"; 2732 _exceptionMessage = "offset < 0"; 2733 goto exit; 2734 } 2735 _remaining = _env->GetArrayLength(params_ref) - offset; 2736 params_base = (GLint *) 2737 _env->GetIntArrayElements(params_ref, (jboolean *)0); 2738 params = params_base + offset; 2739 2740 glGetFramebufferAttachmentParameteriv( 2741 (GLenum)target, 2742 (GLenum)attachment, 2743 (GLenum)pname, 2744 (GLint *)params 2745 ); 2746 2747exit: 2748 if (params_base) { 2749 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 2750 _exception ? JNI_ABORT: 0); 2751 } 2752 if (_exception) { 2753 jniThrowException(_env, _exceptionType, _exceptionMessage); 2754 } 2755} 2756 2757/* void glGetFramebufferAttachmentParameteriv ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */ 2758static void 2759android_glGetFramebufferAttachmentParameteriv__IIILjava_nio_IntBuffer_2 2760 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jobject params_buf) { 2761 jintArray _array = (jintArray) 0; 2762 jint _bufferOffset = (jint) 0; 2763 jint _remaining; 2764 GLint *params = (GLint *) 0; 2765 2766 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2767 if (params == NULL) { 2768 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 2769 params = (GLint *) (_paramsBase + _bufferOffset); 2770 } 2771 glGetFramebufferAttachmentParameteriv( 2772 (GLenum)target, 2773 (GLenum)attachment, 2774 (GLenum)pname, 2775 (GLint *)params 2776 ); 2777 if (_array) { 2778 _env->ReleaseIntArrayElements(_array, (jint*)params, 0); 2779 } 2780} 2781 2782/* void glGetIntegerv ( GLenum pname, GLint *params ) */ 2783static void 2784android_glGetIntegerv__I_3II 2785 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) { 2786 get<jintArray, IntArrayGetter, jint*, IntArrayReleaser, GLint, glGetIntegerv>( 2787 _env, _this, pname, params_ref, offset); 2788} 2789 2790/* void glGetIntegerv ( GLenum pname, GLint *params ) */ 2791static void 2792android_glGetIntegerv__ILjava_nio_IntBuffer_2 2793 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 2794 getarray<GLint, jintArray, IntArrayGetter, jint*, IntArrayReleaser, glGetIntegerv>( 2795 _env, _this, pname, params_buf); 2796} 2797/* void glGetProgramiv ( GLuint program, GLenum pname, GLint *params ) */ 2798static void 2799android_glGetProgramiv__II_3II 2800 (JNIEnv *_env, jobject _this, jint program, jint pname, jintArray params_ref, jint offset) { 2801 jint _exception = 0; 2802 const char * _exceptionType = NULL; 2803 const char * _exceptionMessage = NULL; 2804 GLint *params_base = (GLint *) 0; 2805 jint _remaining; 2806 GLint *params = (GLint *) 0; 2807 2808 if (!params_ref) { 2809 _exception = 1; 2810 _exceptionType = "java/lang/IllegalArgumentException"; 2811 _exceptionMessage = "params == null"; 2812 goto exit; 2813 } 2814 if (offset < 0) { 2815 _exception = 1; 2816 _exceptionType = "java/lang/IllegalArgumentException"; 2817 _exceptionMessage = "offset < 0"; 2818 goto exit; 2819 } 2820 _remaining = _env->GetArrayLength(params_ref) - offset; 2821 if (_remaining < 1) { 2822 _exception = 1; 2823 _exceptionType = "java/lang/IllegalArgumentException"; 2824 _exceptionMessage = "length - offset < 1 < needed"; 2825 goto exit; 2826 } 2827 params_base = (GLint *) 2828 _env->GetIntArrayElements(params_ref, (jboolean *)0); 2829 params = params_base + offset; 2830 2831 glGetProgramiv( 2832 (GLuint)program, 2833 (GLenum)pname, 2834 (GLint *)params 2835 ); 2836 2837exit: 2838 if (params_base) { 2839 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 2840 _exception ? JNI_ABORT: 0); 2841 } 2842 if (_exception) { 2843 jniThrowException(_env, _exceptionType, _exceptionMessage); 2844 } 2845} 2846 2847/* void glGetProgramiv ( GLuint program, GLenum pname, GLint *params ) */ 2848static void 2849android_glGetProgramiv__IILjava_nio_IntBuffer_2 2850 (JNIEnv *_env, jobject _this, jint program, jint pname, jobject params_buf) { 2851 jint _exception = 0; 2852 const char * _exceptionType = NULL; 2853 const char * _exceptionMessage = NULL; 2854 jintArray _array = (jintArray) 0; 2855 jint _bufferOffset = (jint) 0; 2856 jint _remaining; 2857 GLint *params = (GLint *) 0; 2858 2859 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2860 if (_remaining < 1) { 2861 _exception = 1; 2862 _exceptionType = "java/lang/IllegalArgumentException"; 2863 _exceptionMessage = "remaining() < 1 < needed"; 2864 goto exit; 2865 } 2866 if (params == NULL) { 2867 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 2868 params = (GLint *) (_paramsBase + _bufferOffset); 2869 } 2870 glGetProgramiv( 2871 (GLuint)program, 2872 (GLenum)pname, 2873 (GLint *)params 2874 ); 2875 2876exit: 2877 if (_array) { 2878 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 2879 } 2880 if (_exception) { 2881 jniThrowException(_env, _exceptionType, _exceptionMessage); 2882 } 2883} 2884 2885#include <stdlib.h> 2886 2887/* void glGetProgramInfoLog ( GLuint shader, GLsizei maxLength, GLsizei* length, GLchar* infoLog ) */ 2888static jstring android_glGetProgramInfoLog(JNIEnv *_env, jobject, jint shader) { 2889 GLint infoLen = 0; 2890 glGetProgramiv(shader, GL_INFO_LOG_LENGTH, &infoLen); 2891 if (!infoLen) { 2892 return _env->NewStringUTF(""); 2893 } 2894 char* buf = (char*) malloc(infoLen); 2895 if (buf == NULL) { 2896 jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory"); 2897 return NULL; 2898 } 2899 glGetProgramInfoLog(shader, infoLen, NULL, buf); 2900 jstring result = _env->NewStringUTF(buf); 2901 free(buf); 2902 return result; 2903} 2904/* void glGetRenderbufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 2905static void 2906android_glGetRenderbufferParameteriv__II_3II 2907 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 2908 jint _exception = 0; 2909 const char * _exceptionType = NULL; 2910 const char * _exceptionMessage = NULL; 2911 GLint *params_base = (GLint *) 0; 2912 jint _remaining; 2913 GLint *params = (GLint *) 0; 2914 2915 if (!params_ref) { 2916 _exception = 1; 2917 _exceptionType = "java/lang/IllegalArgumentException"; 2918 _exceptionMessage = "params == null"; 2919 goto exit; 2920 } 2921 if (offset < 0) { 2922 _exception = 1; 2923 _exceptionType = "java/lang/IllegalArgumentException"; 2924 _exceptionMessage = "offset < 0"; 2925 goto exit; 2926 } 2927 _remaining = _env->GetArrayLength(params_ref) - offset; 2928 if (_remaining < 1) { 2929 _exception = 1; 2930 _exceptionType = "java/lang/IllegalArgumentException"; 2931 _exceptionMessage = "length - offset < 1 < needed"; 2932 goto exit; 2933 } 2934 params_base = (GLint *) 2935 _env->GetIntArrayElements(params_ref, (jboolean *)0); 2936 params = params_base + offset; 2937 2938 glGetRenderbufferParameteriv( 2939 (GLenum)target, 2940 (GLenum)pname, 2941 (GLint *)params 2942 ); 2943 2944exit: 2945 if (params_base) { 2946 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 2947 _exception ? JNI_ABORT: 0); 2948 } 2949 if (_exception) { 2950 jniThrowException(_env, _exceptionType, _exceptionMessage); 2951 } 2952} 2953 2954/* void glGetRenderbufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 2955static void 2956android_glGetRenderbufferParameteriv__IILjava_nio_IntBuffer_2 2957 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 2958 jint _exception = 0; 2959 const char * _exceptionType = NULL; 2960 const char * _exceptionMessage = NULL; 2961 jintArray _array = (jintArray) 0; 2962 jint _bufferOffset = (jint) 0; 2963 jint _remaining; 2964 GLint *params = (GLint *) 0; 2965 2966 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2967 if (_remaining < 1) { 2968 _exception = 1; 2969 _exceptionType = "java/lang/IllegalArgumentException"; 2970 _exceptionMessage = "remaining() < 1 < needed"; 2971 goto exit; 2972 } 2973 if (params == NULL) { 2974 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 2975 params = (GLint *) (_paramsBase + _bufferOffset); 2976 } 2977 glGetRenderbufferParameteriv( 2978 (GLenum)target, 2979 (GLenum)pname, 2980 (GLint *)params 2981 ); 2982 2983exit: 2984 if (_array) { 2985 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 2986 } 2987 if (_exception) { 2988 jniThrowException(_env, _exceptionType, _exceptionMessage); 2989 } 2990} 2991 2992/* void glGetShaderiv ( GLuint shader, GLenum pname, GLint *params ) */ 2993static void 2994android_glGetShaderiv__II_3II 2995 (JNIEnv *_env, jobject _this, jint shader, jint pname, jintArray params_ref, jint offset) { 2996 jint _exception = 0; 2997 const char * _exceptionType = NULL; 2998 const char * _exceptionMessage = NULL; 2999 GLint *params_base = (GLint *) 0; 3000 jint _remaining; 3001 GLint *params = (GLint *) 0; 3002 3003 if (!params_ref) { 3004 _exception = 1; 3005 _exceptionType = "java/lang/IllegalArgumentException"; 3006 _exceptionMessage = "params == null"; 3007 goto exit; 3008 } 3009 if (offset < 0) { 3010 _exception = 1; 3011 _exceptionType = "java/lang/IllegalArgumentException"; 3012 _exceptionMessage = "offset < 0"; 3013 goto exit; 3014 } 3015 _remaining = _env->GetArrayLength(params_ref) - offset; 3016 if (_remaining < 1) { 3017 _exception = 1; 3018 _exceptionType = "java/lang/IllegalArgumentException"; 3019 _exceptionMessage = "length - offset < 1 < needed"; 3020 goto exit; 3021 } 3022 params_base = (GLint *) 3023 _env->GetIntArrayElements(params_ref, (jboolean *)0); 3024 params = params_base + offset; 3025 3026 glGetShaderiv( 3027 (GLuint)shader, 3028 (GLenum)pname, 3029 (GLint *)params 3030 ); 3031 3032exit: 3033 if (params_base) { 3034 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 3035 _exception ? JNI_ABORT: 0); 3036 } 3037 if (_exception) { 3038 jniThrowException(_env, _exceptionType, _exceptionMessage); 3039 } 3040} 3041 3042/* void glGetShaderiv ( GLuint shader, GLenum pname, GLint *params ) */ 3043static void 3044android_glGetShaderiv__IILjava_nio_IntBuffer_2 3045 (JNIEnv *_env, jobject _this, jint shader, jint pname, jobject params_buf) { 3046 jint _exception = 0; 3047 const char * _exceptionType = NULL; 3048 const char * _exceptionMessage = NULL; 3049 jintArray _array = (jintArray) 0; 3050 jint _bufferOffset = (jint) 0; 3051 jint _remaining; 3052 GLint *params = (GLint *) 0; 3053 3054 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3055 if (_remaining < 1) { 3056 _exception = 1; 3057 _exceptionType = "java/lang/IllegalArgumentException"; 3058 _exceptionMessage = "remaining() < 1 < needed"; 3059 goto exit; 3060 } 3061 if (params == NULL) { 3062 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 3063 params = (GLint *) (_paramsBase + _bufferOffset); 3064 } 3065 glGetShaderiv( 3066 (GLuint)shader, 3067 (GLenum)pname, 3068 (GLint *)params 3069 ); 3070 3071exit: 3072 if (_array) { 3073 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 3074 } 3075 if (_exception) { 3076 jniThrowException(_env, _exceptionType, _exceptionMessage); 3077 } 3078} 3079 3080#include <stdlib.h> 3081 3082/* void glGetShaderInfoLog ( GLuint shader, GLsizei maxLength, GLsizei* length, GLchar* infoLog ) */ 3083static jstring android_glGetShaderInfoLog(JNIEnv *_env, jobject, jint shader) { 3084 GLint infoLen = 0; 3085 glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen); 3086 if (!infoLen) { 3087 return _env->NewStringUTF(""); 3088 } 3089 char* buf = (char*) malloc(infoLen); 3090 if (buf == NULL) { 3091 jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory"); 3092 return NULL; 3093 } 3094 glGetShaderInfoLog(shader, infoLen, NULL, buf); 3095 jstring result = _env->NewStringUTF(buf); 3096 free(buf); 3097 return result; 3098} 3099/* void glGetShaderPrecisionFormat ( GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision ) */ 3100static void 3101android_glGetShaderPrecisionFormat__II_3II_3II 3102 (JNIEnv *_env, jobject _this, jint shadertype, jint precisiontype, jintArray range_ref, jint rangeOffset, jintArray precision_ref, jint precisionOffset) { 3103 jint _exception = 0; 3104 const char * _exceptionType = NULL; 3105 const char * _exceptionMessage = NULL; 3106 GLint *range_base = (GLint *) 0; 3107 jint _rangeRemaining; 3108 GLint *range = (GLint *) 0; 3109 GLint *precision_base = (GLint *) 0; 3110 jint _precisionRemaining; 3111 GLint *precision = (GLint *) 0; 3112 3113 if (!range_ref) { 3114 _exception = 1; 3115 _exceptionType = "java/lang/IllegalArgumentException"; 3116 _exceptionMessage = "range == null"; 3117 goto exit; 3118 } 3119 if (rangeOffset < 0) { 3120 _exception = 1; 3121 _exceptionType = "java/lang/IllegalArgumentException"; 3122 _exceptionMessage = "rangeOffset < 0"; 3123 goto exit; 3124 } 3125 _rangeRemaining = _env->GetArrayLength(range_ref) - rangeOffset; 3126 if (_rangeRemaining < 1) { 3127 _exception = 1; 3128 _exceptionType = "java/lang/IllegalArgumentException"; 3129 _exceptionMessage = "length - rangeOffset < 1 < needed"; 3130 goto exit; 3131 } 3132 range_base = (GLint *) 3133 _env->GetIntArrayElements(range_ref, (jboolean *)0); 3134 range = range_base + rangeOffset; 3135 3136 if (!precision_ref) { 3137 _exception = 1; 3138 _exceptionType = "java/lang/IllegalArgumentException"; 3139 _exceptionMessage = "precision == null"; 3140 goto exit; 3141 } 3142 if (precisionOffset < 0) { 3143 _exception = 1; 3144 _exceptionType = "java/lang/IllegalArgumentException"; 3145 _exceptionMessage = "precisionOffset < 0"; 3146 goto exit; 3147 } 3148 _precisionRemaining = _env->GetArrayLength(precision_ref) - precisionOffset; 3149 if (_precisionRemaining < 1) { 3150 _exception = 1; 3151 _exceptionType = "java/lang/IllegalArgumentException"; 3152 _exceptionMessage = "length - precisionOffset < 1 < needed"; 3153 goto exit; 3154 } 3155 precision_base = (GLint *) 3156 _env->GetIntArrayElements(precision_ref, (jboolean *)0); 3157 precision = precision_base + precisionOffset; 3158 3159 glGetShaderPrecisionFormat( 3160 (GLenum)shadertype, 3161 (GLenum)precisiontype, 3162 (GLint *)range, 3163 (GLint *)precision 3164 ); 3165 3166exit: 3167 if (precision_base) { 3168 _env->ReleaseIntArrayElements(precision_ref, (jint*)precision_base, 3169 _exception ? JNI_ABORT: 0); 3170 } 3171 if (range_base) { 3172 _env->ReleaseIntArrayElements(range_ref, (jint*)range_base, 3173 _exception ? JNI_ABORT: 0); 3174 } 3175 if (_exception) { 3176 jniThrowException(_env, _exceptionType, _exceptionMessage); 3177 } 3178} 3179 3180/* void glGetShaderPrecisionFormat ( GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision ) */ 3181static void 3182android_glGetShaderPrecisionFormat__IILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 3183 (JNIEnv *_env, jobject _this, jint shadertype, jint precisiontype, jobject range_buf, jobject precision_buf) { 3184 jint _exception = 0; 3185 const char * _exceptionType = NULL; 3186 const char * _exceptionMessage = NULL; 3187 jintArray _rangeArray = (jintArray) 0; 3188 jint _rangeBufferOffset = (jint) 0; 3189 jintArray _precisionArray = (jintArray) 0; 3190 jint _precisionBufferOffset = (jint) 0; 3191 jint _rangeRemaining; 3192 GLint *range = (GLint *) 0; 3193 jint _precisionRemaining; 3194 GLint *precision = (GLint *) 0; 3195 3196 range = (GLint *)getPointer(_env, range_buf, (jarray*)&_rangeArray, &_rangeRemaining, &_rangeBufferOffset); 3197 if (_rangeRemaining < 1) { 3198 _exception = 1; 3199 _exceptionType = "java/lang/IllegalArgumentException"; 3200 _exceptionMessage = "remaining() < 1 < needed"; 3201 goto exit; 3202 } 3203 precision = (GLint *)getPointer(_env, precision_buf, (jarray*)&_precisionArray, &_precisionRemaining, &_precisionBufferOffset); 3204 if (_precisionRemaining < 1) { 3205 _exception = 1; 3206 _exceptionType = "java/lang/IllegalArgumentException"; 3207 _exceptionMessage = "remaining() < 1 < needed"; 3208 goto exit; 3209 } 3210 if (range == NULL) { 3211 char * _rangeBase = (char *)_env->GetIntArrayElements(_rangeArray, (jboolean *) 0); 3212 range = (GLint *) (_rangeBase + _rangeBufferOffset); 3213 } 3214 if (precision == NULL) { 3215 char * _precisionBase = (char *)_env->GetIntArrayElements(_precisionArray, (jboolean *) 0); 3216 precision = (GLint *) (_precisionBase + _precisionBufferOffset); 3217 } 3218 glGetShaderPrecisionFormat( 3219 (GLenum)shadertype, 3220 (GLenum)precisiontype, 3221 (GLint *)range, 3222 (GLint *)precision 3223 ); 3224 3225exit: 3226 if (_precisionArray) { 3227 _env->ReleaseIntArrayElements(_precisionArray, (jint*)precision, _exception ? JNI_ABORT : 0); 3228 } 3229 if (_rangeArray) { 3230 _env->ReleaseIntArrayElements(_rangeArray, (jint*)range, _exception ? JNI_ABORT : 0); 3231 } 3232 if (_exception) { 3233 jniThrowException(_env, _exceptionType, _exceptionMessage); 3234 } 3235} 3236 3237/* void glGetShaderSource ( GLuint shader, GLsizei bufsize, GLsizei *length, char *source ) */ 3238static void 3239android_glGetShaderSource__II_3II_3BI 3240 (JNIEnv *_env, jobject _this, jint shader, jint bufsize, jintArray length_ref, jint lengthOffset, jbyteArray source_ref, jint sourceOffset) { 3241 jint _exception = 0; 3242 const char * _exceptionType; 3243 const char * _exceptionMessage; 3244 GLsizei *length_base = (GLsizei *) 0; 3245 jint _lengthRemaining; 3246 GLsizei *length = (GLsizei *) 0; 3247 char *source_base = (char *) 0; 3248 jint _sourceRemaining; 3249 char *source = (char *) 0; 3250 3251 if (length_ref) { 3252 if (lengthOffset < 0) { 3253 _exception = 1; 3254 _exceptionType = "java/lang/IllegalArgumentException"; 3255 _exceptionMessage = "lengthOffset < 0"; 3256 goto exit; 3257 } 3258 _lengthRemaining = _env->GetArrayLength(length_ref) - lengthOffset; 3259 length_base = (GLsizei *) 3260 _env->GetIntArrayElements(length_ref, (jboolean *)0); 3261 length = length_base + lengthOffset; 3262 } 3263 3264 if (!source_ref) { 3265 _exception = 1; 3266 _exceptionType = "java/lang/IllegalArgumentException"; 3267 _exceptionMessage = "source == null"; 3268 goto exit; 3269 } 3270 if (sourceOffset < 0) { 3271 _exception = 1; 3272 _exceptionType = "java/lang/IllegalArgumentException"; 3273 _exceptionMessage = "sourceOffset < 0"; 3274 goto exit; 3275 } 3276 _sourceRemaining = _env->GetArrayLength(source_ref) - sourceOffset; 3277 source_base = (char *) 3278 _env->GetByteArrayElements(source_ref, (jboolean *)0); 3279 source = source_base + sourceOffset; 3280 3281 glGetShaderSource( 3282 (GLuint)shader, 3283 (GLsizei)bufsize, 3284 (GLsizei *)length, 3285 (char *)source 3286 ); 3287 3288exit: 3289 if (source_base) { 3290 _env->ReleaseByteArrayElements(source_ref, (jbyte*)source_base, 3291 _exception ? JNI_ABORT: 0); 3292 } 3293 if (length_base) { 3294 _env->ReleaseIntArrayElements(length_ref, (jint*)length_base, 3295 _exception ? JNI_ABORT: 0); 3296 } 3297 if (_exception) { 3298 jniThrowException(_env, _exceptionType, _exceptionMessage); 3299 } 3300} 3301 3302/* void glGetShaderSource ( GLuint shader, GLsizei bufsize, GLsizei *length, char *source ) */ 3303static void 3304android_glGetShaderSource__IILjava_nio_IntBuffer_2B 3305 (JNIEnv *_env, jobject _this, jint shader, jint bufsize, jobject length_buf, jbyte source) { 3306 jintArray _array = (jintArray) 0; 3307 jint _bufferOffset = (jint) 0; 3308 jint _remaining; 3309 GLsizei *length = (GLsizei *) 0; 3310 3311 length = (GLsizei *)getPointer(_env, length_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3312 if (length == NULL) { 3313 char * _lengthBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 3314 length = (GLsizei *) (_lengthBase + _bufferOffset); 3315 } 3316 glGetShaderSource( 3317 (GLuint)shader, 3318 (GLsizei)bufsize, 3319 (GLsizei *)length, 3320 reinterpret_cast<char *>(source) 3321 ); 3322 if (_array) { 3323 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _array, (jint*)length, JNI_TRUE); 3324 } 3325} 3326 3327/* void glGetShaderSource ( GLuint shader, GLsizei bufsize, GLsizei *length, char *source ) */ 3328static jstring android_glGetShaderSource(JNIEnv *_env, jobject, jint shader) { 3329 GLint shaderLen = 0; 3330 glGetShaderiv((GLuint)shader, GL_SHADER_SOURCE_LENGTH, &shaderLen); 3331 if (!shaderLen) { 3332 return _env->NewStringUTF(""); 3333 } 3334 char* buf = (char*) malloc(shaderLen); 3335 if (buf == NULL) { 3336 jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory"); 3337 return NULL; 3338 } 3339 glGetShaderSource(shader, shaderLen, NULL, buf); 3340 jstring result = _env->NewStringUTF(buf); 3341 free(buf); 3342 return result; 3343} 3344/* const GLubyte * glGetString ( GLenum name ) */ 3345static jstring android_glGetString(JNIEnv* _env, jobject, jint name) { 3346 const char* chars = (const char*) glGetString((GLenum) name); 3347 return _env->NewStringUTF(chars); 3348} 3349/* void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) */ 3350static void 3351android_glGetTexParameterfv__II_3FI 3352 (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) { 3353 jint _exception = 0; 3354 const char * _exceptionType = NULL; 3355 const char * _exceptionMessage = NULL; 3356 GLfloat *params_base = (GLfloat *) 0; 3357 jint _remaining; 3358 GLfloat *params = (GLfloat *) 0; 3359 3360 if (!params_ref) { 3361 _exception = 1; 3362 _exceptionType = "java/lang/IllegalArgumentException"; 3363 _exceptionMessage = "params == null"; 3364 goto exit; 3365 } 3366 if (offset < 0) { 3367 _exception = 1; 3368 _exceptionType = "java/lang/IllegalArgumentException"; 3369 _exceptionMessage = "offset < 0"; 3370 goto exit; 3371 } 3372 _remaining = _env->GetArrayLength(params_ref) - offset; 3373 if (_remaining < 1) { 3374 _exception = 1; 3375 _exceptionType = "java/lang/IllegalArgumentException"; 3376 _exceptionMessage = "length - offset < 1 < needed"; 3377 goto exit; 3378 } 3379 params_base = (GLfloat *) 3380 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 3381 params = params_base + offset; 3382 3383 glGetTexParameterfv( 3384 (GLenum)target, 3385 (GLenum)pname, 3386 (GLfloat *)params 3387 ); 3388 3389exit: 3390 if (params_base) { 3391 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 3392 _exception ? JNI_ABORT: 0); 3393 } 3394 if (_exception) { 3395 jniThrowException(_env, _exceptionType, _exceptionMessage); 3396 } 3397} 3398 3399/* void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) */ 3400static void 3401android_glGetTexParameterfv__IILjava_nio_FloatBuffer_2 3402 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 3403 jint _exception = 0; 3404 const char * _exceptionType = NULL; 3405 const char * _exceptionMessage = NULL; 3406 jfloatArray _array = (jfloatArray) 0; 3407 jint _bufferOffset = (jint) 0; 3408 jint _remaining; 3409 GLfloat *params = (GLfloat *) 0; 3410 3411 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3412 if (_remaining < 1) { 3413 _exception = 1; 3414 _exceptionType = "java/lang/IllegalArgumentException"; 3415 _exceptionMessage = "remaining() < 1 < needed"; 3416 goto exit; 3417 } 3418 if (params == NULL) { 3419 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 3420 params = (GLfloat *) (_paramsBase + _bufferOffset); 3421 } 3422 glGetTexParameterfv( 3423 (GLenum)target, 3424 (GLenum)pname, 3425 (GLfloat *)params 3426 ); 3427 3428exit: 3429 if (_array) { 3430 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0); 3431 } 3432 if (_exception) { 3433 jniThrowException(_env, _exceptionType, _exceptionMessage); 3434 } 3435} 3436 3437/* void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 3438static void 3439android_glGetTexParameteriv__II_3II 3440 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 3441 jint _exception = 0; 3442 const char * _exceptionType = NULL; 3443 const char * _exceptionMessage = NULL; 3444 GLint *params_base = (GLint *) 0; 3445 jint _remaining; 3446 GLint *params = (GLint *) 0; 3447 3448 if (!params_ref) { 3449 _exception = 1; 3450 _exceptionType = "java/lang/IllegalArgumentException"; 3451 _exceptionMessage = "params == null"; 3452 goto exit; 3453 } 3454 if (offset < 0) { 3455 _exception = 1; 3456 _exceptionType = "java/lang/IllegalArgumentException"; 3457 _exceptionMessage = "offset < 0"; 3458 goto exit; 3459 } 3460 _remaining = _env->GetArrayLength(params_ref) - offset; 3461 if (_remaining < 1) { 3462 _exception = 1; 3463 _exceptionType = "java/lang/IllegalArgumentException"; 3464 _exceptionMessage = "length - offset < 1 < needed"; 3465 goto exit; 3466 } 3467 params_base = (GLint *) 3468 _env->GetIntArrayElements(params_ref, (jboolean *)0); 3469 params = params_base + offset; 3470 3471 glGetTexParameteriv( 3472 (GLenum)target, 3473 (GLenum)pname, 3474 (GLint *)params 3475 ); 3476 3477exit: 3478 if (params_base) { 3479 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 3480 _exception ? JNI_ABORT: 0); 3481 } 3482 if (_exception) { 3483 jniThrowException(_env, _exceptionType, _exceptionMessage); 3484 } 3485} 3486 3487/* void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 3488static void 3489android_glGetTexParameteriv__IILjava_nio_IntBuffer_2 3490 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 3491 jint _exception = 0; 3492 const char * _exceptionType = NULL; 3493 const char * _exceptionMessage = NULL; 3494 jintArray _array = (jintArray) 0; 3495 jint _bufferOffset = (jint) 0; 3496 jint _remaining; 3497 GLint *params = (GLint *) 0; 3498 3499 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3500 if (_remaining < 1) { 3501 _exception = 1; 3502 _exceptionType = "java/lang/IllegalArgumentException"; 3503 _exceptionMessage = "remaining() < 1 < needed"; 3504 goto exit; 3505 } 3506 if (params == NULL) { 3507 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 3508 params = (GLint *) (_paramsBase + _bufferOffset); 3509 } 3510 glGetTexParameteriv( 3511 (GLenum)target, 3512 (GLenum)pname, 3513 (GLint *)params 3514 ); 3515 3516exit: 3517 if (_array) { 3518 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 3519 } 3520 if (_exception) { 3521 jniThrowException(_env, _exceptionType, _exceptionMessage); 3522 } 3523} 3524 3525/* void glGetUniformfv ( GLuint program, GLint location, GLfloat *params ) */ 3526static void 3527android_glGetUniformfv__II_3FI 3528 (JNIEnv *_env, jobject _this, jint program, jint location, jfloatArray params_ref, jint offset) { 3529 jint _exception = 0; 3530 const char * _exceptionType = NULL; 3531 const char * _exceptionMessage = NULL; 3532 GLfloat *params_base = (GLfloat *) 0; 3533 jint _remaining; 3534 GLfloat *params = (GLfloat *) 0; 3535 3536 if (!params_ref) { 3537 _exception = 1; 3538 _exceptionType = "java/lang/IllegalArgumentException"; 3539 _exceptionMessage = "params == null"; 3540 goto exit; 3541 } 3542 if (offset < 0) { 3543 _exception = 1; 3544 _exceptionType = "java/lang/IllegalArgumentException"; 3545 _exceptionMessage = "offset < 0"; 3546 goto exit; 3547 } 3548 _remaining = _env->GetArrayLength(params_ref) - offset; 3549 if (_remaining < 1) { 3550 _exception = 1; 3551 _exceptionType = "java/lang/IllegalArgumentException"; 3552 _exceptionMessage = "length - offset < 1 < needed"; 3553 goto exit; 3554 } 3555 params_base = (GLfloat *) 3556 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 3557 params = params_base + offset; 3558 3559 glGetUniformfv( 3560 (GLuint)program, 3561 (GLint)location, 3562 (GLfloat *)params 3563 ); 3564 3565exit: 3566 if (params_base) { 3567 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 3568 _exception ? JNI_ABORT: 0); 3569 } 3570 if (_exception) { 3571 jniThrowException(_env, _exceptionType, _exceptionMessage); 3572 } 3573} 3574 3575/* void glGetUniformfv ( GLuint program, GLint location, GLfloat *params ) */ 3576static void 3577android_glGetUniformfv__IILjava_nio_FloatBuffer_2 3578 (JNIEnv *_env, jobject _this, jint program, jint location, jobject params_buf) { 3579 jint _exception = 0; 3580 const char * _exceptionType = NULL; 3581 const char * _exceptionMessage = NULL; 3582 jfloatArray _array = (jfloatArray) 0; 3583 jint _bufferOffset = (jint) 0; 3584 jint _remaining; 3585 GLfloat *params = (GLfloat *) 0; 3586 3587 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3588 if (_remaining < 1) { 3589 _exception = 1; 3590 _exceptionType = "java/lang/IllegalArgumentException"; 3591 _exceptionMessage = "remaining() < 1 < needed"; 3592 goto exit; 3593 } 3594 if (params == NULL) { 3595 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 3596 params = (GLfloat *) (_paramsBase + _bufferOffset); 3597 } 3598 glGetUniformfv( 3599 (GLuint)program, 3600 (GLint)location, 3601 (GLfloat *)params 3602 ); 3603 3604exit: 3605 if (_array) { 3606 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0); 3607 } 3608 if (_exception) { 3609 jniThrowException(_env, _exceptionType, _exceptionMessage); 3610 } 3611} 3612 3613/* void glGetUniformiv ( GLuint program, GLint location, GLint *params ) */ 3614static void 3615android_glGetUniformiv__II_3II 3616 (JNIEnv *_env, jobject _this, jint program, jint location, jintArray params_ref, jint offset) { 3617 jint _exception = 0; 3618 const char * _exceptionType = NULL; 3619 const char * _exceptionMessage = NULL; 3620 GLint *params_base = (GLint *) 0; 3621 jint _remaining; 3622 GLint *params = (GLint *) 0; 3623 3624 if (!params_ref) { 3625 _exception = 1; 3626 _exceptionType = "java/lang/IllegalArgumentException"; 3627 _exceptionMessage = "params == null"; 3628 goto exit; 3629 } 3630 if (offset < 0) { 3631 _exception = 1; 3632 _exceptionType = "java/lang/IllegalArgumentException"; 3633 _exceptionMessage = "offset < 0"; 3634 goto exit; 3635 } 3636 _remaining = _env->GetArrayLength(params_ref) - offset; 3637 if (_remaining < 1) { 3638 _exception = 1; 3639 _exceptionType = "java/lang/IllegalArgumentException"; 3640 _exceptionMessage = "length - offset < 1 < needed"; 3641 goto exit; 3642 } 3643 params_base = (GLint *) 3644 _env->GetIntArrayElements(params_ref, (jboolean *)0); 3645 params = params_base + offset; 3646 3647 glGetUniformiv( 3648 (GLuint)program, 3649 (GLint)location, 3650 (GLint *)params 3651 ); 3652 3653exit: 3654 if (params_base) { 3655 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 3656 _exception ? JNI_ABORT: 0); 3657 } 3658 if (_exception) { 3659 jniThrowException(_env, _exceptionType, _exceptionMessage); 3660 } 3661} 3662 3663/* void glGetUniformiv ( GLuint program, GLint location, GLint *params ) */ 3664static void 3665android_glGetUniformiv__IILjava_nio_IntBuffer_2 3666 (JNIEnv *_env, jobject _this, jint program, jint location, jobject params_buf) { 3667 jint _exception = 0; 3668 const char * _exceptionType = NULL; 3669 const char * _exceptionMessage = NULL; 3670 jintArray _array = (jintArray) 0; 3671 jint _bufferOffset = (jint) 0; 3672 jint _remaining; 3673 GLint *params = (GLint *) 0; 3674 3675 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3676 if (_remaining < 1) { 3677 _exception = 1; 3678 _exceptionType = "java/lang/IllegalArgumentException"; 3679 _exceptionMessage = "remaining() < 1 < needed"; 3680 goto exit; 3681 } 3682 if (params == NULL) { 3683 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 3684 params = (GLint *) (_paramsBase + _bufferOffset); 3685 } 3686 glGetUniformiv( 3687 (GLuint)program, 3688 (GLint)location, 3689 (GLint *)params 3690 ); 3691 3692exit: 3693 if (_array) { 3694 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 3695 } 3696 if (_exception) { 3697 jniThrowException(_env, _exceptionType, _exceptionMessage); 3698 } 3699} 3700 3701/* GLint glGetUniformLocation ( GLuint program, const char *name ) */ 3702static jint 3703android_glGetUniformLocation__ILjava_lang_String_2 3704 (JNIEnv *_env, jobject _this, jint program, jstring name) { 3705 jint _exception = 0; 3706 const char * _exceptionType = NULL; 3707 const char * _exceptionMessage = NULL; 3708 GLint _returnValue = 0; 3709 const char* _nativename = 0; 3710 3711 if (!name) { 3712 _exception = 1; 3713 _exceptionType = "java/lang/IllegalArgumentException"; 3714 _exceptionMessage = "name == null"; 3715 goto exit; 3716 } 3717 _nativename = _env->GetStringUTFChars(name, 0); 3718 3719 _returnValue = glGetUniformLocation( 3720 (GLuint)program, 3721 (char *)_nativename 3722 ); 3723 3724exit: 3725 if (_nativename) { 3726 _env->ReleaseStringUTFChars(name, _nativename); 3727 } 3728 3729 if (_exception) { 3730 jniThrowException(_env, _exceptionType, _exceptionMessage); 3731 } 3732 return (jint)_returnValue; 3733} 3734 3735/* void glGetVertexAttribfv ( GLuint index, GLenum pname, GLfloat *params ) */ 3736static void 3737android_glGetVertexAttribfv__II_3FI 3738 (JNIEnv *_env, jobject _this, jint index, jint pname, jfloatArray params_ref, jint offset) { 3739 jint _exception = 0; 3740 const char * _exceptionType = NULL; 3741 const char * _exceptionMessage = NULL; 3742 GLfloat *params_base = (GLfloat *) 0; 3743 jint _remaining; 3744 GLfloat *params = (GLfloat *) 0; 3745 3746 if (!params_ref) { 3747 _exception = 1; 3748 _exceptionType = "java/lang/IllegalArgumentException"; 3749 _exceptionMessage = "params == null"; 3750 goto exit; 3751 } 3752 if (offset < 0) { 3753 _exception = 1; 3754 _exceptionType = "java/lang/IllegalArgumentException"; 3755 _exceptionMessage = "offset < 0"; 3756 goto exit; 3757 } 3758 _remaining = _env->GetArrayLength(params_ref) - offset; 3759 int _needed; 3760 switch (pname) { 3761#if defined(GL_CURRENT_VERTEX_ATTRIB) 3762 case GL_CURRENT_VERTEX_ATTRIB: 3763#endif // defined(GL_CURRENT_VERTEX_ATTRIB) 3764 _needed = 4; 3765 break; 3766 default: 3767 _needed = 1; 3768 break; 3769 } 3770 if (_remaining < _needed) { 3771 _exception = 1; 3772 _exceptionType = "java/lang/IllegalArgumentException"; 3773 _exceptionMessage = "length - offset < needed"; 3774 goto exit; 3775 } 3776 params_base = (GLfloat *) 3777 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 3778 params = params_base + offset; 3779 3780 glGetVertexAttribfv( 3781 (GLuint)index, 3782 (GLenum)pname, 3783 (GLfloat *)params 3784 ); 3785 3786exit: 3787 if (params_base) { 3788 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 3789 _exception ? JNI_ABORT: 0); 3790 } 3791 if (_exception) { 3792 jniThrowException(_env, _exceptionType, _exceptionMessage); 3793 } 3794} 3795 3796/* void glGetVertexAttribfv ( GLuint index, GLenum pname, GLfloat *params ) */ 3797static void 3798android_glGetVertexAttribfv__IILjava_nio_FloatBuffer_2 3799 (JNIEnv *_env, jobject _this, jint index, jint pname, jobject params_buf) { 3800 jint _exception = 0; 3801 const char * _exceptionType = NULL; 3802 const char * _exceptionMessage = NULL; 3803 jfloatArray _array = (jfloatArray) 0; 3804 jint _bufferOffset = (jint) 0; 3805 jint _remaining; 3806 GLfloat *params = (GLfloat *) 0; 3807 3808 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3809 int _needed; 3810 switch (pname) { 3811#if defined(GL_CURRENT_VERTEX_ATTRIB) 3812 case GL_CURRENT_VERTEX_ATTRIB: 3813#endif // defined(GL_CURRENT_VERTEX_ATTRIB) 3814 _needed = 4; 3815 break; 3816 default: 3817 _needed = 1; 3818 break; 3819 } 3820 if (_remaining < _needed) { 3821 _exception = 1; 3822 _exceptionType = "java/lang/IllegalArgumentException"; 3823 _exceptionMessage = "remaining() < needed"; 3824 goto exit; 3825 } 3826 if (params == NULL) { 3827 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 3828 params = (GLfloat *) (_paramsBase + _bufferOffset); 3829 } 3830 glGetVertexAttribfv( 3831 (GLuint)index, 3832 (GLenum)pname, 3833 (GLfloat *)params 3834 ); 3835 3836exit: 3837 if (_array) { 3838 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0); 3839 } 3840 if (_exception) { 3841 jniThrowException(_env, _exceptionType, _exceptionMessage); 3842 } 3843} 3844 3845/* void glGetVertexAttribiv ( GLuint index, GLenum pname, GLint *params ) */ 3846static void 3847android_glGetVertexAttribiv__II_3II 3848 (JNIEnv *_env, jobject _this, jint index, jint pname, jintArray params_ref, jint offset) { 3849 jint _exception = 0; 3850 const char * _exceptionType = NULL; 3851 const char * _exceptionMessage = NULL; 3852 GLint *params_base = (GLint *) 0; 3853 jint _remaining; 3854 GLint *params = (GLint *) 0; 3855 3856 if (!params_ref) { 3857 _exception = 1; 3858 _exceptionType = "java/lang/IllegalArgumentException"; 3859 _exceptionMessage = "params == null"; 3860 goto exit; 3861 } 3862 if (offset < 0) { 3863 _exception = 1; 3864 _exceptionType = "java/lang/IllegalArgumentException"; 3865 _exceptionMessage = "offset < 0"; 3866 goto exit; 3867 } 3868 _remaining = _env->GetArrayLength(params_ref) - offset; 3869 int _needed; 3870 switch (pname) { 3871#if defined(GL_CURRENT_VERTEX_ATTRIB) 3872 case GL_CURRENT_VERTEX_ATTRIB: 3873#endif // defined(GL_CURRENT_VERTEX_ATTRIB) 3874 _needed = 4; 3875 break; 3876 default: 3877 _needed = 1; 3878 break; 3879 } 3880 if (_remaining < _needed) { 3881 _exception = 1; 3882 _exceptionType = "java/lang/IllegalArgumentException"; 3883 _exceptionMessage = "length - offset < needed"; 3884 goto exit; 3885 } 3886 params_base = (GLint *) 3887 _env->GetIntArrayElements(params_ref, (jboolean *)0); 3888 params = params_base + offset; 3889 3890 glGetVertexAttribiv( 3891 (GLuint)index, 3892 (GLenum)pname, 3893 (GLint *)params 3894 ); 3895 3896exit: 3897 if (params_base) { 3898 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 3899 _exception ? JNI_ABORT: 0); 3900 } 3901 if (_exception) { 3902 jniThrowException(_env, _exceptionType, _exceptionMessage); 3903 } 3904} 3905 3906/* void glGetVertexAttribiv ( GLuint index, GLenum pname, GLint *params ) */ 3907static void 3908android_glGetVertexAttribiv__IILjava_nio_IntBuffer_2 3909 (JNIEnv *_env, jobject _this, jint index, jint pname, jobject params_buf) { 3910 jint _exception = 0; 3911 const char * _exceptionType = NULL; 3912 const char * _exceptionMessage = NULL; 3913 jintArray _array = (jintArray) 0; 3914 jint _bufferOffset = (jint) 0; 3915 jint _remaining; 3916 GLint *params = (GLint *) 0; 3917 3918 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3919 int _needed; 3920 switch (pname) { 3921#if defined(GL_CURRENT_VERTEX_ATTRIB) 3922 case GL_CURRENT_VERTEX_ATTRIB: 3923#endif // defined(GL_CURRENT_VERTEX_ATTRIB) 3924 _needed = 4; 3925 break; 3926 default: 3927 _needed = 1; 3928 break; 3929 } 3930 if (_remaining < _needed) { 3931 _exception = 1; 3932 _exceptionType = "java/lang/IllegalArgumentException"; 3933 _exceptionMessage = "remaining() < needed"; 3934 goto exit; 3935 } 3936 if (params == NULL) { 3937 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 3938 params = (GLint *) (_paramsBase + _bufferOffset); 3939 } 3940 glGetVertexAttribiv( 3941 (GLuint)index, 3942 (GLenum)pname, 3943 (GLint *)params 3944 ); 3945 3946exit: 3947 if (_array) { 3948 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 3949 } 3950 if (_exception) { 3951 jniThrowException(_env, _exceptionType, _exceptionMessage); 3952 } 3953} 3954 3955/* void glHint ( GLenum target, GLenum mode ) */ 3956static void 3957android_glHint__II 3958 (JNIEnv *_env, jobject _this, jint target, jint mode) { 3959 glHint( 3960 (GLenum)target, 3961 (GLenum)mode 3962 ); 3963} 3964 3965/* GLboolean glIsBuffer ( GLuint buffer ) */ 3966static jboolean 3967android_glIsBuffer__I 3968 (JNIEnv *_env, jobject _this, jint buffer) { 3969 GLboolean _returnValue; 3970 _returnValue = glIsBuffer( 3971 (GLuint)buffer 3972 ); 3973 return (jboolean)_returnValue; 3974} 3975 3976/* GLboolean glIsEnabled ( GLenum cap ) */ 3977static jboolean 3978android_glIsEnabled__I 3979 (JNIEnv *_env, jobject _this, jint cap) { 3980 GLboolean _returnValue; 3981 _returnValue = glIsEnabled( 3982 (GLenum)cap 3983 ); 3984 return (jboolean)_returnValue; 3985} 3986 3987/* GLboolean glIsFramebuffer ( GLuint framebuffer ) */ 3988static jboolean 3989android_glIsFramebuffer__I 3990 (JNIEnv *_env, jobject _this, jint framebuffer) { 3991 GLboolean _returnValue; 3992 _returnValue = glIsFramebuffer( 3993 (GLuint)framebuffer 3994 ); 3995 return (jboolean)_returnValue; 3996} 3997 3998/* GLboolean glIsProgram ( GLuint program ) */ 3999static jboolean 4000android_glIsProgram__I 4001 (JNIEnv *_env, jobject _this, jint program) { 4002 GLboolean _returnValue; 4003 _returnValue = glIsProgram( 4004 (GLuint)program 4005 ); 4006 return (jboolean)_returnValue; 4007} 4008 4009/* GLboolean glIsRenderbuffer ( GLuint renderbuffer ) */ 4010static jboolean 4011android_glIsRenderbuffer__I 4012 (JNIEnv *_env, jobject _this, jint renderbuffer) { 4013 GLboolean _returnValue; 4014 _returnValue = glIsRenderbuffer( 4015 (GLuint)renderbuffer 4016 ); 4017 return (jboolean)_returnValue; 4018} 4019 4020/* GLboolean glIsShader ( GLuint shader ) */ 4021static jboolean 4022android_glIsShader__I 4023 (JNIEnv *_env, jobject _this, jint shader) { 4024 GLboolean _returnValue; 4025 _returnValue = glIsShader( 4026 (GLuint)shader 4027 ); 4028 return (jboolean)_returnValue; 4029} 4030 4031/* GLboolean glIsTexture ( GLuint texture ) */ 4032static jboolean 4033android_glIsTexture__I 4034 (JNIEnv *_env, jobject _this, jint texture) { 4035 GLboolean _returnValue; 4036 _returnValue = glIsTexture( 4037 (GLuint)texture 4038 ); 4039 return (jboolean)_returnValue; 4040} 4041 4042/* void glLineWidth ( GLfloat width ) */ 4043static void 4044android_glLineWidth__F 4045 (JNIEnv *_env, jobject _this, jfloat width) { 4046 glLineWidth( 4047 (GLfloat)width 4048 ); 4049} 4050 4051/* void glLinkProgram ( GLuint program ) */ 4052static void 4053android_glLinkProgram__I 4054 (JNIEnv *_env, jobject _this, jint program) { 4055 glLinkProgram( 4056 (GLuint)program 4057 ); 4058} 4059 4060/* void glPixelStorei ( GLenum pname, GLint param ) */ 4061static void 4062android_glPixelStorei__II 4063 (JNIEnv *_env, jobject _this, jint pname, jint param) { 4064 glPixelStorei( 4065 (GLenum)pname, 4066 (GLint)param 4067 ); 4068} 4069 4070/* void glPolygonOffset ( GLfloat factor, GLfloat units ) */ 4071static void 4072android_glPolygonOffset__FF 4073 (JNIEnv *_env, jobject _this, jfloat factor, jfloat units) { 4074 glPolygonOffset( 4075 (GLfloat)factor, 4076 (GLfloat)units 4077 ); 4078} 4079 4080/* void glReadPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) */ 4081static void 4082android_glReadPixels__IIIIIILjava_nio_Buffer_2 4083 (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height, jint format, jint type, jobject pixels_buf) { 4084 jarray _array = (jarray) 0; 4085 jint _bufferOffset = (jint) 0; 4086 jint _remaining; 4087 GLvoid *pixels = (GLvoid *) 0; 4088 4089 pixels = (GLvoid *)getPointer(_env, pixels_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4090 if (pixels == NULL) { 4091 char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 4092 pixels = (GLvoid *) (_pixelsBase + _bufferOffset); 4093 } 4094 glReadPixels( 4095 (GLint)x, 4096 (GLint)y, 4097 (GLsizei)width, 4098 (GLsizei)height, 4099 (GLenum)format, 4100 (GLenum)type, 4101 (GLvoid *)pixels 4102 ); 4103 if (_array) { 4104 releasePointer(_env, _array, pixels, JNI_TRUE); 4105 } 4106} 4107 4108/* void glReleaseShaderCompiler ( void ) */ 4109static void 4110android_glReleaseShaderCompiler__ 4111 (JNIEnv *_env, jobject _this) { 4112 glReleaseShaderCompiler(); 4113} 4114 4115/* void glRenderbufferStorage ( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) */ 4116static void 4117android_glRenderbufferStorage__IIII 4118 (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint width, jint height) { 4119 glRenderbufferStorage( 4120 (GLenum)target, 4121 (GLenum)internalformat, 4122 (GLsizei)width, 4123 (GLsizei)height 4124 ); 4125} 4126 4127/* void glSampleCoverage ( GLclampf value, GLboolean invert ) */ 4128static void 4129android_glSampleCoverage__FZ 4130 (JNIEnv *_env, jobject _this, jfloat value, jboolean invert) { 4131 glSampleCoverage( 4132 (GLclampf)value, 4133 (GLboolean)invert 4134 ); 4135} 4136 4137/* void glScissor ( GLint x, GLint y, GLsizei width, GLsizei height ) */ 4138static void 4139android_glScissor__IIII 4140 (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height) { 4141 glScissor( 4142 (GLint)x, 4143 (GLint)y, 4144 (GLsizei)width, 4145 (GLsizei)height 4146 ); 4147} 4148 4149/* void glShaderBinary ( GLsizei n, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length ) */ 4150static void 4151android_glShaderBinary__I_3IIILjava_nio_Buffer_2I 4152 (JNIEnv *_env, jobject _this, jint n, jintArray shaders_ref, jint offset, jint binaryformat, jobject binary_buf, jint length) { 4153 jint _exception = 0; 4154 const char * _exceptionType = NULL; 4155 const char * _exceptionMessage = NULL; 4156 jarray _array = (jarray) 0; 4157 jint _bufferOffset = (jint) 0; 4158 GLuint *shaders_base = (GLuint *) 0; 4159 jint _shadersRemaining; 4160 GLuint *shaders = (GLuint *) 0; 4161 jint _binaryRemaining; 4162 GLvoid *binary = (GLvoid *) 0; 4163 4164 if (!shaders_ref) { 4165 _exception = 1; 4166 _exceptionType = "java/lang/IllegalArgumentException"; 4167 _exceptionMessage = "shaders == null"; 4168 goto exit; 4169 } 4170 if (offset < 0) { 4171 _exception = 1; 4172 _exceptionType = "java/lang/IllegalArgumentException"; 4173 _exceptionMessage = "offset < 0"; 4174 goto exit; 4175 } 4176 _shadersRemaining = _env->GetArrayLength(shaders_ref) - offset; 4177 shaders_base = (GLuint *) 4178 _env->GetIntArrayElements(shaders_ref, (jboolean *)0); 4179 shaders = shaders_base + offset; 4180 4181 binary = (GLvoid *)getPointer(_env, binary_buf, (jarray*)&_array, &_binaryRemaining, &_bufferOffset); 4182 if (_binaryRemaining < length) { 4183 _exception = 1; 4184 _exceptionType = "java/lang/IllegalArgumentException"; 4185 _exceptionMessage = "remaining() < length < needed"; 4186 goto exit; 4187 } 4188 if (binary == NULL) { 4189 char * _binaryBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 4190 binary = (GLvoid *) (_binaryBase + _bufferOffset); 4191 } 4192 glShaderBinary( 4193 (GLsizei)n, 4194 (GLuint *)shaders, 4195 (GLenum)binaryformat, 4196 (GLvoid *)binary, 4197 (GLsizei)length 4198 ); 4199 4200exit: 4201 if (_array) { 4202 releasePointer(_env, _array, binary, JNI_FALSE); 4203 } 4204 if (shaders_base) { 4205 _env->ReleaseIntArrayElements(shaders_ref, (jint*)shaders_base, 4206 JNI_ABORT); 4207 } 4208 if (_exception) { 4209 jniThrowException(_env, _exceptionType, _exceptionMessage); 4210 } 4211} 4212 4213/* void glShaderBinary ( GLsizei n, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length ) */ 4214static void 4215android_glShaderBinary__ILjava_nio_IntBuffer_2ILjava_nio_Buffer_2I 4216 (JNIEnv *_env, jobject _this, jint n, jobject shaders_buf, jint binaryformat, jobject binary_buf, jint length) { 4217 jint _exception = 0; 4218 const char * _exceptionType = NULL; 4219 const char * _exceptionMessage = NULL; 4220 jintArray _shadersArray = (jintArray) 0; 4221 jint _shadersBufferOffset = (jint) 0; 4222 jintArray _binaryArray = (jintArray) 0; 4223 jint _binaryBufferOffset = (jint) 0; 4224 jint _shadersRemaining; 4225 GLuint *shaders = (GLuint *) 0; 4226 jint _binaryRemaining; 4227 GLvoid *binary = (GLvoid *) 0; 4228 4229 shaders = (GLuint *)getPointer(_env, shaders_buf, (jarray*)&_shadersArray, &_shadersRemaining, &_shadersBufferOffset); 4230 binary = (GLvoid *)getPointer(_env, binary_buf, (jarray*)&_binaryArray, &_binaryRemaining, &_binaryBufferOffset); 4231 if (_binaryRemaining < length) { 4232 _exception = 1; 4233 _exceptionType = "java/lang/IllegalArgumentException"; 4234 _exceptionMessage = "remaining() < length < needed"; 4235 goto exit; 4236 } 4237 if (shaders == NULL) { 4238 char * _shadersBase = (char *)_env->GetIntArrayElements(_shadersArray, (jboolean *) 0); 4239 shaders = (GLuint *) (_shadersBase + _shadersBufferOffset); 4240 } 4241 if (binary == NULL) { 4242 char * _binaryBase = (char *)_env->GetPrimitiveArrayCritical(_binaryArray, (jboolean *) 0); 4243 binary = (GLvoid *) (_binaryBase + _binaryBufferOffset); 4244 } 4245 glShaderBinary( 4246 (GLsizei)n, 4247 (GLuint *)shaders, 4248 (GLenum)binaryformat, 4249 (GLvoid *)binary, 4250 (GLsizei)length 4251 ); 4252 4253exit: 4254 if (_binaryArray) { 4255 releasePointer(_env, _binaryArray, binary, JNI_FALSE); 4256 } 4257 if (_shadersArray) { 4258 _env->ReleaseIntArrayElements(_shadersArray, (jint*)shaders, JNI_ABORT); 4259 } 4260 if (_exception) { 4261 jniThrowException(_env, _exceptionType, _exceptionMessage); 4262 } 4263} 4264 4265 4266/* void glShaderSource ( GLuint shader, GLsizei count, const GLchar ** string, const GLint * length ) */ 4267static 4268void 4269android_glShaderSource 4270 (JNIEnv *_env, jobject _this, jint shader, jstring string) { 4271 4272 if (!string) { 4273 jniThrowException(_env, "java/lang/IllegalArgumentException", "string == null"); 4274 return; 4275 } 4276 4277 const char* nativeString = _env->GetStringUTFChars(string, 0); 4278 const char* strings[] = {nativeString}; 4279 glShaderSource(shader, 1, strings, 0); 4280 _env->ReleaseStringUTFChars(string, nativeString); 4281} 4282/* void glStencilFunc ( GLenum func, GLint ref, GLuint mask ) */ 4283static void 4284android_glStencilFunc__III 4285 (JNIEnv *_env, jobject _this, jint func, jint ref, jint mask) { 4286 glStencilFunc( 4287 (GLenum)func, 4288 (GLint)ref, 4289 (GLuint)mask 4290 ); 4291} 4292 4293/* void glStencilFuncSeparate ( GLenum face, GLenum func, GLint ref, GLuint mask ) */ 4294static void 4295android_glStencilFuncSeparate__IIII 4296 (JNIEnv *_env, jobject _this, jint face, jint func, jint ref, jint mask) { 4297 glStencilFuncSeparate( 4298 (GLenum)face, 4299 (GLenum)func, 4300 (GLint)ref, 4301 (GLuint)mask 4302 ); 4303} 4304 4305/* void glStencilMask ( GLuint mask ) */ 4306static void 4307android_glStencilMask__I 4308 (JNIEnv *_env, jobject _this, jint mask) { 4309 glStencilMask( 4310 (GLuint)mask 4311 ); 4312} 4313 4314/* void glStencilMaskSeparate ( GLenum face, GLuint mask ) */ 4315static void 4316android_glStencilMaskSeparate__II 4317 (JNIEnv *_env, jobject _this, jint face, jint mask) { 4318 glStencilMaskSeparate( 4319 (GLenum)face, 4320 (GLuint)mask 4321 ); 4322} 4323 4324/* void glStencilOp ( GLenum fail, GLenum zfail, GLenum zpass ) */ 4325static void 4326android_glStencilOp__III 4327 (JNIEnv *_env, jobject _this, jint fail, jint zfail, jint zpass) { 4328 glStencilOp( 4329 (GLenum)fail, 4330 (GLenum)zfail, 4331 (GLenum)zpass 4332 ); 4333} 4334 4335/* void glStencilOpSeparate ( GLenum face, GLenum fail, GLenum zfail, GLenum zpass ) */ 4336static void 4337android_glStencilOpSeparate__IIII 4338 (JNIEnv *_env, jobject _this, jint face, jint fail, jint zfail, jint zpass) { 4339 glStencilOpSeparate( 4340 (GLenum)face, 4341 (GLenum)fail, 4342 (GLenum)zfail, 4343 (GLenum)zpass 4344 ); 4345} 4346 4347/* void glTexImage2D ( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) */ 4348static void 4349android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2 4350 (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint format, jint type, jobject pixels_buf) { 4351 jarray _array = (jarray) 0; 4352 jint _bufferOffset = (jint) 0; 4353 jint _remaining; 4354 GLvoid *pixels = (GLvoid *) 0; 4355 4356 if (pixels_buf) { 4357 pixels = (GLvoid *)getPointer(_env, pixels_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4358 } 4359 if (pixels_buf && pixels == NULL) { 4360 char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 4361 pixels = (GLvoid *) (_pixelsBase + _bufferOffset); 4362 } 4363 glTexImage2D( 4364 (GLenum)target, 4365 (GLint)level, 4366 (GLint)internalformat, 4367 (GLsizei)width, 4368 (GLsizei)height, 4369 (GLint)border, 4370 (GLenum)format, 4371 (GLenum)type, 4372 (GLvoid *)pixels 4373 ); 4374 if (_array) { 4375 releasePointer(_env, _array, pixels, JNI_FALSE); 4376 } 4377} 4378 4379/* void glTexParameterf ( GLenum target, GLenum pname, GLfloat param ) */ 4380static void 4381android_glTexParameterf__IIF 4382 (JNIEnv *_env, jobject _this, jint target, jint pname, jfloat param) { 4383 glTexParameterf( 4384 (GLenum)target, 4385 (GLenum)pname, 4386 (GLfloat)param 4387 ); 4388} 4389 4390/* void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params ) */ 4391static void 4392android_glTexParameterfv__II_3FI 4393 (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) { 4394 jint _exception = 0; 4395 const char * _exceptionType = NULL; 4396 const char * _exceptionMessage = NULL; 4397 GLfloat *params_base = (GLfloat *) 0; 4398 jint _remaining; 4399 GLfloat *params = (GLfloat *) 0; 4400 4401 if (!params_ref) { 4402 _exception = 1; 4403 _exceptionType = "java/lang/IllegalArgumentException"; 4404 _exceptionMessage = "params == null"; 4405 goto exit; 4406 } 4407 if (offset < 0) { 4408 _exception = 1; 4409 _exceptionType = "java/lang/IllegalArgumentException"; 4410 _exceptionMessage = "offset < 0"; 4411 goto exit; 4412 } 4413 _remaining = _env->GetArrayLength(params_ref) - offset; 4414 if (_remaining < 1) { 4415 _exception = 1; 4416 _exceptionType = "java/lang/IllegalArgumentException"; 4417 _exceptionMessage = "length - offset < 1 < needed"; 4418 goto exit; 4419 } 4420 params_base = (GLfloat *) 4421 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 4422 params = params_base + offset; 4423 4424 glTexParameterfv( 4425 (GLenum)target, 4426 (GLenum)pname, 4427 (GLfloat *)params 4428 ); 4429 4430exit: 4431 if (params_base) { 4432 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 4433 JNI_ABORT); 4434 } 4435 if (_exception) { 4436 jniThrowException(_env, _exceptionType, _exceptionMessage); 4437 } 4438} 4439 4440/* void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params ) */ 4441static void 4442android_glTexParameterfv__IILjava_nio_FloatBuffer_2 4443 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 4444 jint _exception = 0; 4445 const char * _exceptionType = NULL; 4446 const char * _exceptionMessage = NULL; 4447 jfloatArray _array = (jfloatArray) 0; 4448 jint _bufferOffset = (jint) 0; 4449 jint _remaining; 4450 GLfloat *params = (GLfloat *) 0; 4451 4452 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4453 if (_remaining < 1) { 4454 _exception = 1; 4455 _exceptionType = "java/lang/IllegalArgumentException"; 4456 _exceptionMessage = "remaining() < 1 < needed"; 4457 goto exit; 4458 } 4459 if (params == NULL) { 4460 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 4461 params = (GLfloat *) (_paramsBase + _bufferOffset); 4462 } 4463 glTexParameterfv( 4464 (GLenum)target, 4465 (GLenum)pname, 4466 (GLfloat *)params 4467 ); 4468 4469exit: 4470 if (_array) { 4471 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT); 4472 } 4473 if (_exception) { 4474 jniThrowException(_env, _exceptionType, _exceptionMessage); 4475 } 4476} 4477 4478/* void glTexParameteri ( GLenum target, GLenum pname, GLint param ) */ 4479static void 4480android_glTexParameteri__III 4481 (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) { 4482 glTexParameteri( 4483 (GLenum)target, 4484 (GLenum)pname, 4485 (GLint)param 4486 ); 4487} 4488 4489/* void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params ) */ 4490static void 4491android_glTexParameteriv__II_3II 4492 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 4493 jint _exception = 0; 4494 const char * _exceptionType = NULL; 4495 const char * _exceptionMessage = NULL; 4496 GLint *params_base = (GLint *) 0; 4497 jint _remaining; 4498 GLint *params = (GLint *) 0; 4499 4500 if (!params_ref) { 4501 _exception = 1; 4502 _exceptionType = "java/lang/IllegalArgumentException"; 4503 _exceptionMessage = "params == null"; 4504 goto exit; 4505 } 4506 if (offset < 0) { 4507 _exception = 1; 4508 _exceptionType = "java/lang/IllegalArgumentException"; 4509 _exceptionMessage = "offset < 0"; 4510 goto exit; 4511 } 4512 _remaining = _env->GetArrayLength(params_ref) - offset; 4513 if (_remaining < 1) { 4514 _exception = 1; 4515 _exceptionType = "java/lang/IllegalArgumentException"; 4516 _exceptionMessage = "length - offset < 1 < needed"; 4517 goto exit; 4518 } 4519 params_base = (GLint *) 4520 _env->GetIntArrayElements(params_ref, (jboolean *)0); 4521 params = params_base + offset; 4522 4523 glTexParameteriv( 4524 (GLenum)target, 4525 (GLenum)pname, 4526 (GLint *)params 4527 ); 4528 4529exit: 4530 if (params_base) { 4531 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 4532 JNI_ABORT); 4533 } 4534 if (_exception) { 4535 jniThrowException(_env, _exceptionType, _exceptionMessage); 4536 } 4537} 4538 4539/* void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params ) */ 4540static void 4541android_glTexParameteriv__IILjava_nio_IntBuffer_2 4542 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 4543 jint _exception = 0; 4544 const char * _exceptionType = NULL; 4545 const char * _exceptionMessage = NULL; 4546 jintArray _array = (jintArray) 0; 4547 jint _bufferOffset = (jint) 0; 4548 jint _remaining; 4549 GLint *params = (GLint *) 0; 4550 4551 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4552 if (_remaining < 1) { 4553 _exception = 1; 4554 _exceptionType = "java/lang/IllegalArgumentException"; 4555 _exceptionMessage = "remaining() < 1 < needed"; 4556 goto exit; 4557 } 4558 if (params == NULL) { 4559 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 4560 params = (GLint *) (_paramsBase + _bufferOffset); 4561 } 4562 glTexParameteriv( 4563 (GLenum)target, 4564 (GLenum)pname, 4565 (GLint *)params 4566 ); 4567 4568exit: 4569 if (_array) { 4570 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT); 4571 } 4572 if (_exception) { 4573 jniThrowException(_env, _exceptionType, _exceptionMessage); 4574 } 4575} 4576 4577/* void glTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels ) */ 4578static void 4579android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 4580 (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint type, jobject pixels_buf) { 4581 jarray _array = (jarray) 0; 4582 jint _bufferOffset = (jint) 0; 4583 jint _remaining; 4584 GLvoid *pixels = (GLvoid *) 0; 4585 4586 if (pixels_buf) { 4587 pixels = (GLvoid *)getPointer(_env, pixels_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4588 } 4589 if (pixels_buf && pixels == NULL) { 4590 char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 4591 pixels = (GLvoid *) (_pixelsBase + _bufferOffset); 4592 } 4593 glTexSubImage2D( 4594 (GLenum)target, 4595 (GLint)level, 4596 (GLint)xoffset, 4597 (GLint)yoffset, 4598 (GLsizei)width, 4599 (GLsizei)height, 4600 (GLenum)format, 4601 (GLenum)type, 4602 (GLvoid *)pixels 4603 ); 4604 if (_array) { 4605 releasePointer(_env, _array, pixels, JNI_FALSE); 4606 } 4607} 4608 4609/* void glUniform1f ( GLint location, GLfloat x ) */ 4610static void 4611android_glUniform1f__IF 4612 (JNIEnv *_env, jobject _this, jint location, jfloat x) { 4613 glUniform1f( 4614 (GLint)location, 4615 (GLfloat)x 4616 ); 4617} 4618 4619/* void glUniform1fv ( GLint location, GLsizei count, const GLfloat *v ) */ 4620static void 4621android_glUniform1fv__II_3FI 4622 (JNIEnv *_env, jobject _this, jint location, jint count, jfloatArray v_ref, jint offset) { 4623 jint _exception = 0; 4624 const char * _exceptionType = NULL; 4625 const char * _exceptionMessage = NULL; 4626 GLfloat *v_base = (GLfloat *) 0; 4627 jint _remaining; 4628 GLfloat *v = (GLfloat *) 0; 4629 4630 if (!v_ref) { 4631 _exception = 1; 4632 _exceptionType = "java/lang/IllegalArgumentException"; 4633 _exceptionMessage = "v == null"; 4634 goto exit; 4635 } 4636 if (offset < 0) { 4637 _exception = 1; 4638 _exceptionType = "java/lang/IllegalArgumentException"; 4639 _exceptionMessage = "offset < 0"; 4640 goto exit; 4641 } 4642 _remaining = _env->GetArrayLength(v_ref) - offset; 4643 if (_remaining < count) { 4644 _exception = 1; 4645 _exceptionType = "java/lang/IllegalArgumentException"; 4646 _exceptionMessage = "length - offset < count < needed"; 4647 goto exit; 4648 } 4649 v_base = (GLfloat *) 4650 _env->GetFloatArrayElements(v_ref, (jboolean *)0); 4651 v = v_base + offset; 4652 4653 glUniform1fv( 4654 (GLint)location, 4655 (GLsizei)count, 4656 (GLfloat *)v 4657 ); 4658 4659exit: 4660 if (v_base) { 4661 _env->ReleaseFloatArrayElements(v_ref, (jfloat*)v_base, 4662 JNI_ABORT); 4663 } 4664 if (_exception) { 4665 jniThrowException(_env, _exceptionType, _exceptionMessage); 4666 } 4667} 4668 4669/* void glUniform1fv ( GLint location, GLsizei count, const GLfloat *v ) */ 4670static void 4671android_glUniform1fv__IILjava_nio_FloatBuffer_2 4672 (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) { 4673 jint _exception = 0; 4674 const char * _exceptionType = NULL; 4675 const char * _exceptionMessage = NULL; 4676 jfloatArray _array = (jfloatArray) 0; 4677 jint _bufferOffset = (jint) 0; 4678 jint _remaining; 4679 GLfloat *v = (GLfloat *) 0; 4680 4681 v = (GLfloat *)getPointer(_env, v_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4682 if (_remaining < count) { 4683 _exception = 1; 4684 _exceptionType = "java/lang/IllegalArgumentException"; 4685 _exceptionMessage = "remaining() < count < needed"; 4686 goto exit; 4687 } 4688 if (v == NULL) { 4689 char * _vBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 4690 v = (GLfloat *) (_vBase + _bufferOffset); 4691 } 4692 glUniform1fv( 4693 (GLint)location, 4694 (GLsizei)count, 4695 (GLfloat *)v 4696 ); 4697 4698exit: 4699 if (_array) { 4700 _env->ReleaseFloatArrayElements(_array, (jfloat*)v, JNI_ABORT); 4701 } 4702 if (_exception) { 4703 jniThrowException(_env, _exceptionType, _exceptionMessage); 4704 } 4705} 4706 4707/* void glUniform1i ( GLint location, GLint x ) */ 4708static void 4709android_glUniform1i__II 4710 (JNIEnv *_env, jobject _this, jint location, jint x) { 4711 glUniform1i( 4712 (GLint)location, 4713 (GLint)x 4714 ); 4715} 4716 4717/* void glUniform1iv ( GLint location, GLsizei count, const GLint *v ) */ 4718static void 4719android_glUniform1iv__II_3II 4720 (JNIEnv *_env, jobject _this, jint location, jint count, jintArray v_ref, jint offset) { 4721 jint _exception = 0; 4722 const char * _exceptionType = NULL; 4723 const char * _exceptionMessage = NULL; 4724 GLint *v_base = (GLint *) 0; 4725 jint _remaining; 4726 GLint *v = (GLint *) 0; 4727 4728 if (!v_ref) { 4729 _exception = 1; 4730 _exceptionType = "java/lang/IllegalArgumentException"; 4731 _exceptionMessage = "v == null"; 4732 goto exit; 4733 } 4734 if (offset < 0) { 4735 _exception = 1; 4736 _exceptionType = "java/lang/IllegalArgumentException"; 4737 _exceptionMessage = "offset < 0"; 4738 goto exit; 4739 } 4740 _remaining = _env->GetArrayLength(v_ref) - offset; 4741 if (_remaining < count) { 4742 _exception = 1; 4743 _exceptionType = "java/lang/IllegalArgumentException"; 4744 _exceptionMessage = "length - offset < count < needed"; 4745 goto exit; 4746 } 4747 v_base = (GLint *) 4748 _env->GetIntArrayElements(v_ref, (jboolean *)0); 4749 v = v_base + offset; 4750 4751 glUniform1iv( 4752 (GLint)location, 4753 (GLsizei)count, 4754 (GLint *)v 4755 ); 4756 4757exit: 4758 if (v_base) { 4759 _env->ReleaseIntArrayElements(v_ref, (jint*)v_base, 4760 JNI_ABORT); 4761 } 4762 if (_exception) { 4763 jniThrowException(_env, _exceptionType, _exceptionMessage); 4764 } 4765} 4766 4767/* void glUniform1iv ( GLint location, GLsizei count, const GLint *v ) */ 4768static void 4769android_glUniform1iv__IILjava_nio_IntBuffer_2 4770 (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) { 4771 jint _exception = 0; 4772 const char * _exceptionType = NULL; 4773 const char * _exceptionMessage = NULL; 4774 jintArray _array = (jintArray) 0; 4775 jint _bufferOffset = (jint) 0; 4776 jint _remaining; 4777 GLint *v = (GLint *) 0; 4778 4779 v = (GLint *)getPointer(_env, v_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4780 if (_remaining < count) { 4781 _exception = 1; 4782 _exceptionType = "java/lang/IllegalArgumentException"; 4783 _exceptionMessage = "remaining() < count < needed"; 4784 goto exit; 4785 } 4786 if (v == NULL) { 4787 char * _vBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 4788 v = (GLint *) (_vBase + _bufferOffset); 4789 } 4790 glUniform1iv( 4791 (GLint)location, 4792 (GLsizei)count, 4793 (GLint *)v 4794 ); 4795 4796exit: 4797 if (_array) { 4798 _env->ReleaseIntArrayElements(_array, (jint*)v, JNI_ABORT); 4799 } 4800 if (_exception) { 4801 jniThrowException(_env, _exceptionType, _exceptionMessage); 4802 } 4803} 4804 4805/* void glUniform2f ( GLint location, GLfloat x, GLfloat y ) */ 4806static void 4807android_glUniform2f__IFF 4808 (JNIEnv *_env, jobject _this, jint location, jfloat x, jfloat y) { 4809 glUniform2f( 4810 (GLint)location, 4811 (GLfloat)x, 4812 (GLfloat)y 4813 ); 4814} 4815 4816/* void glUniform2fv ( GLint location, GLsizei count, const GLfloat *v ) */ 4817static void 4818android_glUniform2fv__II_3FI 4819 (JNIEnv *_env, jobject _this, jint location, jint count, jfloatArray v_ref, jint offset) { 4820 jint _exception = 0; 4821 const char * _exceptionType = NULL; 4822 const char * _exceptionMessage = NULL; 4823 GLfloat *v_base = (GLfloat *) 0; 4824 jint _remaining; 4825 GLfloat *v = (GLfloat *) 0; 4826 4827 if (!v_ref) { 4828 _exception = 1; 4829 _exceptionType = "java/lang/IllegalArgumentException"; 4830 _exceptionMessage = "v == null"; 4831 goto exit; 4832 } 4833 if (offset < 0) { 4834 _exception = 1; 4835 _exceptionType = "java/lang/IllegalArgumentException"; 4836 _exceptionMessage = "offset < 0"; 4837 goto exit; 4838 } 4839 _remaining = _env->GetArrayLength(v_ref) - offset; 4840 if (_remaining < count*2) { 4841 _exception = 1; 4842 _exceptionType = "java/lang/IllegalArgumentException"; 4843 _exceptionMessage = "length - offset < count*2 < needed"; 4844 goto exit; 4845 } 4846 v_base = (GLfloat *) 4847 _env->GetFloatArrayElements(v_ref, (jboolean *)0); 4848 v = v_base + offset; 4849 4850 glUniform2fv( 4851 (GLint)location, 4852 (GLsizei)count, 4853 (GLfloat *)v 4854 ); 4855 4856exit: 4857 if (v_base) { 4858 _env->ReleaseFloatArrayElements(v_ref, (jfloat*)v_base, 4859 JNI_ABORT); 4860 } 4861 if (_exception) { 4862 jniThrowException(_env, _exceptionType, _exceptionMessage); 4863 } 4864} 4865 4866/* void glUniform2fv ( GLint location, GLsizei count, const GLfloat *v ) */ 4867static void 4868android_glUniform2fv__IILjava_nio_FloatBuffer_2 4869 (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) { 4870 jint _exception = 0; 4871 const char * _exceptionType = NULL; 4872 const char * _exceptionMessage = NULL; 4873 jfloatArray _array = (jfloatArray) 0; 4874 jint _bufferOffset = (jint) 0; 4875 jint _remaining; 4876 GLfloat *v = (GLfloat *) 0; 4877 4878 v = (GLfloat *)getPointer(_env, v_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4879 if (_remaining < count*2) { 4880 _exception = 1; 4881 _exceptionType = "java/lang/IllegalArgumentException"; 4882 _exceptionMessage = "remaining() < count*2 < needed"; 4883 goto exit; 4884 } 4885 if (v == NULL) { 4886 char * _vBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 4887 v = (GLfloat *) (_vBase + _bufferOffset); 4888 } 4889 glUniform2fv( 4890 (GLint)location, 4891 (GLsizei)count, 4892 (GLfloat *)v 4893 ); 4894 4895exit: 4896 if (_array) { 4897 _env->ReleaseFloatArrayElements(_array, (jfloat*)v, JNI_ABORT); 4898 } 4899 if (_exception) { 4900 jniThrowException(_env, _exceptionType, _exceptionMessage); 4901 } 4902} 4903 4904/* void glUniform2i ( GLint location, GLint x, GLint y ) */ 4905static void 4906android_glUniform2i__III 4907 (JNIEnv *_env, jobject _this, jint location, jint x, jint y) { 4908 glUniform2i( 4909 (GLint)location, 4910 (GLint)x, 4911 (GLint)y 4912 ); 4913} 4914 4915/* void glUniform2iv ( GLint location, GLsizei count, const GLint *v ) */ 4916static void 4917android_glUniform2iv__II_3II 4918 (JNIEnv *_env, jobject _this, jint location, jint count, jintArray v_ref, jint offset) { 4919 jint _exception = 0; 4920 const char * _exceptionType = NULL; 4921 const char * _exceptionMessage = NULL; 4922 GLint *v_base = (GLint *) 0; 4923 jint _remaining; 4924 GLint *v = (GLint *) 0; 4925 4926 if (!v_ref) { 4927 _exception = 1; 4928 _exceptionType = "java/lang/IllegalArgumentException"; 4929 _exceptionMessage = "v == null"; 4930 goto exit; 4931 } 4932 if (offset < 0) { 4933 _exception = 1; 4934 _exceptionType = "java/lang/IllegalArgumentException"; 4935 _exceptionMessage = "offset < 0"; 4936 goto exit; 4937 } 4938 _remaining = _env->GetArrayLength(v_ref) - offset; 4939 if (_remaining < count*2) { 4940 _exception = 1; 4941 _exceptionType = "java/lang/IllegalArgumentException"; 4942 _exceptionMessage = "length - offset < count*2 < needed"; 4943 goto exit; 4944 } 4945 v_base = (GLint *) 4946 _env->GetIntArrayElements(v_ref, (jboolean *)0); 4947 v = v_base + offset; 4948 4949 glUniform2iv( 4950 (GLint)location, 4951 (GLsizei)count, 4952 (GLint *)v 4953 ); 4954 4955exit: 4956 if (v_base) { 4957 _env->ReleaseIntArrayElements(v_ref, (jint*)v_base, 4958 JNI_ABORT); 4959 } 4960 if (_exception) { 4961 jniThrowException(_env, _exceptionType, _exceptionMessage); 4962 } 4963} 4964 4965/* void glUniform2iv ( GLint location, GLsizei count, const GLint *v ) */ 4966static void 4967android_glUniform2iv__IILjava_nio_IntBuffer_2 4968 (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) { 4969 jint _exception = 0; 4970 const char * _exceptionType = NULL; 4971 const char * _exceptionMessage = NULL; 4972 jintArray _array = (jintArray) 0; 4973 jint _bufferOffset = (jint) 0; 4974 jint _remaining; 4975 GLint *v = (GLint *) 0; 4976 4977 v = (GLint *)getPointer(_env, v_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4978 if (_remaining < count*2) { 4979 _exception = 1; 4980 _exceptionType = "java/lang/IllegalArgumentException"; 4981 _exceptionMessage = "remaining() < count*2 < needed"; 4982 goto exit; 4983 } 4984 if (v == NULL) { 4985 char * _vBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 4986 v = (GLint *) (_vBase + _bufferOffset); 4987 } 4988 glUniform2iv( 4989 (GLint)location, 4990 (GLsizei)count, 4991 (GLint *)v 4992 ); 4993 4994exit: 4995 if (_array) { 4996 _env->ReleaseIntArrayElements(_array, (jint*)v, JNI_ABORT); 4997 } 4998 if (_exception) { 4999 jniThrowException(_env, _exceptionType, _exceptionMessage); 5000 } 5001} 5002 5003/* void glUniform3f ( GLint location, GLfloat x, GLfloat y, GLfloat z ) */ 5004static void 5005android_glUniform3f__IFFF 5006 (JNIEnv *_env, jobject _this, jint location, jfloat x, jfloat y, jfloat z) { 5007 glUniform3f( 5008 (GLint)location, 5009 (GLfloat)x, 5010 (GLfloat)y, 5011 (GLfloat)z 5012 ); 5013} 5014 5015/* void glUniform3fv ( GLint location, GLsizei count, const GLfloat *v ) */ 5016static void 5017android_glUniform3fv__II_3FI 5018 (JNIEnv *_env, jobject _this, jint location, jint count, jfloatArray v_ref, jint offset) { 5019 jint _exception = 0; 5020 const char * _exceptionType = NULL; 5021 const char * _exceptionMessage = NULL; 5022 GLfloat *v_base = (GLfloat *) 0; 5023 jint _remaining; 5024 GLfloat *v = (GLfloat *) 0; 5025 5026 if (!v_ref) { 5027 _exception = 1; 5028 _exceptionType = "java/lang/IllegalArgumentException"; 5029 _exceptionMessage = "v == null"; 5030 goto exit; 5031 } 5032 if (offset < 0) { 5033 _exception = 1; 5034 _exceptionType = "java/lang/IllegalArgumentException"; 5035 _exceptionMessage = "offset < 0"; 5036 goto exit; 5037 } 5038 _remaining = _env->GetArrayLength(v_ref) - offset; 5039 if (_remaining < count*3) { 5040 _exception = 1; 5041 _exceptionType = "java/lang/IllegalArgumentException"; 5042 _exceptionMessage = "length - offset < count*3 < needed"; 5043 goto exit; 5044 } 5045 v_base = (GLfloat *) 5046 _env->GetFloatArrayElements(v_ref, (jboolean *)0); 5047 v = v_base + offset; 5048 5049 glUniform3fv( 5050 (GLint)location, 5051 (GLsizei)count, 5052 (GLfloat *)v 5053 ); 5054 5055exit: 5056 if (v_base) { 5057 _env->ReleaseFloatArrayElements(v_ref, (jfloat*)v_base, 5058 JNI_ABORT); 5059 } 5060 if (_exception) { 5061 jniThrowException(_env, _exceptionType, _exceptionMessage); 5062 } 5063} 5064 5065/* void glUniform3fv ( GLint location, GLsizei count, const GLfloat *v ) */ 5066static void 5067android_glUniform3fv__IILjava_nio_FloatBuffer_2 5068 (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) { 5069 jint _exception = 0; 5070 const char * _exceptionType = NULL; 5071 const char * _exceptionMessage = NULL; 5072 jfloatArray _array = (jfloatArray) 0; 5073 jint _bufferOffset = (jint) 0; 5074 jint _remaining; 5075 GLfloat *v = (GLfloat *) 0; 5076 5077 v = (GLfloat *)getPointer(_env, v_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5078 if (_remaining < count*3) { 5079 _exception = 1; 5080 _exceptionType = "java/lang/IllegalArgumentException"; 5081 _exceptionMessage = "remaining() < count*3 < needed"; 5082 goto exit; 5083 } 5084 if (v == NULL) { 5085 char * _vBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5086 v = (GLfloat *) (_vBase + _bufferOffset); 5087 } 5088 glUniform3fv( 5089 (GLint)location, 5090 (GLsizei)count, 5091 (GLfloat *)v 5092 ); 5093 5094exit: 5095 if (_array) { 5096 _env->ReleaseFloatArrayElements(_array, (jfloat*)v, JNI_ABORT); 5097 } 5098 if (_exception) { 5099 jniThrowException(_env, _exceptionType, _exceptionMessage); 5100 } 5101} 5102 5103/* void glUniform3i ( GLint location, GLint x, GLint y, GLint z ) */ 5104static void 5105android_glUniform3i__IIII 5106 (JNIEnv *_env, jobject _this, jint location, jint x, jint y, jint z) { 5107 glUniform3i( 5108 (GLint)location, 5109 (GLint)x, 5110 (GLint)y, 5111 (GLint)z 5112 ); 5113} 5114 5115/* void glUniform3iv ( GLint location, GLsizei count, const GLint *v ) */ 5116static void 5117android_glUniform3iv__II_3II 5118 (JNIEnv *_env, jobject _this, jint location, jint count, jintArray v_ref, jint offset) { 5119 jint _exception = 0; 5120 const char * _exceptionType = NULL; 5121 const char * _exceptionMessage = NULL; 5122 GLint *v_base = (GLint *) 0; 5123 jint _remaining; 5124 GLint *v = (GLint *) 0; 5125 5126 if (!v_ref) { 5127 _exception = 1; 5128 _exceptionType = "java/lang/IllegalArgumentException"; 5129 _exceptionMessage = "v == null"; 5130 goto exit; 5131 } 5132 if (offset < 0) { 5133 _exception = 1; 5134 _exceptionType = "java/lang/IllegalArgumentException"; 5135 _exceptionMessage = "offset < 0"; 5136 goto exit; 5137 } 5138 _remaining = _env->GetArrayLength(v_ref) - offset; 5139 if (_remaining < count*3) { 5140 _exception = 1; 5141 _exceptionType = "java/lang/IllegalArgumentException"; 5142 _exceptionMessage = "length - offset < count*3 < needed"; 5143 goto exit; 5144 } 5145 v_base = (GLint *) 5146 _env->GetIntArrayElements(v_ref, (jboolean *)0); 5147 v = v_base + offset; 5148 5149 glUniform3iv( 5150 (GLint)location, 5151 (GLsizei)count, 5152 (GLint *)v 5153 ); 5154 5155exit: 5156 if (v_base) { 5157 _env->ReleaseIntArrayElements(v_ref, (jint*)v_base, 5158 JNI_ABORT); 5159 } 5160 if (_exception) { 5161 jniThrowException(_env, _exceptionType, _exceptionMessage); 5162 } 5163} 5164 5165/* void glUniform3iv ( GLint location, GLsizei count, const GLint *v ) */ 5166static void 5167android_glUniform3iv__IILjava_nio_IntBuffer_2 5168 (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) { 5169 jint _exception = 0; 5170 const char * _exceptionType = NULL; 5171 const char * _exceptionMessage = NULL; 5172 jintArray _array = (jintArray) 0; 5173 jint _bufferOffset = (jint) 0; 5174 jint _remaining; 5175 GLint *v = (GLint *) 0; 5176 5177 v = (GLint *)getPointer(_env, v_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5178 if (_remaining < count*3) { 5179 _exception = 1; 5180 _exceptionType = "java/lang/IllegalArgumentException"; 5181 _exceptionMessage = "remaining() < count*3 < needed"; 5182 goto exit; 5183 } 5184 if (v == NULL) { 5185 char * _vBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 5186 v = (GLint *) (_vBase + _bufferOffset); 5187 } 5188 glUniform3iv( 5189 (GLint)location, 5190 (GLsizei)count, 5191 (GLint *)v 5192 ); 5193 5194exit: 5195 if (_array) { 5196 _env->ReleaseIntArrayElements(_array, (jint*)v, JNI_ABORT); 5197 } 5198 if (_exception) { 5199 jniThrowException(_env, _exceptionType, _exceptionMessage); 5200 } 5201} 5202 5203/* void glUniform4f ( GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) */ 5204static void 5205android_glUniform4f__IFFFF 5206 (JNIEnv *_env, jobject _this, jint location, jfloat x, jfloat y, jfloat z, jfloat w) { 5207 glUniform4f( 5208 (GLint)location, 5209 (GLfloat)x, 5210 (GLfloat)y, 5211 (GLfloat)z, 5212 (GLfloat)w 5213 ); 5214} 5215 5216/* void glUniform4fv ( GLint location, GLsizei count, const GLfloat *v ) */ 5217static void 5218android_glUniform4fv__II_3FI 5219 (JNIEnv *_env, jobject _this, jint location, jint count, jfloatArray v_ref, jint offset) { 5220 jint _exception = 0; 5221 const char * _exceptionType = NULL; 5222 const char * _exceptionMessage = NULL; 5223 GLfloat *v_base = (GLfloat *) 0; 5224 jint _remaining; 5225 GLfloat *v = (GLfloat *) 0; 5226 5227 if (!v_ref) { 5228 _exception = 1; 5229 _exceptionType = "java/lang/IllegalArgumentException"; 5230 _exceptionMessage = "v == null"; 5231 goto exit; 5232 } 5233 if (offset < 0) { 5234 _exception = 1; 5235 _exceptionType = "java/lang/IllegalArgumentException"; 5236 _exceptionMessage = "offset < 0"; 5237 goto exit; 5238 } 5239 _remaining = _env->GetArrayLength(v_ref) - offset; 5240 if (_remaining < count*4) { 5241 _exception = 1; 5242 _exceptionType = "java/lang/IllegalArgumentException"; 5243 _exceptionMessage = "length - offset < count*4 < needed"; 5244 goto exit; 5245 } 5246 v_base = (GLfloat *) 5247 _env->GetFloatArrayElements(v_ref, (jboolean *)0); 5248 v = v_base + offset; 5249 5250 glUniform4fv( 5251 (GLint)location, 5252 (GLsizei)count, 5253 (GLfloat *)v 5254 ); 5255 5256exit: 5257 if (v_base) { 5258 _env->ReleaseFloatArrayElements(v_ref, (jfloat*)v_base, 5259 JNI_ABORT); 5260 } 5261 if (_exception) { 5262 jniThrowException(_env, _exceptionType, _exceptionMessage); 5263 } 5264} 5265 5266/* void glUniform4fv ( GLint location, GLsizei count, const GLfloat *v ) */ 5267static void 5268android_glUniform4fv__IILjava_nio_FloatBuffer_2 5269 (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) { 5270 jint _exception = 0; 5271 const char * _exceptionType = NULL; 5272 const char * _exceptionMessage = NULL; 5273 jfloatArray _array = (jfloatArray) 0; 5274 jint _bufferOffset = (jint) 0; 5275 jint _remaining; 5276 GLfloat *v = (GLfloat *) 0; 5277 5278 v = (GLfloat *)getPointer(_env, v_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5279 if (_remaining < count*4) { 5280 _exception = 1; 5281 _exceptionType = "java/lang/IllegalArgumentException"; 5282 _exceptionMessage = "remaining() < count*4 < needed"; 5283 goto exit; 5284 } 5285 if (v == NULL) { 5286 char * _vBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5287 v = (GLfloat *) (_vBase + _bufferOffset); 5288 } 5289 glUniform4fv( 5290 (GLint)location, 5291 (GLsizei)count, 5292 (GLfloat *)v 5293 ); 5294 5295exit: 5296 if (_array) { 5297 _env->ReleaseFloatArrayElements(_array, (jfloat*)v, JNI_ABORT); 5298 } 5299 if (_exception) { 5300 jniThrowException(_env, _exceptionType, _exceptionMessage); 5301 } 5302} 5303 5304/* void glUniform4i ( GLint location, GLint x, GLint y, GLint z, GLint w ) */ 5305static void 5306android_glUniform4i__IIIII 5307 (JNIEnv *_env, jobject _this, jint location, jint x, jint y, jint z, jint w) { 5308 glUniform4i( 5309 (GLint)location, 5310 (GLint)x, 5311 (GLint)y, 5312 (GLint)z, 5313 (GLint)w 5314 ); 5315} 5316 5317/* void glUniform4iv ( GLint location, GLsizei count, const GLint *v ) */ 5318static void 5319android_glUniform4iv__II_3II 5320 (JNIEnv *_env, jobject _this, jint location, jint count, jintArray v_ref, jint offset) { 5321 jint _exception = 0; 5322 const char * _exceptionType = NULL; 5323 const char * _exceptionMessage = NULL; 5324 GLint *v_base = (GLint *) 0; 5325 jint _remaining; 5326 GLint *v = (GLint *) 0; 5327 5328 if (!v_ref) { 5329 _exception = 1; 5330 _exceptionType = "java/lang/IllegalArgumentException"; 5331 _exceptionMessage = "v == null"; 5332 goto exit; 5333 } 5334 if (offset < 0) { 5335 _exception = 1; 5336 _exceptionType = "java/lang/IllegalArgumentException"; 5337 _exceptionMessage = "offset < 0"; 5338 goto exit; 5339 } 5340 _remaining = _env->GetArrayLength(v_ref) - offset; 5341 if (_remaining < count*4) { 5342 _exception = 1; 5343 _exceptionType = "java/lang/IllegalArgumentException"; 5344 _exceptionMessage = "length - offset < count*4 < needed"; 5345 goto exit; 5346 } 5347 v_base = (GLint *) 5348 _env->GetIntArrayElements(v_ref, (jboolean *)0); 5349 v = v_base + offset; 5350 5351 glUniform4iv( 5352 (GLint)location, 5353 (GLsizei)count, 5354 (GLint *)v 5355 ); 5356 5357exit: 5358 if (v_base) { 5359 _env->ReleaseIntArrayElements(v_ref, (jint*)v_base, 5360 JNI_ABORT); 5361 } 5362 if (_exception) { 5363 jniThrowException(_env, _exceptionType, _exceptionMessage); 5364 } 5365} 5366 5367/* void glUniform4iv ( GLint location, GLsizei count, const GLint *v ) */ 5368static void 5369android_glUniform4iv__IILjava_nio_IntBuffer_2 5370 (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) { 5371 jint _exception = 0; 5372 const char * _exceptionType = NULL; 5373 const char * _exceptionMessage = NULL; 5374 jintArray _array = (jintArray) 0; 5375 jint _bufferOffset = (jint) 0; 5376 jint _remaining; 5377 GLint *v = (GLint *) 0; 5378 5379 v = (GLint *)getPointer(_env, v_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5380 if (_remaining < count*4) { 5381 _exception = 1; 5382 _exceptionType = "java/lang/IllegalArgumentException"; 5383 _exceptionMessage = "remaining() < count*4 < needed"; 5384 goto exit; 5385 } 5386 if (v == NULL) { 5387 char * _vBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 5388 v = (GLint *) (_vBase + _bufferOffset); 5389 } 5390 glUniform4iv( 5391 (GLint)location, 5392 (GLsizei)count, 5393 (GLint *)v 5394 ); 5395 5396exit: 5397 if (_array) { 5398 _env->ReleaseIntArrayElements(_array, (jint*)v, JNI_ABORT); 5399 } 5400 if (_exception) { 5401 jniThrowException(_env, _exceptionType, _exceptionMessage); 5402 } 5403} 5404 5405/* void glUniformMatrix2fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 5406static void 5407android_glUniformMatrix2fv__IIZ_3FI 5408 (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { 5409 jint _exception = 0; 5410 const char * _exceptionType = NULL; 5411 const char * _exceptionMessage = NULL; 5412 GLfloat *value_base = (GLfloat *) 0; 5413 jint _remaining; 5414 GLfloat *value = (GLfloat *) 0; 5415 5416 if (!value_ref) { 5417 _exception = 1; 5418 _exceptionType = "java/lang/IllegalArgumentException"; 5419 _exceptionMessage = "value == null"; 5420 goto exit; 5421 } 5422 if (offset < 0) { 5423 _exception = 1; 5424 _exceptionType = "java/lang/IllegalArgumentException"; 5425 _exceptionMessage = "offset < 0"; 5426 goto exit; 5427 } 5428 _remaining = _env->GetArrayLength(value_ref) - offset; 5429 if (_remaining < count*4) { 5430 _exception = 1; 5431 _exceptionType = "java/lang/IllegalArgumentException"; 5432 _exceptionMessage = "length - offset < count*4 < needed"; 5433 goto exit; 5434 } 5435 value_base = (GLfloat *) 5436 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 5437 value = value_base + offset; 5438 5439 glUniformMatrix2fv( 5440 (GLint)location, 5441 (GLsizei)count, 5442 (GLboolean)transpose, 5443 (GLfloat *)value 5444 ); 5445 5446exit: 5447 if (value_base) { 5448 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 5449 JNI_ABORT); 5450 } 5451 if (_exception) { 5452 jniThrowException(_env, _exceptionType, _exceptionMessage); 5453 } 5454} 5455 5456/* void glUniformMatrix2fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 5457static void 5458android_glUniformMatrix2fv__IIZLjava_nio_FloatBuffer_2 5459 (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jobject value_buf) { 5460 jint _exception = 0; 5461 const char * _exceptionType = NULL; 5462 const char * _exceptionMessage = NULL; 5463 jfloatArray _array = (jfloatArray) 0; 5464 jint _bufferOffset = (jint) 0; 5465 jint _remaining; 5466 GLfloat *value = (GLfloat *) 0; 5467 5468 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5469 if (_remaining < count*4) { 5470 _exception = 1; 5471 _exceptionType = "java/lang/IllegalArgumentException"; 5472 _exceptionMessage = "remaining() < count*4 < needed"; 5473 goto exit; 5474 } 5475 if (value == NULL) { 5476 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5477 value = (GLfloat *) (_valueBase + _bufferOffset); 5478 } 5479 glUniformMatrix2fv( 5480 (GLint)location, 5481 (GLsizei)count, 5482 (GLboolean)transpose, 5483 (GLfloat *)value 5484 ); 5485 5486exit: 5487 if (_array) { 5488 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 5489 } 5490 if (_exception) { 5491 jniThrowException(_env, _exceptionType, _exceptionMessage); 5492 } 5493} 5494 5495/* void glUniformMatrix3fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 5496static void 5497android_glUniformMatrix3fv__IIZ_3FI 5498 (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { 5499 jint _exception = 0; 5500 const char * _exceptionType = NULL; 5501 const char * _exceptionMessage = NULL; 5502 GLfloat *value_base = (GLfloat *) 0; 5503 jint _remaining; 5504 GLfloat *value = (GLfloat *) 0; 5505 5506 if (!value_ref) { 5507 _exception = 1; 5508 _exceptionType = "java/lang/IllegalArgumentException"; 5509 _exceptionMessage = "value == null"; 5510 goto exit; 5511 } 5512 if (offset < 0) { 5513 _exception = 1; 5514 _exceptionType = "java/lang/IllegalArgumentException"; 5515 _exceptionMessage = "offset < 0"; 5516 goto exit; 5517 } 5518 _remaining = _env->GetArrayLength(value_ref) - offset; 5519 if (_remaining < count*9) { 5520 _exception = 1; 5521 _exceptionType = "java/lang/IllegalArgumentException"; 5522 _exceptionMessage = "length - offset < count*9 < needed"; 5523 goto exit; 5524 } 5525 value_base = (GLfloat *) 5526 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 5527 value = value_base + offset; 5528 5529 glUniformMatrix3fv( 5530 (GLint)location, 5531 (GLsizei)count, 5532 (GLboolean)transpose, 5533 (GLfloat *)value 5534 ); 5535 5536exit: 5537 if (value_base) { 5538 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 5539 JNI_ABORT); 5540 } 5541 if (_exception) { 5542 jniThrowException(_env, _exceptionType, _exceptionMessage); 5543 } 5544} 5545 5546/* void glUniformMatrix3fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 5547static void 5548android_glUniformMatrix3fv__IIZLjava_nio_FloatBuffer_2 5549 (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jobject value_buf) { 5550 jint _exception = 0; 5551 const char * _exceptionType = NULL; 5552 const char * _exceptionMessage = NULL; 5553 jfloatArray _array = (jfloatArray) 0; 5554 jint _bufferOffset = (jint) 0; 5555 jint _remaining; 5556 GLfloat *value = (GLfloat *) 0; 5557 5558 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5559 if (_remaining < count*9) { 5560 _exception = 1; 5561 _exceptionType = "java/lang/IllegalArgumentException"; 5562 _exceptionMessage = "remaining() < count*9 < needed"; 5563 goto exit; 5564 } 5565 if (value == NULL) { 5566 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5567 value = (GLfloat *) (_valueBase + _bufferOffset); 5568 } 5569 glUniformMatrix3fv( 5570 (GLint)location, 5571 (GLsizei)count, 5572 (GLboolean)transpose, 5573 (GLfloat *)value 5574 ); 5575 5576exit: 5577 if (_array) { 5578 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 5579 } 5580 if (_exception) { 5581 jniThrowException(_env, _exceptionType, _exceptionMessage); 5582 } 5583} 5584 5585/* void glUniformMatrix4fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 5586static void 5587android_glUniformMatrix4fv__IIZ_3FI 5588 (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { 5589 jint _exception = 0; 5590 const char * _exceptionType = NULL; 5591 const char * _exceptionMessage = NULL; 5592 GLfloat *value_base = (GLfloat *) 0; 5593 jint _remaining; 5594 GLfloat *value = (GLfloat *) 0; 5595 5596 if (!value_ref) { 5597 _exception = 1; 5598 _exceptionType = "java/lang/IllegalArgumentException"; 5599 _exceptionMessage = "value == null"; 5600 goto exit; 5601 } 5602 if (offset < 0) { 5603 _exception = 1; 5604 _exceptionType = "java/lang/IllegalArgumentException"; 5605 _exceptionMessage = "offset < 0"; 5606 goto exit; 5607 } 5608 _remaining = _env->GetArrayLength(value_ref) - offset; 5609 if (_remaining < count*16) { 5610 _exception = 1; 5611 _exceptionType = "java/lang/IllegalArgumentException"; 5612 _exceptionMessage = "length - offset < count*16 < needed"; 5613 goto exit; 5614 } 5615 value_base = (GLfloat *) 5616 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 5617 value = value_base + offset; 5618 5619 glUniformMatrix4fv( 5620 (GLint)location, 5621 (GLsizei)count, 5622 (GLboolean)transpose, 5623 (GLfloat *)value 5624 ); 5625 5626exit: 5627 if (value_base) { 5628 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 5629 JNI_ABORT); 5630 } 5631 if (_exception) { 5632 jniThrowException(_env, _exceptionType, _exceptionMessage); 5633 } 5634} 5635 5636/* void glUniformMatrix4fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 5637static void 5638android_glUniformMatrix4fv__IIZLjava_nio_FloatBuffer_2 5639 (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jobject value_buf) { 5640 jint _exception = 0; 5641 const char * _exceptionType = NULL; 5642 const char * _exceptionMessage = NULL; 5643 jfloatArray _array = (jfloatArray) 0; 5644 jint _bufferOffset = (jint) 0; 5645 jint _remaining; 5646 GLfloat *value = (GLfloat *) 0; 5647 5648 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5649 if (_remaining < count*16) { 5650 _exception = 1; 5651 _exceptionType = "java/lang/IllegalArgumentException"; 5652 _exceptionMessage = "remaining() < count*16 < needed"; 5653 goto exit; 5654 } 5655 if (value == NULL) { 5656 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5657 value = (GLfloat *) (_valueBase + _bufferOffset); 5658 } 5659 glUniformMatrix4fv( 5660 (GLint)location, 5661 (GLsizei)count, 5662 (GLboolean)transpose, 5663 (GLfloat *)value 5664 ); 5665 5666exit: 5667 if (_array) { 5668 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 5669 } 5670 if (_exception) { 5671 jniThrowException(_env, _exceptionType, _exceptionMessage); 5672 } 5673} 5674 5675/* void glUseProgram ( GLuint program ) */ 5676static void 5677android_glUseProgram__I 5678 (JNIEnv *_env, jobject _this, jint program) { 5679 glUseProgram( 5680 (GLuint)program 5681 ); 5682} 5683 5684/* void glValidateProgram ( GLuint program ) */ 5685static void 5686android_glValidateProgram__I 5687 (JNIEnv *_env, jobject _this, jint program) { 5688 glValidateProgram( 5689 (GLuint)program 5690 ); 5691} 5692 5693/* void glVertexAttrib1f ( GLuint indx, GLfloat x ) */ 5694static void 5695android_glVertexAttrib1f__IF 5696 (JNIEnv *_env, jobject _this, jint indx, jfloat x) { 5697 glVertexAttrib1f( 5698 (GLuint)indx, 5699 (GLfloat)x 5700 ); 5701} 5702 5703/* void glVertexAttrib1fv ( GLuint indx, const GLfloat *values ) */ 5704static void 5705android_glVertexAttrib1fv__I_3FI 5706 (JNIEnv *_env, jobject _this, jint indx, jfloatArray values_ref, jint offset) { 5707 jint _exception = 0; 5708 const char * _exceptionType = NULL; 5709 const char * _exceptionMessage = NULL; 5710 GLfloat *values_base = (GLfloat *) 0; 5711 jint _remaining; 5712 GLfloat *values = (GLfloat *) 0; 5713 5714 if (!values_ref) { 5715 _exception = 1; 5716 _exceptionType = "java/lang/IllegalArgumentException"; 5717 _exceptionMessage = "values == null"; 5718 goto exit; 5719 } 5720 if (offset < 0) { 5721 _exception = 1; 5722 _exceptionType = "java/lang/IllegalArgumentException"; 5723 _exceptionMessage = "offset < 0"; 5724 goto exit; 5725 } 5726 _remaining = _env->GetArrayLength(values_ref) - offset; 5727 if (_remaining < 1) { 5728 _exception = 1; 5729 _exceptionType = "java/lang/IllegalArgumentException"; 5730 _exceptionMessage = "length - offset < 1 < needed"; 5731 goto exit; 5732 } 5733 values_base = (GLfloat *) 5734 _env->GetFloatArrayElements(values_ref, (jboolean *)0); 5735 values = values_base + offset; 5736 5737 glVertexAttrib1fv( 5738 (GLuint)indx, 5739 (GLfloat *)values 5740 ); 5741 5742exit: 5743 if (values_base) { 5744 _env->ReleaseFloatArrayElements(values_ref, (jfloat*)values_base, 5745 JNI_ABORT); 5746 } 5747 if (_exception) { 5748 jniThrowException(_env, _exceptionType, _exceptionMessage); 5749 } 5750} 5751 5752/* void glVertexAttrib1fv ( GLuint indx, const GLfloat *values ) */ 5753static void 5754android_glVertexAttrib1fv__ILjava_nio_FloatBuffer_2 5755 (JNIEnv *_env, jobject _this, jint indx, jobject values_buf) { 5756 jint _exception = 0; 5757 const char * _exceptionType = NULL; 5758 const char * _exceptionMessage = NULL; 5759 jfloatArray _array = (jfloatArray) 0; 5760 jint _bufferOffset = (jint) 0; 5761 jint _remaining; 5762 GLfloat *values = (GLfloat *) 0; 5763 5764 values = (GLfloat *)getPointer(_env, values_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5765 if (_remaining < 1) { 5766 _exception = 1; 5767 _exceptionType = "java/lang/IllegalArgumentException"; 5768 _exceptionMessage = "remaining() < 1 < needed"; 5769 goto exit; 5770 } 5771 if (values == NULL) { 5772 char * _valuesBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5773 values = (GLfloat *) (_valuesBase + _bufferOffset); 5774 } 5775 glVertexAttrib1fv( 5776 (GLuint)indx, 5777 (GLfloat *)values 5778 ); 5779 5780exit: 5781 if (_array) { 5782 _env->ReleaseFloatArrayElements(_array, (jfloat*)values, JNI_ABORT); 5783 } 5784 if (_exception) { 5785 jniThrowException(_env, _exceptionType, _exceptionMessage); 5786 } 5787} 5788 5789/* void glVertexAttrib2f ( GLuint indx, GLfloat x, GLfloat y ) */ 5790static void 5791android_glVertexAttrib2f__IFF 5792 (JNIEnv *_env, jobject _this, jint indx, jfloat x, jfloat y) { 5793 glVertexAttrib2f( 5794 (GLuint)indx, 5795 (GLfloat)x, 5796 (GLfloat)y 5797 ); 5798} 5799 5800/* void glVertexAttrib2fv ( GLuint indx, const GLfloat *values ) */ 5801static void 5802android_glVertexAttrib2fv__I_3FI 5803 (JNIEnv *_env, jobject _this, jint indx, jfloatArray values_ref, jint offset) { 5804 jint _exception = 0; 5805 const char * _exceptionType = NULL; 5806 const char * _exceptionMessage = NULL; 5807 GLfloat *values_base = (GLfloat *) 0; 5808 jint _remaining; 5809 GLfloat *values = (GLfloat *) 0; 5810 5811 if (!values_ref) { 5812 _exception = 1; 5813 _exceptionType = "java/lang/IllegalArgumentException"; 5814 _exceptionMessage = "values == null"; 5815 goto exit; 5816 } 5817 if (offset < 0) { 5818 _exception = 1; 5819 _exceptionType = "java/lang/IllegalArgumentException"; 5820 _exceptionMessage = "offset < 0"; 5821 goto exit; 5822 } 5823 _remaining = _env->GetArrayLength(values_ref) - offset; 5824 if (_remaining < 2) { 5825 _exception = 1; 5826 _exceptionType = "java/lang/IllegalArgumentException"; 5827 _exceptionMessage = "length - offset < 2 < needed"; 5828 goto exit; 5829 } 5830 values_base = (GLfloat *) 5831 _env->GetFloatArrayElements(values_ref, (jboolean *)0); 5832 values = values_base + offset; 5833 5834 glVertexAttrib2fv( 5835 (GLuint)indx, 5836 (GLfloat *)values 5837 ); 5838 5839exit: 5840 if (values_base) { 5841 _env->ReleaseFloatArrayElements(values_ref, (jfloat*)values_base, 5842 JNI_ABORT); 5843 } 5844 if (_exception) { 5845 jniThrowException(_env, _exceptionType, _exceptionMessage); 5846 } 5847} 5848 5849/* void glVertexAttrib2fv ( GLuint indx, const GLfloat *values ) */ 5850static void 5851android_glVertexAttrib2fv__ILjava_nio_FloatBuffer_2 5852 (JNIEnv *_env, jobject _this, jint indx, jobject values_buf) { 5853 jint _exception = 0; 5854 const char * _exceptionType = NULL; 5855 const char * _exceptionMessage = NULL; 5856 jfloatArray _array = (jfloatArray) 0; 5857 jint _bufferOffset = (jint) 0; 5858 jint _remaining; 5859 GLfloat *values = (GLfloat *) 0; 5860 5861 values = (GLfloat *)getPointer(_env, values_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5862 if (_remaining < 2) { 5863 _exception = 1; 5864 _exceptionType = "java/lang/IllegalArgumentException"; 5865 _exceptionMessage = "remaining() < 2 < needed"; 5866 goto exit; 5867 } 5868 if (values == NULL) { 5869 char * _valuesBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5870 values = (GLfloat *) (_valuesBase + _bufferOffset); 5871 } 5872 glVertexAttrib2fv( 5873 (GLuint)indx, 5874 (GLfloat *)values 5875 ); 5876 5877exit: 5878 if (_array) { 5879 _env->ReleaseFloatArrayElements(_array, (jfloat*)values, JNI_ABORT); 5880 } 5881 if (_exception) { 5882 jniThrowException(_env, _exceptionType, _exceptionMessage); 5883 } 5884} 5885 5886/* void glVertexAttrib3f ( GLuint indx, GLfloat x, GLfloat y, GLfloat z ) */ 5887static void 5888android_glVertexAttrib3f__IFFF 5889 (JNIEnv *_env, jobject _this, jint indx, jfloat x, jfloat y, jfloat z) { 5890 glVertexAttrib3f( 5891 (GLuint)indx, 5892 (GLfloat)x, 5893 (GLfloat)y, 5894 (GLfloat)z 5895 ); 5896} 5897 5898/* void glVertexAttrib3fv ( GLuint indx, const GLfloat *values ) */ 5899static void 5900android_glVertexAttrib3fv__I_3FI 5901 (JNIEnv *_env, jobject _this, jint indx, jfloatArray values_ref, jint offset) { 5902 jint _exception = 0; 5903 const char * _exceptionType = NULL; 5904 const char * _exceptionMessage = NULL; 5905 GLfloat *values_base = (GLfloat *) 0; 5906 jint _remaining; 5907 GLfloat *values = (GLfloat *) 0; 5908 5909 if (!values_ref) { 5910 _exception = 1; 5911 _exceptionType = "java/lang/IllegalArgumentException"; 5912 _exceptionMessage = "values == null"; 5913 goto exit; 5914 } 5915 if (offset < 0) { 5916 _exception = 1; 5917 _exceptionType = "java/lang/IllegalArgumentException"; 5918 _exceptionMessage = "offset < 0"; 5919 goto exit; 5920 } 5921 _remaining = _env->GetArrayLength(values_ref) - offset; 5922 if (_remaining < 3) { 5923 _exception = 1; 5924 _exceptionType = "java/lang/IllegalArgumentException"; 5925 _exceptionMessage = "length - offset < 3 < needed"; 5926 goto exit; 5927 } 5928 values_base = (GLfloat *) 5929 _env->GetFloatArrayElements(values_ref, (jboolean *)0); 5930 values = values_base + offset; 5931 5932 glVertexAttrib3fv( 5933 (GLuint)indx, 5934 (GLfloat *)values 5935 ); 5936 5937exit: 5938 if (values_base) { 5939 _env->ReleaseFloatArrayElements(values_ref, (jfloat*)values_base, 5940 JNI_ABORT); 5941 } 5942 if (_exception) { 5943 jniThrowException(_env, _exceptionType, _exceptionMessage); 5944 } 5945} 5946 5947/* void glVertexAttrib3fv ( GLuint indx, const GLfloat *values ) */ 5948static void 5949android_glVertexAttrib3fv__ILjava_nio_FloatBuffer_2 5950 (JNIEnv *_env, jobject _this, jint indx, jobject values_buf) { 5951 jint _exception = 0; 5952 const char * _exceptionType = NULL; 5953 const char * _exceptionMessage = NULL; 5954 jfloatArray _array = (jfloatArray) 0; 5955 jint _bufferOffset = (jint) 0; 5956 jint _remaining; 5957 GLfloat *values = (GLfloat *) 0; 5958 5959 values = (GLfloat *)getPointer(_env, values_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5960 if (_remaining < 3) { 5961 _exception = 1; 5962 _exceptionType = "java/lang/IllegalArgumentException"; 5963 _exceptionMessage = "remaining() < 3 < needed"; 5964 goto exit; 5965 } 5966 if (values == NULL) { 5967 char * _valuesBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5968 values = (GLfloat *) (_valuesBase + _bufferOffset); 5969 } 5970 glVertexAttrib3fv( 5971 (GLuint)indx, 5972 (GLfloat *)values 5973 ); 5974 5975exit: 5976 if (_array) { 5977 _env->ReleaseFloatArrayElements(_array, (jfloat*)values, JNI_ABORT); 5978 } 5979 if (_exception) { 5980 jniThrowException(_env, _exceptionType, _exceptionMessage); 5981 } 5982} 5983 5984/* void glVertexAttrib4f ( GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) */ 5985static void 5986android_glVertexAttrib4f__IFFFF 5987 (JNIEnv *_env, jobject _this, jint indx, jfloat x, jfloat y, jfloat z, jfloat w) { 5988 glVertexAttrib4f( 5989 (GLuint)indx, 5990 (GLfloat)x, 5991 (GLfloat)y, 5992 (GLfloat)z, 5993 (GLfloat)w 5994 ); 5995} 5996 5997/* void glVertexAttrib4fv ( GLuint indx, const GLfloat *values ) */ 5998static void 5999android_glVertexAttrib4fv__I_3FI 6000 (JNIEnv *_env, jobject _this, jint indx, jfloatArray values_ref, jint offset) { 6001 jint _exception = 0; 6002 const char * _exceptionType = NULL; 6003 const char * _exceptionMessage = NULL; 6004 GLfloat *values_base = (GLfloat *) 0; 6005 jint _remaining; 6006 GLfloat *values = (GLfloat *) 0; 6007 6008 if (!values_ref) { 6009 _exception = 1; 6010 _exceptionType = "java/lang/IllegalArgumentException"; 6011 _exceptionMessage = "values == null"; 6012 goto exit; 6013 } 6014 if (offset < 0) { 6015 _exception = 1; 6016 _exceptionType = "java/lang/IllegalArgumentException"; 6017 _exceptionMessage = "offset < 0"; 6018 goto exit; 6019 } 6020 _remaining = _env->GetArrayLength(values_ref) - offset; 6021 if (_remaining < 4) { 6022 _exception = 1; 6023 _exceptionType = "java/lang/IllegalArgumentException"; 6024 _exceptionMessage = "length - offset < 4 < needed"; 6025 goto exit; 6026 } 6027 values_base = (GLfloat *) 6028 _env->GetFloatArrayElements(values_ref, (jboolean *)0); 6029 values = values_base + offset; 6030 6031 glVertexAttrib4fv( 6032 (GLuint)indx, 6033 (GLfloat *)values 6034 ); 6035 6036exit: 6037 if (values_base) { 6038 _env->ReleaseFloatArrayElements(values_ref, (jfloat*)values_base, 6039 JNI_ABORT); 6040 } 6041 if (_exception) { 6042 jniThrowException(_env, _exceptionType, _exceptionMessage); 6043 } 6044} 6045 6046/* void glVertexAttrib4fv ( GLuint indx, const GLfloat *values ) */ 6047static void 6048android_glVertexAttrib4fv__ILjava_nio_FloatBuffer_2 6049 (JNIEnv *_env, jobject _this, jint indx, jobject values_buf) { 6050 jint _exception = 0; 6051 const char * _exceptionType = NULL; 6052 const char * _exceptionMessage = NULL; 6053 jfloatArray _array = (jfloatArray) 0; 6054 jint _bufferOffset = (jint) 0; 6055 jint _remaining; 6056 GLfloat *values = (GLfloat *) 0; 6057 6058 values = (GLfloat *)getPointer(_env, values_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 6059 if (_remaining < 4) { 6060 _exception = 1; 6061 _exceptionType = "java/lang/IllegalArgumentException"; 6062 _exceptionMessage = "remaining() < 4 < needed"; 6063 goto exit; 6064 } 6065 if (values == NULL) { 6066 char * _valuesBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 6067 values = (GLfloat *) (_valuesBase + _bufferOffset); 6068 } 6069 glVertexAttrib4fv( 6070 (GLuint)indx, 6071 (GLfloat *)values 6072 ); 6073 6074exit: 6075 if (_array) { 6076 _env->ReleaseFloatArrayElements(_array, (jfloat*)values, JNI_ABORT); 6077 } 6078 if (_exception) { 6079 jniThrowException(_env, _exceptionType, _exceptionMessage); 6080 } 6081} 6082 6083/* void glVertexAttribPointer ( GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLint offset ) */ 6084static void 6085android_glVertexAttribPointer__IIIZII 6086 (JNIEnv *_env, jobject _this, jint indx, jint size, jint type, jboolean normalized, jint stride, jint offset) { 6087 glVertexAttribPointer( 6088 (GLuint)indx, 6089 (GLint)size, 6090 (GLenum)type, 6091 (GLboolean)normalized, 6092 (GLsizei)stride, 6093 reinterpret_cast<GLvoid *>(offset) 6094 ); 6095} 6096 6097/* void glVertexAttribPointer ( GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *ptr ) */ 6098static void 6099android_glVertexAttribPointerBounds__IIIZILjava_nio_Buffer_2I 6100 (JNIEnv *_env, jobject _this, jint indx, jint size, jint type, jboolean normalized, jint stride, jobject ptr_buf, jint remaining) { 6101 jarray _array = (jarray) 0; 6102 jint _bufferOffset = (jint) 0; 6103 jint _remaining; 6104 GLvoid *ptr = (GLvoid *) 0; 6105 6106 if (ptr_buf) { 6107 ptr = (GLvoid *) getDirectBufferPointer(_env, ptr_buf); 6108 if ( ! ptr ) { 6109 return; 6110 } 6111 } 6112 glVertexAttribPointerBounds( 6113 (GLuint)indx, 6114 (GLint)size, 6115 (GLenum)type, 6116 (GLboolean)normalized, 6117 (GLsizei)stride, 6118 (GLvoid *)ptr, 6119 (GLsizei)remaining 6120 ); 6121} 6122 6123/* void glViewport ( GLint x, GLint y, GLsizei width, GLsizei height ) */ 6124static void 6125android_glViewport__IIII 6126 (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height) { 6127 glViewport( 6128 (GLint)x, 6129 (GLint)y, 6130 (GLsizei)width, 6131 (GLsizei)height 6132 ); 6133} 6134 6135static const char *classPathName = "android/opengl/GLES20"; 6136 6137static const JNINativeMethod methods[] = { 6138{"_nativeClassInit", "()V", (void*)nativeClassInit }, 6139{"glActiveTexture", "(I)V", (void *) android_glActiveTexture__I }, 6140{"glAttachShader", "(II)V", (void *) android_glAttachShader__II }, 6141{"glBindAttribLocation", "(IILjava/lang/String;)V", (void *) android_glBindAttribLocation__IILjava_lang_String_2 }, 6142{"glBindBuffer", "(II)V", (void *) android_glBindBuffer__II }, 6143{"glBindFramebuffer", "(II)V", (void *) android_glBindFramebuffer__II }, 6144{"glBindRenderbuffer", "(II)V", (void *) android_glBindRenderbuffer__II }, 6145{"glBindTexture", "(II)V", (void *) android_glBindTexture__II }, 6146{"glBlendColor", "(FFFF)V", (void *) android_glBlendColor__FFFF }, 6147{"glBlendEquation", "(I)V", (void *) android_glBlendEquation__I }, 6148{"glBlendEquationSeparate", "(II)V", (void *) android_glBlendEquationSeparate__II }, 6149{"glBlendFunc", "(II)V", (void *) android_glBlendFunc__II }, 6150{"glBlendFuncSeparate", "(IIII)V", (void *) android_glBlendFuncSeparate__IIII }, 6151{"glBufferData", "(IILjava/nio/Buffer;I)V", (void *) android_glBufferData__IILjava_nio_Buffer_2I }, 6152{"glBufferSubData", "(IIILjava/nio/Buffer;)V", (void *) android_glBufferSubData__IIILjava_nio_Buffer_2 }, 6153{"glCheckFramebufferStatus", "(I)I", (void *) android_glCheckFramebufferStatus__I }, 6154{"glClear", "(I)V", (void *) android_glClear__I }, 6155{"glClearColor", "(FFFF)V", (void *) android_glClearColor__FFFF }, 6156{"glClearDepthf", "(F)V", (void *) android_glClearDepthf__F }, 6157{"glClearStencil", "(I)V", (void *) android_glClearStencil__I }, 6158{"glColorMask", "(ZZZZ)V", (void *) android_glColorMask__ZZZZ }, 6159{"glCompileShader", "(I)V", (void *) android_glCompileShader__I }, 6160{"glCompressedTexImage2D", "(IIIIIIILjava/nio/Buffer;)V", (void *) android_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2 }, 6161{"glCompressedTexSubImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 }, 6162{"glCopyTexImage2D", "(IIIIIIII)V", (void *) android_glCopyTexImage2D__IIIIIIII }, 6163{"glCopyTexSubImage2D", "(IIIIIIII)V", (void *) android_glCopyTexSubImage2D__IIIIIIII }, 6164{"glCreateProgram", "()I", (void *) android_glCreateProgram__ }, 6165{"glCreateShader", "(I)I", (void *) android_glCreateShader__I }, 6166{"glCullFace", "(I)V", (void *) android_glCullFace__I }, 6167{"glDeleteBuffers", "(I[II)V", (void *) android_glDeleteBuffers__I_3II }, 6168{"glDeleteBuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteBuffers__ILjava_nio_IntBuffer_2 }, 6169{"glDeleteFramebuffers", "(I[II)V", (void *) android_glDeleteFramebuffers__I_3II }, 6170{"glDeleteFramebuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteFramebuffers__ILjava_nio_IntBuffer_2 }, 6171{"glDeleteProgram", "(I)V", (void *) android_glDeleteProgram__I }, 6172{"glDeleteRenderbuffers", "(I[II)V", (void *) android_glDeleteRenderbuffers__I_3II }, 6173{"glDeleteRenderbuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteRenderbuffers__ILjava_nio_IntBuffer_2 }, 6174{"glDeleteShader", "(I)V", (void *) android_glDeleteShader__I }, 6175{"glDeleteTextures", "(I[II)V", (void *) android_glDeleteTextures__I_3II }, 6176{"glDeleteTextures", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteTextures__ILjava_nio_IntBuffer_2 }, 6177{"glDepthFunc", "(I)V", (void *) android_glDepthFunc__I }, 6178{"glDepthMask", "(Z)V", (void *) android_glDepthMask__Z }, 6179{"glDepthRangef", "(FF)V", (void *) android_glDepthRangef__FF }, 6180{"glDetachShader", "(II)V", (void *) android_glDetachShader__II }, 6181{"glDisable", "(I)V", (void *) android_glDisable__I }, 6182{"glDisableVertexAttribArray", "(I)V", (void *) android_glDisableVertexAttribArray__I }, 6183{"glDrawArrays", "(III)V", (void *) android_glDrawArrays__III }, 6184{"glDrawElements", "(IIII)V", (void *) android_glDrawElements__IIII }, 6185{"glDrawElements", "(IIILjava/nio/Buffer;)V", (void *) android_glDrawElements__IIILjava_nio_Buffer_2 }, 6186{"glEnable", "(I)V", (void *) android_glEnable__I }, 6187{"glEnableVertexAttribArray", "(I)V", (void *) android_glEnableVertexAttribArray__I }, 6188{"glFinish", "()V", (void *) android_glFinish__ }, 6189{"glFlush", "()V", (void *) android_glFlush__ }, 6190{"glFramebufferRenderbuffer", "(IIII)V", (void *) android_glFramebufferRenderbuffer__IIII }, 6191{"glFramebufferTexture2D", "(IIIII)V", (void *) android_glFramebufferTexture2D__IIIII }, 6192{"glFrontFace", "(I)V", (void *) android_glFrontFace__I }, 6193{"glGenBuffers", "(I[II)V", (void *) android_glGenBuffers__I_3II }, 6194{"glGenBuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenBuffers__ILjava_nio_IntBuffer_2 }, 6195{"glGenerateMipmap", "(I)V", (void *) android_glGenerateMipmap__I }, 6196{"glGenFramebuffers", "(I[II)V", (void *) android_glGenFramebuffers__I_3II }, 6197{"glGenFramebuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenFramebuffers__ILjava_nio_IntBuffer_2 }, 6198{"glGenRenderbuffers", "(I[II)V", (void *) android_glGenRenderbuffers__I_3II }, 6199{"glGenRenderbuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenRenderbuffers__ILjava_nio_IntBuffer_2 }, 6200{"glGenTextures", "(I[II)V", (void *) android_glGenTextures__I_3II }, 6201{"glGenTextures", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenTextures__ILjava_nio_IntBuffer_2 }, 6202{"glGetActiveAttrib", "(III[II[II[II[BI)V", (void *) android_glGetActiveAttrib__III_3II_3II_3II_3BI }, 6203{"glGetActiveAttrib", "(IIILjava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;B)V", (void *) android_glGetActiveAttrib__IIILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2B }, 6204{"glGetActiveAttrib", "(II[II[II)Ljava/lang/String;", (void *) android_glGetActiveAttrib1 }, 6205{"glGetActiveAttrib", "(IILjava/nio/IntBuffer;Ljava/nio/IntBuffer;)Ljava/lang/String;", (void *) android_glGetActiveAttrib2 }, 6206{"glGetActiveUniform", "(III[II[II[II[BI)V", (void *) android_glGetActiveUniform__III_3II_3II_3II_3BI }, 6207{"glGetActiveUniform", "(II[II[II)Ljava/lang/String;", (void *) android_glGetActiveUniform1 }, 6208{"glGetActiveUniform", "(IIILjava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;B)V", (void *) android_glGetActiveUniform__IIILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2B }, 6209{"glGetActiveUniform", "(IILjava/nio/IntBuffer;Ljava/nio/IntBuffer;)Ljava/lang/String;", (void *) android_glGetActiveUniform2 }, 6210{"glGetAttachedShaders", "(II[II[II)V", (void *) android_glGetAttachedShaders__II_3II_3II }, 6211{"glGetAttachedShaders", "(IILjava/nio/IntBuffer;Ljava/nio/IntBuffer;)V", (void *) android_glGetAttachedShaders__IILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 }, 6212{"glGetAttribLocation", "(ILjava/lang/String;)I", (void *) android_glGetAttribLocation__ILjava_lang_String_2 }, 6213{"glGetBooleanv", "(I[ZI)V", (void *) android_glGetBooleanv__I_3ZI }, 6214{"glGetBooleanv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetBooleanv__ILjava_nio_IntBuffer_2 }, 6215{"glGetBufferParameteriv", "(II[II)V", (void *) android_glGetBufferParameteriv__II_3II }, 6216{"glGetBufferParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetBufferParameteriv__IILjava_nio_IntBuffer_2 }, 6217{"glGetError", "()I", (void *) android_glGetError__ }, 6218{"glGetFloatv", "(I[FI)V", (void *) android_glGetFloatv__I_3FI }, 6219{"glGetFloatv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glGetFloatv__ILjava_nio_FloatBuffer_2 }, 6220{"glGetFramebufferAttachmentParameteriv", "(III[II)V", (void *) android_glGetFramebufferAttachmentParameteriv__III_3II }, 6221{"glGetFramebufferAttachmentParameteriv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetFramebufferAttachmentParameteriv__IIILjava_nio_IntBuffer_2 }, 6222{"glGetIntegerv", "(I[II)V", (void *) android_glGetIntegerv__I_3II }, 6223{"glGetIntegerv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetIntegerv__ILjava_nio_IntBuffer_2 }, 6224{"glGetProgramiv", "(II[II)V", (void *) android_glGetProgramiv__II_3II }, 6225{"glGetProgramiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetProgramiv__IILjava_nio_IntBuffer_2 }, 6226{"glGetProgramInfoLog", "(I)Ljava/lang/String;", (void *) android_glGetProgramInfoLog }, 6227{"glGetRenderbufferParameteriv", "(II[II)V", (void *) android_glGetRenderbufferParameteriv__II_3II }, 6228{"glGetRenderbufferParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetRenderbufferParameteriv__IILjava_nio_IntBuffer_2 }, 6229{"glGetShaderiv", "(II[II)V", (void *) android_glGetShaderiv__II_3II }, 6230{"glGetShaderiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetShaderiv__IILjava_nio_IntBuffer_2 }, 6231{"glGetShaderInfoLog", "(I)Ljava/lang/String;", (void *) android_glGetShaderInfoLog }, 6232{"glGetShaderPrecisionFormat", "(II[II[II)V", (void *) android_glGetShaderPrecisionFormat__II_3II_3II }, 6233{"glGetShaderPrecisionFormat", "(IILjava/nio/IntBuffer;Ljava/nio/IntBuffer;)V", (void *) android_glGetShaderPrecisionFormat__IILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 }, 6234{"glGetShaderSource", "(II[II[BI)V", (void *) android_glGetShaderSource__II_3II_3BI }, 6235{"glGetShaderSource", "(IILjava/nio/IntBuffer;B)V", (void *) android_glGetShaderSource__IILjava_nio_IntBuffer_2B }, 6236{"glGetShaderSource", "(I)Ljava/lang/String;", (void *) android_glGetShaderSource }, 6237{"glGetString", "(I)Ljava/lang/String;", (void *) android_glGetString }, 6238{"glGetTexParameterfv", "(II[FI)V", (void *) android_glGetTexParameterfv__II_3FI }, 6239{"glGetTexParameterfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetTexParameterfv__IILjava_nio_FloatBuffer_2 }, 6240{"glGetTexParameteriv", "(II[II)V", (void *) android_glGetTexParameteriv__II_3II }, 6241{"glGetTexParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameteriv__IILjava_nio_IntBuffer_2 }, 6242{"glGetUniformfv", "(II[FI)V", (void *) android_glGetUniformfv__II_3FI }, 6243{"glGetUniformfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetUniformfv__IILjava_nio_FloatBuffer_2 }, 6244{"glGetUniformiv", "(II[II)V", (void *) android_glGetUniformiv__II_3II }, 6245{"glGetUniformiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetUniformiv__IILjava_nio_IntBuffer_2 }, 6246{"glGetUniformLocation", "(ILjava/lang/String;)I", (void *) android_glGetUniformLocation__ILjava_lang_String_2 }, 6247{"glGetVertexAttribfv", "(II[FI)V", (void *) android_glGetVertexAttribfv__II_3FI }, 6248{"glGetVertexAttribfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetVertexAttribfv__IILjava_nio_FloatBuffer_2 }, 6249{"glGetVertexAttribiv", "(II[II)V", (void *) android_glGetVertexAttribiv__II_3II }, 6250{"glGetVertexAttribiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetVertexAttribiv__IILjava_nio_IntBuffer_2 }, 6251{"glHint", "(II)V", (void *) android_glHint__II }, 6252{"glIsBuffer", "(I)Z", (void *) android_glIsBuffer__I }, 6253{"glIsEnabled", "(I)Z", (void *) android_glIsEnabled__I }, 6254{"glIsFramebuffer", "(I)Z", (void *) android_glIsFramebuffer__I }, 6255{"glIsProgram", "(I)Z", (void *) android_glIsProgram__I }, 6256{"glIsRenderbuffer", "(I)Z", (void *) android_glIsRenderbuffer__I }, 6257{"glIsShader", "(I)Z", (void *) android_glIsShader__I }, 6258{"glIsTexture", "(I)Z", (void *) android_glIsTexture__I }, 6259{"glLineWidth", "(F)V", (void *) android_glLineWidth__F }, 6260{"glLinkProgram", "(I)V", (void *) android_glLinkProgram__I }, 6261{"glPixelStorei", "(II)V", (void *) android_glPixelStorei__II }, 6262{"glPolygonOffset", "(FF)V", (void *) android_glPolygonOffset__FF }, 6263{"glReadPixels", "(IIIIIILjava/nio/Buffer;)V", (void *) android_glReadPixels__IIIIIILjava_nio_Buffer_2 }, 6264{"glReleaseShaderCompiler", "()V", (void *) android_glReleaseShaderCompiler__ }, 6265{"glRenderbufferStorage", "(IIII)V", (void *) android_glRenderbufferStorage__IIII }, 6266{"glSampleCoverage", "(FZ)V", (void *) android_glSampleCoverage__FZ }, 6267{"glScissor", "(IIII)V", (void *) android_glScissor__IIII }, 6268{"glShaderBinary", "(I[IIILjava/nio/Buffer;I)V", (void *) android_glShaderBinary__I_3IIILjava_nio_Buffer_2I }, 6269{"glShaderBinary", "(ILjava/nio/IntBuffer;ILjava/nio/Buffer;I)V", (void *) android_glShaderBinary__ILjava_nio_IntBuffer_2ILjava_nio_Buffer_2I }, 6270{"glShaderSource", "(ILjava/lang/String;)V", (void *) android_glShaderSource }, 6271{"glStencilFunc", "(III)V", (void *) android_glStencilFunc__III }, 6272{"glStencilFuncSeparate", "(IIII)V", (void *) android_glStencilFuncSeparate__IIII }, 6273{"glStencilMask", "(I)V", (void *) android_glStencilMask__I }, 6274{"glStencilMaskSeparate", "(II)V", (void *) android_glStencilMaskSeparate__II }, 6275{"glStencilOp", "(III)V", (void *) android_glStencilOp__III }, 6276{"glStencilOpSeparate", "(IIII)V", (void *) android_glStencilOpSeparate__IIII }, 6277{"glTexImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2 }, 6278{"glTexParameterf", "(IIF)V", (void *) android_glTexParameterf__IIF }, 6279{"glTexParameterfv", "(II[FI)V", (void *) android_glTexParameterfv__II_3FI }, 6280{"glTexParameterfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexParameterfv__IILjava_nio_FloatBuffer_2 }, 6281{"glTexParameteri", "(III)V", (void *) android_glTexParameteri__III }, 6282{"glTexParameteriv", "(II[II)V", (void *) android_glTexParameteriv__II_3II }, 6283{"glTexParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameteriv__IILjava_nio_IntBuffer_2 }, 6284{"glTexSubImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 }, 6285{"glUniform1f", "(IF)V", (void *) android_glUniform1f__IF }, 6286{"glUniform1fv", "(II[FI)V", (void *) android_glUniform1fv__II_3FI }, 6287{"glUniform1fv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glUniform1fv__IILjava_nio_FloatBuffer_2 }, 6288{"glUniform1i", "(II)V", (void *) android_glUniform1i__II }, 6289{"glUniform1iv", "(II[II)V", (void *) android_glUniform1iv__II_3II }, 6290{"glUniform1iv", "(IILjava/nio/IntBuffer;)V", (void *) android_glUniform1iv__IILjava_nio_IntBuffer_2 }, 6291{"glUniform2f", "(IFF)V", (void *) android_glUniform2f__IFF }, 6292{"glUniform2fv", "(II[FI)V", (void *) android_glUniform2fv__II_3FI }, 6293{"glUniform2fv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glUniform2fv__IILjava_nio_FloatBuffer_2 }, 6294{"glUniform2i", "(III)V", (void *) android_glUniform2i__III }, 6295{"glUniform2iv", "(II[II)V", (void *) android_glUniform2iv__II_3II }, 6296{"glUniform2iv", "(IILjava/nio/IntBuffer;)V", (void *) android_glUniform2iv__IILjava_nio_IntBuffer_2 }, 6297{"glUniform3f", "(IFFF)V", (void *) android_glUniform3f__IFFF }, 6298{"glUniform3fv", "(II[FI)V", (void *) android_glUniform3fv__II_3FI }, 6299{"glUniform3fv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glUniform3fv__IILjava_nio_FloatBuffer_2 }, 6300{"glUniform3i", "(IIII)V", (void *) android_glUniform3i__IIII }, 6301{"glUniform3iv", "(II[II)V", (void *) android_glUniform3iv__II_3II }, 6302{"glUniform3iv", "(IILjava/nio/IntBuffer;)V", (void *) android_glUniform3iv__IILjava_nio_IntBuffer_2 }, 6303{"glUniform4f", "(IFFFF)V", (void *) android_glUniform4f__IFFFF }, 6304{"glUniform4fv", "(II[FI)V", (void *) android_glUniform4fv__II_3FI }, 6305{"glUniform4fv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glUniform4fv__IILjava_nio_FloatBuffer_2 }, 6306{"glUniform4i", "(IIIII)V", (void *) android_glUniform4i__IIIII }, 6307{"glUniform4iv", "(II[II)V", (void *) android_glUniform4iv__II_3II }, 6308{"glUniform4iv", "(IILjava/nio/IntBuffer;)V", (void *) android_glUniform4iv__IILjava_nio_IntBuffer_2 }, 6309{"glUniformMatrix2fv", "(IIZ[FI)V", (void *) android_glUniformMatrix2fv__IIZ_3FI }, 6310{"glUniformMatrix2fv", "(IIZLjava/nio/FloatBuffer;)V", (void *) android_glUniformMatrix2fv__IIZLjava_nio_FloatBuffer_2 }, 6311{"glUniformMatrix3fv", "(IIZ[FI)V", (void *) android_glUniformMatrix3fv__IIZ_3FI }, 6312{"glUniformMatrix3fv", "(IIZLjava/nio/FloatBuffer;)V", (void *) android_glUniformMatrix3fv__IIZLjava_nio_FloatBuffer_2 }, 6313{"glUniformMatrix4fv", "(IIZ[FI)V", (void *) android_glUniformMatrix4fv__IIZ_3FI }, 6314{"glUniformMatrix4fv", "(IIZLjava/nio/FloatBuffer;)V", (void *) android_glUniformMatrix4fv__IIZLjava_nio_FloatBuffer_2 }, 6315{"glUseProgram", "(I)V", (void *) android_glUseProgram__I }, 6316{"glValidateProgram", "(I)V", (void *) android_glValidateProgram__I }, 6317{"glVertexAttrib1f", "(IF)V", (void *) android_glVertexAttrib1f__IF }, 6318{"glVertexAttrib1fv", "(I[FI)V", (void *) android_glVertexAttrib1fv__I_3FI }, 6319{"glVertexAttrib1fv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glVertexAttrib1fv__ILjava_nio_FloatBuffer_2 }, 6320{"glVertexAttrib2f", "(IFF)V", (void *) android_glVertexAttrib2f__IFF }, 6321{"glVertexAttrib2fv", "(I[FI)V", (void *) android_glVertexAttrib2fv__I_3FI }, 6322{"glVertexAttrib2fv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glVertexAttrib2fv__ILjava_nio_FloatBuffer_2 }, 6323{"glVertexAttrib3f", "(IFFF)V", (void *) android_glVertexAttrib3f__IFFF }, 6324{"glVertexAttrib3fv", "(I[FI)V", (void *) android_glVertexAttrib3fv__I_3FI }, 6325{"glVertexAttrib3fv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glVertexAttrib3fv__ILjava_nio_FloatBuffer_2 }, 6326{"glVertexAttrib4f", "(IFFFF)V", (void *) android_glVertexAttrib4f__IFFFF }, 6327{"glVertexAttrib4fv", "(I[FI)V", (void *) android_glVertexAttrib4fv__I_3FI }, 6328{"glVertexAttrib4fv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glVertexAttrib4fv__ILjava_nio_FloatBuffer_2 }, 6329{"glVertexAttribPointer", "(IIIZII)V", (void *) android_glVertexAttribPointer__IIIZII }, 6330{"glVertexAttribPointerBounds", "(IIIZILjava/nio/Buffer;I)V", (void *) android_glVertexAttribPointerBounds__IIIZILjava_nio_Buffer_2I }, 6331{"glViewport", "(IIII)V", (void *) android_glViewport__IIII }, 6332}; 6333 6334int register_android_opengl_jni_GLES20(JNIEnv *_env) 6335{ 6336 int err; 6337 err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods)); 6338 return err; 6339} 6340