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