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