1/* 2 * Copyright 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17// This source file is automatically generated 18 19#pragma GCC diagnostic ignored "-Wunused-variable" 20#pragma GCC diagnostic ignored "-Wunused-but-set-variable" 21#pragma GCC diagnostic ignored "-Wunused-function" 22 23#include <stdint.h> 24#include <GLES3/gl31.h> 25#include <jni.h> 26#include <JNIHelp.h> 27#include <android_runtime/AndroidRuntime.h> 28#include <utils/misc.h> 29#include <assert.h> 30 31static int initialized = 0; 32 33static jclass nioAccessClass; 34static jclass bufferClass; 35static jmethodID getBasePointerID; 36static jmethodID getBaseArrayID; 37static jmethodID getBaseArrayOffsetID; 38static jfieldID positionID; 39static jfieldID limitID; 40static jfieldID elementSizeShiftID; 41 42 43/* special calls implemented in Android's GLES wrapper used to more 44 * efficiently bound-check passed arrays */ 45extern "C" { 46#ifdef GL_VERSION_ES_CM_1_1 47GL_API void GL_APIENTRY glColorPointerBounds(GLint size, GLenum type, GLsizei stride, 48 const GLvoid *ptr, GLsizei count); 49GL_API void GL_APIENTRY glNormalPointerBounds(GLenum type, GLsizei stride, 50 const GLvoid *pointer, GLsizei count); 51GL_API void GL_APIENTRY glTexCoordPointerBounds(GLint size, GLenum type, 52 GLsizei stride, const GLvoid *pointer, GLsizei count); 53GL_API void GL_APIENTRY glVertexPointerBounds(GLint size, GLenum type, 54 GLsizei stride, const GLvoid *pointer, GLsizei count); 55GL_API void GL_APIENTRY glPointSizePointerOESBounds(GLenum type, 56 GLsizei stride, const GLvoid *pointer, GLsizei count); 57GL_API void GL_APIENTRY glMatrixIndexPointerOESBounds(GLint size, GLenum type, 58 GLsizei stride, const GLvoid *pointer, GLsizei count); 59GL_API void GL_APIENTRY glWeightPointerOESBounds(GLint size, GLenum type, 60 GLsizei stride, const GLvoid *pointer, GLsizei count); 61#endif 62#ifdef GL_ES_VERSION_2_0 63static void glVertexAttribPointerBounds(GLuint indx, GLint size, GLenum type, 64 GLboolean normalized, GLsizei stride, const GLvoid *pointer, GLsizei count) { 65 glVertexAttribPointer(indx, size, type, normalized, stride, pointer); 66} 67#endif 68#ifdef GL_ES_VERSION_3_0 69static void glVertexAttribIPointerBounds(GLuint indx, GLint size, GLenum type, 70 GLsizei stride, const GLvoid *pointer, GLsizei count) { 71 glVertexAttribIPointer(indx, size, type, stride, pointer); 72} 73#endif 74} 75 76/* Cache method IDs each time the class is loaded. */ 77 78static void 79nativeClassInit(JNIEnv *_env, jclass glImplClass) 80{ 81 jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess"); 82 nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal); 83 84 jclass bufferClassLocal = _env->FindClass("java/nio/Buffer"); 85 bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal); 86 87 getBasePointerID = _env->GetStaticMethodID(nioAccessClass, 88 "getBasePointer", "(Ljava/nio/Buffer;)J"); 89 getBaseArrayID = _env->GetStaticMethodID(nioAccessClass, 90 "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;"); 91 getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass, 92 "getBaseArrayOffset", "(Ljava/nio/Buffer;)I"); 93 94 positionID = _env->GetFieldID(bufferClass, "position", "I"); 95 limitID = _env->GetFieldID(bufferClass, "limit", "I"); 96 elementSizeShiftID = 97 _env->GetFieldID(bufferClass, "_elementSizeShift", "I"); 98} 99 100static void * 101getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining, jint *offset) 102{ 103 jint position; 104 jint limit; 105 jint elementSizeShift; 106 jlong pointer; 107 108 position = _env->GetIntField(buffer, positionID); 109 limit = _env->GetIntField(buffer, limitID); 110 elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID); 111 *remaining = (limit - position) << elementSizeShift; 112 pointer = _env->CallStaticLongMethod(nioAccessClass, 113 getBasePointerID, buffer); 114 if (pointer != 0L) { 115 *array = NULL; 116 return reinterpret_cast<void*>(pointer); 117 } 118 119 *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass, 120 getBaseArrayID, buffer); 121 *offset = _env->CallStaticIntMethod(nioAccessClass, 122 getBaseArrayOffsetID, buffer); 123 124 return NULL; 125} 126 127class ByteArrayGetter { 128public: 129 static void* Get(JNIEnv* _env, jbyteArray array, jboolean* is_copy) { 130 return _env->GetByteArrayElements(array, is_copy); 131 } 132}; 133class BooleanArrayGetter { 134public: 135 static void* Get(JNIEnv* _env, jbooleanArray array, jboolean* is_copy) { 136 return _env->GetBooleanArrayElements(array, is_copy); 137 } 138}; 139class CharArrayGetter { 140public: 141 static void* Get(JNIEnv* _env, jcharArray array, jboolean* is_copy) { 142 return _env->GetCharArrayElements(array, is_copy); 143 } 144}; 145class ShortArrayGetter { 146public: 147 static void* Get(JNIEnv* _env, jshortArray array, jboolean* is_copy) { 148 return _env->GetShortArrayElements(array, is_copy); 149 } 150}; 151class IntArrayGetter { 152public: 153 static void* Get(JNIEnv* _env, jintArray array, jboolean* is_copy) { 154 return _env->GetIntArrayElements(array, is_copy); 155 } 156}; 157class LongArrayGetter { 158public: 159 static void* Get(JNIEnv* _env, jlongArray array, jboolean* is_copy) { 160 return _env->GetLongArrayElements(array, is_copy); 161 } 162}; 163class FloatArrayGetter { 164public: 165 static void* Get(JNIEnv* _env, jfloatArray array, jboolean* is_copy) { 166 return _env->GetFloatArrayElements(array, is_copy); 167 } 168}; 169class DoubleArrayGetter { 170public: 171 static void* Get(JNIEnv* _env, jdoubleArray array, jboolean* is_copy) { 172 return _env->GetDoubleArrayElements(array, is_copy); 173 } 174}; 175 176template<typename JTYPEARRAY, typename ARRAYGETTER> 177static void* 178getArrayPointer(JNIEnv *_env, JTYPEARRAY array, jboolean* is_copy) { 179 return ARRAYGETTER::Get(_env, array, is_copy); 180} 181 182class ByteArrayReleaser { 183public: 184 static void Release(JNIEnv* _env, jbyteArray array, jbyte* data, jboolean commit) { 185 _env->ReleaseByteArrayElements(array, data, commit ? 0 : JNI_ABORT); 186 } 187}; 188class BooleanArrayReleaser { 189public: 190 static void Release(JNIEnv* _env, jbooleanArray array, jboolean* data, jboolean commit) { 191 _env->ReleaseBooleanArrayElements(array, data, commit ? 0 : JNI_ABORT); 192 } 193}; 194class CharArrayReleaser { 195public: 196 static void Release(JNIEnv* _env, jcharArray array, jchar* data, jboolean commit) { 197 _env->ReleaseCharArrayElements(array, data, commit ? 0 : JNI_ABORT); 198 } 199}; 200class ShortArrayReleaser { 201public: 202 static void Release(JNIEnv* _env, jshortArray array, jshort* data, jboolean commit) { 203 _env->ReleaseShortArrayElements(array, data, commit ? 0 : JNI_ABORT); 204 } 205}; 206class IntArrayReleaser { 207public: 208 static void Release(JNIEnv* _env, jintArray array, jint* data, jboolean commit) { 209 _env->ReleaseIntArrayElements(array, data, commit ? 0 : JNI_ABORT); 210 } 211}; 212class LongArrayReleaser { 213public: 214 static void Release(JNIEnv* _env, jlongArray array, jlong* data, jboolean commit) { 215 _env->ReleaseLongArrayElements(array, data, commit ? 0 : JNI_ABORT); 216 } 217}; 218class FloatArrayReleaser { 219public: 220 static void Release(JNIEnv* _env, jfloatArray array, jfloat* data, jboolean commit) { 221 _env->ReleaseFloatArrayElements(array, data, commit ? 0 : JNI_ABORT); 222 } 223}; 224class DoubleArrayReleaser { 225public: 226 static void Release(JNIEnv* _env, jdoubleArray array, jdouble* data, jboolean commit) { 227 _env->ReleaseDoubleArrayElements(array, data, commit ? 0 : JNI_ABORT); 228 } 229}; 230 231template<typename JTYPEARRAY, typename NTYPEARRAY, typename ARRAYRELEASER> 232static void 233releaseArrayPointer(JNIEnv *_env, JTYPEARRAY array, NTYPEARRAY data, jboolean commit) { 234 ARRAYRELEASER::Release(_env, array, data, commit); 235} 236 237static void 238releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit) 239{ 240 _env->ReleasePrimitiveArrayCritical(array, data, 241 commit ? 0 : JNI_ABORT); 242} 243 244static void * 245getDirectBufferPointer(JNIEnv *_env, jobject buffer) { 246 char* buf = (char*) _env->GetDirectBufferAddress(buffer); 247 if (buf) { 248 jint position = _env->GetIntField(buffer, positionID); 249 jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID); 250 buf += position << elementSizeShift; 251 } else { 252 jniThrowException(_env, "java/lang/IllegalArgumentException", 253 "Must use a native order direct Buffer"); 254 } 255 return (void*) buf; 256} 257 258// -------------------------------------------------------------------------- 259 260/* 261 * returns the number of values glGet returns for a given pname. 262 * 263 * The code below is written such that pnames requiring only one values 264 * are the default (and are not explicitely tested for). This makes the 265 * checking code much shorter/readable/efficient. 266 * 267 * This means that unknown pnames (e.g.: extensions) will default to 1. If 268 * that unknown pname needs more than 1 value, then the validation check 269 * is incomplete and the app may crash if it passed the wrong number params. 270 */ 271static int getNeededCount(GLint pname) { 272 int needed = 1; 273#ifdef GL_ES_VERSION_2_0 274 // GLES 2.x pnames 275 switch (pname) { 276 case GL_ALIASED_LINE_WIDTH_RANGE: 277 case GL_ALIASED_POINT_SIZE_RANGE: 278 needed = 2; 279 break; 280 281 case GL_BLEND_COLOR: 282 case GL_COLOR_CLEAR_VALUE: 283 case GL_COLOR_WRITEMASK: 284 case GL_SCISSOR_BOX: 285 case GL_VIEWPORT: 286 needed = 4; 287 break; 288 289 case GL_COMPRESSED_TEXTURE_FORMATS: 290 glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed); 291 break; 292 293 case GL_SHADER_BINARY_FORMATS: 294 glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &needed); 295 break; 296 } 297#endif 298 299#ifdef GL_VERSION_ES_CM_1_1 300 // GLES 1.x pnames 301 switch (pname) { 302 case GL_ALIASED_LINE_WIDTH_RANGE: 303 case GL_ALIASED_POINT_SIZE_RANGE: 304 case GL_DEPTH_RANGE: 305 case GL_SMOOTH_LINE_WIDTH_RANGE: 306 case GL_SMOOTH_POINT_SIZE_RANGE: 307 needed = 2; 308 break; 309 310 case GL_CURRENT_NORMAL: 311 case GL_POINT_DISTANCE_ATTENUATION: 312 needed = 3; 313 break; 314 315 case GL_COLOR_CLEAR_VALUE: 316 case GL_COLOR_WRITEMASK: 317 case GL_CURRENT_COLOR: 318 case GL_CURRENT_TEXTURE_COORDS: 319 case GL_FOG_COLOR: 320 case GL_LIGHT_MODEL_AMBIENT: 321 case GL_SCISSOR_BOX: 322 case GL_VIEWPORT: 323 needed = 4; 324 break; 325 326 case GL_MODELVIEW_MATRIX: 327 case GL_PROJECTION_MATRIX: 328 case GL_TEXTURE_MATRIX: 329 needed = 16; 330 break; 331 332 case GL_COMPRESSED_TEXTURE_FORMATS: 333 glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed); 334 break; 335 } 336#endif 337 return needed; 338} 339 340template <typename JTYPEARRAY, typename ARRAYGETTER, typename NTYPEARRAY, 341 typename ARRAYRELEASER, typename CTYPE, void GET(GLenum, CTYPE*)> 342static void 343get 344 (JNIEnv *_env, jobject _this, jint pname, JTYPEARRAY params_ref, jint offset) { 345 jint _exception = 0; 346 const char * _exceptionType; 347 const char * _exceptionMessage; 348 CTYPE *params_base = (CTYPE *) 0; 349 jint _remaining; 350 CTYPE *params = (CTYPE *) 0; 351 int _needed = 0; 352 353 if (!params_ref) { 354 _exception = 1; 355 _exceptionType = "java/lang/IllegalArgumentException"; 356 _exceptionMessage = "params == null"; 357 goto exit; 358 } 359 if (offset < 0) { 360 _exception = 1; 361 _exceptionType = "java/lang/IllegalArgumentException"; 362 _exceptionMessage = "offset < 0"; 363 goto exit; 364 } 365 _remaining = _env->GetArrayLength(params_ref) - offset; 366 _needed = getNeededCount(pname); 367 // if we didn't find this pname, we just assume the user passed 368 // an array of the right size -- this might happen with extensions 369 // or if we forget an enum here. 370 if (_remaining < _needed) { 371 _exception = 1; 372 _exceptionType = "java/lang/IllegalArgumentException"; 373 _exceptionMessage = "length - offset < needed"; 374 goto exit; 375 } 376 params_base = (CTYPE *) getArrayPointer<JTYPEARRAY, ARRAYGETTER>( 377 _env, params_ref, (jboolean *)0); 378 params = params_base + offset; 379 380 GET( 381 (GLenum)pname, 382 (CTYPE *)params 383 ); 384 385exit: 386 if (params_base) { 387 releaseArrayPointer<JTYPEARRAY, NTYPEARRAY, ARRAYRELEASER>( 388 _env, params_ref, params_base, !_exception); 389 } 390 if (_exception) { 391 jniThrowException(_env, _exceptionType, _exceptionMessage); 392 } 393} 394 395 396template <typename CTYPE, typename JTYPEARRAY, typename ARRAYGETTER, typename NTYPEARRAY, 397 typename ARRAYRELEASER, void GET(GLenum, CTYPE*)> 398static void 399getarray 400 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { 401 jint _exception = 0; 402 const char * _exceptionType; 403 const char * _exceptionMessage; 404 JTYPEARRAY _array = (JTYPEARRAY) 0; 405 jint _bufferOffset = (jint) 0; 406 jint _remaining; 407 CTYPE *params = (CTYPE *) 0; 408 int _needed = 0; 409 410 params = (CTYPE *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 411 _remaining /= sizeof(CTYPE); // convert from bytes to item count 412 _needed = getNeededCount(pname); 413 // if we didn't find this pname, we just assume the user passed 414 // an array of the right size -- this might happen with extensions 415 // or if we forget an enum here. 416 if (_needed>0 && _remaining < _needed) { 417 _exception = 1; 418 _exceptionType = "java/lang/IllegalArgumentException"; 419 _exceptionMessage = "remaining() < needed"; 420 goto exit; 421 } 422 if (params == NULL) { 423 char * _paramsBase = (char *) getArrayPointer<JTYPEARRAY, ARRAYGETTER>( 424 _env, _array, (jboolean *) 0); 425 params = (CTYPE *) (_paramsBase + _bufferOffset); 426 } 427 GET( 428 (GLenum)pname, 429 (CTYPE *)params 430 ); 431 432exit: 433 if (_array) { 434 releaseArrayPointer<JTYPEARRAY, NTYPEARRAY, ARRAYRELEASER>( 435 _env, _array, (NTYPEARRAY)params, _exception ? JNI_FALSE : JNI_TRUE); 436 } 437 if (_exception) { 438 jniThrowException(_env, _exceptionType, _exceptionMessage); 439 } 440} 441 442// -------------------------------------------------------------------------- 443/* void glDispatchCompute ( GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z ) */ 444static void 445android_glDispatchCompute__III 446 (JNIEnv *_env, jobject _this, jint num_groups_x, jint num_groups_y, jint num_groups_z) { 447 glDispatchCompute( 448 (GLuint)num_groups_x, 449 (GLuint)num_groups_y, 450 (GLuint)num_groups_z 451 ); 452} 453 454/* void glDispatchComputeIndirect ( GLintptr indirect ) */ 455static void android_glDispatchComputeIndirect(JNIEnv *_env, jobject, jlong indirect) { 456 // 'indirect' is a byte offset, not a pointer. GL checks for negative and too-large values. 457 // Here we only need to check for successful 64-bit to 32-bit conversion. 458 // - jlong is a int64_t (jni.h) 459 // - GLintptr is a long (khrplatform.h) 460 if (sizeof(GLintptr) != sizeof(jlong) && (indirect < LONG_MIN || indirect > LONG_MAX)) { 461 jniThrowException(_env, "java/lang/IllegalArgumentException", "indirect offset too large"); 462 return; 463 } 464 glDispatchComputeIndirect((GLintptr)indirect); 465} 466 467/* void glDrawArraysIndirect ( GLenum mode, const void *indirect ) */ 468static void android_glDrawArraysIndirect(JNIEnv *_env, jobject, int mode, jlong indirect) { 469 // In OpenGL ES, 'indirect' is a byte offset into a buffer, not a raw pointer. 470 // GL checks for too-large values. Here we only need to check for successful signed 64-bit 471 // to unsigned 32-bit conversion. 472 if (sizeof(void*) != sizeof(jlong) && indirect > static_cast<jlong>(UINT32_MAX)) { 473 jniThrowException(_env, "java/lang/IllegalArgumentException", "indirect offset too large"); 474 return; 475 } 476 glDrawArraysIndirect(mode, (const void*)indirect); 477} 478 479/* void glDrawElementsIndirect ( GLenum mode, GLenum type, const void *indirect ) */ 480static void android_glDrawElementsIndirect(JNIEnv *_env, jobject, jint mode, jint type, jlong indirect) { 481 // In OpenGL ES, 'indirect' is a byte offset into a buffer, not a raw pointer. 482 // GL checks for too-large values. Here we only need to check for successful signed 64-bit 483 // to unsigned 32-bit conversion. 484 if (sizeof(void*) != sizeof(jlong) && indirect > static_cast<jlong>(UINT32_MAX)) { 485 jniThrowException(_env, "java/lang/IllegalArgumentException", "indirect offset too large"); 486 return; 487 } 488 glDrawElementsIndirect(mode, type, (const void*)indirect); 489} 490 491/* void glFramebufferParameteri ( GLenum target, GLenum pname, GLint param ) */ 492static void 493android_glFramebufferParameteri__III 494 (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) { 495 glFramebufferParameteri( 496 (GLenum)target, 497 (GLenum)pname, 498 (GLint)param 499 ); 500} 501 502/* void glGetFramebufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 503static void 504android_glGetFramebufferParameteriv__II_3II 505 (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { 506 jint _exception = 0; 507 const char * _exceptionType = NULL; 508 const char * _exceptionMessage = NULL; 509 GLint *params_base = (GLint *) 0; 510 jint _remaining; 511 GLint *params = (GLint *) 0; 512 513 if (!params_ref) { 514 _exception = 1; 515 _exceptionType = "java/lang/IllegalArgumentException"; 516 _exceptionMessage = "params == null"; 517 goto exit; 518 } 519 if (offset < 0) { 520 _exception = 1; 521 _exceptionType = "java/lang/IllegalArgumentException"; 522 _exceptionMessage = "offset < 0"; 523 goto exit; 524 } 525 _remaining = _env->GetArrayLength(params_ref) - offset; 526 params_base = (GLint *) 527 _env->GetIntArrayElements(params_ref, (jboolean *)0); 528 params = params_base + offset; 529 530 glGetFramebufferParameteriv( 531 (GLenum)target, 532 (GLenum)pname, 533 (GLint *)params 534 ); 535 536exit: 537 if (params_base) { 538 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 539 _exception ? JNI_ABORT: 0); 540 } 541 if (_exception) { 542 jniThrowException(_env, _exceptionType, _exceptionMessage); 543 } 544} 545 546/* void glGetFramebufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */ 547static void 548android_glGetFramebufferParameteriv__IILjava_nio_IntBuffer_2 549 (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { 550 jintArray _array = (jintArray) 0; 551 jint _bufferOffset = (jint) 0; 552 jint _remaining; 553 GLint *params = (GLint *) 0; 554 555 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 556 if (params == NULL) { 557 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 558 params = (GLint *) (_paramsBase + _bufferOffset); 559 } 560 glGetFramebufferParameteriv( 561 (GLenum)target, 562 (GLenum)pname, 563 (GLint *)params 564 ); 565 if (_array) { 566 _env->ReleaseIntArrayElements(_array, (jint*)params, 0); 567 } 568} 569 570/* void glGetProgramInterfaceiv ( GLuint program, GLenum programInterface, GLenum pname, GLint *params ) */ 571static void 572android_glGetProgramInterfaceiv__III_3II 573 (JNIEnv *_env, jobject _this, jint program, jint programInterface, jint pname, jintArray params_ref, jint offset) { 574 jint _exception = 0; 575 const char * _exceptionType = NULL; 576 const char * _exceptionMessage = NULL; 577 GLint *params_base = (GLint *) 0; 578 jint _remaining; 579 GLint *params = (GLint *) 0; 580 581 if (!params_ref) { 582 _exception = 1; 583 _exceptionType = "java/lang/IllegalArgumentException"; 584 _exceptionMessage = "params == null"; 585 goto exit; 586 } 587 if (offset < 0) { 588 _exception = 1; 589 _exceptionType = "java/lang/IllegalArgumentException"; 590 _exceptionMessage = "offset < 0"; 591 goto exit; 592 } 593 _remaining = _env->GetArrayLength(params_ref) - offset; 594 params_base = (GLint *) 595 _env->GetIntArrayElements(params_ref, (jboolean *)0); 596 params = params_base + offset; 597 598 glGetProgramInterfaceiv( 599 (GLuint)program, 600 (GLenum)programInterface, 601 (GLenum)pname, 602 (GLint *)params 603 ); 604 605exit: 606 if (params_base) { 607 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 608 _exception ? JNI_ABORT: 0); 609 } 610 if (_exception) { 611 jniThrowException(_env, _exceptionType, _exceptionMessage); 612 } 613} 614 615/* void glGetProgramInterfaceiv ( GLuint program, GLenum programInterface, GLenum pname, GLint *params ) */ 616static void 617android_glGetProgramInterfaceiv__IIILjava_nio_IntBuffer_2 618 (JNIEnv *_env, jobject _this, jint program, jint programInterface, jint pname, jobject params_buf) { 619 jintArray _array = (jintArray) 0; 620 jint _bufferOffset = (jint) 0; 621 jint _remaining; 622 GLint *params = (GLint *) 0; 623 624 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 625 if (params == NULL) { 626 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 627 params = (GLint *) (_paramsBase + _bufferOffset); 628 } 629 glGetProgramInterfaceiv( 630 (GLuint)program, 631 (GLenum)programInterface, 632 (GLenum)pname, 633 (GLint *)params 634 ); 635 if (_array) { 636 _env->ReleaseIntArrayElements(_array, (jint*)params, 0); 637 } 638} 639 640/* GLuint glGetProgramResourceIndex ( GLuint program, GLenum programInterface, const GLchar *name ) */ 641static jint 642android_glGetProgramResourceIndex__IILjava_lang_String_2 643 (JNIEnv *_env, jobject _this, jint program, jint programInterface, jstring name) { 644 jint _exception = 0; 645 const char * _exceptionType = NULL; 646 const char * _exceptionMessage = NULL; 647 GLuint _returnValue = 0; 648 const char* _nativename = 0; 649 650 if (!name) { 651 _exception = 1; 652 _exceptionType = "java/lang/IllegalArgumentException"; 653 _exceptionMessage = "name == null"; 654 goto exit; 655 } 656 _nativename = _env->GetStringUTFChars(name, 0); 657 658 _returnValue = glGetProgramResourceIndex( 659 (GLuint)program, 660 (GLenum)programInterface, 661 (GLchar *)_nativename 662 ); 663 664exit: 665 if (_nativename) { 666 _env->ReleaseStringUTFChars(name, _nativename); 667 } 668 669 if (_exception) { 670 jniThrowException(_env, _exceptionType, _exceptionMessage); 671 } 672 return (jint)_returnValue; 673} 674 675/* void glGetProgramResourceName ( GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name ) */ 676static jstring 677android_glGetProgramResourceName 678 (JNIEnv *_env, jobject _this, jint program, jint programInterface, jint index) { 679 jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented"); 680 return NULL; 681} 682 683/* void glGetProgramResourceiv ( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params ) */ 684static void 685android_glGetProgramResourceiv__IIII_3III_3II_3II 686 (JNIEnv *_env, jobject _this, jint program, jint programInterface, jint index, jint propCount, jintArray props_ref, jint propsOffset, jint bufSize, jintArray length_ref, jint lengthOffset, jintArray params_ref, jint paramsOffset) { 687 jint _exception = 0; 688 const char * _exceptionType = NULL; 689 const char * _exceptionMessage = NULL; 690 GLenum *props_base = (GLenum *) 0; 691 jint _propsRemaining; 692 GLenum *props = (GLenum *) 0; 693 GLsizei *length_base = (GLsizei *) 0; 694 jint _lengthRemaining; 695 GLsizei *length = (GLsizei *) 0; 696 GLint *params_base = (GLint *) 0; 697 jint _paramsRemaining; 698 GLint *params = (GLint *) 0; 699 700 if (!props_ref) { 701 _exception = 1; 702 _exceptionType = "java/lang/IllegalArgumentException"; 703 _exceptionMessage = "props == null"; 704 goto exit; 705 } 706 if (propsOffset < 0) { 707 _exception = 1; 708 _exceptionType = "java/lang/IllegalArgumentException"; 709 _exceptionMessage = "propsOffset < 0"; 710 goto exit; 711 } 712 _propsRemaining = _env->GetArrayLength(props_ref) - propsOffset; 713 props_base = (GLenum *) 714 _env->GetIntArrayElements(props_ref, (jboolean *)0); 715 props = props_base + propsOffset; 716 717 if (length_ref) { 718 if (lengthOffset < 0) { 719 _exception = 1; 720 _exceptionType = "java/lang/IllegalArgumentException"; 721 _exceptionMessage = "lengthOffset < 0"; 722 goto exit; 723 } 724 _lengthRemaining = _env->GetArrayLength(length_ref) - lengthOffset; 725 length_base = (GLsizei *) 726 _env->GetIntArrayElements(length_ref, (jboolean *)0); 727 length = length_base + lengthOffset; 728 } 729 730 if (!params_ref) { 731 _exception = 1; 732 _exceptionType = "java/lang/IllegalArgumentException"; 733 _exceptionMessage = "params == null"; 734 goto exit; 735 } 736 if (paramsOffset < 0) { 737 _exception = 1; 738 _exceptionType = "java/lang/IllegalArgumentException"; 739 _exceptionMessage = "paramsOffset < 0"; 740 goto exit; 741 } 742 _paramsRemaining = _env->GetArrayLength(params_ref) - paramsOffset; 743 params_base = (GLint *) 744 _env->GetIntArrayElements(params_ref, (jboolean *)0); 745 params = params_base + paramsOffset; 746 747 glGetProgramResourceiv( 748 (GLuint)program, 749 (GLenum)programInterface, 750 (GLuint)index, 751 (GLsizei)propCount, 752 (GLenum *)props, 753 (GLsizei)bufSize, 754 (GLsizei *)length, 755 (GLint *)params 756 ); 757 758exit: 759 if (params_base) { 760 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 761 _exception ? JNI_ABORT: 0); 762 } 763 if (length_base) { 764 _env->ReleaseIntArrayElements(length_ref, (jint*)length_base, 765 _exception ? JNI_ABORT: 0); 766 } 767 if (props_base) { 768 _env->ReleaseIntArrayElements(props_ref, (jint*)props_base, 769 JNI_ABORT); 770 } 771 if (_exception) { 772 jniThrowException(_env, _exceptionType, _exceptionMessage); 773 } 774} 775 776/* void glGetProgramResourceiv ( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params ) */ 777static void 778android_glGetProgramResourceiv__IIIILjava_nio_IntBuffer_2ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 779 (JNIEnv *_env, jobject _this, jint program, jint programInterface, jint index, jint propCount, jobject props_buf, jint bufSize, jobject length_buf, jobject params_buf) { 780 jintArray _propsArray = (jintArray) 0; 781 jint _propsBufferOffset = (jint) 0; 782 jintArray _lengthArray = (jintArray) 0; 783 jint _lengthBufferOffset = (jint) 0; 784 jintArray _paramsArray = (jintArray) 0; 785 jint _paramsBufferOffset = (jint) 0; 786 jint _propsRemaining; 787 GLenum *props = (GLenum *) 0; 788 jint _lengthRemaining; 789 GLsizei *length = (GLsizei *) 0; 790 jint _paramsRemaining; 791 GLint *params = (GLint *) 0; 792 793 props = (GLenum *)getPointer(_env, props_buf, (jarray*)&_propsArray, &_propsRemaining, &_propsBufferOffset); 794 if (length_buf) { 795 length = (GLsizei *)getPointer(_env, length_buf, (jarray*)&_lengthArray, &_lengthRemaining, &_lengthBufferOffset); 796 } 797 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_paramsArray, &_paramsRemaining, &_paramsBufferOffset); 798 if (props == NULL) { 799 char * _propsBase = (char *)_env->GetIntArrayElements(_propsArray, (jboolean *) 0); 800 props = (GLenum *) (_propsBase + _propsBufferOffset); 801 } 802 if (length_buf && length == NULL) { 803 char * _lengthBase = (char *)_env->GetIntArrayElements(_lengthArray, (jboolean *) 0); 804 length = (GLsizei *) (_lengthBase + _lengthBufferOffset); 805 } 806 if (params == NULL) { 807 char * _paramsBase = (char *)_env->GetIntArrayElements(_paramsArray, (jboolean *) 0); 808 params = (GLint *) (_paramsBase + _paramsBufferOffset); 809 } 810 glGetProgramResourceiv( 811 (GLuint)program, 812 (GLenum)programInterface, 813 (GLuint)index, 814 (GLsizei)propCount, 815 (GLenum *)props, 816 (GLsizei)bufSize, 817 (GLsizei *)length, 818 (GLint *)params 819 ); 820 if (_paramsArray) { 821 _env->ReleaseIntArrayElements(_paramsArray, (jint*)params, 0); 822 } 823 if (_lengthArray) { 824 _env->ReleaseIntArrayElements(_lengthArray, (jint*)length, 0); 825 } 826 if (_propsArray) { 827 _env->ReleaseIntArrayElements(_propsArray, (jint*)props, JNI_ABORT); 828 } 829} 830 831/* GLint glGetProgramResourceLocation ( GLuint program, GLenum programInterface, const GLchar *name ) */ 832static jint 833android_glGetProgramResourceLocation__IILjava_lang_String_2 834 (JNIEnv *_env, jobject _this, jint program, jint programInterface, jstring name) { 835 jint _exception = 0; 836 const char * _exceptionType = NULL; 837 const char * _exceptionMessage = NULL; 838 GLint _returnValue = 0; 839 const char* _nativename = 0; 840 841 if (!name) { 842 _exception = 1; 843 _exceptionType = "java/lang/IllegalArgumentException"; 844 _exceptionMessage = "name == null"; 845 goto exit; 846 } 847 _nativename = _env->GetStringUTFChars(name, 0); 848 849 _returnValue = glGetProgramResourceLocation( 850 (GLuint)program, 851 (GLenum)programInterface, 852 (GLchar *)_nativename 853 ); 854 855exit: 856 if (_nativename) { 857 _env->ReleaseStringUTFChars(name, _nativename); 858 } 859 860 if (_exception) { 861 jniThrowException(_env, _exceptionType, _exceptionMessage); 862 } 863 return (jint)_returnValue; 864} 865 866/* void glUseProgramStages ( GLuint pipeline, GLbitfield stages, GLuint program ) */ 867static void 868android_glUseProgramStages__III 869 (JNIEnv *_env, jobject _this, jint pipeline, jint stages, jint program) { 870 glUseProgramStages( 871 (GLuint)pipeline, 872 (GLbitfield)stages, 873 (GLuint)program 874 ); 875} 876 877/* void glActiveShaderProgram ( GLuint pipeline, GLuint program ) */ 878static void 879android_glActiveShaderProgram__II 880 (JNIEnv *_env, jobject _this, jint pipeline, jint program) { 881 glActiveShaderProgram( 882 (GLuint)pipeline, 883 (GLuint)program 884 ); 885} 886 887/* GLuint glCreateShaderProgramv ( GLenum type, GLsizei count, const GLchar *const *strings ) */ 888static jint 889android_glCreateShaderProgramv 890 (JNIEnv *_env, jobject _this, jint type, jobjectArray strings) { 891 jint _exception = 0; 892 const char * _exceptionType = NULL; 893 const char * _exceptionMessage = NULL; 894 GLsizei _count; 895 const GLchar** _strings = NULL; 896 jstring* _jstrings = NULL; 897 GLuint _returnValue = 0; 898 899 if (!strings) { 900 _exception = 1; 901 _exceptionType = "java/lang/IllegalArgumentException"; 902 _exceptionMessage = "strings == null"; 903 goto exit; 904 } 905 906 _count = _env->GetArrayLength(strings); 907 908 _strings = (const GLchar**) calloc(_count, sizeof(const GLchar*)); 909 if (!_strings) { 910 _exception = 1; 911 _exceptionType = "java/lang/OutOfMemoryError"; 912 _exceptionMessage = "out of memory"; 913 goto exit; 914 } 915 916 _jstrings = (jstring*) calloc(_count, sizeof(jstring)); 917 if (!_jstrings) { 918 _exception = 1; 919 _exceptionType = "java/lang/OutOfMemoryError"; 920 _exceptionMessage = "out of memory"; 921 goto exit; 922 } 923 924 for(int i = 0; i < _count; i++) { 925 _jstrings[i] = (jstring) _env->GetObjectArrayElement(strings, i); 926 if (!_jstrings[i]) { 927 _exception = 1; 928 _exceptionType = "java/lang/IllegalArgumentException"; 929 _exceptionMessage = "strings == null"; 930 goto exit; 931 } 932 _strings[i] = _env->GetStringUTFChars(_jstrings[i], 0); 933 } 934 935 _returnValue = glCreateShaderProgramv((GLenum)type, _count, _strings); 936exit: 937 if (_strings && _jstrings) { 938 for(int i = 0; i < _count; i++) { 939 if (_strings[i] && _jstrings[i]) { 940 _env->ReleaseStringUTFChars(_jstrings[i], _strings[i]); 941 } 942 } 943 } 944 if (_strings) { 945 free(_strings); 946 } 947 if (_jstrings) { 948 free(_jstrings); 949 } 950 if (_exception) { 951 jniThrowException(_env, _exceptionType, _exceptionMessage); 952 } 953 return (jint)_returnValue; 954} 955/* void glBindProgramPipeline ( GLuint pipeline ) */ 956static void 957android_glBindProgramPipeline__I 958 (JNIEnv *_env, jobject _this, jint pipeline) { 959 glBindProgramPipeline( 960 (GLuint)pipeline 961 ); 962} 963 964/* void glDeleteProgramPipelines ( GLsizei n, const GLuint *pipelines ) */ 965static void 966android_glDeleteProgramPipelines__I_3II 967 (JNIEnv *_env, jobject _this, jint n, jintArray pipelines_ref, jint offset) { 968 jint _exception = 0; 969 const char * _exceptionType = NULL; 970 const char * _exceptionMessage = NULL; 971 GLuint *pipelines_base = (GLuint *) 0; 972 jint _remaining; 973 GLuint *pipelines = (GLuint *) 0; 974 975 if (!pipelines_ref) { 976 _exception = 1; 977 _exceptionType = "java/lang/IllegalArgumentException"; 978 _exceptionMessage = "pipelines == null"; 979 goto exit; 980 } 981 if (offset < 0) { 982 _exception = 1; 983 _exceptionType = "java/lang/IllegalArgumentException"; 984 _exceptionMessage = "offset < 0"; 985 goto exit; 986 } 987 _remaining = _env->GetArrayLength(pipelines_ref) - offset; 988 pipelines_base = (GLuint *) 989 _env->GetIntArrayElements(pipelines_ref, (jboolean *)0); 990 pipelines = pipelines_base + offset; 991 992 glDeleteProgramPipelines( 993 (GLsizei)n, 994 (GLuint *)pipelines 995 ); 996 997exit: 998 if (pipelines_base) { 999 _env->ReleaseIntArrayElements(pipelines_ref, (jint*)pipelines_base, 1000 JNI_ABORT); 1001 } 1002 if (_exception) { 1003 jniThrowException(_env, _exceptionType, _exceptionMessage); 1004 } 1005} 1006 1007/* void glDeleteProgramPipelines ( GLsizei n, const GLuint *pipelines ) */ 1008static void 1009android_glDeleteProgramPipelines__ILjava_nio_IntBuffer_2 1010 (JNIEnv *_env, jobject _this, jint n, jobject pipelines_buf) { 1011 jintArray _array = (jintArray) 0; 1012 jint _bufferOffset = (jint) 0; 1013 jint _remaining; 1014 GLuint *pipelines = (GLuint *) 0; 1015 1016 pipelines = (GLuint *)getPointer(_env, pipelines_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1017 if (pipelines == NULL) { 1018 char * _pipelinesBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1019 pipelines = (GLuint *) (_pipelinesBase + _bufferOffset); 1020 } 1021 glDeleteProgramPipelines( 1022 (GLsizei)n, 1023 (GLuint *)pipelines 1024 ); 1025 if (_array) { 1026 _env->ReleaseIntArrayElements(_array, (jint*)pipelines, JNI_ABORT); 1027 } 1028} 1029 1030/* void glGenProgramPipelines ( GLsizei n, GLuint *pipelines ) */ 1031static void 1032android_glGenProgramPipelines__I_3II 1033 (JNIEnv *_env, jobject _this, jint n, jintArray pipelines_ref, jint offset) { 1034 jint _exception = 0; 1035 const char * _exceptionType = NULL; 1036 const char * _exceptionMessage = NULL; 1037 GLuint *pipelines_base = (GLuint *) 0; 1038 jint _remaining; 1039 GLuint *pipelines = (GLuint *) 0; 1040 1041 if (!pipelines_ref) { 1042 _exception = 1; 1043 _exceptionType = "java/lang/IllegalArgumentException"; 1044 _exceptionMessage = "pipelines == null"; 1045 goto exit; 1046 } 1047 if (offset < 0) { 1048 _exception = 1; 1049 _exceptionType = "java/lang/IllegalArgumentException"; 1050 _exceptionMessage = "offset < 0"; 1051 goto exit; 1052 } 1053 _remaining = _env->GetArrayLength(pipelines_ref) - offset; 1054 pipelines_base = (GLuint *) 1055 _env->GetIntArrayElements(pipelines_ref, (jboolean *)0); 1056 pipelines = pipelines_base + offset; 1057 1058 glGenProgramPipelines( 1059 (GLsizei)n, 1060 (GLuint *)pipelines 1061 ); 1062 1063exit: 1064 if (pipelines_base) { 1065 _env->ReleaseIntArrayElements(pipelines_ref, (jint*)pipelines_base, 1066 _exception ? JNI_ABORT: 0); 1067 } 1068 if (_exception) { 1069 jniThrowException(_env, _exceptionType, _exceptionMessage); 1070 } 1071} 1072 1073/* void glGenProgramPipelines ( GLsizei n, GLuint *pipelines ) */ 1074static void 1075android_glGenProgramPipelines__ILjava_nio_IntBuffer_2 1076 (JNIEnv *_env, jobject _this, jint n, jobject pipelines_buf) { 1077 jintArray _array = (jintArray) 0; 1078 jint _bufferOffset = (jint) 0; 1079 jint _remaining; 1080 GLuint *pipelines = (GLuint *) 0; 1081 1082 pipelines = (GLuint *)getPointer(_env, pipelines_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1083 if (pipelines == NULL) { 1084 char * _pipelinesBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1085 pipelines = (GLuint *) (_pipelinesBase + _bufferOffset); 1086 } 1087 glGenProgramPipelines( 1088 (GLsizei)n, 1089 (GLuint *)pipelines 1090 ); 1091 if (_array) { 1092 _env->ReleaseIntArrayElements(_array, (jint*)pipelines, 0); 1093 } 1094} 1095 1096/* GLboolean glIsProgramPipeline ( GLuint pipeline ) */ 1097static jboolean 1098android_glIsProgramPipeline__I 1099 (JNIEnv *_env, jobject _this, jint pipeline) { 1100 GLboolean _returnValue; 1101 _returnValue = glIsProgramPipeline( 1102 (GLuint)pipeline 1103 ); 1104 return (jboolean)_returnValue; 1105} 1106 1107/* void glGetProgramPipelineiv ( GLuint pipeline, GLenum pname, GLint *params ) */ 1108static void 1109android_glGetProgramPipelineiv__II_3II 1110 (JNIEnv *_env, jobject _this, jint pipeline, jint pname, jintArray params_ref, jint offset) { 1111 jint _exception = 0; 1112 const char * _exceptionType = NULL; 1113 const char * _exceptionMessage = NULL; 1114 GLint *params_base = (GLint *) 0; 1115 jint _remaining; 1116 GLint *params = (GLint *) 0; 1117 1118 if (!params_ref) { 1119 _exception = 1; 1120 _exceptionType = "java/lang/IllegalArgumentException"; 1121 _exceptionMessage = "params == null"; 1122 goto exit; 1123 } 1124 if (offset < 0) { 1125 _exception = 1; 1126 _exceptionType = "java/lang/IllegalArgumentException"; 1127 _exceptionMessage = "offset < 0"; 1128 goto exit; 1129 } 1130 _remaining = _env->GetArrayLength(params_ref) - offset; 1131 params_base = (GLint *) 1132 _env->GetIntArrayElements(params_ref, (jboolean *)0); 1133 params = params_base + offset; 1134 1135 glGetProgramPipelineiv( 1136 (GLuint)pipeline, 1137 (GLenum)pname, 1138 (GLint *)params 1139 ); 1140 1141exit: 1142 if (params_base) { 1143 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 1144 _exception ? JNI_ABORT: 0); 1145 } 1146 if (_exception) { 1147 jniThrowException(_env, _exceptionType, _exceptionMessage); 1148 } 1149} 1150 1151/* void glGetProgramPipelineiv ( GLuint pipeline, GLenum pname, GLint *params ) */ 1152static void 1153android_glGetProgramPipelineiv__IILjava_nio_IntBuffer_2 1154 (JNIEnv *_env, jobject _this, jint pipeline, jint pname, jobject params_buf) { 1155 jintArray _array = (jintArray) 0; 1156 jint _bufferOffset = (jint) 0; 1157 jint _remaining; 1158 GLint *params = (GLint *) 0; 1159 1160 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1161 if (params == NULL) { 1162 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1163 params = (GLint *) (_paramsBase + _bufferOffset); 1164 } 1165 glGetProgramPipelineiv( 1166 (GLuint)pipeline, 1167 (GLenum)pname, 1168 (GLint *)params 1169 ); 1170 if (_array) { 1171 _env->ReleaseIntArrayElements(_array, (jint*)params, 0); 1172 } 1173} 1174 1175/* void glProgramUniform1i ( GLuint program, GLint location, GLint v0 ) */ 1176static void 1177android_glProgramUniform1i__III 1178 (JNIEnv *_env, jobject _this, jint program, jint location, jint v0) { 1179 glProgramUniform1i( 1180 (GLuint)program, 1181 (GLint)location, 1182 (GLint)v0 1183 ); 1184} 1185 1186/* void glProgramUniform2i ( GLuint program, GLint location, GLint v0, GLint v1 ) */ 1187static void 1188android_glProgramUniform2i__IIII 1189 (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1) { 1190 glProgramUniform2i( 1191 (GLuint)program, 1192 (GLint)location, 1193 (GLint)v0, 1194 (GLint)v1 1195 ); 1196} 1197 1198/* void glProgramUniform3i ( GLuint program, GLint location, GLint v0, GLint v1, GLint v2 ) */ 1199static void 1200android_glProgramUniform3i__IIIII 1201 (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1, jint v2) { 1202 glProgramUniform3i( 1203 (GLuint)program, 1204 (GLint)location, 1205 (GLint)v0, 1206 (GLint)v1, 1207 (GLint)v2 1208 ); 1209} 1210 1211/* void glProgramUniform4i ( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 ) */ 1212static void 1213android_glProgramUniform4i__IIIIII 1214 (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1, jint v2, jint v3) { 1215 glProgramUniform4i( 1216 (GLuint)program, 1217 (GLint)location, 1218 (GLint)v0, 1219 (GLint)v1, 1220 (GLint)v2, 1221 (GLint)v3 1222 ); 1223} 1224 1225/* void glProgramUniform1ui ( GLuint program, GLint location, GLuint v0 ) */ 1226static void 1227android_glProgramUniform1ui__III 1228 (JNIEnv *_env, jobject _this, jint program, jint location, jint v0) { 1229 glProgramUniform1ui( 1230 (GLuint)program, 1231 (GLint)location, 1232 (GLuint)v0 1233 ); 1234} 1235 1236/* void glProgramUniform2ui ( GLuint program, GLint location, GLuint v0, GLuint v1 ) */ 1237static void 1238android_glProgramUniform2ui__IIII 1239 (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1) { 1240 glProgramUniform2ui( 1241 (GLuint)program, 1242 (GLint)location, 1243 (GLuint)v0, 1244 (GLuint)v1 1245 ); 1246} 1247 1248/* void glProgramUniform3ui ( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 ) */ 1249static void 1250android_glProgramUniform3ui__IIIII 1251 (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1, jint v2) { 1252 glProgramUniform3ui( 1253 (GLuint)program, 1254 (GLint)location, 1255 (GLuint)v0, 1256 (GLuint)v1, 1257 (GLuint)v2 1258 ); 1259} 1260 1261/* void glProgramUniform4ui ( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) */ 1262static void 1263android_glProgramUniform4ui__IIIIII 1264 (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1, jint v2, jint v3) { 1265 glProgramUniform4ui( 1266 (GLuint)program, 1267 (GLint)location, 1268 (GLuint)v0, 1269 (GLuint)v1, 1270 (GLuint)v2, 1271 (GLuint)v3 1272 ); 1273} 1274 1275/* void glProgramUniform1f ( GLuint program, GLint location, GLfloat v0 ) */ 1276static void 1277android_glProgramUniform1f__IIF 1278 (JNIEnv *_env, jobject _this, jint program, jint location, jfloat v0) { 1279 glProgramUniform1f( 1280 (GLuint)program, 1281 (GLint)location, 1282 (GLfloat)v0 1283 ); 1284} 1285 1286/* void glProgramUniform2f ( GLuint program, GLint location, GLfloat v0, GLfloat v1 ) */ 1287static void 1288android_glProgramUniform2f__IIFF 1289 (JNIEnv *_env, jobject _this, jint program, jint location, jfloat v0, jfloat v1) { 1290 glProgramUniform2f( 1291 (GLuint)program, 1292 (GLint)location, 1293 (GLfloat)v0, 1294 (GLfloat)v1 1295 ); 1296} 1297 1298/* void glProgramUniform3f ( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 ) */ 1299static void 1300android_glProgramUniform3f__IIFFF 1301 (JNIEnv *_env, jobject _this, jint program, jint location, jfloat v0, jfloat v1, jfloat v2) { 1302 glProgramUniform3f( 1303 (GLuint)program, 1304 (GLint)location, 1305 (GLfloat)v0, 1306 (GLfloat)v1, 1307 (GLfloat)v2 1308 ); 1309} 1310 1311/* void glProgramUniform4f ( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) */ 1312static void 1313android_glProgramUniform4f__IIFFFF 1314 (JNIEnv *_env, jobject _this, jint program, jint location, jfloat v0, jfloat v1, jfloat v2, jfloat v3) { 1315 glProgramUniform4f( 1316 (GLuint)program, 1317 (GLint)location, 1318 (GLfloat)v0, 1319 (GLfloat)v1, 1320 (GLfloat)v2, 1321 (GLfloat)v3 1322 ); 1323} 1324 1325/* void glProgramUniform1iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */ 1326static void 1327android_glProgramUniform1iv__III_3II 1328 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) { 1329 jint _exception = 0; 1330 const char * _exceptionType = NULL; 1331 const char * _exceptionMessage = NULL; 1332 GLint *value_base = (GLint *) 0; 1333 jint _remaining; 1334 GLint *value = (GLint *) 0; 1335 1336 if (!value_ref) { 1337 _exception = 1; 1338 _exceptionType = "java/lang/IllegalArgumentException"; 1339 _exceptionMessage = "value == null"; 1340 goto exit; 1341 } 1342 if (offset < 0) { 1343 _exception = 1; 1344 _exceptionType = "java/lang/IllegalArgumentException"; 1345 _exceptionMessage = "offset < 0"; 1346 goto exit; 1347 } 1348 _remaining = _env->GetArrayLength(value_ref) - offset; 1349 value_base = (GLint *) 1350 _env->GetIntArrayElements(value_ref, (jboolean *)0); 1351 value = value_base + offset; 1352 1353 glProgramUniform1iv( 1354 (GLuint)program, 1355 (GLint)location, 1356 (GLsizei)count, 1357 (GLint *)value 1358 ); 1359 1360exit: 1361 if (value_base) { 1362 _env->ReleaseIntArrayElements(value_ref, (jint*)value_base, 1363 JNI_ABORT); 1364 } 1365 if (_exception) { 1366 jniThrowException(_env, _exceptionType, _exceptionMessage); 1367 } 1368} 1369 1370/* void glProgramUniform1iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */ 1371static void 1372android_glProgramUniform1iv__IIILjava_nio_IntBuffer_2 1373 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { 1374 jintArray _array = (jintArray) 0; 1375 jint _bufferOffset = (jint) 0; 1376 jint _remaining; 1377 GLint *value = (GLint *) 0; 1378 1379 value = (GLint *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1380 if (value == NULL) { 1381 char * _valueBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1382 value = (GLint *) (_valueBase + _bufferOffset); 1383 } 1384 glProgramUniform1iv( 1385 (GLuint)program, 1386 (GLint)location, 1387 (GLsizei)count, 1388 (GLint *)value 1389 ); 1390 if (_array) { 1391 _env->ReleaseIntArrayElements(_array, (jint*)value, JNI_ABORT); 1392 } 1393} 1394 1395/* void glProgramUniform2iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */ 1396static void 1397android_glProgramUniform2iv__III_3II 1398 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) { 1399 jint _exception = 0; 1400 const char * _exceptionType = NULL; 1401 const char * _exceptionMessage = NULL; 1402 GLint *value_base = (GLint *) 0; 1403 jint _remaining; 1404 GLint *value = (GLint *) 0; 1405 1406 if (!value_ref) { 1407 _exception = 1; 1408 _exceptionType = "java/lang/IllegalArgumentException"; 1409 _exceptionMessage = "value == null"; 1410 goto exit; 1411 } 1412 if (offset < 0) { 1413 _exception = 1; 1414 _exceptionType = "java/lang/IllegalArgumentException"; 1415 _exceptionMessage = "offset < 0"; 1416 goto exit; 1417 } 1418 _remaining = _env->GetArrayLength(value_ref) - offset; 1419 value_base = (GLint *) 1420 _env->GetIntArrayElements(value_ref, (jboolean *)0); 1421 value = value_base + offset; 1422 1423 glProgramUniform2iv( 1424 (GLuint)program, 1425 (GLint)location, 1426 (GLsizei)count, 1427 (GLint *)value 1428 ); 1429 1430exit: 1431 if (value_base) { 1432 _env->ReleaseIntArrayElements(value_ref, (jint*)value_base, 1433 JNI_ABORT); 1434 } 1435 if (_exception) { 1436 jniThrowException(_env, _exceptionType, _exceptionMessage); 1437 } 1438} 1439 1440/* void glProgramUniform2iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */ 1441static void 1442android_glProgramUniform2iv__IIILjava_nio_IntBuffer_2 1443 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { 1444 jintArray _array = (jintArray) 0; 1445 jint _bufferOffset = (jint) 0; 1446 jint _remaining; 1447 GLint *value = (GLint *) 0; 1448 1449 value = (GLint *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1450 if (value == NULL) { 1451 char * _valueBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1452 value = (GLint *) (_valueBase + _bufferOffset); 1453 } 1454 glProgramUniform2iv( 1455 (GLuint)program, 1456 (GLint)location, 1457 (GLsizei)count, 1458 (GLint *)value 1459 ); 1460 if (_array) { 1461 _env->ReleaseIntArrayElements(_array, (jint*)value, JNI_ABORT); 1462 } 1463} 1464 1465/* void glProgramUniform3iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */ 1466static void 1467android_glProgramUniform3iv__III_3II 1468 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) { 1469 jint _exception = 0; 1470 const char * _exceptionType = NULL; 1471 const char * _exceptionMessage = NULL; 1472 GLint *value_base = (GLint *) 0; 1473 jint _remaining; 1474 GLint *value = (GLint *) 0; 1475 1476 if (!value_ref) { 1477 _exception = 1; 1478 _exceptionType = "java/lang/IllegalArgumentException"; 1479 _exceptionMessage = "value == null"; 1480 goto exit; 1481 } 1482 if (offset < 0) { 1483 _exception = 1; 1484 _exceptionType = "java/lang/IllegalArgumentException"; 1485 _exceptionMessage = "offset < 0"; 1486 goto exit; 1487 } 1488 _remaining = _env->GetArrayLength(value_ref) - offset; 1489 value_base = (GLint *) 1490 _env->GetIntArrayElements(value_ref, (jboolean *)0); 1491 value = value_base + offset; 1492 1493 glProgramUniform3iv( 1494 (GLuint)program, 1495 (GLint)location, 1496 (GLsizei)count, 1497 (GLint *)value 1498 ); 1499 1500exit: 1501 if (value_base) { 1502 _env->ReleaseIntArrayElements(value_ref, (jint*)value_base, 1503 JNI_ABORT); 1504 } 1505 if (_exception) { 1506 jniThrowException(_env, _exceptionType, _exceptionMessage); 1507 } 1508} 1509 1510/* void glProgramUniform3iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */ 1511static void 1512android_glProgramUniform3iv__IIILjava_nio_IntBuffer_2 1513 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { 1514 jintArray _array = (jintArray) 0; 1515 jint _bufferOffset = (jint) 0; 1516 jint _remaining; 1517 GLint *value = (GLint *) 0; 1518 1519 value = (GLint *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1520 if (value == NULL) { 1521 char * _valueBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1522 value = (GLint *) (_valueBase + _bufferOffset); 1523 } 1524 glProgramUniform3iv( 1525 (GLuint)program, 1526 (GLint)location, 1527 (GLsizei)count, 1528 (GLint *)value 1529 ); 1530 if (_array) { 1531 _env->ReleaseIntArrayElements(_array, (jint*)value, JNI_ABORT); 1532 } 1533} 1534 1535/* void glProgramUniform4iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */ 1536static void 1537android_glProgramUniform4iv__III_3II 1538 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) { 1539 jint _exception = 0; 1540 const char * _exceptionType = NULL; 1541 const char * _exceptionMessage = NULL; 1542 GLint *value_base = (GLint *) 0; 1543 jint _remaining; 1544 GLint *value = (GLint *) 0; 1545 1546 if (!value_ref) { 1547 _exception = 1; 1548 _exceptionType = "java/lang/IllegalArgumentException"; 1549 _exceptionMessage = "value == null"; 1550 goto exit; 1551 } 1552 if (offset < 0) { 1553 _exception = 1; 1554 _exceptionType = "java/lang/IllegalArgumentException"; 1555 _exceptionMessage = "offset < 0"; 1556 goto exit; 1557 } 1558 _remaining = _env->GetArrayLength(value_ref) - offset; 1559 value_base = (GLint *) 1560 _env->GetIntArrayElements(value_ref, (jboolean *)0); 1561 value = value_base + offset; 1562 1563 glProgramUniform4iv( 1564 (GLuint)program, 1565 (GLint)location, 1566 (GLsizei)count, 1567 (GLint *)value 1568 ); 1569 1570exit: 1571 if (value_base) { 1572 _env->ReleaseIntArrayElements(value_ref, (jint*)value_base, 1573 JNI_ABORT); 1574 } 1575 if (_exception) { 1576 jniThrowException(_env, _exceptionType, _exceptionMessage); 1577 } 1578} 1579 1580/* void glProgramUniform4iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */ 1581static void 1582android_glProgramUniform4iv__IIILjava_nio_IntBuffer_2 1583 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { 1584 jintArray _array = (jintArray) 0; 1585 jint _bufferOffset = (jint) 0; 1586 jint _remaining; 1587 GLint *value = (GLint *) 0; 1588 1589 value = (GLint *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1590 if (value == NULL) { 1591 char * _valueBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1592 value = (GLint *) (_valueBase + _bufferOffset); 1593 } 1594 glProgramUniform4iv( 1595 (GLuint)program, 1596 (GLint)location, 1597 (GLsizei)count, 1598 (GLint *)value 1599 ); 1600 if (_array) { 1601 _env->ReleaseIntArrayElements(_array, (jint*)value, JNI_ABORT); 1602 } 1603} 1604 1605/* void glProgramUniform1uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */ 1606static void 1607android_glProgramUniform1uiv__III_3II 1608 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) { 1609 jint _exception = 0; 1610 const char * _exceptionType = NULL; 1611 const char * _exceptionMessage = NULL; 1612 GLuint *value_base = (GLuint *) 0; 1613 jint _remaining; 1614 GLuint *value = (GLuint *) 0; 1615 1616 if (!value_ref) { 1617 _exception = 1; 1618 _exceptionType = "java/lang/IllegalArgumentException"; 1619 _exceptionMessage = "value == null"; 1620 goto exit; 1621 } 1622 if (offset < 0) { 1623 _exception = 1; 1624 _exceptionType = "java/lang/IllegalArgumentException"; 1625 _exceptionMessage = "offset < 0"; 1626 goto exit; 1627 } 1628 _remaining = _env->GetArrayLength(value_ref) - offset; 1629 value_base = (GLuint *) 1630 _env->GetIntArrayElements(value_ref, (jboolean *)0); 1631 value = value_base + offset; 1632 1633 glProgramUniform1uiv( 1634 (GLuint)program, 1635 (GLint)location, 1636 (GLsizei)count, 1637 (GLuint *)value 1638 ); 1639 1640exit: 1641 if (value_base) { 1642 _env->ReleaseIntArrayElements(value_ref, (jint*)value_base, 1643 JNI_ABORT); 1644 } 1645 if (_exception) { 1646 jniThrowException(_env, _exceptionType, _exceptionMessage); 1647 } 1648} 1649 1650/* void glProgramUniform1uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */ 1651static void 1652android_glProgramUniform1uiv__IIILjava_nio_IntBuffer_2 1653 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { 1654 jintArray _array = (jintArray) 0; 1655 jint _bufferOffset = (jint) 0; 1656 jint _remaining; 1657 GLuint *value = (GLuint *) 0; 1658 1659 value = (GLuint *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1660 if (value == NULL) { 1661 char * _valueBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1662 value = (GLuint *) (_valueBase + _bufferOffset); 1663 } 1664 glProgramUniform1uiv( 1665 (GLuint)program, 1666 (GLint)location, 1667 (GLsizei)count, 1668 (GLuint *)value 1669 ); 1670 if (_array) { 1671 _env->ReleaseIntArrayElements(_array, (jint*)value, JNI_ABORT); 1672 } 1673} 1674 1675/* void glProgramUniform2uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */ 1676static void 1677android_glProgramUniform2uiv__III_3II 1678 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) { 1679 jint _exception = 0; 1680 const char * _exceptionType = NULL; 1681 const char * _exceptionMessage = NULL; 1682 GLuint *value_base = (GLuint *) 0; 1683 jint _remaining; 1684 GLuint *value = (GLuint *) 0; 1685 1686 if (!value_ref) { 1687 _exception = 1; 1688 _exceptionType = "java/lang/IllegalArgumentException"; 1689 _exceptionMessage = "value == null"; 1690 goto exit; 1691 } 1692 if (offset < 0) { 1693 _exception = 1; 1694 _exceptionType = "java/lang/IllegalArgumentException"; 1695 _exceptionMessage = "offset < 0"; 1696 goto exit; 1697 } 1698 _remaining = _env->GetArrayLength(value_ref) - offset; 1699 value_base = (GLuint *) 1700 _env->GetIntArrayElements(value_ref, (jboolean *)0); 1701 value = value_base + offset; 1702 1703 glProgramUniform2uiv( 1704 (GLuint)program, 1705 (GLint)location, 1706 (GLsizei)count, 1707 (GLuint *)value 1708 ); 1709 1710exit: 1711 if (value_base) { 1712 _env->ReleaseIntArrayElements(value_ref, (jint*)value_base, 1713 JNI_ABORT); 1714 } 1715 if (_exception) { 1716 jniThrowException(_env, _exceptionType, _exceptionMessage); 1717 } 1718} 1719 1720/* void glProgramUniform2uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */ 1721static void 1722android_glProgramUniform2uiv__IIILjava_nio_IntBuffer_2 1723 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { 1724 jintArray _array = (jintArray) 0; 1725 jint _bufferOffset = (jint) 0; 1726 jint _remaining; 1727 GLuint *value = (GLuint *) 0; 1728 1729 value = (GLuint *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1730 if (value == NULL) { 1731 char * _valueBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1732 value = (GLuint *) (_valueBase + _bufferOffset); 1733 } 1734 glProgramUniform2uiv( 1735 (GLuint)program, 1736 (GLint)location, 1737 (GLsizei)count, 1738 (GLuint *)value 1739 ); 1740 if (_array) { 1741 _env->ReleaseIntArrayElements(_array, (jint*)value, JNI_ABORT); 1742 } 1743} 1744 1745/* void glProgramUniform3uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */ 1746static void 1747android_glProgramUniform3uiv__III_3II 1748 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) { 1749 jint _exception = 0; 1750 const char * _exceptionType = NULL; 1751 const char * _exceptionMessage = NULL; 1752 GLuint *value_base = (GLuint *) 0; 1753 jint _remaining; 1754 GLuint *value = (GLuint *) 0; 1755 1756 if (!value_ref) { 1757 _exception = 1; 1758 _exceptionType = "java/lang/IllegalArgumentException"; 1759 _exceptionMessage = "value == null"; 1760 goto exit; 1761 } 1762 if (offset < 0) { 1763 _exception = 1; 1764 _exceptionType = "java/lang/IllegalArgumentException"; 1765 _exceptionMessage = "offset < 0"; 1766 goto exit; 1767 } 1768 _remaining = _env->GetArrayLength(value_ref) - offset; 1769 value_base = (GLuint *) 1770 _env->GetIntArrayElements(value_ref, (jboolean *)0); 1771 value = value_base + offset; 1772 1773 glProgramUniform3uiv( 1774 (GLuint)program, 1775 (GLint)location, 1776 (GLsizei)count, 1777 (GLuint *)value 1778 ); 1779 1780exit: 1781 if (value_base) { 1782 _env->ReleaseIntArrayElements(value_ref, (jint*)value_base, 1783 JNI_ABORT); 1784 } 1785 if (_exception) { 1786 jniThrowException(_env, _exceptionType, _exceptionMessage); 1787 } 1788} 1789 1790/* void glProgramUniform3uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */ 1791static void 1792android_glProgramUniform3uiv__IIILjava_nio_IntBuffer_2 1793 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { 1794 jintArray _array = (jintArray) 0; 1795 jint _bufferOffset = (jint) 0; 1796 jint _remaining; 1797 GLuint *value = (GLuint *) 0; 1798 1799 value = (GLuint *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1800 if (value == NULL) { 1801 char * _valueBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1802 value = (GLuint *) (_valueBase + _bufferOffset); 1803 } 1804 glProgramUniform3uiv( 1805 (GLuint)program, 1806 (GLint)location, 1807 (GLsizei)count, 1808 (GLuint *)value 1809 ); 1810 if (_array) { 1811 _env->ReleaseIntArrayElements(_array, (jint*)value, JNI_ABORT); 1812 } 1813} 1814 1815/* void glProgramUniform4uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */ 1816static void 1817android_glProgramUniform4uiv__III_3II 1818 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) { 1819 jint _exception = 0; 1820 const char * _exceptionType = NULL; 1821 const char * _exceptionMessage = NULL; 1822 GLuint *value_base = (GLuint *) 0; 1823 jint _remaining; 1824 GLuint *value = (GLuint *) 0; 1825 1826 if (!value_ref) { 1827 _exception = 1; 1828 _exceptionType = "java/lang/IllegalArgumentException"; 1829 _exceptionMessage = "value == null"; 1830 goto exit; 1831 } 1832 if (offset < 0) { 1833 _exception = 1; 1834 _exceptionType = "java/lang/IllegalArgumentException"; 1835 _exceptionMessage = "offset < 0"; 1836 goto exit; 1837 } 1838 _remaining = _env->GetArrayLength(value_ref) - offset; 1839 value_base = (GLuint *) 1840 _env->GetIntArrayElements(value_ref, (jboolean *)0); 1841 value = value_base + offset; 1842 1843 glProgramUniform4uiv( 1844 (GLuint)program, 1845 (GLint)location, 1846 (GLsizei)count, 1847 (GLuint *)value 1848 ); 1849 1850exit: 1851 if (value_base) { 1852 _env->ReleaseIntArrayElements(value_ref, (jint*)value_base, 1853 JNI_ABORT); 1854 } 1855 if (_exception) { 1856 jniThrowException(_env, _exceptionType, _exceptionMessage); 1857 } 1858} 1859 1860/* void glProgramUniform4uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */ 1861static void 1862android_glProgramUniform4uiv__IIILjava_nio_IntBuffer_2 1863 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { 1864 jintArray _array = (jintArray) 0; 1865 jint _bufferOffset = (jint) 0; 1866 jint _remaining; 1867 GLuint *value = (GLuint *) 0; 1868 1869 value = (GLuint *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1870 if (value == NULL) { 1871 char * _valueBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 1872 value = (GLuint *) (_valueBase + _bufferOffset); 1873 } 1874 glProgramUniform4uiv( 1875 (GLuint)program, 1876 (GLint)location, 1877 (GLsizei)count, 1878 (GLuint *)value 1879 ); 1880 if (_array) { 1881 _env->ReleaseIntArrayElements(_array, (jint*)value, JNI_ABORT); 1882 } 1883} 1884 1885/* void glProgramUniform1fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */ 1886static void 1887android_glProgramUniform1fv__III_3FI 1888 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jfloatArray value_ref, jint offset) { 1889 jint _exception = 0; 1890 const char * _exceptionType = NULL; 1891 const char * _exceptionMessage = NULL; 1892 GLfloat *value_base = (GLfloat *) 0; 1893 jint _remaining; 1894 GLfloat *value = (GLfloat *) 0; 1895 1896 if (!value_ref) { 1897 _exception = 1; 1898 _exceptionType = "java/lang/IllegalArgumentException"; 1899 _exceptionMessage = "value == null"; 1900 goto exit; 1901 } 1902 if (offset < 0) { 1903 _exception = 1; 1904 _exceptionType = "java/lang/IllegalArgumentException"; 1905 _exceptionMessage = "offset < 0"; 1906 goto exit; 1907 } 1908 _remaining = _env->GetArrayLength(value_ref) - offset; 1909 value_base = (GLfloat *) 1910 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 1911 value = value_base + offset; 1912 1913 glProgramUniform1fv( 1914 (GLuint)program, 1915 (GLint)location, 1916 (GLsizei)count, 1917 (GLfloat *)value 1918 ); 1919 1920exit: 1921 if (value_base) { 1922 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 1923 JNI_ABORT); 1924 } 1925 if (_exception) { 1926 jniThrowException(_env, _exceptionType, _exceptionMessage); 1927 } 1928} 1929 1930/* void glProgramUniform1fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */ 1931static void 1932android_glProgramUniform1fv__IIILjava_nio_FloatBuffer_2 1933 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { 1934 jfloatArray _array = (jfloatArray) 0; 1935 jint _bufferOffset = (jint) 0; 1936 jint _remaining; 1937 GLfloat *value = (GLfloat *) 0; 1938 1939 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 1940 if (value == NULL) { 1941 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 1942 value = (GLfloat *) (_valueBase + _bufferOffset); 1943 } 1944 glProgramUniform1fv( 1945 (GLuint)program, 1946 (GLint)location, 1947 (GLsizei)count, 1948 (GLfloat *)value 1949 ); 1950 if (_array) { 1951 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 1952 } 1953} 1954 1955/* void glProgramUniform2fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */ 1956static void 1957android_glProgramUniform2fv__III_3FI 1958 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jfloatArray value_ref, jint offset) { 1959 jint _exception = 0; 1960 const char * _exceptionType = NULL; 1961 const char * _exceptionMessage = NULL; 1962 GLfloat *value_base = (GLfloat *) 0; 1963 jint _remaining; 1964 GLfloat *value = (GLfloat *) 0; 1965 1966 if (!value_ref) { 1967 _exception = 1; 1968 _exceptionType = "java/lang/IllegalArgumentException"; 1969 _exceptionMessage = "value == null"; 1970 goto exit; 1971 } 1972 if (offset < 0) { 1973 _exception = 1; 1974 _exceptionType = "java/lang/IllegalArgumentException"; 1975 _exceptionMessage = "offset < 0"; 1976 goto exit; 1977 } 1978 _remaining = _env->GetArrayLength(value_ref) - offset; 1979 value_base = (GLfloat *) 1980 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 1981 value = value_base + offset; 1982 1983 glProgramUniform2fv( 1984 (GLuint)program, 1985 (GLint)location, 1986 (GLsizei)count, 1987 (GLfloat *)value 1988 ); 1989 1990exit: 1991 if (value_base) { 1992 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 1993 JNI_ABORT); 1994 } 1995 if (_exception) { 1996 jniThrowException(_env, _exceptionType, _exceptionMessage); 1997 } 1998} 1999 2000/* void glProgramUniform2fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */ 2001static void 2002android_glProgramUniform2fv__IIILjava_nio_FloatBuffer_2 2003 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { 2004 jfloatArray _array = (jfloatArray) 0; 2005 jint _bufferOffset = (jint) 0; 2006 jint _remaining; 2007 GLfloat *value = (GLfloat *) 0; 2008 2009 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2010 if (value == NULL) { 2011 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 2012 value = (GLfloat *) (_valueBase + _bufferOffset); 2013 } 2014 glProgramUniform2fv( 2015 (GLuint)program, 2016 (GLint)location, 2017 (GLsizei)count, 2018 (GLfloat *)value 2019 ); 2020 if (_array) { 2021 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 2022 } 2023} 2024 2025/* void glProgramUniform3fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */ 2026static void 2027android_glProgramUniform3fv__III_3FI 2028 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jfloatArray value_ref, jint offset) { 2029 jint _exception = 0; 2030 const char * _exceptionType = NULL; 2031 const char * _exceptionMessage = NULL; 2032 GLfloat *value_base = (GLfloat *) 0; 2033 jint _remaining; 2034 GLfloat *value = (GLfloat *) 0; 2035 2036 if (!value_ref) { 2037 _exception = 1; 2038 _exceptionType = "java/lang/IllegalArgumentException"; 2039 _exceptionMessage = "value == null"; 2040 goto exit; 2041 } 2042 if (offset < 0) { 2043 _exception = 1; 2044 _exceptionType = "java/lang/IllegalArgumentException"; 2045 _exceptionMessage = "offset < 0"; 2046 goto exit; 2047 } 2048 _remaining = _env->GetArrayLength(value_ref) - offset; 2049 value_base = (GLfloat *) 2050 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 2051 value = value_base + offset; 2052 2053 glProgramUniform3fv( 2054 (GLuint)program, 2055 (GLint)location, 2056 (GLsizei)count, 2057 (GLfloat *)value 2058 ); 2059 2060exit: 2061 if (value_base) { 2062 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 2063 JNI_ABORT); 2064 } 2065 if (_exception) { 2066 jniThrowException(_env, _exceptionType, _exceptionMessage); 2067 } 2068} 2069 2070/* void glProgramUniform3fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */ 2071static void 2072android_glProgramUniform3fv__IIILjava_nio_FloatBuffer_2 2073 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { 2074 jfloatArray _array = (jfloatArray) 0; 2075 jint _bufferOffset = (jint) 0; 2076 jint _remaining; 2077 GLfloat *value = (GLfloat *) 0; 2078 2079 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2080 if (value == NULL) { 2081 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 2082 value = (GLfloat *) (_valueBase + _bufferOffset); 2083 } 2084 glProgramUniform3fv( 2085 (GLuint)program, 2086 (GLint)location, 2087 (GLsizei)count, 2088 (GLfloat *)value 2089 ); 2090 if (_array) { 2091 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 2092 } 2093} 2094 2095/* void glProgramUniform4fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */ 2096static void 2097android_glProgramUniform4fv__III_3FI 2098 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jfloatArray value_ref, jint offset) { 2099 jint _exception = 0; 2100 const char * _exceptionType = NULL; 2101 const char * _exceptionMessage = NULL; 2102 GLfloat *value_base = (GLfloat *) 0; 2103 jint _remaining; 2104 GLfloat *value = (GLfloat *) 0; 2105 2106 if (!value_ref) { 2107 _exception = 1; 2108 _exceptionType = "java/lang/IllegalArgumentException"; 2109 _exceptionMessage = "value == null"; 2110 goto exit; 2111 } 2112 if (offset < 0) { 2113 _exception = 1; 2114 _exceptionType = "java/lang/IllegalArgumentException"; 2115 _exceptionMessage = "offset < 0"; 2116 goto exit; 2117 } 2118 _remaining = _env->GetArrayLength(value_ref) - offset; 2119 value_base = (GLfloat *) 2120 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 2121 value = value_base + offset; 2122 2123 glProgramUniform4fv( 2124 (GLuint)program, 2125 (GLint)location, 2126 (GLsizei)count, 2127 (GLfloat *)value 2128 ); 2129 2130exit: 2131 if (value_base) { 2132 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 2133 JNI_ABORT); 2134 } 2135 if (_exception) { 2136 jniThrowException(_env, _exceptionType, _exceptionMessage); 2137 } 2138} 2139 2140/* void glProgramUniform4fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */ 2141static void 2142android_glProgramUniform4fv__IIILjava_nio_FloatBuffer_2 2143 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { 2144 jfloatArray _array = (jfloatArray) 0; 2145 jint _bufferOffset = (jint) 0; 2146 jint _remaining; 2147 GLfloat *value = (GLfloat *) 0; 2148 2149 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2150 if (value == NULL) { 2151 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 2152 value = (GLfloat *) (_valueBase + _bufferOffset); 2153 } 2154 glProgramUniform4fv( 2155 (GLuint)program, 2156 (GLint)location, 2157 (GLsizei)count, 2158 (GLfloat *)value 2159 ); 2160 if (_array) { 2161 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 2162 } 2163} 2164 2165/* void glProgramUniformMatrix2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2166static void 2167android_glProgramUniformMatrix2fv__IIIZ_3FI 2168 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { 2169 jint _exception = 0; 2170 const char * _exceptionType = NULL; 2171 const char * _exceptionMessage = NULL; 2172 GLfloat *value_base = (GLfloat *) 0; 2173 jint _remaining; 2174 GLfloat *value = (GLfloat *) 0; 2175 2176 if (!value_ref) { 2177 _exception = 1; 2178 _exceptionType = "java/lang/IllegalArgumentException"; 2179 _exceptionMessage = "value == null"; 2180 goto exit; 2181 } 2182 if (offset < 0) { 2183 _exception = 1; 2184 _exceptionType = "java/lang/IllegalArgumentException"; 2185 _exceptionMessage = "offset < 0"; 2186 goto exit; 2187 } 2188 _remaining = _env->GetArrayLength(value_ref) - offset; 2189 value_base = (GLfloat *) 2190 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 2191 value = value_base + offset; 2192 2193 glProgramUniformMatrix2fv( 2194 (GLuint)program, 2195 (GLint)location, 2196 (GLsizei)count, 2197 (GLboolean)transpose, 2198 (GLfloat *)value 2199 ); 2200 2201exit: 2202 if (value_base) { 2203 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 2204 JNI_ABORT); 2205 } 2206 if (_exception) { 2207 jniThrowException(_env, _exceptionType, _exceptionMessage); 2208 } 2209} 2210 2211/* void glProgramUniformMatrix2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2212static void 2213android_glProgramUniformMatrix2fv__IIIZLjava_nio_FloatBuffer_2 2214 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { 2215 jfloatArray _array = (jfloatArray) 0; 2216 jint _bufferOffset = (jint) 0; 2217 jint _remaining; 2218 GLfloat *value = (GLfloat *) 0; 2219 2220 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2221 if (value == NULL) { 2222 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 2223 value = (GLfloat *) (_valueBase + _bufferOffset); 2224 } 2225 glProgramUniformMatrix2fv( 2226 (GLuint)program, 2227 (GLint)location, 2228 (GLsizei)count, 2229 (GLboolean)transpose, 2230 (GLfloat *)value 2231 ); 2232 if (_array) { 2233 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 2234 } 2235} 2236 2237/* void glProgramUniformMatrix3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2238static void 2239android_glProgramUniformMatrix3fv__IIIZ_3FI 2240 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { 2241 jint _exception = 0; 2242 const char * _exceptionType = NULL; 2243 const char * _exceptionMessage = NULL; 2244 GLfloat *value_base = (GLfloat *) 0; 2245 jint _remaining; 2246 GLfloat *value = (GLfloat *) 0; 2247 2248 if (!value_ref) { 2249 _exception = 1; 2250 _exceptionType = "java/lang/IllegalArgumentException"; 2251 _exceptionMessage = "value == null"; 2252 goto exit; 2253 } 2254 if (offset < 0) { 2255 _exception = 1; 2256 _exceptionType = "java/lang/IllegalArgumentException"; 2257 _exceptionMessage = "offset < 0"; 2258 goto exit; 2259 } 2260 _remaining = _env->GetArrayLength(value_ref) - offset; 2261 value_base = (GLfloat *) 2262 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 2263 value = value_base + offset; 2264 2265 glProgramUniformMatrix3fv( 2266 (GLuint)program, 2267 (GLint)location, 2268 (GLsizei)count, 2269 (GLboolean)transpose, 2270 (GLfloat *)value 2271 ); 2272 2273exit: 2274 if (value_base) { 2275 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 2276 JNI_ABORT); 2277 } 2278 if (_exception) { 2279 jniThrowException(_env, _exceptionType, _exceptionMessage); 2280 } 2281} 2282 2283/* void glProgramUniformMatrix3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2284static void 2285android_glProgramUniformMatrix3fv__IIIZLjava_nio_FloatBuffer_2 2286 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { 2287 jfloatArray _array = (jfloatArray) 0; 2288 jint _bufferOffset = (jint) 0; 2289 jint _remaining; 2290 GLfloat *value = (GLfloat *) 0; 2291 2292 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2293 if (value == NULL) { 2294 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 2295 value = (GLfloat *) (_valueBase + _bufferOffset); 2296 } 2297 glProgramUniformMatrix3fv( 2298 (GLuint)program, 2299 (GLint)location, 2300 (GLsizei)count, 2301 (GLboolean)transpose, 2302 (GLfloat *)value 2303 ); 2304 if (_array) { 2305 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 2306 } 2307} 2308 2309/* void glProgramUniformMatrix4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2310static void 2311android_glProgramUniformMatrix4fv__IIIZ_3FI 2312 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { 2313 jint _exception = 0; 2314 const char * _exceptionType = NULL; 2315 const char * _exceptionMessage = NULL; 2316 GLfloat *value_base = (GLfloat *) 0; 2317 jint _remaining; 2318 GLfloat *value = (GLfloat *) 0; 2319 2320 if (!value_ref) { 2321 _exception = 1; 2322 _exceptionType = "java/lang/IllegalArgumentException"; 2323 _exceptionMessage = "value == null"; 2324 goto exit; 2325 } 2326 if (offset < 0) { 2327 _exception = 1; 2328 _exceptionType = "java/lang/IllegalArgumentException"; 2329 _exceptionMessage = "offset < 0"; 2330 goto exit; 2331 } 2332 _remaining = _env->GetArrayLength(value_ref) - offset; 2333 value_base = (GLfloat *) 2334 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 2335 value = value_base + offset; 2336 2337 glProgramUniformMatrix4fv( 2338 (GLuint)program, 2339 (GLint)location, 2340 (GLsizei)count, 2341 (GLboolean)transpose, 2342 (GLfloat *)value 2343 ); 2344 2345exit: 2346 if (value_base) { 2347 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 2348 JNI_ABORT); 2349 } 2350 if (_exception) { 2351 jniThrowException(_env, _exceptionType, _exceptionMessage); 2352 } 2353} 2354 2355/* void glProgramUniformMatrix4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2356static void 2357android_glProgramUniformMatrix4fv__IIIZLjava_nio_FloatBuffer_2 2358 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { 2359 jfloatArray _array = (jfloatArray) 0; 2360 jint _bufferOffset = (jint) 0; 2361 jint _remaining; 2362 GLfloat *value = (GLfloat *) 0; 2363 2364 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2365 if (value == NULL) { 2366 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 2367 value = (GLfloat *) (_valueBase + _bufferOffset); 2368 } 2369 glProgramUniformMatrix4fv( 2370 (GLuint)program, 2371 (GLint)location, 2372 (GLsizei)count, 2373 (GLboolean)transpose, 2374 (GLfloat *)value 2375 ); 2376 if (_array) { 2377 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 2378 } 2379} 2380 2381/* void glProgramUniformMatrix2x3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2382static void 2383android_glProgramUniformMatrix2x3fv__IIIZ_3FI 2384 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { 2385 jint _exception = 0; 2386 const char * _exceptionType = NULL; 2387 const char * _exceptionMessage = NULL; 2388 GLfloat *value_base = (GLfloat *) 0; 2389 jint _remaining; 2390 GLfloat *value = (GLfloat *) 0; 2391 2392 if (!value_ref) { 2393 _exception = 1; 2394 _exceptionType = "java/lang/IllegalArgumentException"; 2395 _exceptionMessage = "value == null"; 2396 goto exit; 2397 } 2398 if (offset < 0) { 2399 _exception = 1; 2400 _exceptionType = "java/lang/IllegalArgumentException"; 2401 _exceptionMessage = "offset < 0"; 2402 goto exit; 2403 } 2404 _remaining = _env->GetArrayLength(value_ref) - offset; 2405 value_base = (GLfloat *) 2406 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 2407 value = value_base + offset; 2408 2409 glProgramUniformMatrix2x3fv( 2410 (GLuint)program, 2411 (GLint)location, 2412 (GLsizei)count, 2413 (GLboolean)transpose, 2414 (GLfloat *)value 2415 ); 2416 2417exit: 2418 if (value_base) { 2419 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 2420 JNI_ABORT); 2421 } 2422 if (_exception) { 2423 jniThrowException(_env, _exceptionType, _exceptionMessage); 2424 } 2425} 2426 2427/* void glProgramUniformMatrix2x3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2428static void 2429android_glProgramUniformMatrix2x3fv__IIIZLjava_nio_FloatBuffer_2 2430 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { 2431 jfloatArray _array = (jfloatArray) 0; 2432 jint _bufferOffset = (jint) 0; 2433 jint _remaining; 2434 GLfloat *value = (GLfloat *) 0; 2435 2436 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2437 if (value == NULL) { 2438 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 2439 value = (GLfloat *) (_valueBase + _bufferOffset); 2440 } 2441 glProgramUniformMatrix2x3fv( 2442 (GLuint)program, 2443 (GLint)location, 2444 (GLsizei)count, 2445 (GLboolean)transpose, 2446 (GLfloat *)value 2447 ); 2448 if (_array) { 2449 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 2450 } 2451} 2452 2453/* void glProgramUniformMatrix3x2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2454static void 2455android_glProgramUniformMatrix3x2fv__IIIZ_3FI 2456 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { 2457 jint _exception = 0; 2458 const char * _exceptionType = NULL; 2459 const char * _exceptionMessage = NULL; 2460 GLfloat *value_base = (GLfloat *) 0; 2461 jint _remaining; 2462 GLfloat *value = (GLfloat *) 0; 2463 2464 if (!value_ref) { 2465 _exception = 1; 2466 _exceptionType = "java/lang/IllegalArgumentException"; 2467 _exceptionMessage = "value == null"; 2468 goto exit; 2469 } 2470 if (offset < 0) { 2471 _exception = 1; 2472 _exceptionType = "java/lang/IllegalArgumentException"; 2473 _exceptionMessage = "offset < 0"; 2474 goto exit; 2475 } 2476 _remaining = _env->GetArrayLength(value_ref) - offset; 2477 value_base = (GLfloat *) 2478 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 2479 value = value_base + offset; 2480 2481 glProgramUniformMatrix3x2fv( 2482 (GLuint)program, 2483 (GLint)location, 2484 (GLsizei)count, 2485 (GLboolean)transpose, 2486 (GLfloat *)value 2487 ); 2488 2489exit: 2490 if (value_base) { 2491 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 2492 JNI_ABORT); 2493 } 2494 if (_exception) { 2495 jniThrowException(_env, _exceptionType, _exceptionMessage); 2496 } 2497} 2498 2499/* void glProgramUniformMatrix3x2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2500static void 2501android_glProgramUniformMatrix3x2fv__IIIZLjava_nio_FloatBuffer_2 2502 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { 2503 jfloatArray _array = (jfloatArray) 0; 2504 jint _bufferOffset = (jint) 0; 2505 jint _remaining; 2506 GLfloat *value = (GLfloat *) 0; 2507 2508 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2509 if (value == NULL) { 2510 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 2511 value = (GLfloat *) (_valueBase + _bufferOffset); 2512 } 2513 glProgramUniformMatrix3x2fv( 2514 (GLuint)program, 2515 (GLint)location, 2516 (GLsizei)count, 2517 (GLboolean)transpose, 2518 (GLfloat *)value 2519 ); 2520 if (_array) { 2521 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 2522 } 2523} 2524 2525/* void glProgramUniformMatrix2x4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2526static void 2527android_glProgramUniformMatrix2x4fv__IIIZ_3FI 2528 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { 2529 jint _exception = 0; 2530 const char * _exceptionType = NULL; 2531 const char * _exceptionMessage = NULL; 2532 GLfloat *value_base = (GLfloat *) 0; 2533 jint _remaining; 2534 GLfloat *value = (GLfloat *) 0; 2535 2536 if (!value_ref) { 2537 _exception = 1; 2538 _exceptionType = "java/lang/IllegalArgumentException"; 2539 _exceptionMessage = "value == null"; 2540 goto exit; 2541 } 2542 if (offset < 0) { 2543 _exception = 1; 2544 _exceptionType = "java/lang/IllegalArgumentException"; 2545 _exceptionMessage = "offset < 0"; 2546 goto exit; 2547 } 2548 _remaining = _env->GetArrayLength(value_ref) - offset; 2549 value_base = (GLfloat *) 2550 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 2551 value = value_base + offset; 2552 2553 glProgramUniformMatrix2x4fv( 2554 (GLuint)program, 2555 (GLint)location, 2556 (GLsizei)count, 2557 (GLboolean)transpose, 2558 (GLfloat *)value 2559 ); 2560 2561exit: 2562 if (value_base) { 2563 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 2564 JNI_ABORT); 2565 } 2566 if (_exception) { 2567 jniThrowException(_env, _exceptionType, _exceptionMessage); 2568 } 2569} 2570 2571/* void glProgramUniformMatrix2x4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2572static void 2573android_glProgramUniformMatrix2x4fv__IIIZLjava_nio_FloatBuffer_2 2574 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { 2575 jfloatArray _array = (jfloatArray) 0; 2576 jint _bufferOffset = (jint) 0; 2577 jint _remaining; 2578 GLfloat *value = (GLfloat *) 0; 2579 2580 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2581 if (value == NULL) { 2582 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 2583 value = (GLfloat *) (_valueBase + _bufferOffset); 2584 } 2585 glProgramUniformMatrix2x4fv( 2586 (GLuint)program, 2587 (GLint)location, 2588 (GLsizei)count, 2589 (GLboolean)transpose, 2590 (GLfloat *)value 2591 ); 2592 if (_array) { 2593 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 2594 } 2595} 2596 2597/* void glProgramUniformMatrix4x2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2598static void 2599android_glProgramUniformMatrix4x2fv__IIIZ_3FI 2600 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { 2601 jint _exception = 0; 2602 const char * _exceptionType = NULL; 2603 const char * _exceptionMessage = NULL; 2604 GLfloat *value_base = (GLfloat *) 0; 2605 jint _remaining; 2606 GLfloat *value = (GLfloat *) 0; 2607 2608 if (!value_ref) { 2609 _exception = 1; 2610 _exceptionType = "java/lang/IllegalArgumentException"; 2611 _exceptionMessage = "value == null"; 2612 goto exit; 2613 } 2614 if (offset < 0) { 2615 _exception = 1; 2616 _exceptionType = "java/lang/IllegalArgumentException"; 2617 _exceptionMessage = "offset < 0"; 2618 goto exit; 2619 } 2620 _remaining = _env->GetArrayLength(value_ref) - offset; 2621 value_base = (GLfloat *) 2622 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 2623 value = value_base + offset; 2624 2625 glProgramUniformMatrix4x2fv( 2626 (GLuint)program, 2627 (GLint)location, 2628 (GLsizei)count, 2629 (GLboolean)transpose, 2630 (GLfloat *)value 2631 ); 2632 2633exit: 2634 if (value_base) { 2635 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 2636 JNI_ABORT); 2637 } 2638 if (_exception) { 2639 jniThrowException(_env, _exceptionType, _exceptionMessage); 2640 } 2641} 2642 2643/* void glProgramUniformMatrix4x2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2644static void 2645android_glProgramUniformMatrix4x2fv__IIIZLjava_nio_FloatBuffer_2 2646 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { 2647 jfloatArray _array = (jfloatArray) 0; 2648 jint _bufferOffset = (jint) 0; 2649 jint _remaining; 2650 GLfloat *value = (GLfloat *) 0; 2651 2652 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2653 if (value == NULL) { 2654 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 2655 value = (GLfloat *) (_valueBase + _bufferOffset); 2656 } 2657 glProgramUniformMatrix4x2fv( 2658 (GLuint)program, 2659 (GLint)location, 2660 (GLsizei)count, 2661 (GLboolean)transpose, 2662 (GLfloat *)value 2663 ); 2664 if (_array) { 2665 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 2666 } 2667} 2668 2669/* void glProgramUniformMatrix3x4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2670static void 2671android_glProgramUniformMatrix3x4fv__IIIZ_3FI 2672 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { 2673 jint _exception = 0; 2674 const char * _exceptionType = NULL; 2675 const char * _exceptionMessage = NULL; 2676 GLfloat *value_base = (GLfloat *) 0; 2677 jint _remaining; 2678 GLfloat *value = (GLfloat *) 0; 2679 2680 if (!value_ref) { 2681 _exception = 1; 2682 _exceptionType = "java/lang/IllegalArgumentException"; 2683 _exceptionMessage = "value == null"; 2684 goto exit; 2685 } 2686 if (offset < 0) { 2687 _exception = 1; 2688 _exceptionType = "java/lang/IllegalArgumentException"; 2689 _exceptionMessage = "offset < 0"; 2690 goto exit; 2691 } 2692 _remaining = _env->GetArrayLength(value_ref) - offset; 2693 value_base = (GLfloat *) 2694 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 2695 value = value_base + offset; 2696 2697 glProgramUniformMatrix3x4fv( 2698 (GLuint)program, 2699 (GLint)location, 2700 (GLsizei)count, 2701 (GLboolean)transpose, 2702 (GLfloat *)value 2703 ); 2704 2705exit: 2706 if (value_base) { 2707 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 2708 JNI_ABORT); 2709 } 2710 if (_exception) { 2711 jniThrowException(_env, _exceptionType, _exceptionMessage); 2712 } 2713} 2714 2715/* void glProgramUniformMatrix3x4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2716static void 2717android_glProgramUniformMatrix3x4fv__IIIZLjava_nio_FloatBuffer_2 2718 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { 2719 jfloatArray _array = (jfloatArray) 0; 2720 jint _bufferOffset = (jint) 0; 2721 jint _remaining; 2722 GLfloat *value = (GLfloat *) 0; 2723 2724 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2725 if (value == NULL) { 2726 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 2727 value = (GLfloat *) (_valueBase + _bufferOffset); 2728 } 2729 glProgramUniformMatrix3x4fv( 2730 (GLuint)program, 2731 (GLint)location, 2732 (GLsizei)count, 2733 (GLboolean)transpose, 2734 (GLfloat *)value 2735 ); 2736 if (_array) { 2737 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 2738 } 2739} 2740 2741/* void glProgramUniformMatrix4x3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2742static void 2743android_glProgramUniformMatrix4x3fv__IIIZ_3FI 2744 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { 2745 jint _exception = 0; 2746 const char * _exceptionType = NULL; 2747 const char * _exceptionMessage = NULL; 2748 GLfloat *value_base = (GLfloat *) 0; 2749 jint _remaining; 2750 GLfloat *value = (GLfloat *) 0; 2751 2752 if (!value_ref) { 2753 _exception = 1; 2754 _exceptionType = "java/lang/IllegalArgumentException"; 2755 _exceptionMessage = "value == null"; 2756 goto exit; 2757 } 2758 if (offset < 0) { 2759 _exception = 1; 2760 _exceptionType = "java/lang/IllegalArgumentException"; 2761 _exceptionMessage = "offset < 0"; 2762 goto exit; 2763 } 2764 _remaining = _env->GetArrayLength(value_ref) - offset; 2765 value_base = (GLfloat *) 2766 _env->GetFloatArrayElements(value_ref, (jboolean *)0); 2767 value = value_base + offset; 2768 2769 glProgramUniformMatrix4x3fv( 2770 (GLuint)program, 2771 (GLint)location, 2772 (GLsizei)count, 2773 (GLboolean)transpose, 2774 (GLfloat *)value 2775 ); 2776 2777exit: 2778 if (value_base) { 2779 _env->ReleaseFloatArrayElements(value_ref, (jfloat*)value_base, 2780 JNI_ABORT); 2781 } 2782 if (_exception) { 2783 jniThrowException(_env, _exceptionType, _exceptionMessage); 2784 } 2785} 2786 2787/* void glProgramUniformMatrix4x3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ 2788static void 2789android_glProgramUniformMatrix4x3fv__IIIZLjava_nio_FloatBuffer_2 2790 (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { 2791 jfloatArray _array = (jfloatArray) 0; 2792 jint _bufferOffset = (jint) 0; 2793 jint _remaining; 2794 GLfloat *value = (GLfloat *) 0; 2795 2796 value = (GLfloat *)getPointer(_env, value_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2797 if (value == NULL) { 2798 char * _valueBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 2799 value = (GLfloat *) (_valueBase + _bufferOffset); 2800 } 2801 glProgramUniformMatrix4x3fv( 2802 (GLuint)program, 2803 (GLint)location, 2804 (GLsizei)count, 2805 (GLboolean)transpose, 2806 (GLfloat *)value 2807 ); 2808 if (_array) { 2809 _env->ReleaseFloatArrayElements(_array, (jfloat*)value, JNI_ABORT); 2810 } 2811} 2812 2813/* void glValidateProgramPipeline ( GLuint pipeline ) */ 2814static void 2815android_glValidateProgramPipeline__I 2816 (JNIEnv *_env, jobject _this, jint pipeline) { 2817 glValidateProgramPipeline( 2818 (GLuint)pipeline 2819 ); 2820} 2821 2822#include <stdlib.h> 2823 2824/* void glGetProgramPipelineInfoLog ( GLuint shader, GLsizei maxLength, GLsizei* length, GLchar* infoLog ) */ 2825static jstring android_glGetProgramPipelineInfoLog(JNIEnv *_env, jobject, jint shader) { 2826 GLint infoLen = 0; 2827 glGetProgramPipelineiv(shader, GL_INFO_LOG_LENGTH, &infoLen); 2828 if (!infoLen) { 2829 return _env->NewStringUTF(""); 2830 } 2831 char* buf = (char*) malloc(infoLen); 2832 if (buf == NULL) { 2833 jniThrowException(_env, "java/lang/OutOfMemoryError", "out of memory"); 2834 return NULL; 2835 } 2836 glGetProgramPipelineInfoLog(shader, infoLen, NULL, buf); 2837 jstring result = _env->NewStringUTF(buf); 2838 free(buf); 2839 return result; 2840} 2841/* void glBindImageTexture ( GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format ) */ 2842static void 2843android_glBindImageTexture__IIIZIII 2844 (JNIEnv *_env, jobject _this, jint unit, jint texture, jint level, jboolean layered, jint layer, jint access, jint format) { 2845 glBindImageTexture( 2846 (GLuint)unit, 2847 (GLuint)texture, 2848 (GLint)level, 2849 (GLboolean)layered, 2850 (GLint)layer, 2851 (GLenum)access, 2852 (GLenum)format 2853 ); 2854} 2855 2856/* void glGetBooleani_v ( GLenum target, GLuint index, GLboolean *data ) */ 2857static void 2858android_glGetBooleani_v__II_3ZI 2859 (JNIEnv *_env, jobject _this, jint target, jint index, jbooleanArray data_ref, jint offset) { 2860 jint _exception = 0; 2861 const char * _exceptionType = NULL; 2862 const char * _exceptionMessage = NULL; 2863 GLboolean *data_base = (GLboolean *) 0; 2864 jint _remaining; 2865 GLboolean *data = (GLboolean *) 0; 2866 2867 if (!data_ref) { 2868 _exception = 1; 2869 _exceptionType = "java/lang/IllegalArgumentException"; 2870 _exceptionMessage = "data == null"; 2871 goto exit; 2872 } 2873 if (offset < 0) { 2874 _exception = 1; 2875 _exceptionType = "java/lang/IllegalArgumentException"; 2876 _exceptionMessage = "offset < 0"; 2877 goto exit; 2878 } 2879 _remaining = _env->GetArrayLength(data_ref) - offset; 2880 data_base = (GLboolean *) 2881 _env->GetBooleanArrayElements(data_ref, (jboolean *)0); 2882 data = data_base + offset; 2883 2884 glGetBooleani_v( 2885 (GLenum)target, 2886 (GLuint)index, 2887 (GLboolean *)data 2888 ); 2889 2890exit: 2891 if (data_base) { 2892 _env->ReleaseBooleanArrayElements(data_ref, (jboolean*)data_base, 2893 _exception ? JNI_ABORT: 0); 2894 } 2895 if (_exception) { 2896 jniThrowException(_env, _exceptionType, _exceptionMessage); 2897 } 2898} 2899 2900/* void glGetBooleani_v ( GLenum target, GLuint index, GLboolean *data ) */ 2901static void 2902android_glGetBooleani_v__IILjava_nio_IntBuffer_2 2903 (JNIEnv *_env, jobject _this, jint target, jint index, jobject data_buf) { 2904 jintArray _array = (jintArray) 0; 2905 jint _bufferOffset = (jint) 0; 2906 jint _remaining; 2907 GLboolean *data = (GLboolean *) 0; 2908 2909 data = (GLboolean *)getPointer(_env, data_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 2910 if (data == NULL) { 2911 char * _dataBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 2912 data = (GLboolean *) (_dataBase + _bufferOffset); 2913 } 2914 glGetBooleani_v( 2915 (GLenum)target, 2916 (GLuint)index, 2917 (GLboolean *)data 2918 ); 2919 if (_array) { 2920 _env->ReleaseIntArrayElements(_array, (jint*)data, 0); 2921 } 2922} 2923 2924/* void glMemoryBarrier ( GLbitfield barriers ) */ 2925static void 2926android_glMemoryBarrier__I 2927 (JNIEnv *_env, jobject _this, jint barriers) { 2928 glMemoryBarrier( 2929 (GLbitfield)barriers 2930 ); 2931} 2932 2933/* void glMemoryBarrierByRegion ( GLbitfield barriers ) */ 2934static void 2935android_glMemoryBarrierByRegion__I 2936 (JNIEnv *_env, jobject _this, jint barriers) { 2937 glMemoryBarrierByRegion( 2938 (GLbitfield)barriers 2939 ); 2940} 2941 2942/* void glTexStorage2DMultisample ( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations ) */ 2943static void 2944android_glTexStorage2DMultisample__IIIIIZ 2945 (JNIEnv *_env, jobject _this, jint target, jint samples, jint internalformat, jint width, jint height, jboolean fixedsamplelocations) { 2946 glTexStorage2DMultisample( 2947 (GLenum)target, 2948 (GLsizei)samples, 2949 (GLenum)internalformat, 2950 (GLsizei)width, 2951 (GLsizei)height, 2952 (GLboolean)fixedsamplelocations 2953 ); 2954} 2955 2956/* void glGetMultisamplefv ( GLenum pname, GLuint index, GLfloat *val ) */ 2957static void 2958android_glGetMultisamplefv__II_3FI 2959 (JNIEnv *_env, jobject _this, jint pname, jint index, jfloatArray val_ref, jint offset) { 2960 jint _exception = 0; 2961 const char * _exceptionType = NULL; 2962 const char * _exceptionMessage = NULL; 2963 GLfloat *val_base = (GLfloat *) 0; 2964 jint _remaining; 2965 GLfloat *val = (GLfloat *) 0; 2966 2967 if (!val_ref) { 2968 _exception = 1; 2969 _exceptionType = "java/lang/IllegalArgumentException"; 2970 _exceptionMessage = "val == null"; 2971 goto exit; 2972 } 2973 if (offset < 0) { 2974 _exception = 1; 2975 _exceptionType = "java/lang/IllegalArgumentException"; 2976 _exceptionMessage = "offset < 0"; 2977 goto exit; 2978 } 2979 _remaining = _env->GetArrayLength(val_ref) - offset; 2980 val_base = (GLfloat *) 2981 _env->GetFloatArrayElements(val_ref, (jboolean *)0); 2982 val = val_base + offset; 2983 2984 glGetMultisamplefv( 2985 (GLenum)pname, 2986 (GLuint)index, 2987 (GLfloat *)val 2988 ); 2989 2990exit: 2991 if (val_base) { 2992 _env->ReleaseFloatArrayElements(val_ref, (jfloat*)val_base, 2993 _exception ? JNI_ABORT: 0); 2994 } 2995 if (_exception) { 2996 jniThrowException(_env, _exceptionType, _exceptionMessage); 2997 } 2998} 2999 3000/* void glGetMultisamplefv ( GLenum pname, GLuint index, GLfloat *val ) */ 3001static void 3002android_glGetMultisamplefv__IILjava_nio_FloatBuffer_2 3003 (JNIEnv *_env, jobject _this, jint pname, jint index, jobject val_buf) { 3004 jfloatArray _array = (jfloatArray) 0; 3005 jint _bufferOffset = (jint) 0; 3006 jint _remaining; 3007 GLfloat *val = (GLfloat *) 0; 3008 3009 val = (GLfloat *)getPointer(_env, val_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3010 if (val == NULL) { 3011 char * _valBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 3012 val = (GLfloat *) (_valBase + _bufferOffset); 3013 } 3014 glGetMultisamplefv( 3015 (GLenum)pname, 3016 (GLuint)index, 3017 (GLfloat *)val 3018 ); 3019 if (_array) { 3020 _env->ReleaseFloatArrayElements(_array, (jfloat*)val, 0); 3021 } 3022} 3023 3024/* void glSampleMaski ( GLuint maskNumber, GLbitfield mask ) */ 3025static void 3026android_glSampleMaski__II 3027 (JNIEnv *_env, jobject _this, jint maskNumber, jint mask) { 3028 glSampleMaski( 3029 (GLuint)maskNumber, 3030 (GLbitfield)mask 3031 ); 3032} 3033 3034/* void glGetTexLevelParameteriv ( GLenum target, GLint level, GLenum pname, GLint *params ) */ 3035static void 3036android_glGetTexLevelParameteriv__III_3II 3037 (JNIEnv *_env, jobject _this, jint target, jint level, jint pname, jintArray params_ref, jint offset) { 3038 jint _exception = 0; 3039 const char * _exceptionType = NULL; 3040 const char * _exceptionMessage = NULL; 3041 GLint *params_base = (GLint *) 0; 3042 jint _remaining; 3043 GLint *params = (GLint *) 0; 3044 3045 if (!params_ref) { 3046 _exception = 1; 3047 _exceptionType = "java/lang/IllegalArgumentException"; 3048 _exceptionMessage = "params == null"; 3049 goto exit; 3050 } 3051 if (offset < 0) { 3052 _exception = 1; 3053 _exceptionType = "java/lang/IllegalArgumentException"; 3054 _exceptionMessage = "offset < 0"; 3055 goto exit; 3056 } 3057 _remaining = _env->GetArrayLength(params_ref) - offset; 3058 params_base = (GLint *) 3059 _env->GetIntArrayElements(params_ref, (jboolean *)0); 3060 params = params_base + offset; 3061 3062 glGetTexLevelParameteriv( 3063 (GLenum)target, 3064 (GLint)level, 3065 (GLenum)pname, 3066 (GLint *)params 3067 ); 3068 3069exit: 3070 if (params_base) { 3071 _env->ReleaseIntArrayElements(params_ref, (jint*)params_base, 3072 _exception ? JNI_ABORT: 0); 3073 } 3074 if (_exception) { 3075 jniThrowException(_env, _exceptionType, _exceptionMessage); 3076 } 3077} 3078 3079/* void glGetTexLevelParameteriv ( GLenum target, GLint level, GLenum pname, GLint *params ) */ 3080static void 3081android_glGetTexLevelParameteriv__IIILjava_nio_IntBuffer_2 3082 (JNIEnv *_env, jobject _this, jint target, jint level, jint pname, jobject params_buf) { 3083 jintArray _array = (jintArray) 0; 3084 jint _bufferOffset = (jint) 0; 3085 jint _remaining; 3086 GLint *params = (GLint *) 0; 3087 3088 params = (GLint *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3089 if (params == NULL) { 3090 char * _paramsBase = (char *)_env->GetIntArrayElements(_array, (jboolean *) 0); 3091 params = (GLint *) (_paramsBase + _bufferOffset); 3092 } 3093 glGetTexLevelParameteriv( 3094 (GLenum)target, 3095 (GLint)level, 3096 (GLenum)pname, 3097 (GLint *)params 3098 ); 3099 if (_array) { 3100 _env->ReleaseIntArrayElements(_array, (jint*)params, 0); 3101 } 3102} 3103 3104/* void glGetTexLevelParameterfv ( GLenum target, GLint level, GLenum pname, GLfloat *params ) */ 3105static void 3106android_glGetTexLevelParameterfv__III_3FI 3107 (JNIEnv *_env, jobject _this, jint target, jint level, jint pname, jfloatArray params_ref, jint offset) { 3108 jint _exception = 0; 3109 const char * _exceptionType = NULL; 3110 const char * _exceptionMessage = NULL; 3111 GLfloat *params_base = (GLfloat *) 0; 3112 jint _remaining; 3113 GLfloat *params = (GLfloat *) 0; 3114 3115 if (!params_ref) { 3116 _exception = 1; 3117 _exceptionType = "java/lang/IllegalArgumentException"; 3118 _exceptionMessage = "params == null"; 3119 goto exit; 3120 } 3121 if (offset < 0) { 3122 _exception = 1; 3123 _exceptionType = "java/lang/IllegalArgumentException"; 3124 _exceptionMessage = "offset < 0"; 3125 goto exit; 3126 } 3127 _remaining = _env->GetArrayLength(params_ref) - offset; 3128 params_base = (GLfloat *) 3129 _env->GetFloatArrayElements(params_ref, (jboolean *)0); 3130 params = params_base + offset; 3131 3132 glGetTexLevelParameterfv( 3133 (GLenum)target, 3134 (GLint)level, 3135 (GLenum)pname, 3136 (GLfloat *)params 3137 ); 3138 3139exit: 3140 if (params_base) { 3141 _env->ReleaseFloatArrayElements(params_ref, (jfloat*)params_base, 3142 _exception ? JNI_ABORT: 0); 3143 } 3144 if (_exception) { 3145 jniThrowException(_env, _exceptionType, _exceptionMessage); 3146 } 3147} 3148 3149/* void glGetTexLevelParameterfv ( GLenum target, GLint level, GLenum pname, GLfloat *params ) */ 3150static void 3151android_glGetTexLevelParameterfv__IIILjava_nio_FloatBuffer_2 3152 (JNIEnv *_env, jobject _this, jint target, jint level, jint pname, jobject params_buf) { 3153 jfloatArray _array = (jfloatArray) 0; 3154 jint _bufferOffset = (jint) 0; 3155 jint _remaining; 3156 GLfloat *params = (GLfloat *) 0; 3157 3158 params = (GLfloat *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset); 3159 if (params == NULL) { 3160 char * _paramsBase = (char *)_env->GetFloatArrayElements(_array, (jboolean *) 0); 3161 params = (GLfloat *) (_paramsBase + _bufferOffset); 3162 } 3163 glGetTexLevelParameterfv( 3164 (GLenum)target, 3165 (GLint)level, 3166 (GLenum)pname, 3167 (GLfloat *)params 3168 ); 3169 if (_array) { 3170 _env->ReleaseFloatArrayElements(_array, (jfloat*)params, 0); 3171 } 3172} 3173 3174/* void glBindVertexBuffer ( GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride ) */ 3175static void 3176android_glBindVertexBuffer__IIJI 3177 (JNIEnv *_env, jobject _this, jint bindingindex, jint buffer, jlong offset, jint stride) { 3178 if (sizeof(GLintptr) != sizeof(jlong) && (offset < LONG_MIN || offset > LONG_MAX)) { 3179 jniThrowException(_env, "java/lang/IllegalArgumentException", "offset too large"); 3180 return; 3181 } 3182 glBindVertexBuffer( 3183 (GLuint)bindingindex, 3184 (GLuint)buffer, 3185 (GLintptr)offset, 3186 (GLsizei)stride 3187 ); 3188} 3189/* void glVertexAttribFormat ( GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset ) */ 3190static void 3191android_glVertexAttribFormat__IIIZI 3192 (JNIEnv *_env, jobject _this, jint attribindex, jint size, jint type, jboolean normalized, jint relativeoffset) { 3193 glVertexAttribFormat( 3194 (GLuint)attribindex, 3195 (GLint)size, 3196 (GLenum)type, 3197 (GLboolean)normalized, 3198 (GLuint)relativeoffset 3199 ); 3200} 3201 3202/* void glVertexAttribIFormat ( GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset ) */ 3203static void 3204android_glVertexAttribIFormat__IIII 3205 (JNIEnv *_env, jobject _this, jint attribindex, jint size, jint type, jint relativeoffset) { 3206 glVertexAttribIFormat( 3207 (GLuint)attribindex, 3208 (GLint)size, 3209 (GLenum)type, 3210 (GLuint)relativeoffset 3211 ); 3212} 3213 3214/* void glVertexAttribBinding ( GLuint attribindex, GLuint bindingindex ) */ 3215static void 3216android_glVertexAttribBinding__II 3217 (JNIEnv *_env, jobject _this, jint attribindex, jint bindingindex) { 3218 glVertexAttribBinding( 3219 (GLuint)attribindex, 3220 (GLuint)bindingindex 3221 ); 3222} 3223 3224/* void glVertexBindingDivisor ( GLuint bindingindex, GLuint divisor ) */ 3225static void 3226android_glVertexBindingDivisor__II 3227 (JNIEnv *_env, jobject _this, jint bindingindex, jint divisor) { 3228 glVertexBindingDivisor( 3229 (GLuint)bindingindex, 3230 (GLuint)divisor 3231 ); 3232} 3233 3234static const char *classPathName = "android/opengl/GLES31"; 3235 3236static const JNINativeMethod methods[] = { 3237{"_nativeClassInit", "()V", (void*)nativeClassInit }, 3238{"glDispatchCompute", "(III)V", (void *) android_glDispatchCompute__III }, 3239{"glDispatchComputeIndirect", "(J)V", (void *) android_glDispatchComputeIndirect }, 3240{"glDrawArraysIndirect", "(IJ)V", (void *) android_glDrawArraysIndirect }, 3241{"glDrawElementsIndirect", "(IIJ)V", (void *) android_glDrawElementsIndirect }, 3242{"glFramebufferParameteri", "(III)V", (void *) android_glFramebufferParameteri__III }, 3243{"glGetFramebufferParameteriv", "(II[II)V", (void *) android_glGetFramebufferParameteriv__II_3II }, 3244{"glGetFramebufferParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetFramebufferParameteriv__IILjava_nio_IntBuffer_2 }, 3245{"glGetProgramInterfaceiv", "(III[II)V", (void *) android_glGetProgramInterfaceiv__III_3II }, 3246{"glGetProgramInterfaceiv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetProgramInterfaceiv__IIILjava_nio_IntBuffer_2 }, 3247{"glGetProgramResourceIndex", "(IILjava/lang/String;)I", (void *) android_glGetProgramResourceIndex__IILjava_lang_String_2 }, 3248{"glGetProgramResourceName", "(III)Ljava/lang/String;", (void *) android_glGetProgramResourceName }, 3249{"glGetProgramResourceiv", "(IIII[III[II[II)V", (void *) android_glGetProgramResourceiv__IIII_3III_3II_3II }, 3250{"glGetProgramResourceiv", "(IIIILjava/nio/IntBuffer;ILjava/nio/IntBuffer;Ljava/nio/IntBuffer;)V", (void *) android_glGetProgramResourceiv__IIIILjava_nio_IntBuffer_2ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 }, 3251{"glGetProgramResourceLocation", "(IILjava/lang/String;)I", (void *) android_glGetProgramResourceLocation__IILjava_lang_String_2 }, 3252{"glUseProgramStages", "(III)V", (void *) android_glUseProgramStages__III }, 3253{"glActiveShaderProgram", "(II)V", (void *) android_glActiveShaderProgram__II }, 3254{"glCreateShaderProgramv", "(I[Ljava/lang/String;)I", (void *) android_glCreateShaderProgramv }, 3255{"glBindProgramPipeline", "(I)V", (void *) android_glBindProgramPipeline__I }, 3256{"glDeleteProgramPipelines", "(I[II)V", (void *) android_glDeleteProgramPipelines__I_3II }, 3257{"glDeleteProgramPipelines", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteProgramPipelines__ILjava_nio_IntBuffer_2 }, 3258{"glGenProgramPipelines", "(I[II)V", (void *) android_glGenProgramPipelines__I_3II }, 3259{"glGenProgramPipelines", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenProgramPipelines__ILjava_nio_IntBuffer_2 }, 3260{"glIsProgramPipeline", "(I)Z", (void *) android_glIsProgramPipeline__I }, 3261{"glGetProgramPipelineiv", "(II[II)V", (void *) android_glGetProgramPipelineiv__II_3II }, 3262{"glGetProgramPipelineiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetProgramPipelineiv__IILjava_nio_IntBuffer_2 }, 3263{"glProgramUniform1i", "(III)V", (void *) android_glProgramUniform1i__III }, 3264{"glProgramUniform2i", "(IIII)V", (void *) android_glProgramUniform2i__IIII }, 3265{"glProgramUniform3i", "(IIIII)V", (void *) android_glProgramUniform3i__IIIII }, 3266{"glProgramUniform4i", "(IIIIII)V", (void *) android_glProgramUniform4i__IIIIII }, 3267{"glProgramUniform1ui", "(III)V", (void *) android_glProgramUniform1ui__III }, 3268{"glProgramUniform2ui", "(IIII)V", (void *) android_glProgramUniform2ui__IIII }, 3269{"glProgramUniform3ui", "(IIIII)V", (void *) android_glProgramUniform3ui__IIIII }, 3270{"glProgramUniform4ui", "(IIIIII)V", (void *) android_glProgramUniform4ui__IIIIII }, 3271{"glProgramUniform1f", "(IIF)V", (void *) android_glProgramUniform1f__IIF }, 3272{"glProgramUniform2f", "(IIFF)V", (void *) android_glProgramUniform2f__IIFF }, 3273{"glProgramUniform3f", "(IIFFF)V", (void *) android_glProgramUniform3f__IIFFF }, 3274{"glProgramUniform4f", "(IIFFFF)V", (void *) android_glProgramUniform4f__IIFFFF }, 3275{"glProgramUniform1iv", "(III[II)V", (void *) android_glProgramUniform1iv__III_3II }, 3276{"glProgramUniform1iv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform1iv__IIILjava_nio_IntBuffer_2 }, 3277{"glProgramUniform2iv", "(III[II)V", (void *) android_glProgramUniform2iv__III_3II }, 3278{"glProgramUniform2iv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform2iv__IIILjava_nio_IntBuffer_2 }, 3279{"glProgramUniform3iv", "(III[II)V", (void *) android_glProgramUniform3iv__III_3II }, 3280{"glProgramUniform3iv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform3iv__IIILjava_nio_IntBuffer_2 }, 3281{"glProgramUniform4iv", "(III[II)V", (void *) android_glProgramUniform4iv__III_3II }, 3282{"glProgramUniform4iv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform4iv__IIILjava_nio_IntBuffer_2 }, 3283{"glProgramUniform1uiv", "(III[II)V", (void *) android_glProgramUniform1uiv__III_3II }, 3284{"glProgramUniform1uiv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform1uiv__IIILjava_nio_IntBuffer_2 }, 3285{"glProgramUniform2uiv", "(III[II)V", (void *) android_glProgramUniform2uiv__III_3II }, 3286{"glProgramUniform2uiv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform2uiv__IIILjava_nio_IntBuffer_2 }, 3287{"glProgramUniform3uiv", "(III[II)V", (void *) android_glProgramUniform3uiv__III_3II }, 3288{"glProgramUniform3uiv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform3uiv__IIILjava_nio_IntBuffer_2 }, 3289{"glProgramUniform4uiv", "(III[II)V", (void *) android_glProgramUniform4uiv__III_3II }, 3290{"glProgramUniform4uiv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform4uiv__IIILjava_nio_IntBuffer_2 }, 3291{"glProgramUniform1fv", "(III[FI)V", (void *) android_glProgramUniform1fv__III_3FI }, 3292{"glProgramUniform1fv", "(IIILjava/nio/FloatBuffer;)V", (void *) android_glProgramUniform1fv__IIILjava_nio_FloatBuffer_2 }, 3293{"glProgramUniform2fv", "(III[FI)V", (void *) android_glProgramUniform2fv__III_3FI }, 3294{"glProgramUniform2fv", "(IIILjava/nio/FloatBuffer;)V", (void *) android_glProgramUniform2fv__IIILjava_nio_FloatBuffer_2 }, 3295{"glProgramUniform3fv", "(III[FI)V", (void *) android_glProgramUniform3fv__III_3FI }, 3296{"glProgramUniform3fv", "(IIILjava/nio/FloatBuffer;)V", (void *) android_glProgramUniform3fv__IIILjava_nio_FloatBuffer_2 }, 3297{"glProgramUniform4fv", "(III[FI)V", (void *) android_glProgramUniform4fv__III_3FI }, 3298{"glProgramUniform4fv", "(IIILjava/nio/FloatBuffer;)V", (void *) android_glProgramUniform4fv__IIILjava_nio_FloatBuffer_2 }, 3299{"glProgramUniformMatrix2fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix2fv__IIIZ_3FI }, 3300{"glProgramUniformMatrix2fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix2fv__IIIZLjava_nio_FloatBuffer_2 }, 3301{"glProgramUniformMatrix3fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix3fv__IIIZ_3FI }, 3302{"glProgramUniformMatrix3fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix3fv__IIIZLjava_nio_FloatBuffer_2 }, 3303{"glProgramUniformMatrix4fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix4fv__IIIZ_3FI }, 3304{"glProgramUniformMatrix4fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix4fv__IIIZLjava_nio_FloatBuffer_2 }, 3305{"glProgramUniformMatrix2x3fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix2x3fv__IIIZ_3FI }, 3306{"glProgramUniformMatrix2x3fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix2x3fv__IIIZLjava_nio_FloatBuffer_2 }, 3307{"glProgramUniformMatrix3x2fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix3x2fv__IIIZ_3FI }, 3308{"glProgramUniformMatrix3x2fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix3x2fv__IIIZLjava_nio_FloatBuffer_2 }, 3309{"glProgramUniformMatrix2x4fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix2x4fv__IIIZ_3FI }, 3310{"glProgramUniformMatrix2x4fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix2x4fv__IIIZLjava_nio_FloatBuffer_2 }, 3311{"glProgramUniformMatrix4x2fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix4x2fv__IIIZ_3FI }, 3312{"glProgramUniformMatrix4x2fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix4x2fv__IIIZLjava_nio_FloatBuffer_2 }, 3313{"glProgramUniformMatrix3x4fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix3x4fv__IIIZ_3FI }, 3314{"glProgramUniformMatrix3x4fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix3x4fv__IIIZLjava_nio_FloatBuffer_2 }, 3315{"glProgramUniformMatrix4x3fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix4x3fv__IIIZ_3FI }, 3316{"glProgramUniformMatrix4x3fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix4x3fv__IIIZLjava_nio_FloatBuffer_2 }, 3317{"glValidateProgramPipeline", "(I)V", (void *) android_glValidateProgramPipeline__I }, 3318{"glGetProgramPipelineInfoLog", "(I)Ljava/lang/String;", (void *) android_glGetProgramPipelineInfoLog }, 3319{"glBindImageTexture", "(IIIZIII)V", (void *) android_glBindImageTexture__IIIZIII }, 3320{"glGetBooleani_v", "(II[ZI)V", (void *) android_glGetBooleani_v__II_3ZI }, 3321{"glGetBooleani_v", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetBooleani_v__IILjava_nio_IntBuffer_2 }, 3322{"glMemoryBarrier", "(I)V", (void *) android_glMemoryBarrier__I }, 3323{"glMemoryBarrierByRegion", "(I)V", (void *) android_glMemoryBarrierByRegion__I }, 3324{"glTexStorage2DMultisample", "(IIIIIZ)V", (void *) android_glTexStorage2DMultisample__IIIIIZ }, 3325{"glGetMultisamplefv", "(II[FI)V", (void *) android_glGetMultisamplefv__II_3FI }, 3326{"glGetMultisamplefv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetMultisamplefv__IILjava_nio_FloatBuffer_2 }, 3327{"glSampleMaski", "(II)V", (void *) android_glSampleMaski__II }, 3328{"glGetTexLevelParameteriv", "(III[II)V", (void *) android_glGetTexLevelParameteriv__III_3II }, 3329{"glGetTexLevelParameteriv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetTexLevelParameteriv__IIILjava_nio_IntBuffer_2 }, 3330{"glGetTexLevelParameterfv", "(III[FI)V", (void *) android_glGetTexLevelParameterfv__III_3FI }, 3331{"glGetTexLevelParameterfv", "(IIILjava/nio/FloatBuffer;)V", (void *) android_glGetTexLevelParameterfv__IIILjava_nio_FloatBuffer_2 }, 3332{"glBindVertexBuffer", "(IIJI)V", (void *) android_glBindVertexBuffer__IIJI }, 3333{"glVertexAttribFormat", "(IIIZI)V", (void *) android_glVertexAttribFormat__IIIZI }, 3334{"glVertexAttribIFormat", "(IIII)V", (void *) android_glVertexAttribIFormat__IIII }, 3335{"glVertexAttribBinding", "(II)V", (void *) android_glVertexAttribBinding__II }, 3336{"glVertexBindingDivisor", "(II)V", (void *) android_glVertexBindingDivisor__II }, 3337}; 3338 3339int register_android_opengl_jni_GLES31(JNIEnv *_env) 3340{ 3341 int err; 3342 err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods)); 3343 return err; 3344} 3345