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