android_opengl_GLES20.cpp revision 3b1d46e809ed38cd5662c110c511b8d98868ed72
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 _exception = 1; 1788 _exceptionType = "java/lang/IllegalArgumentException"; 1789 _exceptionMessage = "length == null"; 1790 goto exit; 1791 } 1792 if (lengthOffset < 0) { 1793 _exception = 1; 1794 _exceptionType = "java/lang/IllegalArgumentException"; 1795 _exceptionMessage = "lengthOffset < 0"; 1796 goto exit; 1797 } 1798 _lengthRemaining = _env->GetArrayLength(length_ref) - lengthOffset; 1799 length_base = (GLsizei *) 1800 _env->GetIntArrayElements(length_ref, (jboolean *)0); 1801 length = length_base + lengthOffset; 1802 1803 if (!size_ref) { 1804 _exception = 1; 1805 _exceptionType = "java/lang/IllegalArgumentException"; 1806 _exceptionMessage = "size == null"; 1807 goto exit; 1808 } 1809 if (sizeOffset < 0) { 1810 _exception = 1; 1811 _exceptionType = "java/lang/IllegalArgumentException"; 1812 _exceptionMessage = "sizeOffset < 0"; 1813 goto exit; 1814 } 1815 _sizeRemaining = _env->GetArrayLength(size_ref) - sizeOffset; 1816 size_base = (GLint *) 1817 _env->GetIntArrayElements(size_ref, (jboolean *)0); 1818 size = size_base + sizeOffset; 1819 1820 if (!type_ref) { 1821 _exception = 1; 1822 _exceptionType = "java/lang/IllegalArgumentException"; 1823 _exceptionMessage = "type == null"; 1824 goto exit; 1825 } 1826 if (typeOffset < 0) { 1827 _exception = 1; 1828 _exceptionType = "java/lang/IllegalArgumentException"; 1829 _exceptionMessage = "typeOffset < 0"; 1830 goto exit; 1831 } 1832 _typeRemaining = _env->GetArrayLength(type_ref) - typeOffset; 1833 type_base = (GLenum *) 1834 _env->GetIntArrayElements(type_ref, (jboolean *)0); 1835 type = type_base + typeOffset; 1836 1837 if (!name_ref) { 1838 _exception = 1; 1839 _exceptionType = "java/lang/IllegalArgumentException"; 1840 _exceptionMessage = "name == null"; 1841 goto exit; 1842 } 1843 if (nameOffset < 0) { 1844 _exception = 1; 1845 _exceptionType = "java/lang/IllegalArgumentException"; 1846 _exceptionMessage = "nameOffset < 0"; 1847 goto exit; 1848 } 1849 _nameRemaining = _env->GetArrayLength(name_ref) - nameOffset; 1850 name_base = (char *) 1851 _env->GetByteArrayElements(name_ref, (jboolean *)0); 1852 name = name_base + nameOffset; 1853 1854 glGetActiveAttrib( 1855 (GLuint)program, 1856 (GLuint)index, 1857 (GLsizei)bufsize, 1858 (GLsizei *)length, 1859 (GLint *)size, 1860 (GLenum *)type, 1861 (char *)name 1862 ); 1863 1864exit: 1865 if (name_base) { 1866 _env->ReleaseByteArrayElements(name_ref, (jbyte*)name_base, 1867 _exception ? JNI_ABORT: 0); 1868 } 1869 if (type_base) { 1870 _env->ReleaseIntArrayElements(type_ref, (jint*)type_base, 1871 _exception ? JNI_ABORT: 0); 1872 } 1873 if (size_base) { 1874 _env->ReleaseIntArrayElements(size_ref, (jint*)size_base, 1875 _exception ? JNI_ABORT: 0); 1876 } 1877 if (length_base) { 1878 _env->ReleaseIntArrayElements(length_ref, (jint*)length_base, 1879 _exception ? JNI_ABORT: 0); 1880 } 1881 if (_exception) { 1882 jniThrowException(_env, _exceptionType, _exceptionMessage); 1883 } 1884} 1885 1886/* void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */ 1887static void 1888android_glGetActiveAttrib__IIILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2B 1889 (JNIEnv *_env, jobject _this, jint program, jint index, jint bufsize, jobject length_buf, jobject size_buf, jobject type_buf, jbyte name) { 1890 jintArray _lengthArray = (jintArray) 0; 1891 jint _lengthBufferOffset = (jint) 0; 1892 jintArray _sizeArray = (jintArray) 0; 1893 jint _sizeBufferOffset = (jint) 0; 1894 jintArray _typeArray = (jintArray) 0; 1895 jint _typeBufferOffset = (jint) 0; 1896 jint _lengthRemaining; 1897 GLsizei *length = (GLsizei *) 0; 1898 jint _sizeRemaining; 1899 GLint *size = (GLint *) 0; 1900 jint _typeRemaining; 1901 GLenum *type = (GLenum *) 0; 1902 1903 length = (GLsizei *)getPointer(_env, length_buf, (jarray*)&_lengthArray, &_lengthRemaining, &_lengthBufferOffset); 1904 size = (GLint *)getPointer(_env, size_buf, (jarray*)&_sizeArray, &_sizeRemaining, &_sizeBufferOffset); 1905 type = (GLenum *)getPointer(_env, type_buf, (jarray*)&_typeArray, &_typeRemaining, &_typeBufferOffset); 1906 if (length == NULL) { 1907 char * _lengthBase = (char *)_env->GetIntArrayElements(_lengthArray, (jboolean *) 0); 1908 length = (GLsizei *) (_lengthBase + _lengthBufferOffset); 1909 } 1910 if (size == NULL) { 1911 char * _sizeBase = (char *)_env->GetIntArrayElements(_sizeArray, (jboolean *) 0); 1912 size = (GLint *) (_sizeBase + _sizeBufferOffset); 1913 } 1914 if (type == NULL) { 1915 char * _typeBase = (char *)_env->GetIntArrayElements(_typeArray, (jboolean *) 0); 1916 type = (GLenum *) (_typeBase + _typeBufferOffset); 1917 } 1918 glGetActiveAttrib( 1919 (GLuint)program, 1920 (GLuint)index, 1921 (GLsizei)bufsize, 1922 (GLsizei *)length, 1923 (GLint *)size, 1924 (GLenum *)type, 1925 reinterpret_cast<char *>(name) 1926 ); 1927 if (_typeArray) { 1928 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _typeArray, (jint*)type, JNI_TRUE); 1929 } 1930 if (_sizeArray) { 1931 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _sizeArray, (jint*)size, JNI_TRUE); 1932 } 1933 if (_lengthArray) { 1934 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _lengthArray, (jint*)length, JNI_TRUE); 1935 } 1936} 1937 1938/* void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */ 1939static jstring 1940android_glGetActiveAttrib1 1941 (JNIEnv *_env, jobject _this, jint program, jint index, jintArray size_ref, jint sizeOffset, jintArray type_ref, jint typeOffset) { 1942 jint _exception = 0; 1943 const char * _exceptionType; 1944 const char * _exceptionMessage; 1945 GLint *size_base = (GLint *) 0; 1946 jint _sizeRemaining; 1947 GLint *size = (GLint *) 0; 1948 GLenum *type_base = (GLenum *) 0; 1949 jint _typeRemaining; 1950 GLenum *type = (GLenum *) 0; 1951 1952 jstring result = 0; 1953 1954 GLint len = 0; 1955 glGetProgramiv((GLuint)program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &len); 1956 if (!len) { 1957 return _env->NewStringUTF(""); 1958 } 1959 char* buf = (char*) malloc(len); 1960 1961 if (buf == NULL) { 1962 jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory"); 1963 return NULL; 1964 } 1965 if (!size_ref) { 1966 _exception = 1; 1967 _exceptionType = "java/lang/IllegalArgumentException"; 1968 _exceptionMessage = "size == null"; 1969 goto exit; 1970 } 1971 if (sizeOffset < 0) { 1972 _exception = 1; 1973 _exceptionType = "java/lang/IllegalArgumentException"; 1974 _exceptionMessage = "sizeOffset < 0"; 1975 goto exit; 1976 } 1977 _sizeRemaining = _env->GetArrayLength(size_ref) - sizeOffset; 1978 size_base = (GLint *) 1979 _env->GetIntArrayElements(size_ref, (jboolean *)0); 1980 size = size_base + sizeOffset; 1981 1982 if (!type_ref) { 1983 _exception = 1; 1984 _exceptionType = "java/lang/IllegalArgumentException"; 1985 _exceptionMessage = "type == null"; 1986 goto exit; 1987 } 1988 if (typeOffset < 0) { 1989 _exception = 1; 1990 _exceptionType = "java/lang/IllegalArgumentException"; 1991 _exceptionMessage = "typeOffset < 0"; 1992 goto exit; 1993 } 1994 _typeRemaining = _env->GetArrayLength(type_ref) - typeOffset; 1995 type_base = (GLenum *) 1996 _env->GetIntArrayElements(type_ref, (jboolean *)0); 1997 type = type_base + typeOffset; 1998 1999 glGetActiveAttrib( 2000 (GLuint)program, 2001 (GLuint)index, 2002 (GLsizei)len, 2003 NULL, 2004 (GLint *)size, 2005 (GLenum *)type, 2006 (char *)buf 2007 ); 2008exit: 2009 if (type_base) { 2010 _env->ReleaseIntArrayElements(type_ref, (jint*)type_base, 2011 _exception ? JNI_ABORT: 0); 2012 } 2013 if (size_base) { 2014 _env->ReleaseIntArrayElements(size_ref, (jint*)size_base, 2015 _exception ? JNI_ABORT: 0); 2016 } 2017 if (_exception != 1) { 2018 result = _env->NewStringUTF(buf); 2019 } 2020 if (buf) { 2021 free(buf); 2022 } 2023 if (_exception) { 2024 jniThrowException(_env, _exceptionType, _exceptionMessage); 2025 } 2026 if (result == 0) { 2027 result = _env->NewStringUTF(""); 2028 } 2029 2030 return result; 2031} 2032 2033/* void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */ 2034static jstring 2035android_glGetActiveAttrib2 2036 (JNIEnv *_env, jobject _this, jint program, jint index, jobject size_buf, jobject type_buf) { 2037 jintArray _sizeArray = (jintArray) 0; 2038 jint _sizeBufferOffset = (jint) 0; 2039 jintArray _typeArray = (jintArray) 0; 2040 jint _typeBufferOffset = (jint) 0; 2041 jint _lengthRemaining; 2042 GLsizei *length = (GLsizei *) 0; 2043 jint _sizeRemaining; 2044 GLint *size = (GLint *) 0; 2045 jint _typeRemaining; 2046 GLenum *type = (GLenum *) 0; 2047 2048 jstring result = 0; 2049 2050 GLint len = 0; 2051 glGetProgramiv((GLuint)program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &len); 2052 if (!len) { 2053 return _env->NewStringUTF(""); 2054 } 2055 char* buf = (char*) malloc(len); 2056 2057 if (buf == NULL) { 2058 jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory"); 2059 return NULL; 2060 } 2061 2062 size = (GLint *)getPointer(_env, size_buf, (jarray*)&_sizeArray, &_sizeRemaining, &_sizeBufferOffset); 2063 type = (GLenum *)getPointer(_env, type_buf, (jarray*)&_typeArray, &_typeRemaining, &_typeBufferOffset); 2064 if (size == NULL) { 2065 char * _sizeBase = (char *)_env->GetIntArrayElements(_sizeArray, (jboolean *) 0); 2066 size = (GLint *) (_sizeBase + _sizeBufferOffset); 2067 } 2068 if (type == NULL) { 2069 char * _typeBase = (char *)_env->GetIntArrayElements(_typeArray, (jboolean *) 0); 2070 type = (GLenum *) (_typeBase + _typeBufferOffset); 2071 } 2072 glGetActiveAttrib( 2073 (GLuint)program, 2074 (GLuint)index, 2075 (GLsizei)len, 2076 NULL, 2077 (GLint *)size, 2078 (GLenum *)type, 2079 (char *)buf 2080 ); 2081 2082 if (_typeArray) { 2083 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _typeArray, (jint*)type, JNI_TRUE); 2084 } 2085 if (_sizeArray) { 2086 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _sizeArray, (jint*)size, JNI_TRUE); 2087 } 2088 result = _env->NewStringUTF(buf); 2089 if (buf) { 2090 free(buf); 2091 } 2092 return result; 2093} 2094/* void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */ 2095static void 2096android_glGetActiveUniform__III_3II_3II_3II_3BI 2097 (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) { 2098 jint _exception = 0; 2099 const char * _exceptionType; 2100 const char * _exceptionMessage; 2101 GLsizei *length_base = (GLsizei *) 0; 2102 jint _lengthRemaining; 2103 GLsizei *length = (GLsizei *) 0; 2104 GLint *size_base = (GLint *) 0; 2105 jint _sizeRemaining; 2106 GLint *size = (GLint *) 0; 2107 GLenum *type_base = (GLenum *) 0; 2108 jint _typeRemaining; 2109 GLenum *type = (GLenum *) 0; 2110 char *name_base = (char *) 0; 2111 jint _nameRemaining; 2112 char *name = (char *) 0; 2113 2114 if (!length_ref) { 2115 _exception = 1; 2116 _exceptionType = "java/lang/IllegalArgumentException"; 2117 _exceptionMessage = "length == null"; 2118 goto exit; 2119 } 2120 if (lengthOffset < 0) { 2121 _exception = 1; 2122 _exceptionType = "java/lang/IllegalArgumentException"; 2123 _exceptionMessage = "lengthOffset < 0"; 2124 goto exit; 2125 } 2126 _lengthRemaining = _env->GetArrayLength(length_ref) - lengthOffset; 2127 length_base = (GLsizei *) 2128 _env->GetIntArrayElements(length_ref, (jboolean *)0); 2129 length = length_base + lengthOffset; 2130 2131 if (!size_ref) { 2132 _exception = 1; 2133 _exceptionType = "java/lang/IllegalArgumentException"; 2134 _exceptionMessage = "size == null"; 2135 goto exit; 2136 } 2137 if (sizeOffset < 0) { 2138 _exception = 1; 2139 _exceptionType = "java/lang/IllegalArgumentException"; 2140 _exceptionMessage = "sizeOffset < 0"; 2141 goto exit; 2142 } 2143 _sizeRemaining = _env->GetArrayLength(size_ref) - sizeOffset; 2144 size_base = (GLint *) 2145 _env->GetIntArrayElements(size_ref, (jboolean *)0); 2146 size = size_base + sizeOffset; 2147 2148 if (!type_ref) { 2149 _exception = 1; 2150 _exceptionType = "java/lang/IllegalArgumentException"; 2151 _exceptionMessage = "type == null"; 2152 goto exit; 2153 } 2154 if (typeOffset < 0) { 2155 _exception = 1; 2156 _exceptionType = "java/lang/IllegalArgumentException"; 2157 _exceptionMessage = "typeOffset < 0"; 2158 goto exit; 2159 } 2160 _typeRemaining = _env->GetArrayLength(type_ref) - typeOffset; 2161 type_base = (GLenum *) 2162 _env->GetIntArrayElements(type_ref, (jboolean *)0); 2163 type = type_base + typeOffset; 2164 2165 if (!name_ref) { 2166 _exception = 1; 2167 _exceptionType = "java/lang/IllegalArgumentException"; 2168 _exceptionMessage = "name == null"; 2169 goto exit; 2170 } 2171 if (nameOffset < 0) { 2172 _exception = 1; 2173 _exceptionType = "java/lang/IllegalArgumentException"; 2174 _exceptionMessage = "nameOffset < 0"; 2175 goto exit; 2176 } 2177 _nameRemaining = _env->GetArrayLength(name_ref) - nameOffset; 2178 name_base = (char *) 2179 _env->GetByteArrayElements(name_ref, (jboolean *)0); 2180 name = name_base + nameOffset; 2181 2182 glGetActiveUniform( 2183 (GLuint)program, 2184 (GLuint)index, 2185 (GLsizei)bufsize, 2186 (GLsizei *)length, 2187 (GLint *)size, 2188 (GLenum *)type, 2189 (char *)name 2190 ); 2191 2192exit: 2193 if (name_base) { 2194 _env->ReleaseByteArrayElements(name_ref, (jbyte*)name_base, 2195 _exception ? JNI_ABORT: 0); 2196 } 2197 if (type_base) { 2198 _env->ReleaseIntArrayElements(type_ref, (jint*)type_base, 2199 _exception ? JNI_ABORT: 0); 2200 } 2201 if (size_base) { 2202 _env->ReleaseIntArrayElements(size_ref, (jint*)size_base, 2203 _exception ? JNI_ABORT: 0); 2204 } 2205 if (length_base) { 2206 _env->ReleaseIntArrayElements(length_ref, (jint*)length_base, 2207 _exception ? JNI_ABORT: 0); 2208 } 2209 if (_exception) { 2210 jniThrowException(_env, _exceptionType, _exceptionMessage); 2211 } 2212} 2213 2214/* void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */ 2215static void 2216android_glGetActiveUniform__IIILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2B 2217 (JNIEnv *_env, jobject _this, jint program, jint index, jint bufsize, jobject length_buf, jobject size_buf, jobject type_buf, jbyte name) { 2218 jintArray _lengthArray = (jintArray) 0; 2219 jint _lengthBufferOffset = (jint) 0; 2220 jintArray _sizeArray = (jintArray) 0; 2221 jint _sizeBufferOffset = (jint) 0; 2222 jintArray _typeArray = (jintArray) 0; 2223 jint _typeBufferOffset = (jint) 0; 2224 jint _lengthRemaining; 2225 GLsizei *length = (GLsizei *) 0; 2226 jint _sizeRemaining; 2227 GLint *size = (GLint *) 0; 2228 jint _typeRemaining; 2229 GLenum *type = (GLenum *) 0; 2230 2231 length = (GLsizei *)getPointer(_env, length_buf, (jarray*)&_lengthArray, &_lengthRemaining, &_lengthBufferOffset); 2232 size = (GLint *)getPointer(_env, size_buf, (jarray*)&_sizeArray, &_sizeRemaining, &_sizeBufferOffset); 2233 type = (GLenum *)getPointer(_env, type_buf, (jarray*)&_typeArray, &_typeRemaining, &_typeBufferOffset); 2234 if (length == NULL) { 2235 char * _lengthBase = (char *)_env->GetIntArrayElements(_lengthArray, (jboolean *) 0); 2236 length = (GLsizei *) (_lengthBase + _lengthBufferOffset); 2237 } 2238 if (size == NULL) { 2239 char * _sizeBase = (char *)_env->GetIntArrayElements(_sizeArray, (jboolean *) 0); 2240 size = (GLint *) (_sizeBase + _sizeBufferOffset); 2241 } 2242 if (type == NULL) { 2243 char * _typeBase = (char *)_env->GetIntArrayElements(_typeArray, (jboolean *) 0); 2244 type = (GLenum *) (_typeBase + _typeBufferOffset); 2245 } 2246 glGetActiveUniform( 2247 (GLuint)program, 2248 (GLuint)index, 2249 (GLsizei)bufsize, 2250 (GLsizei *)length, 2251 (GLint *)size, 2252 (GLenum *)type, 2253 reinterpret_cast<char *>(name) 2254 ); 2255 if (_typeArray) { 2256 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _typeArray, (jint*)type, JNI_TRUE); 2257 } 2258 if (_sizeArray) { 2259 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _sizeArray, (jint*)size, JNI_TRUE); 2260 } 2261 if (_lengthArray) { 2262 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _lengthArray, (jint*)length, JNI_TRUE); 2263 } 2264} 2265 2266/* void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */ 2267static jstring 2268android_glGetActiveUniform1 2269 (JNIEnv *_env, jobject _this, jint program, jint index, jintArray size_ref, jint sizeOffset, jintArray type_ref, jint typeOffset) { 2270 jint _exception = 0; 2271 const char * _exceptionType; 2272 const char * _exceptionMessage; 2273 2274 GLint *size_base = (GLint *) 0; 2275 jint _sizeRemaining; 2276 GLint *size = (GLint *) 0; 2277 2278 GLenum *type_base = (GLenum *) 0; 2279 jint _typeRemaining; 2280 GLenum *type = (GLenum *) 0; 2281 2282 jstring result = 0; 2283 2284 GLint len = 0; 2285 glGetProgramiv((GLuint)program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &len); 2286 if (!len) { 2287 return _env->NewStringUTF(""); 2288 } 2289 char* buf = (char*) malloc(len); 2290 2291 if (buf == NULL) { 2292 jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory"); 2293 return NULL; 2294 } 2295 2296 if (!size_ref) { 2297 _exception = 1; 2298 _exceptionType = "java/lang/IllegalArgumentException"; 2299 _exceptionMessage = "size == null"; 2300 goto exit; 2301 } 2302 if (sizeOffset < 0) { 2303 _exception = 1; 2304 _exceptionType = "java/lang/IllegalArgumentException"; 2305 _exceptionMessage = "sizeOffset < 0"; 2306 goto exit; 2307 } 2308 _sizeRemaining = _env->GetArrayLength(size_ref) - sizeOffset; 2309 size_base = (GLint *) 2310 _env->GetIntArrayElements(size_ref, (jboolean *)0); 2311 size = size_base + sizeOffset; 2312 2313 if (!type_ref) { 2314 _exception = 1; 2315 _exceptionType = "java/lang/IllegalArgumentException"; 2316 _exceptionMessage = "type == null"; 2317 goto exit; 2318 } 2319 if (typeOffset < 0) { 2320 _exception = 1; 2321 _exceptionType = "java/lang/IllegalArgumentException"; 2322 _exceptionMessage = "typeOffset < 0"; 2323 goto exit; 2324 } 2325 _typeRemaining = _env->GetArrayLength(type_ref) - typeOffset; 2326 type_base = (GLenum *) 2327 _env->GetIntArrayElements(type_ref, (jboolean *)0); 2328 type = type_base + typeOffset; 2329 2330 glGetActiveUniform( 2331 (GLuint)program, 2332 (GLuint)index, 2333 (GLsizei)len, 2334 NULL, 2335 (GLint *)size, 2336 (GLenum *)type, 2337 (char *)buf 2338 ); 2339 2340exit: 2341 if (type_base) { 2342 _env->ReleaseIntArrayElements(type_ref, (jint*)type_base, 2343 _exception ? JNI_ABORT: 0); 2344 } 2345 if (size_base) { 2346 _env->ReleaseIntArrayElements(size_ref, (jint*)size_base, 2347 _exception ? JNI_ABORT: 0); 2348 } 2349 if (_exception != 1) { 2350 result = _env->NewStringUTF(buf); 2351 } 2352 if (buf) { 2353 free(buf); 2354 } 2355 if (_exception) { 2356 jniThrowException(_env, _exceptionType, _exceptionMessage); 2357 } 2358 if (result == 0) { 2359 result = _env->NewStringUTF(""); 2360 } 2361 return result; 2362} 2363 2364/* void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */ 2365static jstring 2366android_glGetActiveUniform2 2367 (JNIEnv *_env, jobject _this, jint program, jint index, jobject size_buf, jobject type_buf) { 2368 jintArray _sizeArray = (jintArray) 0; 2369 jint _sizeBufferOffset = (jint) 0; 2370 jintArray _typeArray = (jintArray) 0; 2371 jint _typeBufferOffset = (jint) 0; 2372 jint _sizeRemaining; 2373 GLint *size = (GLint *) 0; 2374 jint _typeRemaining; 2375 GLenum *type = (GLenum *) 0; 2376 2377 jstring result = 0; 2378 GLint len = 0; 2379 glGetProgramiv((GLuint)program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &len); 2380 if (!len) { 2381 return _env->NewStringUTF(""); 2382 } 2383 char* buf = (char*) malloc(len); 2384 2385 if (buf == NULL) { 2386 jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory"); 2387 return NULL; 2388 } 2389 2390 size = (GLint *)getPointer(_env, size_buf, (jarray*)&_sizeArray, &_sizeRemaining, &_sizeBufferOffset); 2391 type = (GLenum *)getPointer(_env, type_buf, (jarray*)&_typeArray, &_typeRemaining, &_typeBufferOffset); 2392 2393 if (size == NULL) { 2394 char * _sizeBase = (char *)_env->GetIntArrayElements(_sizeArray, (jboolean *) 0); 2395 size = (GLint *) (_sizeBase + _sizeBufferOffset); 2396 } 2397 if (type == NULL) { 2398 char * _typeBase = (char *)_env->GetIntArrayElements(_typeArray, (jboolean *) 0); 2399 type = (GLenum *) (_typeBase + _typeBufferOffset); 2400 } 2401 glGetActiveUniform( 2402 (GLuint)program, 2403 (GLuint)index, 2404 len, 2405 NULL, 2406 (GLint *)size, 2407 (GLenum *)type, 2408 (char *)buf 2409 ); 2410 2411 if (_typeArray) { 2412 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _typeArray, (jint*)type, JNI_TRUE); 2413 } 2414 if (_sizeArray) { 2415 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _sizeArray, (jint*)size, JNI_TRUE); 2416 } 2417 result = _env->NewStringUTF(buf); 2418 if (buf) { 2419 free(buf); 2420 } 2421 return result; 2422} 2423/* void glGetAttachedShaders ( GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders ) */ 2424static void 2425android_glGetAttachedShaders__II_3II_3II 2426 (JNIEnv *_env, jobject _this, jint program, jint maxcount, jintArray count_ref, jint countOffset, jintArray shaders_ref, jint shadersOffset) { 2427 jint _exception = 0; 2428 const char * _exceptionType = NULL; 2429 const char * _exceptionMessage = NULL; 2430 GLsizei *count_base = (GLsizei *) 0; 2431 jint _countRemaining; 2432 GLsizei *count = (GLsizei *) 0; 2433 GLuint *shaders_base = (GLuint *) 0; 2434 jint _shadersRemaining; 2435 GLuint *shaders = (GLuint *) 0; 2436 2437 if (!count_ref) { 2438 _exception = 1; 2439 _exceptionType = "java/lang/IllegalArgumentException"; 2440 _exceptionMessage = "count == null"; 2441 goto exit; 2442 } 2443 if (countOffset < 0) { 2444 _exception = 1; 2445 _exceptionType = "java/lang/IllegalArgumentException"; 2446 _exceptionMessage = "countOffset < 0"; 2447 goto exit; 2448 } 2449 _countRemaining = _env->GetArrayLength(count_ref) - countOffset; 2450 if (_countRemaining < 1) { 2451 _exception = 1; 2452 _exceptionType = "java/lang/IllegalArgumentException"; 2453 _exceptionMessage = "length - countOffset < 1 < needed"; 2454 goto exit; 2455 } 2456 count_base = (GLsizei *) 2457 _env->GetIntArrayElements(count_ref, (jboolean *)0); 2458 count = count_base + countOffset; 2459 2460 if (!shaders_ref) { 2461 _exception = 1; 2462 _exceptionType = "java/lang/IllegalArgumentException"; 2463 _exceptionMessage = "shaders == null"; 2464 goto exit; 2465 } 2466 if (shadersOffset < 0) { 2467 _exception = 1; 2468 _exceptionType = "java/lang/IllegalArgumentException"; 2469 _exceptionMessage = "shadersOffset < 0"; 2470 goto exit; 2471 } 2472 _shadersRemaining = _env->GetArrayLength(shaders_ref) - shadersOffset; 2473 if (_shadersRemaining < maxcount) { 2474 _exception = 1; 2475 _exceptionType = "java/lang/IllegalArgumentException"; 2476 _exceptionMessage = "length - shadersOffset < maxcount < needed"; 2477 goto exit; 2478 } 2479 shaders_base = (GLuint *) 2480 _env->GetIntArrayElements(shaders_ref, (jboolean *)0); 2481 shaders = shaders_base + shadersOffset; 2482 2483 glGetAttachedShaders( 2484 (GLuint)program, 2485 (GLsizei)maxcount, 2486 (GLsizei *)count, 2487 (GLuint *)shaders 2488 ); 2489 2490exit: 2491 if (shaders_base) { 2492 _env->ReleaseIntArrayElements(shaders_ref, (jint*)shaders_base, 2493 _exception ? JNI_ABORT: 0); 2494 } 2495 if (count_base) { 2496 _env->ReleaseIntArrayElements(count_ref, (jint*)count_base, 2497 _exception ? JNI_ABORT: 0); 2498 } 2499 if (_exception) { 2500 jniThrowException(_env, _exceptionType, _exceptionMessage); 2501 } 2502} 2503 2504/* void glGetAttachedShaders ( GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders ) */ 2505static void 2506android_glGetAttachedShaders__IILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 2507 (JNIEnv *_env, jobject _this, jint program, jint maxcount, jobject count_buf, jobject shaders_buf) { 2508 jint _exception = 0; 2509 const char * _exceptionType = NULL; 2510 const char * _exceptionMessage = NULL; 2511 jintArray _countArray = (jintArray) 0; 2512 jint _countBufferOffset = (jint) 0; 2513 jintArray _shadersArray = (jintArray) 0; 2514 jint _shadersBufferOffset = (jint) 0; 2515 jint _countRemaining; 2516 GLsizei *count = (GLsizei *) 0; 2517 jint _shadersRemaining; 2518 GLuint *shaders = (GLuint *) 0; 2519 2520 if (count_buf) { 2521 count = (GLsizei *)getPointer(_env, count_buf, (jarray*)&_countArray, &_countRemaining, &_countBufferOffset); 2522 if (_countRemaining < 1) { 2523 _exception = 1; 2524 _exceptionType = "java/lang/IllegalArgumentException"; 2525 _exceptionMessage = "remaining() < 1 < needed"; 2526 goto exit; 2527 } 2528 } 2529 if (shaders_buf) { 2530 shaders = (GLuint *)getPointer(_env, shaders_buf, (jarray*)&_shadersArray, &_shadersRemaining, &_shadersBufferOffset); 2531 if (_shadersRemaining < maxcount) { 2532 _exception = 1; 2533 _exceptionType = "java/lang/IllegalArgumentException"; 2534 _exceptionMessage = "remaining() < maxcount < needed"; 2535 goto exit; 2536 } 2537 } 2538 if (count_buf && count == NULL) { 2539 char * _countBase = (char *)_env->GetIntArrayElements(_countArray, (jboolean *) 0); 2540 count = (GLsizei *) (_countBase + _countBufferOffset); 2541 } 2542 if (shaders_buf && shaders == NULL) { 2543 char * _shadersBase = (char *)_env->GetIntArrayElements(_shadersArray, (jboolean *) 0); 2544 shaders = (GLuint *) (_shadersBase + _shadersBufferOffset); 2545 } 2546 glGetAttachedShaders( 2547 (GLuint)program, 2548 (GLsizei)maxcount, 2549 (GLsizei *)count, 2550 (GLuint *)shaders 2551 ); 2552 2553exit: 2554 if (_shadersArray) { 2555 _env->ReleaseIntArrayElements(_shadersArray, (jint*)shaders, _exception ? JNI_ABORT : 0); 2556 } 2557 if (_countArray) { 2558 _env->ReleaseIntArrayElements(_countArray, (jint*)count, _exception ? JNI_ABORT : 0); 2559 } 2560 if (_exception) { 2561 jniThrowException(_env, _exceptionType, _exceptionMessage); 2562 } 2563} 2564 2565/* GLint glGetAttribLocation ( GLuint program, const char *name ) */ 2566static jint 2567android_glGetAttribLocation__ILjava_lang_String_2 2568 (JNIEnv *_env, jobject _this, jint program, jstring name) { 2569 jint _exception = 0; 2570 const char * _exceptionType = NULL; 2571 const char * _exceptionMessage = NULL; 2572 GLint _returnValue = 0; 2573 const char* _nativename = 0; 2574 2575 if (!name) { 2576 _exception = 1; 2577 _exceptionType = "java/lang/IllegalArgumentException"; 2578 _exceptionMessage = "name == null"; 2579 goto exit; 2580 } 2581 _nativename = _env->GetStringUTFChars(name, 0); 2582 2583 _returnValue = glGetAttribLocation( 2584 (GLuint)program, 2585 (char *)_nativename 2586 ); 2587 2588exit: 2589 if (_nativename) { 2590 _env->ReleaseStringUTFChars(name, _nativename); 2591 } 2592 2593 if (_exception) { 2594 jniThrowException(_env, _exceptionType, _exceptionMessage); 2595 } 2596 return (jint)_returnValue; 2597} 2598 2599/* void glGetBooleanv ( GLenum pname, GLboolean *params ) */ 2600static void 2601android_glGetBooleanv__I_3ZI 2602 (JNIEnv *_env, jobject _this, jint pname, jbooleanArray params_ref, jint offset) { 2603 get<jbooleanArray, BooleanArrayGetter, jboolean*, BooleanArrayReleaser, GLboolean, glGetBooleanv>( 2604 _env, _this, pname, params_ref, offset); 2605} 2606 2607/* void glGetBooleanv ( GLenum pname, GLboolean *params ) */ 2608static void 2609android_glGetBooleanv__ILjava_nio_IntBuffer_2 2610 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 2611 getarray<GLboolean, jintArray, IntArrayGetter, jint*, IntArrayReleaser, glGetBooleanv>( 2612 _env, _this, pname, params_buf); 2613} 2614/* void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 2615static void 2616android_glGetBufferParameteriv__II_3II 2617 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 2618 jint _exception = 0; 2619 const char * _exceptionType = NULL; 2620 const char * _exceptionMessage = NULL; 2621 GLint *params_base = (GLint *) 0; 2622 jint _remaining; 2623 GLint *params = (GLint *) 0; 2624 2625 if (!params_ref) { 2626 _exception = 1; 2627 _exceptionType = "java/lang/IllegalArgumentException"; 2628 _exceptionMessage = "params == null"; 2629 goto exit; 2630 } 2631 if (offset < 0) { 2632 _exception = 1; 2633 _exceptionType = "java/lang/IllegalArgumentException"; 2634 _exceptionMessage = "offset < 0"; 2635 goto exit; 2636 } 2637 _remaining = _env->GetArrayLength(params_ref) - offset; 2638 if (_remaining < 1) { 2639 _exception = 1; 2640 _exceptionType = "java/lang/IllegalArgumentException"; 2641 _exceptionMessage = "length - offset < 1 < needed"; 2642 goto exit; 2643 } 2644 params_base = (GLint *) 2645 _env->GetIntArrayElements(params_ref, (jboolean *)0); 2646 params = params_base + offset; 2647 2648 glGetBufferParameteriv( 2649 (GLenum)target, 2650 (GLenum)pname, 2651 (GLint *)params 2652 ); 2653 2654exit: 2655 if (params_base) { 2656 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 2657 _exception ? JNI_ABORT: 0); 2658 } 2659 if (_exception) { 2660 jniThrowException(_env, _exceptionType, _exceptionMessage); 2661 } 2662} 2663 2664/* void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 2665static void 2666android_glGetBufferParameteriv__IILjava_nio_IntBuffer_2 2667 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 2668 jint _exception = 0; 2669 const char * _exceptionType = NULL; 2670 const char * _exceptionMessage = NULL; 2671 jintArray _array = (jintArray) 0; 2672 jint _bufferOffset = (jint) 0; 2673 jint _remaining; 2674 GLint *params = (GLint *) 0; 2675 2676 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2677 if (_remaining < 1) { 2678 _exception = 1; 2679 _exceptionType = "java/lang/IllegalArgumentException"; 2680 _exceptionMessage = "remaining() < 1 < needed"; 2681 goto exit; 2682 } 2683 if (params == NULL) { 2684 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 2685 params = (GLint *) (_paramsBase + _bufferOffset); 2686 } 2687 glGetBufferParameteriv( 2688 (GLenum)target, 2689 (GLenum)pname, 2690 (GLint *)params 2691 ); 2692 2693exit: 2694 if (_array) { 2695 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 2696 } 2697 if (_exception) { 2698 jniThrowException(_env, _exceptionType, _exceptionMessage); 2699 } 2700} 2701 2702/* GLenum glGetError ( void ) */ 2703static jint 2704android_glGetError__ 2705 (JNIEnv *_env, jobject _this) { 2706 GLenum _returnValue; 2707 _returnValue = glGetError(); 2708 return (jint)_returnValue; 2709} 2710 2711/* void glGetFloatv ( GLenum pname, GLfloat *params ) */ 2712static void 2713android_glGetFloatv__I_3FI 2714 (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) { 2715 get<jfloatArray, FloatArrayGetter, jfloat*, FloatArrayReleaser, GLfloat, glGetFloatv>( 2716 _env, _this, pname, params_ref, offset); 2717} 2718 2719/* void glGetFloatv ( GLenum pname, GLfloat *params ) */ 2720static void 2721android_glGetFloatv__ILjava_nio_FloatBuffer_2 2722 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 2723 getarray<GLfloat, jfloatArray, FloatArrayGetter, jfloat*, FloatArrayReleaser, glGetFloatv>( 2724 _env, _this, pname, params_buf); 2725} 2726/* void glGetFramebufferAttachmentParameteriv ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */ 2727static void 2728android_glGetFramebufferAttachmentParameteriv__III_3II 2729 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jintArray params_ref, jint offset) { 2730 jint _exception = 0; 2731 const char * _exceptionType = NULL; 2732 const char * _exceptionMessage = NULL; 2733 GLint *params_base = (GLint *) 0; 2734 jint _remaining; 2735 GLint *params = (GLint *) 0; 2736 2737 if (!params_ref) { 2738 _exception = 1; 2739 _exceptionType = "java/lang/IllegalArgumentException"; 2740 _exceptionMessage = "params == null"; 2741 goto exit; 2742 } 2743 if (offset < 0) { 2744 _exception = 1; 2745 _exceptionType = "java/lang/IllegalArgumentException"; 2746 _exceptionMessage = "offset < 0"; 2747 goto exit; 2748 } 2749 _remaining = _env->GetArrayLength(params_ref) - offset; 2750 params_base = (GLint *) 2751 _env->GetIntArrayElements(params_ref, (jboolean *)0); 2752 params = params_base + offset; 2753 2754 glGetFramebufferAttachmentParameteriv( 2755 (GLenum)target, 2756 (GLenum)attachment, 2757 (GLenum)pname, 2758 (GLint *)params 2759 ); 2760 2761exit: 2762 if (params_base) { 2763 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 2764 _exception ? JNI_ABORT: 0); 2765 } 2766 if (_exception) { 2767 jniThrowException(_env, _exceptionType, _exceptionMessage); 2768 } 2769} 2770 2771/* void glGetFramebufferAttachmentParameteriv ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */ 2772static void 2773android_glGetFramebufferAttachmentParameteriv__IIILjava_nio_IntBuffer_2 2774 (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jobject params_buf) { 2775 jintArray _array = (jintArray) 0; 2776 jint _bufferOffset = (jint) 0; 2777 jint _remaining; 2778 GLint *params = (GLint *) 0; 2779 2780 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2781 if (params == NULL) { 2782 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 2783 params = (GLint *) (_paramsBase + _bufferOffset); 2784 } 2785 glGetFramebufferAttachmentParameteriv( 2786 (GLenum)target, 2787 (GLenum)attachment, 2788 (GLenum)pname, 2789 (GLint *)params 2790 ); 2791 if (_array) { 2792 _env->ReleaseIntArrayElements(_array, (jint*)params, 0); 2793 } 2794} 2795 2796/* void glGetIntegerv ( GLenum pname, GLint *params ) */ 2797static void 2798android_glGetIntegerv__I_3II 2799 (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) { 2800 get<jintArray, IntArrayGetter, jint*, IntArrayReleaser, GLint, glGetIntegerv>( 2801 _env, _this, pname, params_ref, offset); 2802} 2803 2804/* void glGetIntegerv ( GLenum pname, GLint *params ) */ 2805static void 2806android_glGetIntegerv__ILjava_nio_IntBuffer_2 2807 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 2808 getarray<GLint, jintArray, IntArrayGetter, jint*, IntArrayReleaser, glGetIntegerv>( 2809 _env, _this, pname, params_buf); 2810} 2811/* void glGetProgramiv ( GLuint program, GLenum pname, GLint *params ) */ 2812static void 2813android_glGetProgramiv__II_3II 2814 (JNIEnv *_env, jobject _this, jint program, jint pname, jintArray params_ref, jint offset) { 2815 jint _exception = 0; 2816 const char * _exceptionType = NULL; 2817 const char * _exceptionMessage = NULL; 2818 GLint *params_base = (GLint *) 0; 2819 jint _remaining; 2820 GLint *params = (GLint *) 0; 2821 2822 if (!params_ref) { 2823 _exception = 1; 2824 _exceptionType = "java/lang/IllegalArgumentException"; 2825 _exceptionMessage = "params == null"; 2826 goto exit; 2827 } 2828 if (offset < 0) { 2829 _exception = 1; 2830 _exceptionType = "java/lang/IllegalArgumentException"; 2831 _exceptionMessage = "offset < 0"; 2832 goto exit; 2833 } 2834 _remaining = _env->GetArrayLength(params_ref) - offset; 2835 if (_remaining < 1) { 2836 _exception = 1; 2837 _exceptionType = "java/lang/IllegalArgumentException"; 2838 _exceptionMessage = "length - offset < 1 < needed"; 2839 goto exit; 2840 } 2841 params_base = (GLint *) 2842 _env->GetIntArrayElements(params_ref, (jboolean *)0); 2843 params = params_base + offset; 2844 2845 glGetProgramiv( 2846 (GLuint)program, 2847 (GLenum)pname, 2848 (GLint *)params 2849 ); 2850 2851exit: 2852 if (params_base) { 2853 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 2854 _exception ? JNI_ABORT: 0); 2855 } 2856 if (_exception) { 2857 jniThrowException(_env, _exceptionType, _exceptionMessage); 2858 } 2859} 2860 2861/* void glGetProgramiv ( GLuint program, GLenum pname, GLint *params ) */ 2862static void 2863android_glGetProgramiv__IILjava_nio_IntBuffer_2 2864 (JNIEnv *_env, jobject _this, jint program, jint pname, jobject params_buf) { 2865 jint _exception = 0; 2866 const char * _exceptionType = NULL; 2867 const char * _exceptionMessage = NULL; 2868 jintArray _array = (jintArray) 0; 2869 jint _bufferOffset = (jint) 0; 2870 jint _remaining; 2871 GLint *params = (GLint *) 0; 2872 2873 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2874 if (_remaining < 1) { 2875 _exception = 1; 2876 _exceptionType = "java/lang/IllegalArgumentException"; 2877 _exceptionMessage = "remaining() < 1 < needed"; 2878 goto exit; 2879 } 2880 if (params == NULL) { 2881 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 2882 params = (GLint *) (_paramsBase + _bufferOffset); 2883 } 2884 glGetProgramiv( 2885 (GLuint)program, 2886 (GLenum)pname, 2887 (GLint *)params 2888 ); 2889 2890exit: 2891 if (_array) { 2892 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 2893 } 2894 if (_exception) { 2895 jniThrowException(_env, _exceptionType, _exceptionMessage); 2896 } 2897} 2898 2899#include <stdlib.h> 2900 2901/* void glGetProgramInfoLog ( GLuint shader, GLsizei maxLength, GLsizei* length, GLchar* infoLog ) */ 2902static jstring android_glGetProgramInfoLog(JNIEnv *_env, jobject, jint shader) { 2903 GLint infoLen = 0; 2904 glGetProgramiv(shader, GL_INFO_LOG_LENGTH, &infoLen); 2905 if (!infoLen) { 2906 return _env->NewStringUTF(""); 2907 } 2908 char* buf = (char*) malloc(infoLen); 2909 if (buf == NULL) { 2910 jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory"); 2911 return NULL; 2912 } 2913 glGetProgramInfoLog(shader, infoLen, NULL, buf); 2914 jstring result = _env->NewStringUTF(buf); 2915 free(buf); 2916 return result; 2917} 2918/* void glGetRenderbufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 2919static void 2920android_glGetRenderbufferParameteriv__II_3II 2921 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 2922 jint _exception = 0; 2923 const char * _exceptionType = NULL; 2924 const char * _exceptionMessage = NULL; 2925 GLint *params_base = (GLint *) 0; 2926 jint _remaining; 2927 GLint *params = (GLint *) 0; 2928 2929 if (!params_ref) { 2930 _exception = 1; 2931 _exceptionType = "java/lang/IllegalArgumentException"; 2932 _exceptionMessage = "params == null"; 2933 goto exit; 2934 } 2935 if (offset < 0) { 2936 _exception = 1; 2937 _exceptionType = "java/lang/IllegalArgumentException"; 2938 _exceptionMessage = "offset < 0"; 2939 goto exit; 2940 } 2941 _remaining = _env->GetArrayLength(params_ref) - offset; 2942 if (_remaining < 1) { 2943 _exception = 1; 2944 _exceptionType = "java/lang/IllegalArgumentException"; 2945 _exceptionMessage = "length - offset < 1 < needed"; 2946 goto exit; 2947 } 2948 params_base = (GLint *) 2949 _env->GetIntArrayElements(params_ref, (jboolean *)0); 2950 params = params_base + offset; 2951 2952 glGetRenderbufferParameteriv( 2953 (GLenum)target, 2954 (GLenum)pname, 2955 (GLint *)params 2956 ); 2957 2958exit: 2959 if (params_base) { 2960 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 2961 _exception ? JNI_ABORT: 0); 2962 } 2963 if (_exception) { 2964 jniThrowException(_env, _exceptionType, _exceptionMessage); 2965 } 2966} 2967 2968/* void glGetRenderbufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 2969static void 2970android_glGetRenderbufferParameteriv__IILjava_nio_IntBuffer_2 2971 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 2972 jint _exception = 0; 2973 const char * _exceptionType = NULL; 2974 const char * _exceptionMessage = NULL; 2975 jintArray _array = (jintArray) 0; 2976 jint _bufferOffset = (jint) 0; 2977 jint _remaining; 2978 GLint *params = (GLint *) 0; 2979 2980 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2981 if (_remaining < 1) { 2982 _exception = 1; 2983 _exceptionType = "java/lang/IllegalArgumentException"; 2984 _exceptionMessage = "remaining() < 1 < needed"; 2985 goto exit; 2986 } 2987 if (params == NULL) { 2988 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 2989 params = (GLint *) (_paramsBase + _bufferOffset); 2990 } 2991 glGetRenderbufferParameteriv( 2992 (GLenum)target, 2993 (GLenum)pname, 2994 (GLint *)params 2995 ); 2996 2997exit: 2998 if (_array) { 2999 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 3000 } 3001 if (_exception) { 3002 jniThrowException(_env, _exceptionType, _exceptionMessage); 3003 } 3004} 3005 3006/* void glGetShaderiv ( GLuint shader, GLenum pname, GLint *params ) */ 3007static void 3008android_glGetShaderiv__II_3II 3009 (JNIEnv *_env, jobject _this, jint shader, jint pname, jintArray params_ref, jint offset) { 3010 jint _exception = 0; 3011 const char * _exceptionType = NULL; 3012 const char * _exceptionMessage = NULL; 3013 GLint *params_base = (GLint *) 0; 3014 jint _remaining; 3015 GLint *params = (GLint *) 0; 3016 3017 if (!params_ref) { 3018 _exception = 1; 3019 _exceptionType = "java/lang/IllegalArgumentException"; 3020 _exceptionMessage = "params == null"; 3021 goto exit; 3022 } 3023 if (offset < 0) { 3024 _exception = 1; 3025 _exceptionType = "java/lang/IllegalArgumentException"; 3026 _exceptionMessage = "offset < 0"; 3027 goto exit; 3028 } 3029 _remaining = _env->GetArrayLength(params_ref) - offset; 3030 if (_remaining < 1) { 3031 _exception = 1; 3032 _exceptionType = "java/lang/IllegalArgumentException"; 3033 _exceptionMessage = "length - offset < 1 < needed"; 3034 goto exit; 3035 } 3036 params_base = (GLint *) 3037 _env->GetIntArrayElements(params_ref, (jboolean *)0); 3038 params = params_base + offset; 3039 3040 glGetShaderiv( 3041 (GLuint)shader, 3042 (GLenum)pname, 3043 (GLint *)params 3044 ); 3045 3046exit: 3047 if (params_base) { 3048 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 3049 _exception ? JNI_ABORT: 0); 3050 } 3051 if (_exception) { 3052 jniThrowException(_env, _exceptionType, _exceptionMessage); 3053 } 3054} 3055 3056/* void glGetShaderiv ( GLuint shader, GLenum pname, GLint *params ) */ 3057static void 3058android_glGetShaderiv__IILjava_nio_IntBuffer_2 3059 (JNIEnv *_env, jobject _this, jint shader, jint pname, jobject params_buf) { 3060 jint _exception = 0; 3061 const char * _exceptionType = NULL; 3062 const char * _exceptionMessage = NULL; 3063 jintArray _array = (jintArray) 0; 3064 jint _bufferOffset = (jint) 0; 3065 jint _remaining; 3066 GLint *params = (GLint *) 0; 3067 3068 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3069 if (_remaining < 1) { 3070 _exception = 1; 3071 _exceptionType = "java/lang/IllegalArgumentException"; 3072 _exceptionMessage = "remaining() < 1 < needed"; 3073 goto exit; 3074 } 3075 if (params == NULL) { 3076 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 3077 params = (GLint *) (_paramsBase + _bufferOffset); 3078 } 3079 glGetShaderiv( 3080 (GLuint)shader, 3081 (GLenum)pname, 3082 (GLint *)params 3083 ); 3084 3085exit: 3086 if (_array) { 3087 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 3088 } 3089 if (_exception) { 3090 jniThrowException(_env, _exceptionType, _exceptionMessage); 3091 } 3092} 3093 3094#include <stdlib.h> 3095 3096/* void glGetShaderInfoLog ( GLuint shader, GLsizei maxLength, GLsizei* length, GLchar* infoLog ) */ 3097static jstring android_glGetShaderInfoLog(JNIEnv *_env, jobject, jint shader) { 3098 GLint infoLen = 0; 3099 glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen); 3100 if (!infoLen) { 3101 return _env->NewStringUTF(""); 3102 } 3103 char* buf = (char*) malloc(infoLen); 3104 if (buf == NULL) { 3105 jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory"); 3106 return NULL; 3107 } 3108 glGetShaderInfoLog(shader, infoLen, NULL, buf); 3109 jstring result = _env->NewStringUTF(buf); 3110 free(buf); 3111 return result; 3112} 3113/* void glGetShaderPrecisionFormat ( GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision ) */ 3114static void 3115android_glGetShaderPrecisionFormat__II_3II_3II 3116 (JNIEnv *_env, jobject _this, jint shadertype, jint precisiontype, jintArray range_ref, jint rangeOffset, jintArray precision_ref, jint precisionOffset) { 3117 jint _exception = 0; 3118 const char * _exceptionType = NULL; 3119 const char * _exceptionMessage = NULL; 3120 GLint *range_base = (GLint *) 0; 3121 jint _rangeRemaining; 3122 GLint *range = (GLint *) 0; 3123 GLint *precision_base = (GLint *) 0; 3124 jint _precisionRemaining; 3125 GLint *precision = (GLint *) 0; 3126 3127 if (!range_ref) { 3128 _exception = 1; 3129 _exceptionType = "java/lang/IllegalArgumentException"; 3130 _exceptionMessage = "range == null"; 3131 goto exit; 3132 } 3133 if (rangeOffset < 0) { 3134 _exception = 1; 3135 _exceptionType = "java/lang/IllegalArgumentException"; 3136 _exceptionMessage = "rangeOffset < 0"; 3137 goto exit; 3138 } 3139 _rangeRemaining = _env->GetArrayLength(range_ref) - rangeOffset; 3140 if (_rangeRemaining < 1) { 3141 _exception = 1; 3142 _exceptionType = "java/lang/IllegalArgumentException"; 3143 _exceptionMessage = "length - rangeOffset < 1 < needed"; 3144 goto exit; 3145 } 3146 range_base = (GLint *) 3147 _env->GetIntArrayElements(range_ref, (jboolean *)0); 3148 range = range_base + rangeOffset; 3149 3150 if (!precision_ref) { 3151 _exception = 1; 3152 _exceptionType = "java/lang/IllegalArgumentException"; 3153 _exceptionMessage = "precision == null"; 3154 goto exit; 3155 } 3156 if (precisionOffset < 0) { 3157 _exception = 1; 3158 _exceptionType = "java/lang/IllegalArgumentException"; 3159 _exceptionMessage = "precisionOffset < 0"; 3160 goto exit; 3161 } 3162 _precisionRemaining = _env->GetArrayLength(precision_ref) - precisionOffset; 3163 if (_precisionRemaining < 1) { 3164 _exception = 1; 3165 _exceptionType = "java/lang/IllegalArgumentException"; 3166 _exceptionMessage = "length - precisionOffset < 1 < needed"; 3167 goto exit; 3168 } 3169 precision_base = (GLint *) 3170 _env->GetIntArrayElements(precision_ref, (jboolean *)0); 3171 precision = precision_base + precisionOffset; 3172 3173 glGetShaderPrecisionFormat( 3174 (GLenum)shadertype, 3175 (GLenum)precisiontype, 3176 (GLint *)range, 3177 (GLint *)precision 3178 ); 3179 3180exit: 3181 if (precision_base) { 3182 _env->ReleaseIntArrayElements(precision_ref, (jint*)precision_base, 3183 _exception ? JNI_ABORT: 0); 3184 } 3185 if (range_base) { 3186 _env->ReleaseIntArrayElements(range_ref, (jint*)range_base, 3187 _exception ? JNI_ABORT: 0); 3188 } 3189 if (_exception) { 3190 jniThrowException(_env, _exceptionType, _exceptionMessage); 3191 } 3192} 3193 3194/* void glGetShaderPrecisionFormat ( GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision ) */ 3195static void 3196android_glGetShaderPrecisionFormat__IILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 3197 (JNIEnv *_env, jobject _this, jint shadertype, jint precisiontype, jobject range_buf, jobject precision_buf) { 3198 jint _exception = 0; 3199 const char * _exceptionType = NULL; 3200 const char * _exceptionMessage = NULL; 3201 jintArray _rangeArray = (jintArray) 0; 3202 jint _rangeBufferOffset = (jint) 0; 3203 jintArray _precisionArray = (jintArray) 0; 3204 jint _precisionBufferOffset = (jint) 0; 3205 jint _rangeRemaining; 3206 GLint *range = (GLint *) 0; 3207 jint _precisionRemaining; 3208 GLint *precision = (GLint *) 0; 3209 3210 range = (GLint *)getPointer(_env, range_buf, (jarray*)&_rangeArray, &_rangeRemaining, &_rangeBufferOffset); 3211 if (_rangeRemaining < 1) { 3212 _exception = 1; 3213 _exceptionType = "java/lang/IllegalArgumentException"; 3214 _exceptionMessage = "remaining() < 1 < needed"; 3215 goto exit; 3216 } 3217 precision = (GLint *)getPointer(_env, precision_buf, (jarray*)&_precisionArray, &_precisionRemaining, &_precisionBufferOffset); 3218 if (_precisionRemaining < 1) { 3219 _exception = 1; 3220 _exceptionType = "java/lang/IllegalArgumentException"; 3221 _exceptionMessage = "remaining() < 1 < needed"; 3222 goto exit; 3223 } 3224 if (range == NULL) { 3225 char * _rangeBase = (char *)_env->GetIntArrayElements(_rangeArray, (jboolean *) 0); 3226 range = (GLint *) (_rangeBase + _rangeBufferOffset); 3227 } 3228 if (precision == NULL) { 3229 char * _precisionBase = (char *)_env->GetIntArrayElements(_precisionArray, (jboolean *) 0); 3230 precision = (GLint *) (_precisionBase + _precisionBufferOffset); 3231 } 3232 glGetShaderPrecisionFormat( 3233 (GLenum)shadertype, 3234 (GLenum)precisiontype, 3235 (GLint *)range, 3236 (GLint *)precision 3237 ); 3238 3239exit: 3240 if (_precisionArray) { 3241 _env->ReleaseIntArrayElements(_precisionArray, (jint*)precision, _exception ? JNI_ABORT : 0); 3242 } 3243 if (_rangeArray) { 3244 _env->ReleaseIntArrayElements(_rangeArray, (jint*)range, _exception ? JNI_ABORT : 0); 3245 } 3246 if (_exception) { 3247 jniThrowException(_env, _exceptionType, _exceptionMessage); 3248 } 3249} 3250 3251/* void glGetShaderSource ( GLuint shader, GLsizei bufsize, GLsizei *length, char *source ) */ 3252static void 3253android_glGetShaderSource__II_3II_3BI 3254 (JNIEnv *_env, jobject _this, jint shader, jint bufsize, jintArray length_ref, jint lengthOffset, jbyteArray source_ref, jint sourceOffset) { 3255 jint _exception = 0; 3256 const char * _exceptionType; 3257 const char * _exceptionMessage; 3258 GLsizei *length_base = (GLsizei *) 0; 3259 jint _lengthRemaining; 3260 GLsizei *length = (GLsizei *) 0; 3261 char *source_base = (char *) 0; 3262 jint _sourceRemaining; 3263 char *source = (char *) 0; 3264 3265 if (!length_ref) { 3266 _exception = 1; 3267 _exceptionType = "java/lang/IllegalArgumentException"; 3268 _exceptionMessage = "length == null"; 3269 goto exit; 3270 } 3271 if (lengthOffset < 0) { 3272 _exception = 1; 3273 _exceptionType = "java/lang/IllegalArgumentException"; 3274 _exceptionMessage = "lengthOffset < 0"; 3275 goto exit; 3276 } 3277 _lengthRemaining = _env->GetArrayLength(length_ref) - lengthOffset; 3278 length_base = (GLsizei *) 3279 _env->GetIntArrayElements(length_ref, (jboolean *)0); 3280 length = length_base + lengthOffset; 3281 3282 if (!source_ref) { 3283 _exception = 1; 3284 _exceptionType = "java/lang/IllegalArgumentException"; 3285 _exceptionMessage = "source == null"; 3286 goto exit; 3287 } 3288 if (sourceOffset < 0) { 3289 _exception = 1; 3290 _exceptionType = "java/lang/IllegalArgumentException"; 3291 _exceptionMessage = "sourceOffset < 0"; 3292 goto exit; 3293 } 3294 _sourceRemaining = _env->GetArrayLength(source_ref) - sourceOffset; 3295 source_base = (char *) 3296 _env->GetByteArrayElements(source_ref, (jboolean *)0); 3297 source = source_base + sourceOffset; 3298 3299 glGetShaderSource( 3300 (GLuint)shader, 3301 (GLsizei)bufsize, 3302 (GLsizei *)length, 3303 (char *)source 3304 ); 3305 3306exit: 3307 if (source_base) { 3308 _env->ReleaseByteArrayElements(source_ref, (jbyte*)source_base, 3309 _exception ? JNI_ABORT: 0); 3310 } 3311 if (length_base) { 3312 _env->ReleaseIntArrayElements(length_ref, (jint*)length_base, 3313 _exception ? JNI_ABORT: 0); 3314 } 3315 if (_exception) { 3316 jniThrowException(_env, _exceptionType, _exceptionMessage); 3317 } 3318} 3319 3320/* void glGetShaderSource ( GLuint shader, GLsizei bufsize, GLsizei *length, char *source ) */ 3321static void 3322android_glGetShaderSource__IILjava_nio_IntBuffer_2B 3323 (JNIEnv *_env, jobject _this, jint shader, jint bufsize, jobject length_buf, jbyte source) { 3324 jintArray _array = (jintArray) 0; 3325 jint _bufferOffset = (jint) 0; 3326 jint _remaining; 3327 GLsizei *length = (GLsizei *) 0; 3328 3329 length = (GLsizei *)getPointer(_env, length_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3330 if (length == NULL) { 3331 char * _lengthBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 3332 length = (GLsizei *) (_lengthBase + _bufferOffset); 3333 } 3334 glGetShaderSource( 3335 (GLuint)shader, 3336 (GLsizei)bufsize, 3337 (GLsizei *)length, 3338 reinterpret_cast<char *>(source) 3339 ); 3340 if (_array) { 3341 releaseArrayPointer<jintArray, jint*, IntArrayReleaser>(_env, _array, (jint*)length, JNI_TRUE); 3342 } 3343} 3344 3345/* void glGetShaderSource ( GLuint shader, GLsizei bufsize, GLsizei *length, char *source ) */ 3346static jstring android_glGetShaderSource(JNIEnv *_env, jobject, jint shader) { 3347 GLint shaderLen = 0; 3348 glGetShaderiv((GLuint)shader, GL_SHADER_SOURCE_LENGTH, &shaderLen); 3349 if (!shaderLen) { 3350 return _env->NewStringUTF(""); 3351 } 3352 char* buf = (char*) malloc(shaderLen); 3353 if (buf == NULL) { 3354 jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory"); 3355 return NULL; 3356 } 3357 glGetShaderSource(shader, shaderLen, NULL, buf); 3358 jstring result = _env->NewStringUTF(buf); 3359 free(buf); 3360 return result; 3361} 3362/* const GLubyte * glGetString ( GLenum name ) */ 3363static jstring android_glGetString(JNIEnv* _env, jobject, jint name) { 3364 const char* chars = (const char*) glGetString((GLenum) name); 3365 return _env->NewStringUTF(chars); 3366} 3367/* void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) */ 3368static void 3369android_glGetTexParameterfv__II_3FI 3370 (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) { 3371 jint _exception = 0; 3372 const char * _exceptionType = NULL; 3373 const char * _exceptionMessage = NULL; 3374 GLfloat *params_base = (GLfloat *) 0; 3375 jint _remaining; 3376 GLfloat *params = (GLfloat *) 0; 3377 3378 if (!params_ref) { 3379 _exception = 1; 3380 _exceptionType = "java/lang/IllegalArgumentException"; 3381 _exceptionMessage = "params == null"; 3382 goto exit; 3383 } 3384 if (offset < 0) { 3385 _exception = 1; 3386 _exceptionType = "java/lang/IllegalArgumentException"; 3387 _exceptionMessage = "offset < 0"; 3388 goto exit; 3389 } 3390 _remaining = _env->GetArrayLength(params_ref) - offset; 3391 if (_remaining < 1) { 3392 _exception = 1; 3393 _exceptionType = "java/lang/IllegalArgumentException"; 3394 _exceptionMessage = "length - offset < 1 < needed"; 3395 goto exit; 3396 } 3397 params_base = (GLfloat *) 3398 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 3399 params = params_base + offset; 3400 3401 glGetTexParameterfv( 3402 (GLenum)target, 3403 (GLenum)pname, 3404 (GLfloat *)params 3405 ); 3406 3407exit: 3408 if (params_base) { 3409 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 3410 _exception ? JNI_ABORT: 0); 3411 } 3412 if (_exception) { 3413 jniThrowException(_env, _exceptionType, _exceptionMessage); 3414 } 3415} 3416 3417/* void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) */ 3418static void 3419android_glGetTexParameterfv__IILjava_nio_FloatBuffer_2 3420 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 3421 jint _exception = 0; 3422 const char * _exceptionType = NULL; 3423 const char * _exceptionMessage = NULL; 3424 jfloatArray _array = (jfloatArray) 0; 3425 jint _bufferOffset = (jint) 0; 3426 jint _remaining; 3427 GLfloat *params = (GLfloat *) 0; 3428 3429 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3430 if (_remaining < 1) { 3431 _exception = 1; 3432 _exceptionType = "java/lang/IllegalArgumentException"; 3433 _exceptionMessage = "remaining() < 1 < needed"; 3434 goto exit; 3435 } 3436 if (params == NULL) { 3437 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 3438 params = (GLfloat *) (_paramsBase + _bufferOffset); 3439 } 3440 glGetTexParameterfv( 3441 (GLenum)target, 3442 (GLenum)pname, 3443 (GLfloat *)params 3444 ); 3445 3446exit: 3447 if (_array) { 3448 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0); 3449 } 3450 if (_exception) { 3451 jniThrowException(_env, _exceptionType, _exceptionMessage); 3452 } 3453} 3454 3455/* void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 3456static void 3457android_glGetTexParameteriv__II_3II 3458 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 3459 jint _exception = 0; 3460 const char * _exceptionType = NULL; 3461 const char * _exceptionMessage = NULL; 3462 GLint *params_base = (GLint *) 0; 3463 jint _remaining; 3464 GLint *params = (GLint *) 0; 3465 3466 if (!params_ref) { 3467 _exception = 1; 3468 _exceptionType = "java/lang/IllegalArgumentException"; 3469 _exceptionMessage = "params == null"; 3470 goto exit; 3471 } 3472 if (offset < 0) { 3473 _exception = 1; 3474 _exceptionType = "java/lang/IllegalArgumentException"; 3475 _exceptionMessage = "offset < 0"; 3476 goto exit; 3477 } 3478 _remaining = _env->GetArrayLength(params_ref) - offset; 3479 if (_remaining < 1) { 3480 _exception = 1; 3481 _exceptionType = "java/lang/IllegalArgumentException"; 3482 _exceptionMessage = "length - offset < 1 < needed"; 3483 goto exit; 3484 } 3485 params_base = (GLint *) 3486 _env->GetIntArrayElements(params_ref, (jboolean *)0); 3487 params = params_base + offset; 3488 3489 glGetTexParameteriv( 3490 (GLenum)target, 3491 (GLenum)pname, 3492 (GLint *)params 3493 ); 3494 3495exit: 3496 if (params_base) { 3497 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 3498 _exception ? JNI_ABORT: 0); 3499 } 3500 if (_exception) { 3501 jniThrowException(_env, _exceptionType, _exceptionMessage); 3502 } 3503} 3504 3505/* void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 3506static void 3507android_glGetTexParameteriv__IILjava_nio_IntBuffer_2 3508 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 3509 jint _exception = 0; 3510 const char * _exceptionType = NULL; 3511 const char * _exceptionMessage = NULL; 3512 jintArray _array = (jintArray) 0; 3513 jint _bufferOffset = (jint) 0; 3514 jint _remaining; 3515 GLint *params = (GLint *) 0; 3516 3517 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3518 if (_remaining < 1) { 3519 _exception = 1; 3520 _exceptionType = "java/lang/IllegalArgumentException"; 3521 _exceptionMessage = "remaining() < 1 < needed"; 3522 goto exit; 3523 } 3524 if (params == NULL) { 3525 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 3526 params = (GLint *) (_paramsBase + _bufferOffset); 3527 } 3528 glGetTexParameteriv( 3529 (GLenum)target, 3530 (GLenum)pname, 3531 (GLint *)params 3532 ); 3533 3534exit: 3535 if (_array) { 3536 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 3537 } 3538 if (_exception) { 3539 jniThrowException(_env, _exceptionType, _exceptionMessage); 3540 } 3541} 3542 3543/* void glGetUniformfv ( GLuint program, GLint location, GLfloat *params ) */ 3544static void 3545android_glGetUniformfv__II_3FI 3546 (JNIEnv *_env, jobject _this, jint program, jint location, jfloatArray params_ref, jint offset) { 3547 jint _exception = 0; 3548 const char * _exceptionType = NULL; 3549 const char * _exceptionMessage = NULL; 3550 GLfloat *params_base = (GLfloat *) 0; 3551 jint _remaining; 3552 GLfloat *params = (GLfloat *) 0; 3553 3554 if (!params_ref) { 3555 _exception = 1; 3556 _exceptionType = "java/lang/IllegalArgumentException"; 3557 _exceptionMessage = "params == null"; 3558 goto exit; 3559 } 3560 if (offset < 0) { 3561 _exception = 1; 3562 _exceptionType = "java/lang/IllegalArgumentException"; 3563 _exceptionMessage = "offset < 0"; 3564 goto exit; 3565 } 3566 _remaining = _env->GetArrayLength(params_ref) - offset; 3567 if (_remaining < 1) { 3568 _exception = 1; 3569 _exceptionType = "java/lang/IllegalArgumentException"; 3570 _exceptionMessage = "length - offset < 1 < needed"; 3571 goto exit; 3572 } 3573 params_base = (GLfloat *) 3574 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 3575 params = params_base + offset; 3576 3577 glGetUniformfv( 3578 (GLuint)program, 3579 (GLint)location, 3580 (GLfloat *)params 3581 ); 3582 3583exit: 3584 if (params_base) { 3585 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 3586 _exception ? JNI_ABORT: 0); 3587 } 3588 if (_exception) { 3589 jniThrowException(_env, _exceptionType, _exceptionMessage); 3590 } 3591} 3592 3593/* void glGetUniformfv ( GLuint program, GLint location, GLfloat *params ) */ 3594static void 3595android_glGetUniformfv__IILjava_nio_FloatBuffer_2 3596 (JNIEnv *_env, jobject _this, jint program, jint location, jobject params_buf) { 3597 jint _exception = 0; 3598 const char * _exceptionType = NULL; 3599 const char * _exceptionMessage = NULL; 3600 jfloatArray _array = (jfloatArray) 0; 3601 jint _bufferOffset = (jint) 0; 3602 jint _remaining; 3603 GLfloat *params = (GLfloat *) 0; 3604 3605 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3606 if (_remaining < 1) { 3607 _exception = 1; 3608 _exceptionType = "java/lang/IllegalArgumentException"; 3609 _exceptionMessage = "remaining() < 1 < needed"; 3610 goto exit; 3611 } 3612 if (params == NULL) { 3613 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 3614 params = (GLfloat *) (_paramsBase + _bufferOffset); 3615 } 3616 glGetUniformfv( 3617 (GLuint)program, 3618 (GLint)location, 3619 (GLfloat *)params 3620 ); 3621 3622exit: 3623 if (_array) { 3624 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0); 3625 } 3626 if (_exception) { 3627 jniThrowException(_env, _exceptionType, _exceptionMessage); 3628 } 3629} 3630 3631/* void glGetUniformiv ( GLuint program, GLint location, GLint *params ) */ 3632static void 3633android_glGetUniformiv__II_3II 3634 (JNIEnv *_env, jobject _this, jint program, jint location, jintArray params_ref, jint offset) { 3635 jint _exception = 0; 3636 const char * _exceptionType = NULL; 3637 const char * _exceptionMessage = NULL; 3638 GLint *params_base = (GLint *) 0; 3639 jint _remaining; 3640 GLint *params = (GLint *) 0; 3641 3642 if (!params_ref) { 3643 _exception = 1; 3644 _exceptionType = "java/lang/IllegalArgumentException"; 3645 _exceptionMessage = "params == null"; 3646 goto exit; 3647 } 3648 if (offset < 0) { 3649 _exception = 1; 3650 _exceptionType = "java/lang/IllegalArgumentException"; 3651 _exceptionMessage = "offset < 0"; 3652 goto exit; 3653 } 3654 _remaining = _env->GetArrayLength(params_ref) - offset; 3655 if (_remaining < 1) { 3656 _exception = 1; 3657 _exceptionType = "java/lang/IllegalArgumentException"; 3658 _exceptionMessage = "length - offset < 1 < needed"; 3659 goto exit; 3660 } 3661 params_base = (GLint *) 3662 _env->GetIntArrayElements(params_ref, (jboolean *)0); 3663 params = params_base + offset; 3664 3665 glGetUniformiv( 3666 (GLuint)program, 3667 (GLint)location, 3668 (GLint *)params 3669 ); 3670 3671exit: 3672 if (params_base) { 3673 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 3674 _exception ? JNI_ABORT: 0); 3675 } 3676 if (_exception) { 3677 jniThrowException(_env, _exceptionType, _exceptionMessage); 3678 } 3679} 3680 3681/* void glGetUniformiv ( GLuint program, GLint location, GLint *params ) */ 3682static void 3683android_glGetUniformiv__IILjava_nio_IntBuffer_2 3684 (JNIEnv *_env, jobject _this, jint program, jint location, jobject params_buf) { 3685 jint _exception = 0; 3686 const char * _exceptionType = NULL; 3687 const char * _exceptionMessage = NULL; 3688 jintArray _array = (jintArray) 0; 3689 jint _bufferOffset = (jint) 0; 3690 jint _remaining; 3691 GLint *params = (GLint *) 0; 3692 3693 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3694 if (_remaining < 1) { 3695 _exception = 1; 3696 _exceptionType = "java/lang/IllegalArgumentException"; 3697 _exceptionMessage = "remaining() < 1 < needed"; 3698 goto exit; 3699 } 3700 if (params == NULL) { 3701 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 3702 params = (GLint *) (_paramsBase + _bufferOffset); 3703 } 3704 glGetUniformiv( 3705 (GLuint)program, 3706 (GLint)location, 3707 (GLint *)params 3708 ); 3709 3710exit: 3711 if (_array) { 3712 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 3713 } 3714 if (_exception) { 3715 jniThrowException(_env, _exceptionType, _exceptionMessage); 3716 } 3717} 3718 3719/* GLint glGetUniformLocation ( GLuint program, const char *name ) */ 3720static jint 3721android_glGetUniformLocation__ILjava_lang_String_2 3722 (JNIEnv *_env, jobject _this, jint program, jstring name) { 3723 jint _exception = 0; 3724 const char * _exceptionType = NULL; 3725 const char * _exceptionMessage = NULL; 3726 GLint _returnValue = 0; 3727 const char* _nativename = 0; 3728 3729 if (!name) { 3730 _exception = 1; 3731 _exceptionType = "java/lang/IllegalArgumentException"; 3732 _exceptionMessage = "name == null"; 3733 goto exit; 3734 } 3735 _nativename = _env->GetStringUTFChars(name, 0); 3736 3737 _returnValue = glGetUniformLocation( 3738 (GLuint)program, 3739 (char *)_nativename 3740 ); 3741 3742exit: 3743 if (_nativename) { 3744 _env->ReleaseStringUTFChars(name, _nativename); 3745 } 3746 3747 if (_exception) { 3748 jniThrowException(_env, _exceptionType, _exceptionMessage); 3749 } 3750 return (jint)_returnValue; 3751} 3752 3753/* void glGetVertexAttribfv ( GLuint index, GLenum pname, GLfloat *params ) */ 3754static void 3755android_glGetVertexAttribfv__II_3FI 3756 (JNIEnv *_env, jobject _this, jint index, jint pname, jfloatArray params_ref, jint offset) { 3757 jint _exception = 0; 3758 const char * _exceptionType = NULL; 3759 const char * _exceptionMessage = NULL; 3760 GLfloat *params_base = (GLfloat *) 0; 3761 jint _remaining; 3762 GLfloat *params = (GLfloat *) 0; 3763 3764 if (!params_ref) { 3765 _exception = 1; 3766 _exceptionType = "java/lang/IllegalArgumentException"; 3767 _exceptionMessage = "params == null"; 3768 goto exit; 3769 } 3770 if (offset < 0) { 3771 _exception = 1; 3772 _exceptionType = "java/lang/IllegalArgumentException"; 3773 _exceptionMessage = "offset < 0"; 3774 goto exit; 3775 } 3776 _remaining = _env->GetArrayLength(params_ref) - offset; 3777 int _needed; 3778 switch (pname) { 3779#if defined(GL_CURRENT_VERTEX_ATTRIB) 3780 case GL_CURRENT_VERTEX_ATTRIB: 3781#endif // defined(GL_CURRENT_VERTEX_ATTRIB) 3782 _needed = 4; 3783 break; 3784 default: 3785 _needed = 1; 3786 break; 3787 } 3788 if (_remaining < _needed) { 3789 _exception = 1; 3790 _exceptionType = "java/lang/IllegalArgumentException"; 3791 _exceptionMessage = "length - offset < needed"; 3792 goto exit; 3793 } 3794 params_base = (GLfloat *) 3795 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 3796 params = params_base + offset; 3797 3798 glGetVertexAttribfv( 3799 (GLuint)index, 3800 (GLenum)pname, 3801 (GLfloat *)params 3802 ); 3803 3804exit: 3805 if (params_base) { 3806 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 3807 _exception ? JNI_ABORT: 0); 3808 } 3809 if (_exception) { 3810 jniThrowException(_env, _exceptionType, _exceptionMessage); 3811 } 3812} 3813 3814/* void glGetVertexAttribfv ( GLuint index, GLenum pname, GLfloat *params ) */ 3815static void 3816android_glGetVertexAttribfv__IILjava_nio_FloatBuffer_2 3817 (JNIEnv *_env, jobject _this, jint index, jint pname, jobject params_buf) { 3818 jint _exception = 0; 3819 const char * _exceptionType = NULL; 3820 const char * _exceptionMessage = NULL; 3821 jfloatArray _array = (jfloatArray) 0; 3822 jint _bufferOffset = (jint) 0; 3823 jint _remaining; 3824 GLfloat *params = (GLfloat *) 0; 3825 3826 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3827 int _needed; 3828 switch (pname) { 3829#if defined(GL_CURRENT_VERTEX_ATTRIB) 3830 case GL_CURRENT_VERTEX_ATTRIB: 3831#endif // defined(GL_CURRENT_VERTEX_ATTRIB) 3832 _needed = 4; 3833 break; 3834 default: 3835 _needed = 1; 3836 break; 3837 } 3838 if (_remaining < _needed) { 3839 _exception = 1; 3840 _exceptionType = "java/lang/IllegalArgumentException"; 3841 _exceptionMessage = "remaining() < needed"; 3842 goto exit; 3843 } 3844 if (params == NULL) { 3845 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 3846 params = (GLfloat *) (_paramsBase + _bufferOffset); 3847 } 3848 glGetVertexAttribfv( 3849 (GLuint)index, 3850 (GLenum)pname, 3851 (GLfloat *)params 3852 ); 3853 3854exit: 3855 if (_array) { 3856 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, _exception ? JNI_ABORT : 0); 3857 } 3858 if (_exception) { 3859 jniThrowException(_env, _exceptionType, _exceptionMessage); 3860 } 3861} 3862 3863/* void glGetVertexAttribiv ( GLuint index, GLenum pname, GLint *params ) */ 3864static void 3865android_glGetVertexAttribiv__II_3II 3866 (JNIEnv *_env, jobject _this, jint index, jint pname, jintArray params_ref, jint offset) { 3867 jint _exception = 0; 3868 const char * _exceptionType = NULL; 3869 const char * _exceptionMessage = NULL; 3870 GLint *params_base = (GLint *) 0; 3871 jint _remaining; 3872 GLint *params = (GLint *) 0; 3873 3874 if (!params_ref) { 3875 _exception = 1; 3876 _exceptionType = "java/lang/IllegalArgumentException"; 3877 _exceptionMessage = "params == null"; 3878 goto exit; 3879 } 3880 if (offset < 0) { 3881 _exception = 1; 3882 _exceptionType = "java/lang/IllegalArgumentException"; 3883 _exceptionMessage = "offset < 0"; 3884 goto exit; 3885 } 3886 _remaining = _env->GetArrayLength(params_ref) - offset; 3887 int _needed; 3888 switch (pname) { 3889#if defined(GL_CURRENT_VERTEX_ATTRIB) 3890 case GL_CURRENT_VERTEX_ATTRIB: 3891#endif // defined(GL_CURRENT_VERTEX_ATTRIB) 3892 _needed = 4; 3893 break; 3894 default: 3895 _needed = 1; 3896 break; 3897 } 3898 if (_remaining < _needed) { 3899 _exception = 1; 3900 _exceptionType = "java/lang/IllegalArgumentException"; 3901 _exceptionMessage = "length - offset < needed"; 3902 goto exit; 3903 } 3904 params_base = (GLint *) 3905 _env->GetIntArrayElements(params_ref, (jboolean *)0); 3906 params = params_base + offset; 3907 3908 glGetVertexAttribiv( 3909 (GLuint)index, 3910 (GLenum)pname, 3911 (GLint *)params 3912 ); 3913 3914exit: 3915 if (params_base) { 3916 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 3917 _exception ? JNI_ABORT: 0); 3918 } 3919 if (_exception) { 3920 jniThrowException(_env, _exceptionType, _exceptionMessage); 3921 } 3922} 3923 3924/* void glGetVertexAttribiv ( GLuint index, GLenum pname, GLint *params ) */ 3925static void 3926android_glGetVertexAttribiv__IILjava_nio_IntBuffer_2 3927 (JNIEnv *_env, jobject _this, jint index, jint pname, jobject params_buf) { 3928 jint _exception = 0; 3929 const char * _exceptionType = NULL; 3930 const char * _exceptionMessage = NULL; 3931 jintArray _array = (jintArray) 0; 3932 jint _bufferOffset = (jint) 0; 3933 jint _remaining; 3934 GLint *params = (GLint *) 0; 3935 3936 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3937 int _needed; 3938 switch (pname) { 3939#if defined(GL_CURRENT_VERTEX_ATTRIB) 3940 case GL_CURRENT_VERTEX_ATTRIB: 3941#endif // defined(GL_CURRENT_VERTEX_ATTRIB) 3942 _needed = 4; 3943 break; 3944 default: 3945 _needed = 1; 3946 break; 3947 } 3948 if (_remaining < _needed) { 3949 _exception = 1; 3950 _exceptionType = "java/lang/IllegalArgumentException"; 3951 _exceptionMessage = "remaining() < needed"; 3952 goto exit; 3953 } 3954 if (params == NULL) { 3955 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 3956 params = (GLint *) (_paramsBase + _bufferOffset); 3957 } 3958 glGetVertexAttribiv( 3959 (GLuint)index, 3960 (GLenum)pname, 3961 (GLint *)params 3962 ); 3963 3964exit: 3965 if (_array) { 3966 _env->ReleaseIntArrayElements(_array, (jint*)params, _exception ? JNI_ABORT : 0); 3967 } 3968 if (_exception) { 3969 jniThrowException(_env, _exceptionType, _exceptionMessage); 3970 } 3971} 3972 3973/* void glHint ( GLenum target, GLenum mode ) */ 3974static void 3975android_glHint__II 3976 (JNIEnv *_env, jobject _this, jint target, jint mode) { 3977 glHint( 3978 (GLenum)target, 3979 (GLenum)mode 3980 ); 3981} 3982 3983/* GLboolean glIsBuffer ( GLuint buffer ) */ 3984static jboolean 3985android_glIsBuffer__I 3986 (JNIEnv *_env, jobject _this, jint buffer) { 3987 GLboolean _returnValue; 3988 _returnValue = glIsBuffer( 3989 (GLuint)buffer 3990 ); 3991 return (jboolean)_returnValue; 3992} 3993 3994/* GLboolean glIsEnabled ( GLenum cap ) */ 3995static jboolean 3996android_glIsEnabled__I 3997 (JNIEnv *_env, jobject _this, jint cap) { 3998 GLboolean _returnValue; 3999 _returnValue = glIsEnabled( 4000 (GLenum)cap 4001 ); 4002 return (jboolean)_returnValue; 4003} 4004 4005/* GLboolean glIsFramebuffer ( GLuint framebuffer ) */ 4006static jboolean 4007android_glIsFramebuffer__I 4008 (JNIEnv *_env, jobject _this, jint framebuffer) { 4009 GLboolean _returnValue; 4010 _returnValue = glIsFramebuffer( 4011 (GLuint)framebuffer 4012 ); 4013 return (jboolean)_returnValue; 4014} 4015 4016/* GLboolean glIsProgram ( GLuint program ) */ 4017static jboolean 4018android_glIsProgram__I 4019 (JNIEnv *_env, jobject _this, jint program) { 4020 GLboolean _returnValue; 4021 _returnValue = glIsProgram( 4022 (GLuint)program 4023 ); 4024 return (jboolean)_returnValue; 4025} 4026 4027/* GLboolean glIsRenderbuffer ( GLuint renderbuffer ) */ 4028static jboolean 4029android_glIsRenderbuffer__I 4030 (JNIEnv *_env, jobject _this, jint renderbuffer) { 4031 GLboolean _returnValue; 4032 _returnValue = glIsRenderbuffer( 4033 (GLuint)renderbuffer 4034 ); 4035 return (jboolean)_returnValue; 4036} 4037 4038/* GLboolean glIsShader ( GLuint shader ) */ 4039static jboolean 4040android_glIsShader__I 4041 (JNIEnv *_env, jobject _this, jint shader) { 4042 GLboolean _returnValue; 4043 _returnValue = glIsShader( 4044 (GLuint)shader 4045 ); 4046 return (jboolean)_returnValue; 4047} 4048 4049/* GLboolean glIsTexture ( GLuint texture ) */ 4050static jboolean 4051android_glIsTexture__I 4052 (JNIEnv *_env, jobject _this, jint texture) { 4053 GLboolean _returnValue; 4054 _returnValue = glIsTexture( 4055 (GLuint)texture 4056 ); 4057 return (jboolean)_returnValue; 4058} 4059 4060/* void glLineWidth ( GLfloat width ) */ 4061static void 4062android_glLineWidth__F 4063 (JNIEnv *_env, jobject _this, jfloat width) { 4064 glLineWidth( 4065 (GLfloat)width 4066 ); 4067} 4068 4069/* void glLinkProgram ( GLuint program ) */ 4070static void 4071android_glLinkProgram__I 4072 (JNIEnv *_env, jobject _this, jint program) { 4073 glLinkProgram( 4074 (GLuint)program 4075 ); 4076} 4077 4078/* void glPixelStorei ( GLenum pname, GLint param ) */ 4079static void 4080android_glPixelStorei__II 4081 (JNIEnv *_env, jobject _this, jint pname, jint param) { 4082 glPixelStorei( 4083 (GLenum)pname, 4084 (GLint)param 4085 ); 4086} 4087 4088/* void glPolygonOffset ( GLfloat factor, GLfloat units ) */ 4089static void 4090android_glPolygonOffset__FF 4091 (JNIEnv *_env, jobject _this, jfloat factor, jfloat units) { 4092 glPolygonOffset( 4093 (GLfloat)factor, 4094 (GLfloat)units 4095 ); 4096} 4097 4098/* void glReadPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) */ 4099static void 4100android_glReadPixels__IIIIIILjava_nio_Buffer_2 4101 (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height, jint format, jint type, jobject pixels_buf) { 4102 jarray _array = (jarray) 0; 4103 jint _bufferOffset = (jint) 0; 4104 jint _remaining; 4105 GLvoid *pixels = (GLvoid *) 0; 4106 4107 pixels = (GLvoid *)getPointer(_env, pixels_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4108 if (pixels == NULL) { 4109 char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 4110 pixels = (GLvoid *) (_pixelsBase + _bufferOffset); 4111 } 4112 glReadPixels( 4113 (GLint)x, 4114 (GLint)y, 4115 (GLsizei)width, 4116 (GLsizei)height, 4117 (GLenum)format, 4118 (GLenum)type, 4119 (GLvoid *)pixels 4120 ); 4121 if (_array) { 4122 releasePointer(_env, _array, pixels, JNI_TRUE); 4123 } 4124} 4125 4126/* void glReleaseShaderCompiler ( void ) */ 4127static void 4128android_glReleaseShaderCompiler__ 4129 (JNIEnv *_env, jobject _this) { 4130 glReleaseShaderCompiler(); 4131} 4132 4133/* void glRenderbufferStorage ( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) */ 4134static void 4135android_glRenderbufferStorage__IIII 4136 (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint width, jint height) { 4137 glRenderbufferStorage( 4138 (GLenum)target, 4139 (GLenum)internalformat, 4140 (GLsizei)width, 4141 (GLsizei)height 4142 ); 4143} 4144 4145/* void glSampleCoverage ( GLclampf value, GLboolean invert ) */ 4146static void 4147android_glSampleCoverage__FZ 4148 (JNIEnv *_env, jobject _this, jfloat value, jboolean invert) { 4149 glSampleCoverage( 4150 (GLclampf)value, 4151 (GLboolean)invert 4152 ); 4153} 4154 4155/* void glScissor ( GLint x, GLint y, GLsizei width, GLsizei height ) */ 4156static void 4157android_glScissor__IIII 4158 (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height) { 4159 glScissor( 4160 (GLint)x, 4161 (GLint)y, 4162 (GLsizei)width, 4163 (GLsizei)height 4164 ); 4165} 4166 4167/* void glShaderBinary ( GLsizei n, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length ) */ 4168static void 4169android_glShaderBinary__I_3IIILjava_nio_Buffer_2I 4170 (JNIEnv *_env, jobject _this, jint n, jintArray shaders_ref, jint offset, jint binaryformat, jobject binary_buf, jint length) { 4171 jint _exception = 0; 4172 const char * _exceptionType = NULL; 4173 const char * _exceptionMessage = NULL; 4174 jarray _array = (jarray) 0; 4175 jint _bufferOffset = (jint) 0; 4176 GLuint *shaders_base = (GLuint *) 0; 4177 jint _shadersRemaining; 4178 GLuint *shaders = (GLuint *) 0; 4179 jint _binaryRemaining; 4180 GLvoid *binary = (GLvoid *) 0; 4181 4182 if (!shaders_ref) { 4183 _exception = 1; 4184 _exceptionType = "java/lang/IllegalArgumentException"; 4185 _exceptionMessage = "shaders == null"; 4186 goto exit; 4187 } 4188 if (offset < 0) { 4189 _exception = 1; 4190 _exceptionType = "java/lang/IllegalArgumentException"; 4191 _exceptionMessage = "offset < 0"; 4192 goto exit; 4193 } 4194 _shadersRemaining = _env->GetArrayLength(shaders_ref) - offset; 4195 shaders_base = (GLuint *) 4196 _env->GetIntArrayElements(shaders_ref, (jboolean *)0); 4197 shaders = shaders_base + offset; 4198 4199 binary = (GLvoid *)getPointer(_env, binary_buf, (jarray*)&_array, &_binaryRemaining, &_bufferOffset); 4200 if (_binaryRemaining < length) { 4201 _exception = 1; 4202 _exceptionType = "java/lang/IllegalArgumentException"; 4203 _exceptionMessage = "remaining() < length < needed"; 4204 goto exit; 4205 } 4206 if (binary == NULL) { 4207 char * _binaryBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 4208 binary = (GLvoid *) (_binaryBase + _bufferOffset); 4209 } 4210 glShaderBinary( 4211 (GLsizei)n, 4212 (GLuint *)shaders, 4213 (GLenum)binaryformat, 4214 (GLvoid *)binary, 4215 (GLsizei)length 4216 ); 4217 4218exit: 4219 if (_array) { 4220 releasePointer(_env, _array, binary, JNI_FALSE); 4221 } 4222 if (shaders_base) { 4223 _env->ReleaseIntArrayElements(shaders_ref, (jint*)shaders_base, 4224 JNI_ABORT); 4225 } 4226 if (_exception) { 4227 jniThrowException(_env, _exceptionType, _exceptionMessage); 4228 } 4229} 4230 4231/* void glShaderBinary ( GLsizei n, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length ) */ 4232static void 4233android_glShaderBinary__ILjava_nio_IntBuffer_2ILjava_nio_Buffer_2I 4234 (JNIEnv *_env, jobject _this, jint n, jobject shaders_buf, jint binaryformat, jobject binary_buf, jint length) { 4235 jint _exception = 0; 4236 const char * _exceptionType = NULL; 4237 const char * _exceptionMessage = NULL; 4238 jintArray _shadersArray = (jintArray) 0; 4239 jint _shadersBufferOffset = (jint) 0; 4240 jintArray _binaryArray = (jintArray) 0; 4241 jint _binaryBufferOffset = (jint) 0; 4242 jint _shadersRemaining; 4243 GLuint *shaders = (GLuint *) 0; 4244 jint _binaryRemaining; 4245 GLvoid *binary = (GLvoid *) 0; 4246 4247 shaders = (GLuint *)getPointer(_env, shaders_buf, (jarray*)&_shadersArray, &_shadersRemaining, &_shadersBufferOffset); 4248 binary = (GLvoid *)getPointer(_env, binary_buf, (jarray*)&_binaryArray, &_binaryRemaining, &_binaryBufferOffset); 4249 if (_binaryRemaining < length) { 4250 _exception = 1; 4251 _exceptionType = "java/lang/IllegalArgumentException"; 4252 _exceptionMessage = "remaining() < length < needed"; 4253 goto exit; 4254 } 4255 if (shaders == NULL) { 4256 char * _shadersBase = (char *)_env->GetIntArrayElements(_shadersArray, (jboolean *) 0); 4257 shaders = (GLuint *) (_shadersBase + _shadersBufferOffset); 4258 } 4259 if (binary == NULL) { 4260 char * _binaryBase = (char *)_env->GetPrimitiveArrayCritical(_binaryArray, (jboolean *) 0); 4261 binary = (GLvoid *) (_binaryBase + _binaryBufferOffset); 4262 } 4263 glShaderBinary( 4264 (GLsizei)n, 4265 (GLuint *)shaders, 4266 (GLenum)binaryformat, 4267 (GLvoid *)binary, 4268 (GLsizei)length 4269 ); 4270 4271exit: 4272 if (_binaryArray) { 4273 releasePointer(_env, _binaryArray, binary, JNI_FALSE); 4274 } 4275 if (_shadersArray) { 4276 _env->ReleaseIntArrayElements(_shadersArray, (jint*)shaders, JNI_ABORT); 4277 } 4278 if (_exception) { 4279 jniThrowException(_env, _exceptionType, _exceptionMessage); 4280 } 4281} 4282 4283 4284/* void glShaderSource ( GLuint shader, GLsizei count, const GLchar ** string, const GLint * length ) */ 4285static 4286void 4287android_glShaderSource 4288 (JNIEnv *_env, jobject _this, jint shader, jstring string) { 4289 4290 if (!string) { 4291 jniThrowException(_env, "java/lang/IllegalArgumentException", "string == null"); 4292 return; 4293 } 4294 4295 const char* nativeString = _env->GetStringUTFChars(string, 0); 4296 const char* strings[] = {nativeString}; 4297 glShaderSource(shader, 1, strings, 0); 4298 _env->ReleaseStringUTFChars(string, nativeString); 4299} 4300/* void glStencilFunc ( GLenum func, GLint ref, GLuint mask ) */ 4301static void 4302android_glStencilFunc__III 4303 (JNIEnv *_env, jobject _this, jint func, jint ref, jint mask) { 4304 glStencilFunc( 4305 (GLenum)func, 4306 (GLint)ref, 4307 (GLuint)mask 4308 ); 4309} 4310 4311/* void glStencilFuncSeparate ( GLenum face, GLenum func, GLint ref, GLuint mask ) */ 4312static void 4313android_glStencilFuncSeparate__IIII 4314 (JNIEnv *_env, jobject _this, jint face, jint func, jint ref, jint mask) { 4315 glStencilFuncSeparate( 4316 (GLenum)face, 4317 (GLenum)func, 4318 (GLint)ref, 4319 (GLuint)mask 4320 ); 4321} 4322 4323/* void glStencilMask ( GLuint mask ) */ 4324static void 4325android_glStencilMask__I 4326 (JNIEnv *_env, jobject _this, jint mask) { 4327 glStencilMask( 4328 (GLuint)mask 4329 ); 4330} 4331 4332/* void glStencilMaskSeparate ( GLenum face, GLuint mask ) */ 4333static void 4334android_glStencilMaskSeparate__II 4335 (JNIEnv *_env, jobject _this, jint face, jint mask) { 4336 glStencilMaskSeparate( 4337 (GLenum)face, 4338 (GLuint)mask 4339 ); 4340} 4341 4342/* void glStencilOp ( GLenum fail, GLenum zfail, GLenum zpass ) */ 4343static void 4344android_glStencilOp__III 4345 (JNIEnv *_env, jobject _this, jint fail, jint zfail, jint zpass) { 4346 glStencilOp( 4347 (GLenum)fail, 4348 (GLenum)zfail, 4349 (GLenum)zpass 4350 ); 4351} 4352 4353/* void glStencilOpSeparate ( GLenum face, GLenum fail, GLenum zfail, GLenum zpass ) */ 4354static void 4355android_glStencilOpSeparate__IIII 4356 (JNIEnv *_env, jobject _this, jint face, jint fail, jint zfail, jint zpass) { 4357 glStencilOpSeparate( 4358 (GLenum)face, 4359 (GLenum)fail, 4360 (GLenum)zfail, 4361 (GLenum)zpass 4362 ); 4363} 4364 4365/* void glTexImage2D ( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) */ 4366static void 4367android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2 4368 (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint format, jint type, jobject pixels_buf) { 4369 jarray _array = (jarray) 0; 4370 jint _bufferOffset = (jint) 0; 4371 jint _remaining; 4372 GLvoid *pixels = (GLvoid *) 0; 4373 4374 if (pixels_buf) { 4375 pixels = (GLvoid *)getPointer(_env, pixels_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4376 } 4377 if (pixels_buf && pixels == NULL) { 4378 char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 4379 pixels = (GLvoid *) (_pixelsBase + _bufferOffset); 4380 } 4381 glTexImage2D( 4382 (GLenum)target, 4383 (GLint)level, 4384 (GLint)internalformat, 4385 (GLsizei)width, 4386 (GLsizei)height, 4387 (GLint)border, 4388 (GLenum)format, 4389 (GLenum)type, 4390 (GLvoid *)pixels 4391 ); 4392 if (_array) { 4393 releasePointer(_env, _array, pixels, JNI_FALSE); 4394 } 4395} 4396 4397/* void glTexParameterf ( GLenum target, GLenum pname, GLfloat param ) */ 4398static void 4399android_glTexParameterf__IIF 4400 (JNIEnv *_env, jobject _this, jint target, jint pname, jfloat param) { 4401 glTexParameterf( 4402 (GLenum)target, 4403 (GLenum)pname, 4404 (GLfloat)param 4405 ); 4406} 4407 4408/* void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params ) */ 4409static void 4410android_glTexParameterfv__II_3FI 4411 (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) { 4412 jint _exception = 0; 4413 const char * _exceptionType = NULL; 4414 const char * _exceptionMessage = NULL; 4415 GLfloat *params_base = (GLfloat *) 0; 4416 jint _remaining; 4417 GLfloat *params = (GLfloat *) 0; 4418 4419 if (!params_ref) { 4420 _exception = 1; 4421 _exceptionType = "java/lang/IllegalArgumentException"; 4422 _exceptionMessage = "params == null"; 4423 goto exit; 4424 } 4425 if (offset < 0) { 4426 _exception = 1; 4427 _exceptionType = "java/lang/IllegalArgumentException"; 4428 _exceptionMessage = "offset < 0"; 4429 goto exit; 4430 } 4431 _remaining = _env->GetArrayLength(params_ref) - offset; 4432 if (_remaining < 1) { 4433 _exception = 1; 4434 _exceptionType = "java/lang/IllegalArgumentException"; 4435 _exceptionMessage = "length - offset < 1 < needed"; 4436 goto exit; 4437 } 4438 params_base = (GLfloat *) 4439 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 4440 params = params_base + offset; 4441 4442 glTexParameterfv( 4443 (GLenum)target, 4444 (GLenum)pname, 4445 (GLfloat *)params 4446 ); 4447 4448exit: 4449 if (params_base) { 4450 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 4451 JNI_ABORT); 4452 } 4453 if (_exception) { 4454 jniThrowException(_env, _exceptionType, _exceptionMessage); 4455 } 4456} 4457 4458/* void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params ) */ 4459static void 4460android_glTexParameterfv__IILjava_nio_FloatBuffer_2 4461 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 4462 jint _exception = 0; 4463 const char * _exceptionType = NULL; 4464 const char * _exceptionMessage = NULL; 4465 jfloatArray _array = (jfloatArray) 0; 4466 jint _bufferOffset = (jint) 0; 4467 jint _remaining; 4468 GLfloat *params = (GLfloat *) 0; 4469 4470 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4471 if (_remaining < 1) { 4472 _exception = 1; 4473 _exceptionType = "java/lang/IllegalArgumentException"; 4474 _exceptionMessage = "remaining() < 1 < needed"; 4475 goto exit; 4476 } 4477 if (params == NULL) { 4478 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 4479 params = (GLfloat *) (_paramsBase + _bufferOffset); 4480 } 4481 glTexParameterfv( 4482 (GLenum)target, 4483 (GLenum)pname, 4484 (GLfloat *)params 4485 ); 4486 4487exit: 4488 if (_array) { 4489 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, JNI_ABORT); 4490 } 4491 if (_exception) { 4492 jniThrowException(_env, _exceptionType, _exceptionMessage); 4493 } 4494} 4495 4496/* void glTexParameteri ( GLenum target, GLenum pname, GLint param ) */ 4497static void 4498android_glTexParameteri__III 4499 (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) { 4500 glTexParameteri( 4501 (GLenum)target, 4502 (GLenum)pname, 4503 (GLint)param 4504 ); 4505} 4506 4507/* void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params ) */ 4508static void 4509android_glTexParameteriv__II_3II 4510 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 4511 jint _exception = 0; 4512 const char * _exceptionType = NULL; 4513 const char * _exceptionMessage = NULL; 4514 GLint *params_base = (GLint *) 0; 4515 jint _remaining; 4516 GLint *params = (GLint *) 0; 4517 4518 if (!params_ref) { 4519 _exception = 1; 4520 _exceptionType = "java/lang/IllegalArgumentException"; 4521 _exceptionMessage = "params == null"; 4522 goto exit; 4523 } 4524 if (offset < 0) { 4525 _exception = 1; 4526 _exceptionType = "java/lang/IllegalArgumentException"; 4527 _exceptionMessage = "offset < 0"; 4528 goto exit; 4529 } 4530 _remaining = _env->GetArrayLength(params_ref) - offset; 4531 if (_remaining < 1) { 4532 _exception = 1; 4533 _exceptionType = "java/lang/IllegalArgumentException"; 4534 _exceptionMessage = "length - offset < 1 < needed"; 4535 goto exit; 4536 } 4537 params_base = (GLint *) 4538 _env->GetIntArrayElements(params_ref, (jboolean *)0); 4539 params = params_base + offset; 4540 4541 glTexParameteriv( 4542 (GLenum)target, 4543 (GLenum)pname, 4544 (GLint *)params 4545 ); 4546 4547exit: 4548 if (params_base) { 4549 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 4550 JNI_ABORT); 4551 } 4552 if (_exception) { 4553 jniThrowException(_env, _exceptionType, _exceptionMessage); 4554 } 4555} 4556 4557/* void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params ) */ 4558static void 4559android_glTexParameteriv__IILjava_nio_IntBuffer_2 4560 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 4561 jint _exception = 0; 4562 const char * _exceptionType = NULL; 4563 const char * _exceptionMessage = NULL; 4564 jintArray _array = (jintArray) 0; 4565 jint _bufferOffset = (jint) 0; 4566 jint _remaining; 4567 GLint *params = (GLint *) 0; 4568 4569 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4570 if (_remaining < 1) { 4571 _exception = 1; 4572 _exceptionType = "java/lang/IllegalArgumentException"; 4573 _exceptionMessage = "remaining() < 1 < needed"; 4574 goto exit; 4575 } 4576 if (params == NULL) { 4577 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 4578 params = (GLint *) (_paramsBase + _bufferOffset); 4579 } 4580 glTexParameteriv( 4581 (GLenum)target, 4582 (GLenum)pname, 4583 (GLint *)params 4584 ); 4585 4586exit: 4587 if (_array) { 4588 _env->ReleaseIntArrayElements(_array, (jint*)params, JNI_ABORT); 4589 } 4590 if (_exception) { 4591 jniThrowException(_env, _exceptionType, _exceptionMessage); 4592 } 4593} 4594 4595/* void glTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels ) */ 4596static void 4597android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 4598 (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint type, jobject pixels_buf) { 4599 jarray _array = (jarray) 0; 4600 jint _bufferOffset = (jint) 0; 4601 jint _remaining; 4602 GLvoid *pixels = (GLvoid *) 0; 4603 4604 if (pixels_buf) { 4605 pixels = (GLvoid *)getPointer(_env, pixels_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4606 } 4607 if (pixels_buf && pixels == NULL) { 4608 char * _pixelsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); 4609 pixels = (GLvoid *) (_pixelsBase + _bufferOffset); 4610 } 4611 glTexSubImage2D( 4612 (GLenum)target, 4613 (GLint)level, 4614 (GLint)xoffset, 4615 (GLint)yoffset, 4616 (GLsizei)width, 4617 (GLsizei)height, 4618 (GLenum)format, 4619 (GLenum)type, 4620 (GLvoid *)pixels 4621 ); 4622 if (_array) { 4623 releasePointer(_env, _array, pixels, JNI_FALSE); 4624 } 4625} 4626 4627/* void glUniform1f ( GLint location, GLfloat x ) */ 4628static void 4629android_glUniform1f__IF 4630 (JNIEnv *_env, jobject _this, jint location, jfloat x) { 4631 glUniform1f( 4632 (GLint)location, 4633 (GLfloat)x 4634 ); 4635} 4636 4637/* void glUniform1fv ( GLint location, GLsizei count, const GLfloat *v ) */ 4638static void 4639android_glUniform1fv__II_3FI 4640 (JNIEnv *_env, jobject _this, jint location, jint count, jfloatArray v_ref, jint offset) { 4641 jint _exception = 0; 4642 const char * _exceptionType = NULL; 4643 const char * _exceptionMessage = NULL; 4644 GLfloat *v_base = (GLfloat *) 0; 4645 jint _remaining; 4646 GLfloat *v = (GLfloat *) 0; 4647 4648 if (!v_ref) { 4649 _exception = 1; 4650 _exceptionType = "java/lang/IllegalArgumentException"; 4651 _exceptionMessage = "v == null"; 4652 goto exit; 4653 } 4654 if (offset < 0) { 4655 _exception = 1; 4656 _exceptionType = "java/lang/IllegalArgumentException"; 4657 _exceptionMessage = "offset < 0"; 4658 goto exit; 4659 } 4660 _remaining = _env->GetArrayLength(v_ref) - offset; 4661 if (_remaining < count) { 4662 _exception = 1; 4663 _exceptionType = "java/lang/IllegalArgumentException"; 4664 _exceptionMessage = "length - offset < count < needed"; 4665 goto exit; 4666 } 4667 v_base = (GLfloat *) 4668 _env->GetFloatArrayElements(v_ref, (jboolean *)0); 4669 v = v_base + offset; 4670 4671 glUniform1fv( 4672 (GLint)location, 4673 (GLsizei)count, 4674 (GLfloat *)v 4675 ); 4676 4677exit: 4678 if (v_base) { 4679 _env->ReleaseFloatArrayElements(v_ref, (jfloat*)v_base, 4680 JNI_ABORT); 4681 } 4682 if (_exception) { 4683 jniThrowException(_env, _exceptionType, _exceptionMessage); 4684 } 4685} 4686 4687/* void glUniform1fv ( GLint location, GLsizei count, const GLfloat *v ) */ 4688static void 4689android_glUniform1fv__IILjava_nio_FloatBuffer_2 4690 (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) { 4691 jint _exception = 0; 4692 const char * _exceptionType = NULL; 4693 const char * _exceptionMessage = NULL; 4694 jfloatArray _array = (jfloatArray) 0; 4695 jint _bufferOffset = (jint) 0; 4696 jint _remaining; 4697 GLfloat *v = (GLfloat *) 0; 4698 4699 v = (GLfloat *)getPointer(_env, v_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4700 if (_remaining < count) { 4701 _exception = 1; 4702 _exceptionType = "java/lang/IllegalArgumentException"; 4703 _exceptionMessage = "remaining() < count < needed"; 4704 goto exit; 4705 } 4706 if (v == NULL) { 4707 char * _vBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 4708 v = (GLfloat *) (_vBase + _bufferOffset); 4709 } 4710 glUniform1fv( 4711 (GLint)location, 4712 (GLsizei)count, 4713 (GLfloat *)v 4714 ); 4715 4716exit: 4717 if (_array) { 4718 _env->ReleaseFloatArrayElements(_array, (jfloat*)v, JNI_ABORT); 4719 } 4720 if (_exception) { 4721 jniThrowException(_env, _exceptionType, _exceptionMessage); 4722 } 4723} 4724 4725/* void glUniform1i ( GLint location, GLint x ) */ 4726static void 4727android_glUniform1i__II 4728 (JNIEnv *_env, jobject _this, jint location, jint x) { 4729 glUniform1i( 4730 (GLint)location, 4731 (GLint)x 4732 ); 4733} 4734 4735/* void glUniform1iv ( GLint location, GLsizei count, const GLint *v ) */ 4736static void 4737android_glUniform1iv__II_3II 4738 (JNIEnv *_env, jobject _this, jint location, jint count, jintArray v_ref, jint offset) { 4739 jint _exception = 0; 4740 const char * _exceptionType = NULL; 4741 const char * _exceptionMessage = NULL; 4742 GLint *v_base = (GLint *) 0; 4743 jint _remaining; 4744 GLint *v = (GLint *) 0; 4745 4746 if (!v_ref) { 4747 _exception = 1; 4748 _exceptionType = "java/lang/IllegalArgumentException"; 4749 _exceptionMessage = "v == null"; 4750 goto exit; 4751 } 4752 if (offset < 0) { 4753 _exception = 1; 4754 _exceptionType = "java/lang/IllegalArgumentException"; 4755 _exceptionMessage = "offset < 0"; 4756 goto exit; 4757 } 4758 _remaining = _env->GetArrayLength(v_ref) - offset; 4759 if (_remaining < count) { 4760 _exception = 1; 4761 _exceptionType = "java/lang/IllegalArgumentException"; 4762 _exceptionMessage = "length - offset < count < needed"; 4763 goto exit; 4764 } 4765 v_base = (GLint *) 4766 _env->GetIntArrayElements(v_ref, (jboolean *)0); 4767 v = v_base + offset; 4768 4769 glUniform1iv( 4770 (GLint)location, 4771 (GLsizei)count, 4772 (GLint *)v 4773 ); 4774 4775exit: 4776 if (v_base) { 4777 _env->ReleaseIntArrayElements(v_ref, (jint*)v_base, 4778 JNI_ABORT); 4779 } 4780 if (_exception) { 4781 jniThrowException(_env, _exceptionType, _exceptionMessage); 4782 } 4783} 4784 4785/* void glUniform1iv ( GLint location, GLsizei count, const GLint *v ) */ 4786static void 4787android_glUniform1iv__IILjava_nio_IntBuffer_2 4788 (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) { 4789 jint _exception = 0; 4790 const char * _exceptionType = NULL; 4791 const char * _exceptionMessage = NULL; 4792 jintArray _array = (jintArray) 0; 4793 jint _bufferOffset = (jint) 0; 4794 jint _remaining; 4795 GLint *v = (GLint *) 0; 4796 4797 v = (GLint *)getPointer(_env, v_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4798 if (_remaining < count) { 4799 _exception = 1; 4800 _exceptionType = "java/lang/IllegalArgumentException"; 4801 _exceptionMessage = "remaining() < count < needed"; 4802 goto exit; 4803 } 4804 if (v == NULL) { 4805 char * _vBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 4806 v = (GLint *) (_vBase + _bufferOffset); 4807 } 4808 glUniform1iv( 4809 (GLint)location, 4810 (GLsizei)count, 4811 (GLint *)v 4812 ); 4813 4814exit: 4815 if (_array) { 4816 _env->ReleaseIntArrayElements(_array, (jint*)v, JNI_ABORT); 4817 } 4818 if (_exception) { 4819 jniThrowException(_env, _exceptionType, _exceptionMessage); 4820 } 4821} 4822 4823/* void glUniform2f ( GLint location, GLfloat x, GLfloat y ) */ 4824static void 4825android_glUniform2f__IFF 4826 (JNIEnv *_env, jobject _this, jint location, jfloat x, jfloat y) { 4827 glUniform2f( 4828 (GLint)location, 4829 (GLfloat)x, 4830 (GLfloat)y 4831 ); 4832} 4833 4834/* void glUniform2fv ( GLint location, GLsizei count, const GLfloat *v ) */ 4835static void 4836android_glUniform2fv__II_3FI 4837 (JNIEnv *_env, jobject _this, jint location, jint count, jfloatArray v_ref, jint offset) { 4838 jint _exception = 0; 4839 const char * _exceptionType = NULL; 4840 const char * _exceptionMessage = NULL; 4841 GLfloat *v_base = (GLfloat *) 0; 4842 jint _remaining; 4843 GLfloat *v = (GLfloat *) 0; 4844 4845 if (!v_ref) { 4846 _exception = 1; 4847 _exceptionType = "java/lang/IllegalArgumentException"; 4848 _exceptionMessage = "v == null"; 4849 goto exit; 4850 } 4851 if (offset < 0) { 4852 _exception = 1; 4853 _exceptionType = "java/lang/IllegalArgumentException"; 4854 _exceptionMessage = "offset < 0"; 4855 goto exit; 4856 } 4857 _remaining = _env->GetArrayLength(v_ref) - offset; 4858 if (_remaining < count*2) { 4859 _exception = 1; 4860 _exceptionType = "java/lang/IllegalArgumentException"; 4861 _exceptionMessage = "length - offset < count*2 < needed"; 4862 goto exit; 4863 } 4864 v_base = (GLfloat *) 4865 _env->GetFloatArrayElements(v_ref, (jboolean *)0); 4866 v = v_base + offset; 4867 4868 glUniform2fv( 4869 (GLint)location, 4870 (GLsizei)count, 4871 (GLfloat *)v 4872 ); 4873 4874exit: 4875 if (v_base) { 4876 _env->ReleaseFloatArrayElements(v_ref, (jfloat*)v_base, 4877 JNI_ABORT); 4878 } 4879 if (_exception) { 4880 jniThrowException(_env, _exceptionType, _exceptionMessage); 4881 } 4882} 4883 4884/* void glUniform2fv ( GLint location, GLsizei count, const GLfloat *v ) */ 4885static void 4886android_glUniform2fv__IILjava_nio_FloatBuffer_2 4887 (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) { 4888 jint _exception = 0; 4889 const char * _exceptionType = NULL; 4890 const char * _exceptionMessage = NULL; 4891 jfloatArray _array = (jfloatArray) 0; 4892 jint _bufferOffset = (jint) 0; 4893 jint _remaining; 4894 GLfloat *v = (GLfloat *) 0; 4895 4896 v = (GLfloat *)getPointer(_env, v_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4897 if (_remaining < count*2) { 4898 _exception = 1; 4899 _exceptionType = "java/lang/IllegalArgumentException"; 4900 _exceptionMessage = "remaining() < count*2 < needed"; 4901 goto exit; 4902 } 4903 if (v == NULL) { 4904 char * _vBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 4905 v = (GLfloat *) (_vBase + _bufferOffset); 4906 } 4907 glUniform2fv( 4908 (GLint)location, 4909 (GLsizei)count, 4910 (GLfloat *)v 4911 ); 4912 4913exit: 4914 if (_array) { 4915 _env->ReleaseFloatArrayElements(_array, (jfloat*)v, JNI_ABORT); 4916 } 4917 if (_exception) { 4918 jniThrowException(_env, _exceptionType, _exceptionMessage); 4919 } 4920} 4921 4922/* void glUniform2i ( GLint location, GLint x, GLint y ) */ 4923static void 4924android_glUniform2i__III 4925 (JNIEnv *_env, jobject _this, jint location, jint x, jint y) { 4926 glUniform2i( 4927 (GLint)location, 4928 (GLint)x, 4929 (GLint)y 4930 ); 4931} 4932 4933/* void glUniform2iv ( GLint location, GLsizei count, const GLint *v ) */ 4934static void 4935android_glUniform2iv__II_3II 4936 (JNIEnv *_env, jobject _this, jint location, jint count, jintArray v_ref, jint offset) { 4937 jint _exception = 0; 4938 const char * _exceptionType = NULL; 4939 const char * _exceptionMessage = NULL; 4940 GLint *v_base = (GLint *) 0; 4941 jint _remaining; 4942 GLint *v = (GLint *) 0; 4943 4944 if (!v_ref) { 4945 _exception = 1; 4946 _exceptionType = "java/lang/IllegalArgumentException"; 4947 _exceptionMessage = "v == null"; 4948 goto exit; 4949 } 4950 if (offset < 0) { 4951 _exception = 1; 4952 _exceptionType = "java/lang/IllegalArgumentException"; 4953 _exceptionMessage = "offset < 0"; 4954 goto exit; 4955 } 4956 _remaining = _env->GetArrayLength(v_ref) - offset; 4957 if (_remaining < count*2) { 4958 _exception = 1; 4959 _exceptionType = "java/lang/IllegalArgumentException"; 4960 _exceptionMessage = "length - offset < count*2 < needed"; 4961 goto exit; 4962 } 4963 v_base = (GLint *) 4964 _env->GetIntArrayElements(v_ref, (jboolean *)0); 4965 v = v_base + offset; 4966 4967 glUniform2iv( 4968 (GLint)location, 4969 (GLsizei)count, 4970 (GLint *)v 4971 ); 4972 4973exit: 4974 if (v_base) { 4975 _env->ReleaseIntArrayElements(v_ref, (jint*)v_base, 4976 JNI_ABORT); 4977 } 4978 if (_exception) { 4979 jniThrowException(_env, _exceptionType, _exceptionMessage); 4980 } 4981} 4982 4983/* void glUniform2iv ( GLint location, GLsizei count, const GLint *v ) */ 4984static void 4985android_glUniform2iv__IILjava_nio_IntBuffer_2 4986 (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) { 4987 jint _exception = 0; 4988 const char * _exceptionType = NULL; 4989 const char * _exceptionMessage = NULL; 4990 jintArray _array = (jintArray) 0; 4991 jint _bufferOffset = (jint) 0; 4992 jint _remaining; 4993 GLint *v = (GLint *) 0; 4994 4995 v = (GLint *)getPointer(_env, v_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 4996 if (_remaining < count*2) { 4997 _exception = 1; 4998 _exceptionType = "java/lang/IllegalArgumentException"; 4999 _exceptionMessage = "remaining() < count*2 < needed"; 5000 goto exit; 5001 } 5002 if (v == NULL) { 5003 char * _vBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 5004 v = (GLint *) (_vBase + _bufferOffset); 5005 } 5006 glUniform2iv( 5007 (GLint)location, 5008 (GLsizei)count, 5009 (GLint *)v 5010 ); 5011 5012exit: 5013 if (_array) { 5014 _env->ReleaseIntArrayElements(_array, (jint*)v, JNI_ABORT); 5015 } 5016 if (_exception) { 5017 jniThrowException(_env, _exceptionType, _exceptionMessage); 5018 } 5019} 5020 5021/* void glUniform3f ( GLint location, GLfloat x, GLfloat y, GLfloat z ) */ 5022static void 5023android_glUniform3f__IFFF 5024 (JNIEnv *_env, jobject _this, jint location, jfloat x, jfloat y, jfloat z) { 5025 glUniform3f( 5026 (GLint)location, 5027 (GLfloat)x, 5028 (GLfloat)y, 5029 (GLfloat)z 5030 ); 5031} 5032 5033/* void glUniform3fv ( GLint location, GLsizei count, const GLfloat *v ) */ 5034static void 5035android_glUniform3fv__II_3FI 5036 (JNIEnv *_env, jobject _this, jint location, jint count, jfloatArray v_ref, jint offset) { 5037 jint _exception = 0; 5038 const char * _exceptionType = NULL; 5039 const char * _exceptionMessage = NULL; 5040 GLfloat *v_base = (GLfloat *) 0; 5041 jint _remaining; 5042 GLfloat *v = (GLfloat *) 0; 5043 5044 if (!v_ref) { 5045 _exception = 1; 5046 _exceptionType = "java/lang/IllegalArgumentException"; 5047 _exceptionMessage = "v == null"; 5048 goto exit; 5049 } 5050 if (offset < 0) { 5051 _exception = 1; 5052 _exceptionType = "java/lang/IllegalArgumentException"; 5053 _exceptionMessage = "offset < 0"; 5054 goto exit; 5055 } 5056 _remaining = _env->GetArrayLength(v_ref) - offset; 5057 if (_remaining < count*3) { 5058 _exception = 1; 5059 _exceptionType = "java/lang/IllegalArgumentException"; 5060 _exceptionMessage = "length - offset < count*3 < needed"; 5061 goto exit; 5062 } 5063 v_base = (GLfloat *) 5064 _env->GetFloatArrayElements(v_ref, (jboolean *)0); 5065 v = v_base + offset; 5066 5067 glUniform3fv( 5068 (GLint)location, 5069 (GLsizei)count, 5070 (GLfloat *)v 5071 ); 5072 5073exit: 5074 if (v_base) { 5075 _env->ReleaseFloatArrayElements(v_ref, (jfloat*)v_base, 5076 JNI_ABORT); 5077 } 5078 if (_exception) { 5079 jniThrowException(_env, _exceptionType, _exceptionMessage); 5080 } 5081} 5082 5083/* void glUniform3fv ( GLint location, GLsizei count, const GLfloat *v ) */ 5084static void 5085android_glUniform3fv__IILjava_nio_FloatBuffer_2 5086 (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) { 5087 jint _exception = 0; 5088 const char * _exceptionType = NULL; 5089 const char * _exceptionMessage = NULL; 5090 jfloatArray _array = (jfloatArray) 0; 5091 jint _bufferOffset = (jint) 0; 5092 jint _remaining; 5093 GLfloat *v = (GLfloat *) 0; 5094 5095 v = (GLfloat *)getPointer(_env, v_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5096 if (_remaining < count*3) { 5097 _exception = 1; 5098 _exceptionType = "java/lang/IllegalArgumentException"; 5099 _exceptionMessage = "remaining() < count*3 < needed"; 5100 goto exit; 5101 } 5102 if (v == NULL) { 5103 char * _vBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5104 v = (GLfloat *) (_vBase + _bufferOffset); 5105 } 5106 glUniform3fv( 5107 (GLint)location, 5108 (GLsizei)count, 5109 (GLfloat *)v 5110 ); 5111 5112exit: 5113 if (_array) { 5114 _env->ReleaseFloatArrayElements(_array, (jfloat*)v, JNI_ABORT); 5115 } 5116 if (_exception) { 5117 jniThrowException(_env, _exceptionType, _exceptionMessage); 5118 } 5119} 5120 5121/* void glUniform3i ( GLint location, GLint x, GLint y, GLint z ) */ 5122static void 5123android_glUniform3i__IIII 5124 (JNIEnv *_env, jobject _this, jint location, jint x, jint y, jint z) { 5125 glUniform3i( 5126 (GLint)location, 5127 (GLint)x, 5128 (GLint)y, 5129 (GLint)z 5130 ); 5131} 5132 5133/* void glUniform3iv ( GLint location, GLsizei count, const GLint *v ) */ 5134static void 5135android_glUniform3iv__II_3II 5136 (JNIEnv *_env, jobject _this, jint location, jint count, jintArray v_ref, jint offset) { 5137 jint _exception = 0; 5138 const char * _exceptionType = NULL; 5139 const char * _exceptionMessage = NULL; 5140 GLint *v_base = (GLint *) 0; 5141 jint _remaining; 5142 GLint *v = (GLint *) 0; 5143 5144 if (!v_ref) { 5145 _exception = 1; 5146 _exceptionType = "java/lang/IllegalArgumentException"; 5147 _exceptionMessage = "v == null"; 5148 goto exit; 5149 } 5150 if (offset < 0) { 5151 _exception = 1; 5152 _exceptionType = "java/lang/IllegalArgumentException"; 5153 _exceptionMessage = "offset < 0"; 5154 goto exit; 5155 } 5156 _remaining = _env->GetArrayLength(v_ref) - offset; 5157 if (_remaining < count*3) { 5158 _exception = 1; 5159 _exceptionType = "java/lang/IllegalArgumentException"; 5160 _exceptionMessage = "length - offset < count*3 < needed"; 5161 goto exit; 5162 } 5163 v_base = (GLint *) 5164 _env->GetIntArrayElements(v_ref, (jboolean *)0); 5165 v = v_base + offset; 5166 5167 glUniform3iv( 5168 (GLint)location, 5169 (GLsizei)count, 5170 (GLint *)v 5171 ); 5172 5173exit: 5174 if (v_base) { 5175 _env->ReleaseIntArrayElements(v_ref, (jint*)v_base, 5176 JNI_ABORT); 5177 } 5178 if (_exception) { 5179 jniThrowException(_env, _exceptionType, _exceptionMessage); 5180 } 5181} 5182 5183/* void glUniform3iv ( GLint location, GLsizei count, const GLint *v ) */ 5184static void 5185android_glUniform3iv__IILjava_nio_IntBuffer_2 5186 (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) { 5187 jint _exception = 0; 5188 const char * _exceptionType = NULL; 5189 const char * _exceptionMessage = NULL; 5190 jintArray _array = (jintArray) 0; 5191 jint _bufferOffset = (jint) 0; 5192 jint _remaining; 5193 GLint *v = (GLint *) 0; 5194 5195 v = (GLint *)getPointer(_env, v_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5196 if (_remaining < count*3) { 5197 _exception = 1; 5198 _exceptionType = "java/lang/IllegalArgumentException"; 5199 _exceptionMessage = "remaining() < count*3 < needed"; 5200 goto exit; 5201 } 5202 if (v == NULL) { 5203 char * _vBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 5204 v = (GLint *) (_vBase + _bufferOffset); 5205 } 5206 glUniform3iv( 5207 (GLint)location, 5208 (GLsizei)count, 5209 (GLint *)v 5210 ); 5211 5212exit: 5213 if (_array) { 5214 _env->ReleaseIntArrayElements(_array, (jint*)v, JNI_ABORT); 5215 } 5216 if (_exception) { 5217 jniThrowException(_env, _exceptionType, _exceptionMessage); 5218 } 5219} 5220 5221/* void glUniform4f ( GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) */ 5222static void 5223android_glUniform4f__IFFFF 5224 (JNIEnv *_env, jobject _this, jint location, jfloat x, jfloat y, jfloat z, jfloat w) { 5225 glUniform4f( 5226 (GLint)location, 5227 (GLfloat)x, 5228 (GLfloat)y, 5229 (GLfloat)z, 5230 (GLfloat)w 5231 ); 5232} 5233 5234/* void glUniform4fv ( GLint location, GLsizei count, const GLfloat *v ) */ 5235static void 5236android_glUniform4fv__II_3FI 5237 (JNIEnv *_env, jobject _this, jint location, jint count, jfloatArray v_ref, jint offset) { 5238 jint _exception = 0; 5239 const char * _exceptionType = NULL; 5240 const char * _exceptionMessage = NULL; 5241 GLfloat *v_base = (GLfloat *) 0; 5242 jint _remaining; 5243 GLfloat *v = (GLfloat *) 0; 5244 5245 if (!v_ref) { 5246 _exception = 1; 5247 _exceptionType = "java/lang/IllegalArgumentException"; 5248 _exceptionMessage = "v == null"; 5249 goto exit; 5250 } 5251 if (offset < 0) { 5252 _exception = 1; 5253 _exceptionType = "java/lang/IllegalArgumentException"; 5254 _exceptionMessage = "offset < 0"; 5255 goto exit; 5256 } 5257 _remaining = _env->GetArrayLength(v_ref) - offset; 5258 if (_remaining < count*4) { 5259 _exception = 1; 5260 _exceptionType = "java/lang/IllegalArgumentException"; 5261 _exceptionMessage = "length - offset < count*4 < needed"; 5262 goto exit; 5263 } 5264 v_base = (GLfloat *) 5265 _env->GetFloatArrayElements(v_ref, (jboolean *)0); 5266 v = v_base + offset; 5267 5268 glUniform4fv( 5269 (GLint)location, 5270 (GLsizei)count, 5271 (GLfloat *)v 5272 ); 5273 5274exit: 5275 if (v_base) { 5276 _env->ReleaseFloatArrayElements(v_ref, (jfloat*)v_base, 5277 JNI_ABORT); 5278 } 5279 if (_exception) { 5280 jniThrowException(_env, _exceptionType, _exceptionMessage); 5281 } 5282} 5283 5284/* void glUniform4fv ( GLint location, GLsizei count, const GLfloat *v ) */ 5285static void 5286android_glUniform4fv__IILjava_nio_FloatBuffer_2 5287 (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) { 5288 jint _exception = 0; 5289 const char * _exceptionType = NULL; 5290 const char * _exceptionMessage = NULL; 5291 jfloatArray _array = (jfloatArray) 0; 5292 jint _bufferOffset = (jint) 0; 5293 jint _remaining; 5294 GLfloat *v = (GLfloat *) 0; 5295 5296 v = (GLfloat *)getPointer(_env, v_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5297 if (_remaining < count*4) { 5298 _exception = 1; 5299 _exceptionType = "java/lang/IllegalArgumentException"; 5300 _exceptionMessage = "remaining() < count*4 < needed"; 5301 goto exit; 5302 } 5303 if (v == NULL) { 5304 char * _vBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5305 v = (GLfloat *) (_vBase + _bufferOffset); 5306 } 5307 glUniform4fv( 5308 (GLint)location, 5309 (GLsizei)count, 5310 (GLfloat *)v 5311 ); 5312 5313exit: 5314 if (_array) { 5315 _env->ReleaseFloatArrayElements(_array, (jfloat*)v, JNI_ABORT); 5316 } 5317 if (_exception) { 5318 jniThrowException(_env, _exceptionType, _exceptionMessage); 5319 } 5320} 5321 5322/* void glUniform4i ( GLint location, GLint x, GLint y, GLint z, GLint w ) */ 5323static void 5324android_glUniform4i__IIIII 5325 (JNIEnv *_env, jobject _this, jint location, jint x, jint y, jint z, jint w) { 5326 glUniform4i( 5327 (GLint)location, 5328 (GLint)x, 5329 (GLint)y, 5330 (GLint)z, 5331 (GLint)w 5332 ); 5333} 5334 5335/* void glUniform4iv ( GLint location, GLsizei count, const GLint *v ) */ 5336static void 5337android_glUniform4iv__II_3II 5338 (JNIEnv *_env, jobject _this, jint location, jint count, jintArray v_ref, jint offset) { 5339 jint _exception = 0; 5340 const char * _exceptionType = NULL; 5341 const char * _exceptionMessage = NULL; 5342 GLint *v_base = (GLint *) 0; 5343 jint _remaining; 5344 GLint *v = (GLint *) 0; 5345 5346 if (!v_ref) { 5347 _exception = 1; 5348 _exceptionType = "java/lang/IllegalArgumentException"; 5349 _exceptionMessage = "v == null"; 5350 goto exit; 5351 } 5352 if (offset < 0) { 5353 _exception = 1; 5354 _exceptionType = "java/lang/IllegalArgumentException"; 5355 _exceptionMessage = "offset < 0"; 5356 goto exit; 5357 } 5358 _remaining = _env->GetArrayLength(v_ref) - offset; 5359 if (_remaining < count*4) { 5360 _exception = 1; 5361 _exceptionType = "java/lang/IllegalArgumentException"; 5362 _exceptionMessage = "length - offset < count*4 < needed"; 5363 goto exit; 5364 } 5365 v_base = (GLint *) 5366 _env->GetIntArrayElements(v_ref, (jboolean *)0); 5367 v = v_base + offset; 5368 5369 glUniform4iv( 5370 (GLint)location, 5371 (GLsizei)count, 5372 (GLint *)v 5373 ); 5374 5375exit: 5376 if (v_base) { 5377 _env->ReleaseIntArrayElements(v_ref, (jint*)v_base, 5378 JNI_ABORT); 5379 } 5380 if (_exception) { 5381 jniThrowException(_env, _exceptionType, _exceptionMessage); 5382 } 5383} 5384 5385/* void glUniform4iv ( GLint location, GLsizei count, const GLint *v ) */ 5386static void 5387android_glUniform4iv__IILjava_nio_IntBuffer_2 5388 (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) { 5389 jint _exception = 0; 5390 const char * _exceptionType = NULL; 5391 const char * _exceptionMessage = NULL; 5392 jintArray _array = (jintArray) 0; 5393 jint _bufferOffset = (jint) 0; 5394 jint _remaining; 5395 GLint *v = (GLint *) 0; 5396 5397 v = (GLint *)getPointer(_env, v_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5398 if (_remaining < count*4) { 5399 _exception = 1; 5400 _exceptionType = "java/lang/IllegalArgumentException"; 5401 _exceptionMessage = "remaining() < count*4 < needed"; 5402 goto exit; 5403 } 5404 if (v == NULL) { 5405 char * _vBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 5406 v = (GLint *) (_vBase + _bufferOffset); 5407 } 5408 glUniform4iv( 5409 (GLint)location, 5410 (GLsizei)count, 5411 (GLint *)v 5412 ); 5413 5414exit: 5415 if (_array) { 5416 _env->ReleaseIntArrayElements(_array, (jint*)v, JNI_ABORT); 5417 } 5418 if (_exception) { 5419 jniThrowException(_env, _exceptionType, _exceptionMessage); 5420 } 5421} 5422 5423/* void glUniformMatrix2fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 5424static void 5425android_glUniformMatrix2fv__IIZ_3FI 5426 (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { 5427 jint _exception = 0; 5428 const char * _exceptionType = NULL; 5429 const char * _exceptionMessage = NULL; 5430 GLfloat *value_base = (GLfloat *) 0; 5431 jint _remaining; 5432 GLfloat *value = (GLfloat *) 0; 5433 5434 if (!value_ref) { 5435 _exception = 1; 5436 _exceptionType = "java/lang/IllegalArgumentException"; 5437 _exceptionMessage = "value == null"; 5438 goto exit; 5439 } 5440 if (offset < 0) { 5441 _exception = 1; 5442 _exceptionType = "java/lang/IllegalArgumentException"; 5443 _exceptionMessage = "offset < 0"; 5444 goto exit; 5445 } 5446 _remaining = _env->GetArrayLength(value_ref) - offset; 5447 if (_remaining < count*4) { 5448 _exception = 1; 5449 _exceptionType = "java/lang/IllegalArgumentException"; 5450 _exceptionMessage = "length - offset < count*4 < needed"; 5451 goto exit; 5452 } 5453 value_base = (GLfloat *) 5454 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 5455 value = value_base + offset; 5456 5457 glUniformMatrix2fv( 5458 (GLint)location, 5459 (GLsizei)count, 5460 (GLboolean)transpose, 5461 (GLfloat *)value 5462 ); 5463 5464exit: 5465 if (value_base) { 5466 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 5467 JNI_ABORT); 5468 } 5469 if (_exception) { 5470 jniThrowException(_env, _exceptionType, _exceptionMessage); 5471 } 5472} 5473 5474/* void glUniformMatrix2fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 5475static void 5476android_glUniformMatrix2fv__IIZLjava_nio_FloatBuffer_2 5477 (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jobject value_buf) { 5478 jint _exception = 0; 5479 const char * _exceptionType = NULL; 5480 const char * _exceptionMessage = NULL; 5481 jfloatArray _array = (jfloatArray) 0; 5482 jint _bufferOffset = (jint) 0; 5483 jint _remaining; 5484 GLfloat *value = (GLfloat *) 0; 5485 5486 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5487 if (_remaining < count*4) { 5488 _exception = 1; 5489 _exceptionType = "java/lang/IllegalArgumentException"; 5490 _exceptionMessage = "remaining() < count*4 < needed"; 5491 goto exit; 5492 } 5493 if (value == NULL) { 5494 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5495 value = (GLfloat *) (_valueBase + _bufferOffset); 5496 } 5497 glUniformMatrix2fv( 5498 (GLint)location, 5499 (GLsizei)count, 5500 (GLboolean)transpose, 5501 (GLfloat *)value 5502 ); 5503 5504exit: 5505 if (_array) { 5506 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 5507 } 5508 if (_exception) { 5509 jniThrowException(_env, _exceptionType, _exceptionMessage); 5510 } 5511} 5512 5513/* void glUniformMatrix3fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 5514static void 5515android_glUniformMatrix3fv__IIZ_3FI 5516 (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { 5517 jint _exception = 0; 5518 const char * _exceptionType = NULL; 5519 const char * _exceptionMessage = NULL; 5520 GLfloat *value_base = (GLfloat *) 0; 5521 jint _remaining; 5522 GLfloat *value = (GLfloat *) 0; 5523 5524 if (!value_ref) { 5525 _exception = 1; 5526 _exceptionType = "java/lang/IllegalArgumentException"; 5527 _exceptionMessage = "value == null"; 5528 goto exit; 5529 } 5530 if (offset < 0) { 5531 _exception = 1; 5532 _exceptionType = "java/lang/IllegalArgumentException"; 5533 _exceptionMessage = "offset < 0"; 5534 goto exit; 5535 } 5536 _remaining = _env->GetArrayLength(value_ref) - offset; 5537 if (_remaining < count*9) { 5538 _exception = 1; 5539 _exceptionType = "java/lang/IllegalArgumentException"; 5540 _exceptionMessage = "length - offset < count*9 < needed"; 5541 goto exit; 5542 } 5543 value_base = (GLfloat *) 5544 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 5545 value = value_base + offset; 5546 5547 glUniformMatrix3fv( 5548 (GLint)location, 5549 (GLsizei)count, 5550 (GLboolean)transpose, 5551 (GLfloat *)value 5552 ); 5553 5554exit: 5555 if (value_base) { 5556 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 5557 JNI_ABORT); 5558 } 5559 if (_exception) { 5560 jniThrowException(_env, _exceptionType, _exceptionMessage); 5561 } 5562} 5563 5564/* void glUniformMatrix3fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 5565static void 5566android_glUniformMatrix3fv__IIZLjava_nio_FloatBuffer_2 5567 (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jobject value_buf) { 5568 jint _exception = 0; 5569 const char * _exceptionType = NULL; 5570 const char * _exceptionMessage = NULL; 5571 jfloatArray _array = (jfloatArray) 0; 5572 jint _bufferOffset = (jint) 0; 5573 jint _remaining; 5574 GLfloat *value = (GLfloat *) 0; 5575 5576 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5577 if (_remaining < count*9) { 5578 _exception = 1; 5579 _exceptionType = "java/lang/IllegalArgumentException"; 5580 _exceptionMessage = "remaining() < count*9 < needed"; 5581 goto exit; 5582 } 5583 if (value == NULL) { 5584 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5585 value = (GLfloat *) (_valueBase + _bufferOffset); 5586 } 5587 glUniformMatrix3fv( 5588 (GLint)location, 5589 (GLsizei)count, 5590 (GLboolean)transpose, 5591 (GLfloat *)value 5592 ); 5593 5594exit: 5595 if (_array) { 5596 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 5597 } 5598 if (_exception) { 5599 jniThrowException(_env, _exceptionType, _exceptionMessage); 5600 } 5601} 5602 5603/* void glUniformMatrix4fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 5604static void 5605android_glUniformMatrix4fv__IIZ_3FI 5606 (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { 5607 jint _exception = 0; 5608 const char * _exceptionType = NULL; 5609 const char * _exceptionMessage = NULL; 5610 GLfloat *value_base = (GLfloat *) 0; 5611 jint _remaining; 5612 GLfloat *value = (GLfloat *) 0; 5613 5614 if (!value_ref) { 5615 _exception = 1; 5616 _exceptionType = "java/lang/IllegalArgumentException"; 5617 _exceptionMessage = "value == null"; 5618 goto exit; 5619 } 5620 if (offset < 0) { 5621 _exception = 1; 5622 _exceptionType = "java/lang/IllegalArgumentException"; 5623 _exceptionMessage = "offset < 0"; 5624 goto exit; 5625 } 5626 _remaining = _env->GetArrayLength(value_ref) - offset; 5627 if (_remaining < count*16) { 5628 _exception = 1; 5629 _exceptionType = "java/lang/IllegalArgumentException"; 5630 _exceptionMessage = "length - offset < count*16 < needed"; 5631 goto exit; 5632 } 5633 value_base = (GLfloat *) 5634 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 5635 value = value_base + offset; 5636 5637 glUniformMatrix4fv( 5638 (GLint)location, 5639 (GLsizei)count, 5640 (GLboolean)transpose, 5641 (GLfloat *)value 5642 ); 5643 5644exit: 5645 if (value_base) { 5646 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 5647 JNI_ABORT); 5648 } 5649 if (_exception) { 5650 jniThrowException(_env, _exceptionType, _exceptionMessage); 5651 } 5652} 5653 5654/* void glUniformMatrix4fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 5655static void 5656android_glUniformMatrix4fv__IIZLjava_nio_FloatBuffer_2 5657 (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jobject value_buf) { 5658 jint _exception = 0; 5659 const char * _exceptionType = NULL; 5660 const char * _exceptionMessage = NULL; 5661 jfloatArray _array = (jfloatArray) 0; 5662 jint _bufferOffset = (jint) 0; 5663 jint _remaining; 5664 GLfloat *value = (GLfloat *) 0; 5665 5666 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5667 if (_remaining < count*16) { 5668 _exception = 1; 5669 _exceptionType = "java/lang/IllegalArgumentException"; 5670 _exceptionMessage = "remaining() < count*16 < needed"; 5671 goto exit; 5672 } 5673 if (value == NULL) { 5674 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5675 value = (GLfloat *) (_valueBase + _bufferOffset); 5676 } 5677 glUniformMatrix4fv( 5678 (GLint)location, 5679 (GLsizei)count, 5680 (GLboolean)transpose, 5681 (GLfloat *)value 5682 ); 5683 5684exit: 5685 if (_array) { 5686 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 5687 } 5688 if (_exception) { 5689 jniThrowException(_env, _exceptionType, _exceptionMessage); 5690 } 5691} 5692 5693/* void glUseProgram ( GLuint program ) */ 5694static void 5695android_glUseProgram__I 5696 (JNIEnv *_env, jobject _this, jint program) { 5697 glUseProgram( 5698 (GLuint)program 5699 ); 5700} 5701 5702/* void glValidateProgram ( GLuint program ) */ 5703static void 5704android_glValidateProgram__I 5705 (JNIEnv *_env, jobject _this, jint program) { 5706 glValidateProgram( 5707 (GLuint)program 5708 ); 5709} 5710 5711/* void glVertexAttrib1f ( GLuint indx, GLfloat x ) */ 5712static void 5713android_glVertexAttrib1f__IF 5714 (JNIEnv *_env, jobject _this, jint indx, jfloat x) { 5715 glVertexAttrib1f( 5716 (GLuint)indx, 5717 (GLfloat)x 5718 ); 5719} 5720 5721/* void glVertexAttrib1fv ( GLuint indx, const GLfloat *values ) */ 5722static void 5723android_glVertexAttrib1fv__I_3FI 5724 (JNIEnv *_env, jobject _this, jint indx, jfloatArray values_ref, jint offset) { 5725 jint _exception = 0; 5726 const char * _exceptionType = NULL; 5727 const char * _exceptionMessage = NULL; 5728 GLfloat *values_base = (GLfloat *) 0; 5729 jint _remaining; 5730 GLfloat *values = (GLfloat *) 0; 5731 5732 if (!values_ref) { 5733 _exception = 1; 5734 _exceptionType = "java/lang/IllegalArgumentException"; 5735 _exceptionMessage = "values == null"; 5736 goto exit; 5737 } 5738 if (offset < 0) { 5739 _exception = 1; 5740 _exceptionType = "java/lang/IllegalArgumentException"; 5741 _exceptionMessage = "offset < 0"; 5742 goto exit; 5743 } 5744 _remaining = _env->GetArrayLength(values_ref) - offset; 5745 if (_remaining < 1) { 5746 _exception = 1; 5747 _exceptionType = "java/lang/IllegalArgumentException"; 5748 _exceptionMessage = "length - offset < 1 < needed"; 5749 goto exit; 5750 } 5751 values_base = (GLfloat *) 5752 _env->GetFloatArrayElements(values_ref, (jboolean *)0); 5753 values = values_base + offset; 5754 5755 glVertexAttrib1fv( 5756 (GLuint)indx, 5757 (GLfloat *)values 5758 ); 5759 5760exit: 5761 if (values_base) { 5762 _env->ReleaseFloatArrayElements(values_ref, (jfloat*)values_base, 5763 JNI_ABORT); 5764 } 5765 if (_exception) { 5766 jniThrowException(_env, _exceptionType, _exceptionMessage); 5767 } 5768} 5769 5770/* void glVertexAttrib1fv ( GLuint indx, const GLfloat *values ) */ 5771static void 5772android_glVertexAttrib1fv__ILjava_nio_FloatBuffer_2 5773 (JNIEnv *_env, jobject _this, jint indx, jobject values_buf) { 5774 jint _exception = 0; 5775 const char * _exceptionType = NULL; 5776 const char * _exceptionMessage = NULL; 5777 jfloatArray _array = (jfloatArray) 0; 5778 jint _bufferOffset = (jint) 0; 5779 jint _remaining; 5780 GLfloat *values = (GLfloat *) 0; 5781 5782 values = (GLfloat *)getPointer(_env, values_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5783 if (_remaining < 1) { 5784 _exception = 1; 5785 _exceptionType = "java/lang/IllegalArgumentException"; 5786 _exceptionMessage = "remaining() < 1 < needed"; 5787 goto exit; 5788 } 5789 if (values == NULL) { 5790 char * _valuesBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5791 values = (GLfloat *) (_valuesBase + _bufferOffset); 5792 } 5793 glVertexAttrib1fv( 5794 (GLuint)indx, 5795 (GLfloat *)values 5796 ); 5797 5798exit: 5799 if (_array) { 5800 _env->ReleaseFloatArrayElements(_array, (jfloat*)values, JNI_ABORT); 5801 } 5802 if (_exception) { 5803 jniThrowException(_env, _exceptionType, _exceptionMessage); 5804 } 5805} 5806 5807/* void glVertexAttrib2f ( GLuint indx, GLfloat x, GLfloat y ) */ 5808static void 5809android_glVertexAttrib2f__IFF 5810 (JNIEnv *_env, jobject _this, jint indx, jfloat x, jfloat y) { 5811 glVertexAttrib2f( 5812 (GLuint)indx, 5813 (GLfloat)x, 5814 (GLfloat)y 5815 ); 5816} 5817 5818/* void glVertexAttrib2fv ( GLuint indx, const GLfloat *values ) */ 5819static void 5820android_glVertexAttrib2fv__I_3FI 5821 (JNIEnv *_env, jobject _this, jint indx, jfloatArray values_ref, jint offset) { 5822 jint _exception = 0; 5823 const char * _exceptionType = NULL; 5824 const char * _exceptionMessage = NULL; 5825 GLfloat *values_base = (GLfloat *) 0; 5826 jint _remaining; 5827 GLfloat *values = (GLfloat *) 0; 5828 5829 if (!values_ref) { 5830 _exception = 1; 5831 _exceptionType = "java/lang/IllegalArgumentException"; 5832 _exceptionMessage = "values == null"; 5833 goto exit; 5834 } 5835 if (offset < 0) { 5836 _exception = 1; 5837 _exceptionType = "java/lang/IllegalArgumentException"; 5838 _exceptionMessage = "offset < 0"; 5839 goto exit; 5840 } 5841 _remaining = _env->GetArrayLength(values_ref) - offset; 5842 if (_remaining < 2) { 5843 _exception = 1; 5844 _exceptionType = "java/lang/IllegalArgumentException"; 5845 _exceptionMessage = "length - offset < 2 < needed"; 5846 goto exit; 5847 } 5848 values_base = (GLfloat *) 5849 _env->GetFloatArrayElements(values_ref, (jboolean *)0); 5850 values = values_base + offset; 5851 5852 glVertexAttrib2fv( 5853 (GLuint)indx, 5854 (GLfloat *)values 5855 ); 5856 5857exit: 5858 if (values_base) { 5859 _env->ReleaseFloatArrayElements(values_ref, (jfloat*)values_base, 5860 JNI_ABORT); 5861 } 5862 if (_exception) { 5863 jniThrowException(_env, _exceptionType, _exceptionMessage); 5864 } 5865} 5866 5867/* void glVertexAttrib2fv ( GLuint indx, const GLfloat *values ) */ 5868static void 5869android_glVertexAttrib2fv__ILjava_nio_FloatBuffer_2 5870 (JNIEnv *_env, jobject _this, jint indx, jobject values_buf) { 5871 jint _exception = 0; 5872 const char * _exceptionType = NULL; 5873 const char * _exceptionMessage = NULL; 5874 jfloatArray _array = (jfloatArray) 0; 5875 jint _bufferOffset = (jint) 0; 5876 jint _remaining; 5877 GLfloat *values = (GLfloat *) 0; 5878 5879 values = (GLfloat *)getPointer(_env, values_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5880 if (_remaining < 2) { 5881 _exception = 1; 5882 _exceptionType = "java/lang/IllegalArgumentException"; 5883 _exceptionMessage = "remaining() < 2 < needed"; 5884 goto exit; 5885 } 5886 if (values == NULL) { 5887 char * _valuesBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5888 values = (GLfloat *) (_valuesBase + _bufferOffset); 5889 } 5890 glVertexAttrib2fv( 5891 (GLuint)indx, 5892 (GLfloat *)values 5893 ); 5894 5895exit: 5896 if (_array) { 5897 _env->ReleaseFloatArrayElements(_array, (jfloat*)values, JNI_ABORT); 5898 } 5899 if (_exception) { 5900 jniThrowException(_env, _exceptionType, _exceptionMessage); 5901 } 5902} 5903 5904/* void glVertexAttrib3f ( GLuint indx, GLfloat x, GLfloat y, GLfloat z ) */ 5905static void 5906android_glVertexAttrib3f__IFFF 5907 (JNIEnv *_env, jobject _this, jint indx, jfloat x, jfloat y, jfloat z) { 5908 glVertexAttrib3f( 5909 (GLuint)indx, 5910 (GLfloat)x, 5911 (GLfloat)y, 5912 (GLfloat)z 5913 ); 5914} 5915 5916/* void glVertexAttrib3fv ( GLuint indx, const GLfloat *values ) */ 5917static void 5918android_glVertexAttrib3fv__I_3FI 5919 (JNIEnv *_env, jobject _this, jint indx, jfloatArray values_ref, jint offset) { 5920 jint _exception = 0; 5921 const char * _exceptionType = NULL; 5922 const char * _exceptionMessage = NULL; 5923 GLfloat *values_base = (GLfloat *) 0; 5924 jint _remaining; 5925 GLfloat *values = (GLfloat *) 0; 5926 5927 if (!values_ref) { 5928 _exception = 1; 5929 _exceptionType = "java/lang/IllegalArgumentException"; 5930 _exceptionMessage = "values == null"; 5931 goto exit; 5932 } 5933 if (offset < 0) { 5934 _exception = 1; 5935 _exceptionType = "java/lang/IllegalArgumentException"; 5936 _exceptionMessage = "offset < 0"; 5937 goto exit; 5938 } 5939 _remaining = _env->GetArrayLength(values_ref) - offset; 5940 if (_remaining < 3) { 5941 _exception = 1; 5942 _exceptionType = "java/lang/IllegalArgumentException"; 5943 _exceptionMessage = "length - offset < 3 < needed"; 5944 goto exit; 5945 } 5946 values_base = (GLfloat *) 5947 _env->GetFloatArrayElements(values_ref, (jboolean *)0); 5948 values = values_base + offset; 5949 5950 glVertexAttrib3fv( 5951 (GLuint)indx, 5952 (GLfloat *)values 5953 ); 5954 5955exit: 5956 if (values_base) { 5957 _env->ReleaseFloatArrayElements(values_ref, (jfloat*)values_base, 5958 JNI_ABORT); 5959 } 5960 if (_exception) { 5961 jniThrowException(_env, _exceptionType, _exceptionMessage); 5962 } 5963} 5964 5965/* void glVertexAttrib3fv ( GLuint indx, const GLfloat *values ) */ 5966static void 5967android_glVertexAttrib3fv__ILjava_nio_FloatBuffer_2 5968 (JNIEnv *_env, jobject _this, jint indx, jobject values_buf) { 5969 jint _exception = 0; 5970 const char * _exceptionType = NULL; 5971 const char * _exceptionMessage = NULL; 5972 jfloatArray _array = (jfloatArray) 0; 5973 jint _bufferOffset = (jint) 0; 5974 jint _remaining; 5975 GLfloat *values = (GLfloat *) 0; 5976 5977 values = (GLfloat *)getPointer(_env, values_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 5978 if (_remaining < 3) { 5979 _exception = 1; 5980 _exceptionType = "java/lang/IllegalArgumentException"; 5981 _exceptionMessage = "remaining() < 3 < needed"; 5982 goto exit; 5983 } 5984 if (values == NULL) { 5985 char * _valuesBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 5986 values = (GLfloat *) (_valuesBase + _bufferOffset); 5987 } 5988 glVertexAttrib3fv( 5989 (GLuint)indx, 5990 (GLfloat *)values 5991 ); 5992 5993exit: 5994 if (_array) { 5995 _env->ReleaseFloatArrayElements(_array, (jfloat*)values, JNI_ABORT); 5996 } 5997 if (_exception) { 5998 jniThrowException(_env, _exceptionType, _exceptionMessage); 5999 } 6000} 6001 6002/* void glVertexAttrib4f ( GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) */ 6003static void 6004android_glVertexAttrib4f__IFFFF 6005 (JNIEnv *_env, jobject _this, jint indx, jfloat x, jfloat y, jfloat z, jfloat w) { 6006 glVertexAttrib4f( 6007 (GLuint)indx, 6008 (GLfloat)x, 6009 (GLfloat)y, 6010 (GLfloat)z, 6011 (GLfloat)w 6012 ); 6013} 6014 6015/* void glVertexAttrib4fv ( GLuint indx, const GLfloat *values ) */ 6016static void 6017android_glVertexAttrib4fv__I_3FI 6018 (JNIEnv *_env, jobject _this, jint indx, jfloatArray values_ref, jint offset) { 6019 jint _exception = 0; 6020 const char * _exceptionType = NULL; 6021 const char * _exceptionMessage = NULL; 6022 GLfloat *values_base = (GLfloat *) 0; 6023 jint _remaining; 6024 GLfloat *values = (GLfloat *) 0; 6025 6026 if (!values_ref) { 6027 _exception = 1; 6028 _exceptionType = "java/lang/IllegalArgumentException"; 6029 _exceptionMessage = "values == null"; 6030 goto exit; 6031 } 6032 if (offset < 0) { 6033 _exception = 1; 6034 _exceptionType = "java/lang/IllegalArgumentException"; 6035 _exceptionMessage = "offset < 0"; 6036 goto exit; 6037 } 6038 _remaining = _env->GetArrayLength(values_ref) - offset; 6039 if (_remaining < 4) { 6040 _exception = 1; 6041 _exceptionType = "java/lang/IllegalArgumentException"; 6042 _exceptionMessage = "length - offset < 4 < needed"; 6043 goto exit; 6044 } 6045 values_base = (GLfloat *) 6046 _env->GetFloatArrayElements(values_ref, (jboolean *)0); 6047 values = values_base + offset; 6048 6049 glVertexAttrib4fv( 6050 (GLuint)indx, 6051 (GLfloat *)values 6052 ); 6053 6054exit: 6055 if (values_base) { 6056 _env->ReleaseFloatArrayElements(values_ref, (jfloat*)values_base, 6057 JNI_ABORT); 6058 } 6059 if (_exception) { 6060 jniThrowException(_env, _exceptionType, _exceptionMessage); 6061 } 6062} 6063 6064/* void glVertexAttrib4fv ( GLuint indx, const GLfloat *values ) */ 6065static void 6066android_glVertexAttrib4fv__ILjava_nio_FloatBuffer_2 6067 (JNIEnv *_env, jobject _this, jint indx, jobject values_buf) { 6068 jint _exception = 0; 6069 const char * _exceptionType = NULL; 6070 const char * _exceptionMessage = NULL; 6071 jfloatArray _array = (jfloatArray) 0; 6072 jint _bufferOffset = (jint) 0; 6073 jint _remaining; 6074 GLfloat *values = (GLfloat *) 0; 6075 6076 values = (GLfloat *)getPointer(_env, values_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 6077 if (_remaining < 4) { 6078 _exception = 1; 6079 _exceptionType = "java/lang/IllegalArgumentException"; 6080 _exceptionMessage = "remaining() < 4 < needed"; 6081 goto exit; 6082 } 6083 if (values == NULL) { 6084 char * _valuesBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 6085 values = (GLfloat *) (_valuesBase + _bufferOffset); 6086 } 6087 glVertexAttrib4fv( 6088 (GLuint)indx, 6089 (GLfloat *)values 6090 ); 6091 6092exit: 6093 if (_array) { 6094 _env->ReleaseFloatArrayElements(_array, (jfloat*)values, JNI_ABORT); 6095 } 6096 if (_exception) { 6097 jniThrowException(_env, _exceptionType, _exceptionMessage); 6098 } 6099} 6100 6101/* void glVertexAttribPointer ( GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLint offset ) */ 6102static void 6103android_glVertexAttribPointer__IIIZII 6104 (JNIEnv *_env, jobject _this, jint indx, jint size, jint type, jboolean normalized, jint stride, jint offset) { 6105 glVertexAttribPointer( 6106 (GLuint)indx, 6107 (GLint)size, 6108 (GLenum)type, 6109 (GLboolean)normalized, 6110 (GLsizei)stride, 6111 reinterpret_cast<GLvoid *>(offset) 6112 ); 6113} 6114 6115/* void glVertexAttribPointer ( GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *ptr ) */ 6116static void 6117android_glVertexAttribPointerBounds__IIIZILjava_nio_Buffer_2I 6118 (JNIEnv *_env, jobject _this, jint indx, jint size, jint type, jboolean normalized, jint stride, jobject ptr_buf, jint remaining) { 6119 jarray _array = (jarray) 0; 6120 jint _bufferOffset = (jint) 0; 6121 jint _remaining; 6122 GLvoid *ptr = (GLvoid *) 0; 6123 6124 if (ptr_buf) { 6125 ptr = (GLvoid *) getDirectBufferPointer(_env, ptr_buf); 6126 if ( ! ptr ) { 6127 return; 6128 } 6129 } 6130 glVertexAttribPointerBounds( 6131 (GLuint)indx, 6132 (GLint)size, 6133 (GLenum)type, 6134 (GLboolean)normalized, 6135 (GLsizei)stride, 6136 (GLvoid *)ptr, 6137 (GLsizei)remaining 6138 ); 6139} 6140 6141/* void glViewport ( GLint x, GLint y, GLsizei width, GLsizei height ) */ 6142static void 6143android_glViewport__IIII 6144 (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height) { 6145 glViewport( 6146 (GLint)x, 6147 (GLint)y, 6148 (GLsizei)width, 6149 (GLsizei)height 6150 ); 6151} 6152 6153static const char *classPathName = "android/opengl/GLES20"; 6154 6155static JNINativeMethod methods[] = { 6156{"_nativeClassInit", "()V", (void*)nativeClassInit }, 6157{"glActiveTexture", "(I)V", (void *) android_glActiveTexture__I }, 6158{"glAttachShader", "(II)V", (void *) android_glAttachShader__II }, 6159{"glBindAttribLocation", "(IILjava/lang/String;)V", (void *) android_glBindAttribLocation__IILjava_lang_String_2 }, 6160{"glBindBuffer", "(II)V", (void *) android_glBindBuffer__II }, 6161{"glBindFramebuffer", "(II)V", (void *) android_glBindFramebuffer__II }, 6162{"glBindRenderbuffer", "(II)V", (void *) android_glBindRenderbuffer__II }, 6163{"glBindTexture", "(II)V", (void *) android_glBindTexture__II }, 6164{"glBlendColor", "(FFFF)V", (void *) android_glBlendColor__FFFF }, 6165{"glBlendEquation", "(I)V", (void *) android_glBlendEquation__I }, 6166{"glBlendEquationSeparate", "(II)V", (void *) android_glBlendEquationSeparate__II }, 6167{"glBlendFunc", "(II)V", (void *) android_glBlendFunc__II }, 6168{"glBlendFuncSeparate", "(IIII)V", (void *) android_glBlendFuncSeparate__IIII }, 6169{"glBufferData", "(IILjava/nio/Buffer;I)V", (void *) android_glBufferData__IILjava_nio_Buffer_2I }, 6170{"glBufferSubData", "(IIILjava/nio/Buffer;)V", (void *) android_glBufferSubData__IIILjava_nio_Buffer_2 }, 6171{"glCheckFramebufferStatus", "(I)I", (void *) android_glCheckFramebufferStatus__I }, 6172{"glClear", "(I)V", (void *) android_glClear__I }, 6173{"glClearColor", "(FFFF)V", (void *) android_glClearColor__FFFF }, 6174{"glClearDepthf", "(F)V", (void *) android_glClearDepthf__F }, 6175{"glClearStencil", "(I)V", (void *) android_glClearStencil__I }, 6176{"glColorMask", "(ZZZZ)V", (void *) android_glColorMask__ZZZZ }, 6177{"glCompileShader", "(I)V", (void *) android_glCompileShader__I }, 6178{"glCompressedTexImage2D", "(IIIIIIILjava/nio/Buffer;)V", (void *) android_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2 }, 6179{"glCompressedTexSubImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 }, 6180{"glCopyTexImage2D", "(IIIIIIII)V", (void *) android_glCopyTexImage2D__IIIIIIII }, 6181{"glCopyTexSubImage2D", "(IIIIIIII)V", (void *) android_glCopyTexSubImage2D__IIIIIIII }, 6182{"glCreateProgram", "()I", (void *) android_glCreateProgram__ }, 6183{"glCreateShader", "(I)I", (void *) android_glCreateShader__I }, 6184{"glCullFace", "(I)V", (void *) android_glCullFace__I }, 6185{"glDeleteBuffers", "(I[II)V", (void *) android_glDeleteBuffers__I_3II }, 6186{"glDeleteBuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteBuffers__ILjava_nio_IntBuffer_2 }, 6187{"glDeleteFramebuffers", "(I[II)V", (void *) android_glDeleteFramebuffers__I_3II }, 6188{"glDeleteFramebuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteFramebuffers__ILjava_nio_IntBuffer_2 }, 6189{"glDeleteProgram", "(I)V", (void *) android_glDeleteProgram__I }, 6190{"glDeleteRenderbuffers", "(I[II)V", (void *) android_glDeleteRenderbuffers__I_3II }, 6191{"glDeleteRenderbuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteRenderbuffers__ILjava_nio_IntBuffer_2 }, 6192{"glDeleteShader", "(I)V", (void *) android_glDeleteShader__I }, 6193{"glDeleteTextures", "(I[II)V", (void *) android_glDeleteTextures__I_3II }, 6194{"glDeleteTextures", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteTextures__ILjava_nio_IntBuffer_2 }, 6195{"glDepthFunc", "(I)V", (void *) android_glDepthFunc__I }, 6196{"glDepthMask", "(Z)V", (void *) android_glDepthMask__Z }, 6197{"glDepthRangef", "(FF)V", (void *) android_glDepthRangef__FF }, 6198{"glDetachShader", "(II)V", (void *) android_glDetachShader__II }, 6199{"glDisable", "(I)V", (void *) android_glDisable__I }, 6200{"glDisableVertexAttribArray", "(I)V", (void *) android_glDisableVertexAttribArray__I }, 6201{"glDrawArrays", "(III)V", (void *) android_glDrawArrays__III }, 6202{"glDrawElements", "(IIII)V", (void *) android_glDrawElements__IIII }, 6203{"glDrawElements", "(IIILjava/nio/Buffer;)V", (void *) android_glDrawElements__IIILjava_nio_Buffer_2 }, 6204{"glEnable", "(I)V", (void *) android_glEnable__I }, 6205{"glEnableVertexAttribArray", "(I)V", (void *) android_glEnableVertexAttribArray__I }, 6206{"glFinish", "()V", (void *) android_glFinish__ }, 6207{"glFlush", "()V", (void *) android_glFlush__ }, 6208{"glFramebufferRenderbuffer", "(IIII)V", (void *) android_glFramebufferRenderbuffer__IIII }, 6209{"glFramebufferTexture2D", "(IIIII)V", (void *) android_glFramebufferTexture2D__IIIII }, 6210{"glFrontFace", "(I)V", (void *) android_glFrontFace__I }, 6211{"glGenBuffers", "(I[II)V", (void *) android_glGenBuffers__I_3II }, 6212{"glGenBuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenBuffers__ILjava_nio_IntBuffer_2 }, 6213{"glGenerateMipmap", "(I)V", (void *) android_glGenerateMipmap__I }, 6214{"glGenFramebuffers", "(I[II)V", (void *) android_glGenFramebuffers__I_3II }, 6215{"glGenFramebuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenFramebuffers__ILjava_nio_IntBuffer_2 }, 6216{"glGenRenderbuffers", "(I[II)V", (void *) android_glGenRenderbuffers__I_3II }, 6217{"glGenRenderbuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenRenderbuffers__ILjava_nio_IntBuffer_2 }, 6218{"glGenTextures", "(I[II)V", (void *) android_glGenTextures__I_3II }, 6219{"glGenTextures", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenTextures__ILjava_nio_IntBuffer_2 }, 6220{"glGetActiveAttrib", "(III[II[II[II[BI)V", (void *) android_glGetActiveAttrib__III_3II_3II_3II_3BI }, 6221{"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 }, 6222{"glGetActiveAttrib", "(II[II[II)Ljava/lang/String;", (void *) android_glGetActiveAttrib1 }, 6223{"glGetActiveAttrib", "(IILjava/nio/IntBuffer;Ljava/nio/IntBuffer;)Ljava/lang/String;", (void *) android_glGetActiveAttrib2 }, 6224{"glGetActiveUniform", "(III[II[II[II[BI)V", (void *) android_glGetActiveUniform__III_3II_3II_3II_3BI }, 6225{"glGetActiveUniform", "(II[II[II)Ljava/lang/String;", (void *) android_glGetActiveUniform1 }, 6226{"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 }, 6227{"glGetActiveUniform", "(IILjava/nio/IntBuffer;Ljava/nio/IntBuffer;)Ljava/lang/String;", (void *) android_glGetActiveUniform2 }, 6228{"glGetAttachedShaders", "(II[II[II)V", (void *) android_glGetAttachedShaders__II_3II_3II }, 6229{"glGetAttachedShaders", "(IILjava/nio/IntBuffer;Ljava/nio/IntBuffer;)V", (void *) android_glGetAttachedShaders__IILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 }, 6230{"glGetAttribLocation", "(ILjava/lang/String;)I", (void *) android_glGetAttribLocation__ILjava_lang_String_2 }, 6231{"glGetBooleanv", "(I[ZI)V", (void *) android_glGetBooleanv__I_3ZI }, 6232{"glGetBooleanv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetBooleanv__ILjava_nio_IntBuffer_2 }, 6233{"glGetBufferParameteriv", "(II[II)V", (void *) android_glGetBufferParameteriv__II_3II }, 6234{"glGetBufferParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetBufferParameteriv__IILjava_nio_IntBuffer_2 }, 6235{"glGetError", "()I", (void *) android_glGetError__ }, 6236{"glGetFloatv", "(I[FI)V", (void *) android_glGetFloatv__I_3FI }, 6237{"glGetFloatv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glGetFloatv__ILjava_nio_FloatBuffer_2 }, 6238{"glGetFramebufferAttachmentParameteriv", "(III[II)V", (void *) android_glGetFramebufferAttachmentParameteriv__III_3II }, 6239{"glGetFramebufferAttachmentParameteriv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetFramebufferAttachmentParameteriv__IIILjava_nio_IntBuffer_2 }, 6240{"glGetIntegerv", "(I[II)V", (void *) android_glGetIntegerv__I_3II }, 6241{"glGetIntegerv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetIntegerv__ILjava_nio_IntBuffer_2 }, 6242{"glGetProgramiv", "(II[II)V", (void *) android_glGetProgramiv__II_3II }, 6243{"glGetProgramiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetProgramiv__IILjava_nio_IntBuffer_2 }, 6244{"glGetProgramInfoLog", "(I)Ljava/lang/String;", (void *) android_glGetProgramInfoLog }, 6245{"glGetRenderbufferParameteriv", "(II[II)V", (void *) android_glGetRenderbufferParameteriv__II_3II }, 6246{"glGetRenderbufferParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetRenderbufferParameteriv__IILjava_nio_IntBuffer_2 }, 6247{"glGetShaderiv", "(II[II)V", (void *) android_glGetShaderiv__II_3II }, 6248{"glGetShaderiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetShaderiv__IILjava_nio_IntBuffer_2 }, 6249{"glGetShaderInfoLog", "(I)Ljava/lang/String;", (void *) android_glGetShaderInfoLog }, 6250{"glGetShaderPrecisionFormat", "(II[II[II)V", (void *) android_glGetShaderPrecisionFormat__II_3II_3II }, 6251{"glGetShaderPrecisionFormat", "(IILjava/nio/IntBuffer;Ljava/nio/IntBuffer;)V", (void *) android_glGetShaderPrecisionFormat__IILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 }, 6252{"glGetShaderSource", "(II[II[BI)V", (void *) android_glGetShaderSource__II_3II_3BI }, 6253{"glGetShaderSource", "(IILjava/nio/IntBuffer;B)V", (void *) android_glGetShaderSource__IILjava_nio_IntBuffer_2B }, 6254{"glGetShaderSource", "(I)Ljava/lang/String;", (void *) android_glGetShaderSource }, 6255{"glGetString", "(I)Ljava/lang/String;", (void *) android_glGetString }, 6256{"glGetTexParameterfv", "(II[FI)V", (void *) android_glGetTexParameterfv__II_3FI }, 6257{"glGetTexParameterfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetTexParameterfv__IILjava_nio_FloatBuffer_2 }, 6258{"glGetTexParameteriv", "(II[II)V", (void *) android_glGetTexParameteriv__II_3II }, 6259{"glGetTexParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameteriv__IILjava_nio_IntBuffer_2 }, 6260{"glGetUniformfv", "(II[FI)V", (void *) android_glGetUniformfv__II_3FI }, 6261{"glGetUniformfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetUniformfv__IILjava_nio_FloatBuffer_2 }, 6262{"glGetUniformiv", "(II[II)V", (void *) android_glGetUniformiv__II_3II }, 6263{"glGetUniformiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetUniformiv__IILjava_nio_IntBuffer_2 }, 6264{"glGetUniformLocation", "(ILjava/lang/String;)I", (void *) android_glGetUniformLocation__ILjava_lang_String_2 }, 6265{"glGetVertexAttribfv", "(II[FI)V", (void *) android_glGetVertexAttribfv__II_3FI }, 6266{"glGetVertexAttribfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetVertexAttribfv__IILjava_nio_FloatBuffer_2 }, 6267{"glGetVertexAttribiv", "(II[II)V", (void *) android_glGetVertexAttribiv__II_3II }, 6268{"glGetVertexAttribiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetVertexAttribiv__IILjava_nio_IntBuffer_2 }, 6269{"glHint", "(II)V", (void *) android_glHint__II }, 6270{"glIsBuffer", "(I)Z", (void *) android_glIsBuffer__I }, 6271{"glIsEnabled", "(I)Z", (void *) android_glIsEnabled__I }, 6272{"glIsFramebuffer", "(I)Z", (void *) android_glIsFramebuffer__I }, 6273{"glIsProgram", "(I)Z", (void *) android_glIsProgram__I }, 6274{"glIsRenderbuffer", "(I)Z", (void *) android_glIsRenderbuffer__I }, 6275{"glIsShader", "(I)Z", (void *) android_glIsShader__I }, 6276{"glIsTexture", "(I)Z", (void *) android_glIsTexture__I }, 6277{"glLineWidth", "(F)V", (void *) android_glLineWidth__F }, 6278{"glLinkProgram", "(I)V", (void *) android_glLinkProgram__I }, 6279{"glPixelStorei", "(II)V", (void *) android_glPixelStorei__II }, 6280{"glPolygonOffset", "(FF)V", (void *) android_glPolygonOffset__FF }, 6281{"glReadPixels", "(IIIIIILjava/nio/Buffer;)V", (void *) android_glReadPixels__IIIIIILjava_nio_Buffer_2 }, 6282{"glReleaseShaderCompiler", "()V", (void *) android_glReleaseShaderCompiler__ }, 6283{"glRenderbufferStorage", "(IIII)V", (void *) android_glRenderbufferStorage__IIII }, 6284{"glSampleCoverage", "(FZ)V", (void *) android_glSampleCoverage__FZ }, 6285{"glScissor", "(IIII)V", (void *) android_glScissor__IIII }, 6286{"glShaderBinary", "(I[IIILjava/nio/Buffer;I)V", (void *) android_glShaderBinary__I_3IIILjava_nio_Buffer_2I }, 6287{"glShaderBinary", "(ILjava/nio/IntBuffer;ILjava/nio/Buffer;I)V", (void *) android_glShaderBinary__ILjava_nio_IntBuffer_2ILjava_nio_Buffer_2I }, 6288{"glShaderSource", "(ILjava/lang/String;)V", (void *) android_glShaderSource }, 6289{"glStencilFunc", "(III)V", (void *) android_glStencilFunc__III }, 6290{"glStencilFuncSeparate", "(IIII)V", (void *) android_glStencilFuncSeparate__IIII }, 6291{"glStencilMask", "(I)V", (void *) android_glStencilMask__I }, 6292{"glStencilMaskSeparate", "(II)V", (void *) android_glStencilMaskSeparate__II }, 6293{"glStencilOp", "(III)V", (void *) android_glStencilOp__III }, 6294{"glStencilOpSeparate", "(IIII)V", (void *) android_glStencilOpSeparate__IIII }, 6295{"glTexImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2 }, 6296{"glTexParameterf", "(IIF)V", (void *) android_glTexParameterf__IIF }, 6297{"glTexParameterfv", "(II[FI)V", (void *) android_glTexParameterfv__II_3FI }, 6298{"glTexParameterfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexParameterfv__IILjava_nio_FloatBuffer_2 }, 6299{"glTexParameteri", "(III)V", (void *) android_glTexParameteri__III }, 6300{"glTexParameteriv", "(II[II)V", (void *) android_glTexParameteriv__II_3II }, 6301{"glTexParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameteriv__IILjava_nio_IntBuffer_2 }, 6302{"glTexSubImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 }, 6303{"glUniform1f", "(IF)V", (void *) android_glUniform1f__IF }, 6304{"glUniform1fv", "(II[FI)V", (void *) android_glUniform1fv__II_3FI }, 6305{"glUniform1fv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glUniform1fv__IILjava_nio_FloatBuffer_2 }, 6306{"glUniform1i", "(II)V", (void *) android_glUniform1i__II }, 6307{"glUniform1iv", "(II[II)V", (void *) android_glUniform1iv__II_3II }, 6308{"glUniform1iv", "(IILjava/nio/IntBuffer;)V", (void *) android_glUniform1iv__IILjava_nio_IntBuffer_2 }, 6309{"glUniform2f", "(IFF)V", (void *) android_glUniform2f__IFF }, 6310{"glUniform2fv", "(II[FI)V", (void *) android_glUniform2fv__II_3FI }, 6311{"glUniform2fv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glUniform2fv__IILjava_nio_FloatBuffer_2 }, 6312{"glUniform2i", "(III)V", (void *) android_glUniform2i__III }, 6313{"glUniform2iv", "(II[II)V", (void *) android_glUniform2iv__II_3II }, 6314{"glUniform2iv", "(IILjava/nio/IntBuffer;)V", (void *) android_glUniform2iv__IILjava_nio_IntBuffer_2 }, 6315{"glUniform3f", "(IFFF)V", (void *) android_glUniform3f__IFFF }, 6316{"glUniform3fv", "(II[FI)V", (void *) android_glUniform3fv__II_3FI }, 6317{"glUniform3fv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glUniform3fv__IILjava_nio_FloatBuffer_2 }, 6318{"glUniform3i", "(IIII)V", (void *) android_glUniform3i__IIII }, 6319{"glUniform3iv", "(II[II)V", (void *) android_glUniform3iv__II_3II }, 6320{"glUniform3iv", "(IILjava/nio/IntBuffer;)V", (void *) android_glUniform3iv__IILjava_nio_IntBuffer_2 }, 6321{"glUniform4f", "(IFFFF)V", (void *) android_glUniform4f__IFFFF }, 6322{"glUniform4fv", "(II[FI)V", (void *) android_glUniform4fv__II_3FI }, 6323{"glUniform4fv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glUniform4fv__IILjava_nio_FloatBuffer_2 }, 6324{"glUniform4i", "(IIIII)V", (void *) android_glUniform4i__IIIII }, 6325{"glUniform4iv", "(II[II)V", (void *) android_glUniform4iv__II_3II }, 6326{"glUniform4iv", "(IILjava/nio/IntBuffer;)V", (void *) android_glUniform4iv__IILjava_nio_IntBuffer_2 }, 6327{"glUniformMatrix2fv", "(IIZ[FI)V", (void *) android_glUniformMatrix2fv__IIZ_3FI }, 6328{"glUniformMatrix2fv", "(IIZLjava/nio/FloatBuffer;)V", (void *) android_glUniformMatrix2fv__IIZLjava_nio_FloatBuffer_2 }, 6329{"glUniformMatrix3fv", "(IIZ[FI)V", (void *) android_glUniformMatrix3fv__IIZ_3FI }, 6330{"glUniformMatrix3fv", "(IIZLjava/nio/FloatBuffer;)V", (void *) android_glUniformMatrix3fv__IIZLjava_nio_FloatBuffer_2 }, 6331{"glUniformMatrix4fv", "(IIZ[FI)V", (void *) android_glUniformMatrix4fv__IIZ_3FI }, 6332{"glUniformMatrix4fv", "(IIZLjava/nio/FloatBuffer;)V", (void *) android_glUniformMatrix4fv__IIZLjava_nio_FloatBuffer_2 }, 6333{"glUseProgram", "(I)V", (void *) android_glUseProgram__I }, 6334{"glValidateProgram", "(I)V", (void *) android_glValidateProgram__I }, 6335{"glVertexAttrib1f", "(IF)V", (void *) android_glVertexAttrib1f__IF }, 6336{"glVertexAttrib1fv", "(I[FI)V", (void *) android_glVertexAttrib1fv__I_3FI }, 6337{"glVertexAttrib1fv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glVertexAttrib1fv__ILjava_nio_FloatBuffer_2 }, 6338{"glVertexAttrib2f", "(IFF)V", (void *) android_glVertexAttrib2f__IFF }, 6339{"glVertexAttrib2fv", "(I[FI)V", (void *) android_glVertexAttrib2fv__I_3FI }, 6340{"glVertexAttrib2fv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glVertexAttrib2fv__ILjava_nio_FloatBuffer_2 }, 6341{"glVertexAttrib3f", "(IFFF)V", (void *) android_glVertexAttrib3f__IFFF }, 6342{"glVertexAttrib3fv", "(I[FI)V", (void *) android_glVertexAttrib3fv__I_3FI }, 6343{"glVertexAttrib3fv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glVertexAttrib3fv__ILjava_nio_FloatBuffer_2 }, 6344{"glVertexAttrib4f", "(IFFFF)V", (void *) android_glVertexAttrib4f__IFFFF }, 6345{"glVertexAttrib4fv", "(I[FI)V", (void *) android_glVertexAttrib4fv__I_3FI }, 6346{"glVertexAttrib4fv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glVertexAttrib4fv__ILjava_nio_FloatBuffer_2 }, 6347{"glVertexAttribPointer", "(IIIZII)V", (void *) android_glVertexAttribPointer__IIIZII }, 6348{"glVertexAttribPointerBounds", "(IIIZILjava/nio/Buffer;I)V", (void *) android_glVertexAttribPointerBounds__IIIZILjava_nio_Buffer_2I }, 6349{"glViewport", "(IIII)V", (void *) android_glViewport__IIII }, 6350}; 6351 6352int register_android_opengl_jni_GLES20(JNIEnv *_env) 6353{ 6354 int err; 6355 err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods)); 6356 return err; 6357} 6358