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