core/jni/android_opengl_GLES31Ext.cpp

   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 #include <GLES3/gl31.h>
  20 #include <GLES2/gl2ext.h>
  21
  22 #include <jni.h>
  23 #include <JNIHelp.h>
  24 #include <android_runtime/AndroidRuntime.h>
  25 #include <utils/misc.h>
  26 #include <assert.h>
  27
  28 static int initialized = 0;
  29
  30 static jclass nioAccessClass;
  31 static jclass bufferClass;
  32 static jmethodID getBasePointerID;
  33 static jmethodID getBaseArrayID;
  34 static jmethodID getBaseArrayOffsetID;
  35 static jfieldID positionID;
  36 static jfieldID limitID;
  37 static jfieldID elementSizeShiftID;
  38
  39
  40 /* special calls implemented in Android's GLES wrapper used to more
  41  * efficiently bound-check passed arrays */
  42 extern "C" {
  43 #ifdef GL_VERSION_ES_CM_1_1
  44 GL_API void GL_APIENTRY glColorPointerBounds(GLint size, GLenum type, GLsizei stride,
  45         const GLvoid *ptr, GLsizei count);
  46 GL_API void GL_APIENTRY glNormalPointerBounds(GLenum type, GLsizei stride,
  47         const GLvoid *pointer, GLsizei count);
  48 GL_API void GL_APIENTRY glTexCoordPointerBounds(GLint size, GLenum type,
  49         GLsizei stride, const GLvoid *pointer, GLsizei count);
  50 GL_API void GL_APIENTRY glVertexPointerBounds(GLint size, GLenum type,
  51         GLsizei stride, const GLvoid *pointer, GLsizei count);
  52 GL_API void GL_APIENTRY glPointSizePointerOESBounds(GLenum type,
  53         GLsizei stride, const GLvoid *pointer, GLsizei count);
  54 GL_API void GL_APIENTRY glMatrixIndexPointerOESBounds(GLint size, GLenum type,
  55         GLsizei stride, const GLvoid *pointer, GLsizei count);
  56 GL_API void GL_APIENTRY glWeightPointerOESBounds(GLint size, GLenum type,
  57         GLsizei stride, const GLvoid *pointer, GLsizei count);
  58 #endif
  59 #ifdef GL_ES_VERSION_2_0
  60 static void glVertexAttribPointerBounds(GLuint indx, GLint size, GLenum type,
  61         GLboolean normalized, GLsizei stride, const GLvoid *pointer, GLsizei count) {
  62     glVertexAttribPointer(indx, size, type, normalized, stride, pointer);
  63 }
  64 #endif
  65 #ifdef GL_ES_VERSION_3_0
  66 static void glVertexAttribIPointerBounds(GLuint indx, GLint size, GLenum type,
  67         GLsizei stride, const GLvoid *pointer, GLsizei count) {
  68     glVertexAttribIPointer(indx, size, type, stride, pointer);
  69 }
  70 #endif
  71 }
  72
  73 /* Cache method IDs each time the class is loaded. */
  74
  75 static void
  76 nativeClassInit(JNIEnv *_env, jclass glImplClass)
  77 {
  78     jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess");
  79     nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal);
  80
  81     jclass bufferClassLocal = _env->FindClass("java/nio/Buffer");
  82     bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal);
  83
  84     getBasePointerID = _env->GetStaticMethodID(nioAccessClass,
  85             "getBasePointer", "(Ljava/nio/Buffer;)J");
  86     getBaseArrayID = _env->GetStaticMethodID(nioAccessClass,
  87             "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;");
  88     getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass,
  89             "getBaseArrayOffset", "(Ljava/nio/Buffer;)I");
  90
  91     positionID = _env->GetFieldID(bufferClass, "position", "I");
  92     limitID = _env->GetFieldID(bufferClass, "limit", "I");
  93     elementSizeShiftID =
  94         _env->GetFieldID(bufferClass, "_elementSizeShift", "I");
  95 }
  96
  97 static void *
  98 getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining, jint *offset)
  99 {
 100     jint position;
 101     jint limit;
 102     jint elementSizeShift;
 103     jlong pointer;
 104
 105     position = _env->GetIntField(buffer, positionID);
 106     limit = _env->GetIntField(buffer, limitID);
 107     elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
 108     *remaining = (limit - position) << elementSizeShift;
 109     pointer = _env->CallStaticLongMethod(nioAccessClass,
 110             getBasePointerID, buffer);
 111     if (pointer != 0L) {
 112         *array = NULL;
 113         return reinterpret_cast<void*>(pointer);
 114     }
 115
 116     *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass,
 117             getBaseArrayID, buffer);
 118     *offset = _env->CallStaticIntMethod(nioAccessClass,
 119             getBaseArrayOffsetID, buffer);
 120
 121     return NULL;
 122 }
 123
 124 static void
 125 releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit)
 126 {
 127     _env->ReleasePrimitiveArrayCritical(array, data,
 128                        commit ? 0 : JNI_ABORT);
 129 }
 130
 131 static void *
 132 getDirectBufferPointer(JNIEnv *_env, jobject buffer) {
 133     char* buf = (char*) _env->GetDirectBufferAddress(buffer);
 134     if (buf) {
 135         jint position = _env->GetIntField(buffer, positionID);
 136         jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
 137         buf += position << elementSizeShift;
 138     } else {
 139         jniThrowException(_env, "java/lang/IllegalArgumentException",
 140                           "Must use a native order direct Buffer");
 141     }
 142     return (void*) buf;
 143 }
 144
 145 // --------------------------------------------------------------------------
 146
 147 /*
 148  * returns the number of values glGet returns for a given pname.
 149  *
 150  * The code below is written such that pnames requiring only one values
 151  * are the default (and are not explicitely tested for). This makes the
 152  * checking code much shorter/readable/efficient.
 153  *
 154  * This means that unknown pnames (e.g.: extensions) will default to 1. If
 155  * that unknown pname needs more than 1 value, then the validation check
 156  * is incomplete and the app may crash if it passed the wrong number params.
 157  */
 158 static int getNeededCount(GLint pname) {
 159     int needed = 1;
 160 #ifdef GL_ES_VERSION_2_0
 161     // GLES 2.x pnames
 162     switch (pname) {
 163         case GL_ALIASED_LINE_WIDTH_RANGE:
 164         case GL_ALIASED_POINT_SIZE_RANGE:
 165             needed = 2;
 166             break;
 167
 168         case GL_BLEND_COLOR:
 169         case GL_COLOR_CLEAR_VALUE:
 170         case GL_COLOR_WRITEMASK:
 171         case GL_SCISSOR_BOX:
 172         case GL_VIEWPORT:
 173             needed = 4;
 174             break;
 175
 176         case GL_COMPRESSED_TEXTURE_FORMATS:
 177             glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed);
 178             break;
 179
 180         case GL_SHADER_BINARY_FORMATS:
 181             glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &needed);
 182             break;
 183     }
 184 #endif
 185
 186 #ifdef GL_VERSION_ES_CM_1_1
 187     // GLES 1.x pnames
 188     switch (pname) {
 189         case GL_ALIASED_LINE_WIDTH_RANGE:
 190         case GL_ALIASED_POINT_SIZE_RANGE:
 191         case GL_DEPTH_RANGE:
 192         case GL_SMOOTH_LINE_WIDTH_RANGE:
 193         case GL_SMOOTH_POINT_SIZE_RANGE:
 194             needed = 2;
 195             break;
 196
 197         case GL_CURRENT_NORMAL:
 198         case GL_POINT_DISTANCE_ATTENUATION:
 199             needed = 3;
 200             break;
 201
 202         case GL_COLOR_CLEAR_VALUE:
 203         case GL_COLOR_WRITEMASK:
 204         case GL_CURRENT_COLOR:
 205         case GL_CURRENT_TEXTURE_COORDS:
 206         case GL_FOG_COLOR:
 207         case GL_LIGHT_MODEL_AMBIENT:
 208         case GL_SCISSOR_BOX:
 209         case GL_VIEWPORT:
 210             needed = 4;
 211             break;
 212
 213         case GL_MODELVIEW_MATRIX:
 214         case GL_PROJECTION_MATRIX:
 215         case GL_TEXTURE_MATRIX:
 216             needed = 16;
 217             break;
 218
 219         case GL_COMPRESSED_TEXTURE_FORMATS:
 220             glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed);
 221             break;
 222     }
 223 #endif
 224     return needed;
 225 }
 226
 227 template <typename JTYPEARRAY, typename CTYPE, void GET(GLenum, CTYPE*)>
 228 static void
 229 get
 230   (JNIEnv *_env, jobject _this, jint pname, JTYPEARRAY params_ref, jint offset) {
 231     jint _exception = 0;
 232     const char * _exceptionType;
 233     const char * _exceptionMessage;
 234     CTYPE *params_base = (CTYPE *) 0;
 235     jint _remaining;
 236     CTYPE *params = (CTYPE *) 0;
 237     int _needed = 0;
 238
 239     if (!params_ref) {
 240         _exception = 1;
 241         _exceptionType = "java/lang/IllegalArgumentException";
 242         _exceptionMessage = "params == null";
 243         goto exit;
 244     }
 245     if (offset < 0) {
 246         _exception = 1;
 247         _exceptionType = "java/lang/IllegalArgumentException";
 248         _exceptionMessage = "offset < 0";
 249         goto exit;
 250     }
 251     _remaining = _env->GetArrayLength(params_ref) - offset;
 252     _needed = getNeededCount(pname);
 253     // if we didn't find this pname, we just assume the user passed
 254     // an array of the right size -- this might happen with extensions
 255     // or if we forget an enum here.
 256     if (_remaining < _needed) {
 257         _exception = 1;
 258         _exceptionType = "java/lang/IllegalArgumentException";
 259         _exceptionMessage = "length - offset < needed";
 260         goto exit;
 261     }
 262     params_base = (CTYPE *)
 263         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
 264     params = params_base + offset;
 265
 266     GET(
 267         (GLenum)pname,
 268         (CTYPE *)params
 269     );
 270
 271 exit:
 272     if (params_base) {
 273         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
 274             _exception ? JNI_ABORT: 0);
 275     }
 276     if (_exception) {
 277         jniThrowException(_env, _exceptionType, _exceptionMessage);
 278     }
 279 }
 280
 281
 282 template <typename CTYPE, void GET(GLenum, CTYPE*)>
 283 static void
 284 getarray
 285   (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
 286     jint _exception = 0;
 287     const char * _exceptionType;
 288     const char * _exceptionMessage;
 289     jarray _array = (jarray) 0;
 290     jint _bufferOffset = (jint) 0;
 291     jint _remaining;
 292     CTYPE *params = (CTYPE *) 0;
 293     int _needed = 0;
 294
 295     params = (CTYPE *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
 296     _remaining /= sizeof(CTYPE);    // convert from bytes to item count
 297     _needed = getNeededCount(pname);
 298     // if we didn't find this pname, we just assume the user passed
 299     // an array of the right size -- this might happen with extensions
 300     // or if we forget an enum here.
 301     if (_needed>0 && _remaining < _needed) {
 302         _exception = 1;
 303         _exceptionType = "java/lang/IllegalArgumentException";
 304         _exceptionMessage = "remaining() < needed";
 305         goto exit;
 306     }
 307     if (params == NULL) {
 308         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
 309         params = (CTYPE *) (_paramsBase + _bufferOffset);
 310     }
 311     GET(
 312         (GLenum)pname,
 313         (CTYPE *)params
 314     );
 315
 316 exit:
 317     if (_array) {
 318         releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
 319     }
 320     if (_exception) {
 321         jniThrowException(_env, _exceptionType, _exceptionMessage);
 322     }
 323 }
 324
 325 // --------------------------------------------------------------------------
 326 /* void glBlendBarrierKHR ( void ) */
 327 static void
 328 android_glBlendBarrierKHR__
 329   (JNIEnv *_env, jobject _this) {
 330     glBlendBarrierKHR();
 331 }
 332
 333 /* void glDebugMessageControlKHR ( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled ) */
 334 static void
 335 android_glDebugMessageControlKHR__IIII_3IIZ
 336   (JNIEnv *_env, jobject _this, jint source, jint type, jint severity, jint count, jintArray ids_ref, jint offset, jboolean enabled) {
 337     jint _exception = 0;
 338     const char * _exceptionType = NULL;
 339     const char * _exceptionMessage = NULL;
 340     GLuint *ids_base = (GLuint *) 0;
 341     jint _remaining;
 342     GLuint *ids = (GLuint *) 0;
 343
 344     if (!ids_ref) {
 345         _exception = 1;
 346         _exceptionType = "java/lang/IllegalArgumentException";
 347         _exceptionMessage = "ids == null";
 348         goto exit;
 349     }
 350     if (offset < 0) {
 351         _exception = 1;
 352         _exceptionType = "java/lang/IllegalArgumentException";
 353         _exceptionMessage = "offset < 0";
 354         goto exit;
 355     }
 356     _remaining = _env->GetArrayLength(ids_ref) - offset;
 357     ids_base = (GLuint *)
 358         _env->GetPrimitiveArrayCritical(ids_ref, (jboolean *)0);
 359     ids = ids_base + offset;
 360
 361     glDebugMessageControlKHR(
 362         (GLenum)source,
 363         (GLenum)type,
 364         (GLenum)severity,
 365         (GLsizei)count,
 366         (GLuint *)ids,
 367         (GLboolean)enabled
 368     );
 369
 370 exit:
 371     if (ids_base) {
 372         _env->ReleasePrimitiveArrayCritical(ids_ref, ids_base,
 373             JNI_ABORT);
 374     }
 375     if (_exception) {
 376         jniThrowException(_env, _exceptionType, _exceptionMessage);
 377     }
 378 }
 379
 380 /* void glDebugMessageControlKHR ( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled ) */
 381 static void
 382 android_glDebugMessageControlKHR__IIIILjava_nio_IntBuffer_2Z
 383   (JNIEnv *_env, jobject _this, jint source, jint type, jint severity, jint count, jobject ids_buf, jboolean enabled) {
 384     jarray _array = (jarray) 0;
 385     jint _bufferOffset = (jint) 0;
 386     jint _remaining;
 387     GLuint *ids = (GLuint *) 0;
 388
 389     ids = (GLuint *)getPointer(_env, ids_buf, &_array, &_remaining, &_bufferOffset);
 390     if (ids == NULL) {
 391         char * _idsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
 392         ids = (GLuint *) (_idsBase + _bufferOffset);
 393     }
 394     glDebugMessageControlKHR(
 395         (GLenum)source,
 396         (GLenum)type,
 397         (GLenum)severity,
 398         (GLsizei)count,
 399         (GLuint *)ids,
 400         (GLboolean)enabled
 401     );
 402     if (_array) {
 403         releasePointer(_env, _array, ids, JNI_FALSE);
 404     }
 405 }
 406
 407 /* void glDebugMessageInsertKHR ( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf ) */
 408 static void
 409 android_glDebugMessageInsertKHR__IIIILjava_lang_String_2
 410   (JNIEnv *_env, jobject _this, jint source, jint type, jint id, jint severity, jstring buf) {
 411     jint _exception = 0;
 412     const char * _exceptionType = NULL;
 413     const char * _exceptionMessage = NULL;
 414     const char* _nativebuf = 0;
 415     jint _length = 0;
 416
 417     if (!buf) {
 418         _exception = 1;
 419         _exceptionType = "java/lang/IllegalArgumentException";
 420         _exceptionMessage = "buf == null";
 421         goto exit;
 422     }
 423     _nativebuf = _env->GetStringUTFChars(buf, 0);
 424     _length = _env->GetStringUTFLength(buf);
 425
 426     glDebugMessageInsertKHR(
 427         (GLenum)source,
 428         (GLenum)type,
 429         (GLuint)id,
 430         (GLenum)severity,
 431         (GLsizei)_length,
 432         (GLchar *)_nativebuf
 433     );
 434
 435 exit:
 436     if (_nativebuf) {
 437         _env->ReleaseStringUTFChars(buf, _nativebuf);
 438     }
 439
 440     if (_exception) {
 441         jniThrowException(_env, _exceptionType, _exceptionMessage);
 442     }
 443 }
 444
 445 /* void glDebugMessageCallbackKHR ( GLDEBUGPROCKHR callback, const void *userParam ) */
 446 static void
 447 android_glDebugMessageCallbackKHR(JNIEnv *_env, jobject _this, jobject callback) {
 448     jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
 449 }
 450 /* GLuint glGetDebugMessageLogKHR ( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) */
 451 static jint
 452 android_glGetDebugMessageLogKHR__II_3II_3II_3II_3II_3II_3BI
 453   (JNIEnv *_env, jobject _this, jint count, jint bufSize, jintArray sources_ref, jint sourcesOffset, jintArray types_ref, jint typesOffset, jintArray ids_ref, jint idsOffset, jintArray severities_ref, jint severitiesOffset, jintArray lengths_ref, jint lengthsOffset, jbyteArray messageLog_ref, jint messageLogOffset) {
 454     jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
 455     return 0;
 456 }
 457
 458 /* GLuint glGetDebugMessageLogKHR ( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) */
 459 static uint
 460 android_glGetDebugMessageLogKHR__ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_ByteBuffer_2
 461   (JNIEnv *_env, jobject _this, jint count, jobject sources_ref, jobject types_ref, jobject ids_ref, jobject severities_ref, jobject lengths_ref, jobject messageLog_ref) {
 462     jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
 463     return 0;
 464 }
 465
 466 /* GLuint glGetDebugMessageLogKHR ( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) */
 467 static jobjectArray
 468 android_glGetDebugMessageLogKHR__I_3II_3II_3II_3II
 469   (JNIEnv *_env, jobject _this, jint count, jintArray sources_ref, jint sourcesOffset, jintArray types_ref, jint typesOffset, jintArray ids_ref, jint idsOffset, jintArray severities_ref, jint severitiesOffset) {
 470     jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
 471     return 0;
 472 }
 473
 474 /* GLuint glGetDebugMessageLogKHR ( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) */
 475 static jobjectArray
 476 android_glGetDebugMessageLogKHR__ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2
 477   (JNIEnv *_env, jobject _this, jint count, jobject sources_ref, jobject types_ref, jobject ids_ref, jobject severities_ref) {
 478     jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
 479     return 0;
 480 }
 481 /* void glPushDebugGroupKHR ( GLenum source, GLuint id, GLsizei length, const GLchar *message ) */
 482 static void
 483 android_glPushDebugGroupKHR__IIILjava_lang_String_2
 484   (JNIEnv *_env, jobject _this, jint source, jint id, jint length, jstring message) {
 485     jint _exception = 0;
 486     const char * _exceptionType = NULL;
 487     const char * _exceptionMessage = NULL;
 488     const char* _nativemessage = 0;
 489
 490     if (!message) {
 491         _exception = 1;
 492         _exceptionType = "java/lang/IllegalArgumentException";
 493         _exceptionMessage = "message == null";
 494         goto exit;
 495     }
 496     _nativemessage = _env->GetStringUTFChars(message, 0);
 497
 498     glPushDebugGroupKHR(
 499         (GLenum)source,
 500         (GLuint)id,
 501         (GLsizei)length,
 502         (GLchar *)_nativemessage
 503     );
 504
 505 exit:
 506     if (_nativemessage) {
 507         _env->ReleaseStringUTFChars(message, _nativemessage);
 508     }
 509
 510     if (_exception) {
 511         jniThrowException(_env, _exceptionType, _exceptionMessage);
 512     }
 513 }
 514
 515 /* void glPopDebugGroupKHR ( void ) */
 516 static void
 517 android_glPopDebugGroupKHR__
 518   (JNIEnv *_env, jobject _this) {
 519     glPopDebugGroupKHR();
 520 }
 521
 522 /* void glObjectLabelKHR ( GLenum identifier, GLuint name, GLsizei length, const GLchar *label ) */
 523 static void
 524 android_glObjectLabelKHR__IIILjava_lang_String_2
 525   (JNIEnv *_env, jobject _this, jint identifier, jint name, jint length, jstring label) {
 526     jint _exception = 0;
 527     const char * _exceptionType = NULL;
 528     const char * _exceptionMessage = NULL;
 529     const char* _nativelabel = 0;
 530
 531     if (!label) {
 532         _exception = 1;
 533         _exceptionType = "java/lang/IllegalArgumentException";
 534         _exceptionMessage = "label == null";
 535         goto exit;
 536     }
 537     _nativelabel = _env->GetStringUTFChars(label, 0);
 538
 539     glObjectLabelKHR(
 540         (GLenum)identifier,
 541         (GLuint)name,
 542         (GLsizei)length,
 543         (GLchar *)_nativelabel
 544     );
 545
 546 exit:
 547     if (_nativelabel) {
 548         _env->ReleaseStringUTFChars(label, _nativelabel);
 549     }
 550
 551     if (_exception) {
 552         jniThrowException(_env, _exceptionType, _exceptionMessage);
 553     }
 554 }
 555
 556 /* void glGetObjectLabelKHR ( GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label ) */
 557 static jstring
 558 android_glGetObjectLabelKHR(JNIEnv *_env, jobject _this, jint identifier, jint name) {
 559     jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
 560     return NULL;
 561 }
 562
 563 /* void glObjectPtrLabelKHR ( const void *ptr, GLsizei length, const GLchar *label ) */
 564 static void
 565 android_glObjectPtrLabelKHR(JNIEnv *_env, jobject _this, jlong ptr, jstring label) {
 566     jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
 567 }
 568
 569 /* void glGetObjectPtrLabelKHR ( const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label ) */
 570 static jstring
 571 android_glGetObjectPtrLabelKHR(JNIEnv *_env, jobject _this, jlong ptr) {
 572     jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
 573     return NULL;
 574 }
 575
 576 /* void glGetPointervKHR ( GLenum pname, void **params ) */
 577 static jobject
 578 android_glGetDebugMessageCallbackKHR(JNIEnv *_env, jobject _this) {
 579     jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented");
 580     return NULL;
 581 }
 582
 583 /* void glMinSampleShadingOES ( GLfloat value ) */
 584 static void
 585 android_glMinSampleShadingOES__F
 586   (JNIEnv *_env, jobject _this, jfloat value) {
 587     glMinSampleShadingOES(
 588         (GLfloat)value
 589     );
 590 }
 591
 592 /* void glTexStorage3DMultisampleOES ( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations ) */
 593 static void
 594 android_glTexStorage3DMultisampleOES__IIIIIIZ
 595   (JNIEnv *_env, jobject _this, jint target, jint samples, jint internalformat, jint width, jint height, jint depth, jboolean fixedsamplelocations) {
 596     glTexStorage3DMultisampleOES(
 597         (GLenum)target,
 598         (GLsizei)samples,
 599         (GLenum)internalformat,
 600         (GLsizei)width,
 601         (GLsizei)height,
 602         (GLsizei)depth,
 603         (GLboolean)fixedsamplelocations
 604     );
 605 }
 606
 607 /* void glCopyImageSubDataEXT ( GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth ) */
 608 static void
 609 android_glCopyImageSubDataEXT__IIIIIIIIIIIIIII
 610   (JNIEnv *_env, jobject _this, jint srcName, jint srcTarget, jint srcLevel, jint srcX, jint srcY, jint srcZ, jint dstName, jint dstTarget, jint dstLevel, jint dstX, jint dstY, jint dstZ, jint srcWidth, jint srcHeight, jint srcDepth) {
 611     glCopyImageSubDataEXT(
 612         (GLuint)srcName,
 613         (GLenum)srcTarget,
 614         (GLint)srcLevel,
 615         (GLint)srcX,
 616         (GLint)srcY,
 617         (GLint)srcZ,
 618         (GLuint)dstName,
 619         (GLenum)dstTarget,
 620         (GLint)dstLevel,
 621         (GLint)dstX,
 622         (GLint)dstY,
 623         (GLint)dstZ,
 624         (GLsizei)srcWidth,
 625         (GLsizei)srcHeight,
 626         (GLsizei)srcDepth
 627     );
 628 }
 629
 630 /* void glEnableiEXT ( GLenum target, GLuint index ) */
 631 static void
 632 android_glEnableiEXT__II
 633   (JNIEnv *_env, jobject _this, jint target, jint index) {
 634     glEnableiEXT(
 635         (GLenum)target,
 636         (GLuint)index
 637     );
 638 }
 639
 640 /* void glDisableiEXT ( GLenum target, GLuint index ) */
 641 static void
 642 android_glDisableiEXT__II
 643   (JNIEnv *_env, jobject _this, jint target, jint index) {
 644     glDisableiEXT(
 645         (GLenum)target,
 646         (GLuint)index
 647     );
 648 }
 649
 650 /* void glBlendEquationiEXT ( GLuint buf, GLenum mode ) */
 651 static void
 652 android_glBlendEquationiEXT__II
 653   (JNIEnv *_env, jobject _this, jint buf, jint mode) {
 654     glBlendEquationiEXT(
 655         (GLuint)buf,
 656         (GLenum)mode
 657     );
 658 }
 659
 660 /* void glBlendEquationSeparateiEXT ( GLuint buf, GLenum modeRGB, GLenum modeAlpha ) */
 661 static void
 662 android_glBlendEquationSeparateiEXT__III
 663   (JNIEnv *_env, jobject _this, jint buf, jint modeRGB, jint modeAlpha) {
 664     glBlendEquationSeparateiEXT(
 665         (GLuint)buf,
 666         (GLenum)modeRGB,
 667         (GLenum)modeAlpha
 668     );
 669 }
 670
 671 /* void glBlendFunciEXT ( GLuint buf, GLenum src, GLenum dst ) */
 672 static void
 673 android_glBlendFunciEXT__III
 674   (JNIEnv *_env, jobject _this, jint buf, jint src, jint dst) {
 675     glBlendFunciEXT(
 676         (GLuint)buf,
 677         (GLenum)src,
 678         (GLenum)dst
 679     );
 680 }
 681
 682 /* void glBlendFuncSeparateiEXT ( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) */
 683 static void
 684 android_glBlendFuncSeparateiEXT__IIIII
 685   (JNIEnv *_env, jobject _this, jint buf, jint srcRGB, jint dstRGB, jint srcAlpha, jint dstAlpha) {
 686     glBlendFuncSeparateiEXT(
 687         (GLuint)buf,
 688         (GLenum)srcRGB,
 689         (GLenum)dstRGB,
 690         (GLenum)srcAlpha,
 691         (GLenum)dstAlpha
 692     );
 693 }
 694
 695 /* void glColorMaskiEXT ( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a ) */
 696 static void
 697 android_glColorMaskiEXT__IZZZZ
 698   (JNIEnv *_env, jobject _this, jint index, jboolean r, jboolean g, jboolean b, jboolean a) {
 699     glColorMaskiEXT(
 700         (GLuint)index,
 701         (GLboolean)r,
 702         (GLboolean)g,
 703         (GLboolean)b,
 704         (GLboolean)a
 705     );
 706 }
 707
 708 /* GLboolean glIsEnablediEXT ( GLenum target, GLuint index ) */
 709 static jboolean
 710 android_glIsEnablediEXT__II
 711   (JNIEnv *_env, jobject _this, jint target, jint index) {
 712     GLboolean _returnValue;
 713     _returnValue = glIsEnablediEXT(
 714         (GLenum)target,
 715         (GLuint)index
 716     );
 717     return (jboolean)_returnValue;
 718 }
 719
 720 /* void glFramebufferTextureEXT ( GLenum target, GLenum attachment, GLuint texture, GLint level ) */
 721 static void
 722 android_glFramebufferTextureEXT__IIII
 723   (JNIEnv *_env, jobject _this, jint target, jint attachment, jint texture, jint level) {
 724     glFramebufferTextureEXT(
 725         (GLenum)target,
 726         (GLenum)attachment,
 727         (GLuint)texture,
 728         (GLint)level
 729     );
 730 }
 731
 732 /* void glPrimitiveBoundingBoxEXT ( GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW ) */
 733 static void
 734 android_glPrimitiveBoundingBoxEXT__FFFFFFFF
 735   (JNIEnv *_env, jobject _this, jfloat minX, jfloat minY, jfloat minZ, jfloat minW, jfloat maxX, jfloat maxY, jfloat maxZ, jfloat maxW) {
 736     glPrimitiveBoundingBoxEXT(
 737         (GLfloat)minX,
 738         (GLfloat)minY,
 739         (GLfloat)minZ,
 740         (GLfloat)minW,
 741         (GLfloat)maxX,
 742         (GLfloat)maxY,
 743         (GLfloat)maxZ,
 744         (GLfloat)maxW
 745     );
 746 }
 747
 748 /* void glPatchParameteriEXT ( GLenum pname, GLint value ) */
 749 static void
 750 android_glPatchParameteriEXT__II
 751   (JNIEnv *_env, jobject _this, jint pname, jint value) {
 752     glPatchParameteriEXT(
 753         (GLenum)pname,
 754         (GLint)value
 755     );
 756 }
 757
 758 /* void glTexParameterIivEXT ( GLenum target, GLenum pname, const GLint *params ) */
 759 static void
 760 android_glTexParameterIivEXT__II_3II
 761   (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
 762     jint _exception = 0;
 763     const char * _exceptionType = NULL;
 764     const char * _exceptionMessage = NULL;
 765     GLint *params_base = (GLint *) 0;
 766     jint _remaining;
 767     GLint *params = (GLint *) 0;
 768
 769     if (!params_ref) {
 770         _exception = 1;
 771         _exceptionType = "java/lang/IllegalArgumentException";
 772         _exceptionMessage = "params == null";
 773         goto exit;
 774     }
 775     if (offset < 0) {
 776         _exception = 1;
 777         _exceptionType = "java/lang/IllegalArgumentException";
 778         _exceptionMessage = "offset < 0";
 779         goto exit;
 780     }
 781     _remaining = _env->GetArrayLength(params_ref) - offset;
 782     params_base = (GLint *)
 783         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
 784     params = params_base + offset;
 785
 786     glTexParameterIivEXT(
 787         (GLenum)target,
 788         (GLenum)pname,
 789         (GLint *)params
 790     );
 791
 792 exit:
 793     if (params_base) {
 794         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
 795             JNI_ABORT);
 796     }
 797     if (_exception) {
 798         jniThrowException(_env, _exceptionType, _exceptionMessage);
 799     }
 800 }
 801
 802 /* void glTexParameterIivEXT ( GLenum target, GLenum pname, const GLint *params ) */
 803 static void
 804 android_glTexParameterIivEXT__IILjava_nio_IntBuffer_2
 805   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
 806     jarray _array = (jarray) 0;
 807     jint _bufferOffset = (jint) 0;
 808     jint _remaining;
 809     GLint *params = (GLint *) 0;
 810
 811     params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
 812     if (params == NULL) {
 813         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
 814         params = (GLint *) (_paramsBase + _bufferOffset);
 815     }
 816     glTexParameterIivEXT(
 817         (GLenum)target,
 818         (GLenum)pname,
 819         (GLint *)params
 820     );
 821     if (_array) {
 822         releasePointer(_env, _array, params, JNI_FALSE);
 823     }
 824 }
 825
 826 /* void glTexParameterIuivEXT ( GLenum target, GLenum pname, const GLuint *params ) */
 827 static void
 828 android_glTexParameterIuivEXT__II_3II
 829   (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
 830     jint _exception = 0;
 831     const char * _exceptionType = NULL;
 832     const char * _exceptionMessage = NULL;
 833     GLuint *params_base = (GLuint *) 0;
 834     jint _remaining;
 835     GLuint *params = (GLuint *) 0;
 836
 837     if (!params_ref) {
 838         _exception = 1;
 839         _exceptionType = "java/lang/IllegalArgumentException";
 840         _exceptionMessage = "params == null";
 841         goto exit;
 842     }
 843     if (offset < 0) {
 844         _exception = 1;
 845         _exceptionType = "java/lang/IllegalArgumentException";
 846         _exceptionMessage = "offset < 0";
 847         goto exit;
 848     }
 849     _remaining = _env->GetArrayLength(params_ref) - offset;
 850     params_base = (GLuint *)
 851         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
 852     params = params_base + offset;
 853
 854     glTexParameterIuivEXT(
 855         (GLenum)target,
 856         (GLenum)pname,
 857         (GLuint *)params
 858     );
 859
 860 exit:
 861     if (params_base) {
 862         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
 863             JNI_ABORT);
 864     }
 865     if (_exception) {
 866         jniThrowException(_env, _exceptionType, _exceptionMessage);
 867     }
 868 }
 869
 870 /* void glTexParameterIuivEXT ( GLenum target, GLenum pname, const GLuint *params ) */
 871 static void
 872 android_glTexParameterIuivEXT__IILjava_nio_IntBuffer_2
 873   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
 874     jarray _array = (jarray) 0;
 875     jint _bufferOffset = (jint) 0;
 876     jint _remaining;
 877     GLuint *params = (GLuint *) 0;
 878
 879     params = (GLuint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
 880     if (params == NULL) {
 881         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
 882         params = (GLuint *) (_paramsBase + _bufferOffset);
 883     }
 884     glTexParameterIuivEXT(
 885         (GLenum)target,
 886         (GLenum)pname,
 887         (GLuint *)params
 888     );
 889     if (_array) {
 890         releasePointer(_env, _array, params, JNI_FALSE);
 891     }
 892 }
 893
 894 /* void glGetTexParameterIivEXT ( GLenum target, GLenum pname, GLint *params ) */
 895 static void
 896 android_glGetTexParameterIivEXT__II_3II
 897   (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
 898     jint _exception = 0;
 899     const char * _exceptionType = NULL;
 900     const char * _exceptionMessage = NULL;
 901     GLint *params_base = (GLint *) 0;
 902     jint _remaining;
 903     GLint *params = (GLint *) 0;
 904
 905     if (!params_ref) {
 906         _exception = 1;
 907         _exceptionType = "java/lang/IllegalArgumentException";
 908         _exceptionMessage = "params == null";
 909         goto exit;
 910     }
 911     if (offset < 0) {
 912         _exception = 1;
 913         _exceptionType = "java/lang/IllegalArgumentException";
 914         _exceptionMessage = "offset < 0";
 915         goto exit;
 916     }
 917     _remaining = _env->GetArrayLength(params_ref) - offset;
 918     params_base = (GLint *)
 919         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
 920     params = params_base + offset;
 921
 922     glGetTexParameterIivEXT(
 923         (GLenum)target,
 924         (GLenum)pname,
 925         (GLint *)params
 926     );
 927
 928 exit:
 929     if (params_base) {
 930         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
 931             _exception ? JNI_ABORT: 0);
 932     }
 933     if (_exception) {
 934         jniThrowException(_env, _exceptionType, _exceptionMessage);
 935     }
 936 }
 937
 938 /* void glGetTexParameterIivEXT ( GLenum target, GLenum pname, GLint *params ) */
 939 static void
 940 android_glGetTexParameterIivEXT__IILjava_nio_IntBuffer_2
 941   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
 942     jarray _array = (jarray) 0;
 943     jint _bufferOffset = (jint) 0;
 944     jint _remaining;
 945     GLint *params = (GLint *) 0;
 946
 947     params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
 948     if (params == NULL) {
 949         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
 950         params = (GLint *) (_paramsBase + _bufferOffset);
 951     }
 952     glGetTexParameterIivEXT(
 953         (GLenum)target,
 954         (GLenum)pname,
 955         (GLint *)params
 956     );
 957     if (_array) {
 958         releasePointer(_env, _array, params, JNI_TRUE);
 959     }
 960 }
 961
 962 /* void glGetTexParameterIuivEXT ( GLenum target, GLenum pname, GLuint *params ) */
 963 static void
 964 android_glGetTexParameterIuivEXT__II_3II
 965   (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
 966     jint _exception = 0;
 967     const char * _exceptionType = NULL;
 968     const char * _exceptionMessage = NULL;
 969     GLuint *params_base = (GLuint *) 0;
 970     jint _remaining;
 971     GLuint *params = (GLuint *) 0;
 972
 973     if (!params_ref) {
 974         _exception = 1;
 975         _exceptionType = "java/lang/IllegalArgumentException";
 976         _exceptionMessage = "params == null";
 977         goto exit;
 978     }
 979     if (offset < 0) {
 980         _exception = 1;
 981         _exceptionType = "java/lang/IllegalArgumentException";
 982         _exceptionMessage = "offset < 0";
 983         goto exit;
 984     }
 985     _remaining = _env->GetArrayLength(params_ref) - offset;
 986     params_base = (GLuint *)
 987         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
 988     params = params_base + offset;
 989
 990     glGetTexParameterIuivEXT(
 991         (GLenum)target,
 992         (GLenum)pname,
 993         (GLuint *)params
 994     );
 995
 996 exit:
 997     if (params_base) {
 998         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
 999             _exception ? JNI_ABORT: 0);
1000     }
1001     if (_exception) {
1002         jniThrowException(_env, _exceptionType, _exceptionMessage);
1003     }
1004 }
1005
1006 /* void glGetTexParameterIuivEXT ( GLenum target, GLenum pname, GLuint *params ) */
1007 static void
1008 android_glGetTexParameterIuivEXT__IILjava_nio_IntBuffer_2
1009   (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
1010     jarray _array = (jarray) 0;
1011     jint _bufferOffset = (jint) 0;
1012     jint _remaining;
1013     GLuint *params = (GLuint *) 0;
1014
1015     params = (GLuint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
1016     if (params == NULL) {
1017         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1018         params = (GLuint *) (_paramsBase + _bufferOffset);
1019     }
1020     glGetTexParameterIuivEXT(
1021         (GLenum)target,
1022         (GLenum)pname,
1023         (GLuint *)params
1024     );
1025     if (_array) {
1026         releasePointer(_env, _array, params, JNI_TRUE);
1027     }
1028 }
1029
1030 /* void glSamplerParameterIivEXT ( GLuint sampler, GLenum pname, const GLint *param ) */
1031 static void
1032 android_glSamplerParameterIivEXT__II_3II
1033   (JNIEnv *_env, jobject _this, jint sampler, jint pname, jintArray param_ref, jint offset) {
1034     jint _exception = 0;
1035     const char * _exceptionType = NULL;
1036     const char * _exceptionMessage = NULL;
1037     GLint *param_base = (GLint *) 0;
1038     jint _remaining;
1039     GLint *param = (GLint *) 0;
1040
1041     if (!param_ref) {
1042         _exception = 1;
1043         _exceptionType = "java/lang/IllegalArgumentException";
1044         _exceptionMessage = "param == 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(param_ref) - offset;
1054     param_base = (GLint *)
1055         _env->GetPrimitiveArrayCritical(param_ref, (jboolean *)0);
1056     param = param_base + offset;
1057
1058     glSamplerParameterIivEXT(
1059         (GLuint)sampler,
1060         (GLenum)pname,
1061         (GLint *)param
1062     );
1063
1064 exit:
1065     if (param_base) {
1066         _env->ReleasePrimitiveArrayCritical(param_ref, param_base,
1067             JNI_ABORT);
1068     }
1069     if (_exception) {
1070         jniThrowException(_env, _exceptionType, _exceptionMessage);
1071     }
1072 }
1073
1074 /* void glSamplerParameterIivEXT ( GLuint sampler, GLenum pname, const GLint *param ) */
1075 static void
1076 android_glSamplerParameterIivEXT__IILjava_nio_IntBuffer_2
1077   (JNIEnv *_env, jobject _this, jint sampler, jint pname, jobject param_buf) {
1078     jarray _array = (jarray) 0;
1079     jint _bufferOffset = (jint) 0;
1080     jint _remaining;
1081     GLint *param = (GLint *) 0;
1082
1083     param = (GLint *)getPointer(_env, param_buf, &_array, &_remaining, &_bufferOffset);
1084     if (param == NULL) {
1085         char * _paramBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1086         param = (GLint *) (_paramBase + _bufferOffset);
1087     }
1088     glSamplerParameterIivEXT(
1089         (GLuint)sampler,
1090         (GLenum)pname,
1091         (GLint *)param
1092     );
1093     if (_array) {
1094         releasePointer(_env, _array, param, JNI_FALSE);
1095     }
1096 }
1097
1098 /* void glSamplerParameterIuivEXT ( GLuint sampler, GLenum pname, const GLuint *param ) */
1099 static void
1100 android_glSamplerParameterIuivEXT__II_3II
1101   (JNIEnv *_env, jobject _this, jint sampler, jint pname, jintArray param_ref, jint offset) {
1102     jint _exception = 0;
1103     const char * _exceptionType = NULL;
1104     const char * _exceptionMessage = NULL;
1105     GLuint *param_base = (GLuint *) 0;
1106     jint _remaining;
1107     GLuint *param = (GLuint *) 0;
1108
1109     if (!param_ref) {
1110         _exception = 1;
1111         _exceptionType = "java/lang/IllegalArgumentException";
1112         _exceptionMessage = "param == null";
1113         goto exit;
1114     }
1115     if (offset < 0) {
1116         _exception = 1;
1117         _exceptionType = "java/lang/IllegalArgumentException";
1118         _exceptionMessage = "offset < 0";
1119         goto exit;
1120     }
1121     _remaining = _env->GetArrayLength(param_ref) - offset;
1122     param_base = (GLuint *)
1123         _env->GetPrimitiveArrayCritical(param_ref, (jboolean *)0);
1124     param = param_base + offset;
1125
1126     glSamplerParameterIuivEXT(
1127         (GLuint)sampler,
1128         (GLenum)pname,
1129         (GLuint *)param
1130     );
1131
1132 exit:
1133     if (param_base) {
1134         _env->ReleasePrimitiveArrayCritical(param_ref, param_base,
1135             JNI_ABORT);
1136     }
1137     if (_exception) {
1138         jniThrowException(_env, _exceptionType, _exceptionMessage);
1139     }
1140 }
1141
1142 /* void glSamplerParameterIuivEXT ( GLuint sampler, GLenum pname, const GLuint *param ) */
1143 static void
1144 android_glSamplerParameterIuivEXT__IILjava_nio_IntBuffer_2
1145   (JNIEnv *_env, jobject _this, jint sampler, jint pname, jobject param_buf) {
1146     jarray _array = (jarray) 0;
1147     jint _bufferOffset = (jint) 0;
1148     jint _remaining;
1149     GLuint *param = (GLuint *) 0;
1150
1151     param = (GLuint *)getPointer(_env, param_buf, &_array, &_remaining, &_bufferOffset);
1152     if (param == NULL) {
1153         char * _paramBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1154         param = (GLuint *) (_paramBase + _bufferOffset);
1155     }
1156     glSamplerParameterIuivEXT(
1157         (GLuint)sampler,
1158         (GLenum)pname,
1159         (GLuint *)param
1160     );
1161     if (_array) {
1162         releasePointer(_env, _array, param, JNI_FALSE);
1163     }
1164 }
1165
1166 /* void glGetSamplerParameterIivEXT ( GLuint sampler, GLenum pname, GLint *params ) */
1167 static void
1168 android_glGetSamplerParameterIivEXT__II_3II
1169   (JNIEnv *_env, jobject _this, jint sampler, jint pname, jintArray params_ref, jint offset) {
1170     jint _exception = 0;
1171     const char * _exceptionType = NULL;
1172     const char * _exceptionMessage = NULL;
1173     GLint *params_base = (GLint *) 0;
1174     jint _remaining;
1175     GLint *params = (GLint *) 0;
1176
1177     if (!params_ref) {
1178         _exception = 1;
1179         _exceptionType = "java/lang/IllegalArgumentException";
1180         _exceptionMessage = "params == null";
1181         goto exit;
1182     }
1183     if (offset < 0) {
1184         _exception = 1;
1185         _exceptionType = "java/lang/IllegalArgumentException";
1186         _exceptionMessage = "offset < 0";
1187         goto exit;
1188     }
1189     _remaining = _env->GetArrayLength(params_ref) - offset;
1190     params_base = (GLint *)
1191         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1192     params = params_base + offset;
1193
1194     glGetSamplerParameterIivEXT(
1195         (GLuint)sampler,
1196         (GLenum)pname,
1197         (GLint *)params
1198     );
1199
1200 exit:
1201     if (params_base) {
1202         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1203             _exception ? JNI_ABORT: 0);
1204     }
1205     if (_exception) {
1206         jniThrowException(_env, _exceptionType, _exceptionMessage);
1207     }
1208 }
1209
1210 /* void glGetSamplerParameterIivEXT ( GLuint sampler, GLenum pname, GLint *params ) */
1211 static void
1212 android_glGetSamplerParameterIivEXT__IILjava_nio_IntBuffer_2
1213   (JNIEnv *_env, jobject _this, jint sampler, jint pname, jobject params_buf) {
1214     jarray _array = (jarray) 0;
1215     jint _bufferOffset = (jint) 0;
1216     jint _remaining;
1217     GLint *params = (GLint *) 0;
1218
1219     params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
1220     if (params == NULL) {
1221         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1222         params = (GLint *) (_paramsBase + _bufferOffset);
1223     }
1224     glGetSamplerParameterIivEXT(
1225         (GLuint)sampler,
1226         (GLenum)pname,
1227         (GLint *)params
1228     );
1229     if (_array) {
1230         releasePointer(_env, _array, params, JNI_TRUE);
1231     }
1232 }
1233
1234 /* void glGetSamplerParameterIuivEXT ( GLuint sampler, GLenum pname, GLuint *params ) */
1235 static void
1236 android_glGetSamplerParameterIuivEXT__II_3II
1237   (JNIEnv *_env, jobject _this, jint sampler, jint pname, jintArray params_ref, jint offset) {
1238     jint _exception = 0;
1239     const char * _exceptionType = NULL;
1240     const char * _exceptionMessage = NULL;
1241     GLuint *params_base = (GLuint *) 0;
1242     jint _remaining;
1243     GLuint *params = (GLuint *) 0;
1244
1245     if (!params_ref) {
1246         _exception = 1;
1247         _exceptionType = "java/lang/IllegalArgumentException";
1248         _exceptionMessage = "params == null";
1249         goto exit;
1250     }
1251     if (offset < 0) {
1252         _exception = 1;
1253         _exceptionType = "java/lang/IllegalArgumentException";
1254         _exceptionMessage = "offset < 0";
1255         goto exit;
1256     }
1257     _remaining = _env->GetArrayLength(params_ref) - offset;
1258     params_base = (GLuint *)
1259         _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
1260     params = params_base + offset;
1261
1262     glGetSamplerParameterIuivEXT(
1263         (GLuint)sampler,
1264         (GLenum)pname,
1265         (GLuint *)params
1266     );
1267
1268 exit:
1269     if (params_base) {
1270         _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
1271             _exception ? JNI_ABORT: 0);
1272     }
1273     if (_exception) {
1274         jniThrowException(_env, _exceptionType, _exceptionMessage);
1275     }
1276 }
1277
1278 /* void glGetSamplerParameterIuivEXT ( GLuint sampler, GLenum pname, GLuint *params ) */
1279 static void
1280 android_glGetSamplerParameterIuivEXT__IILjava_nio_IntBuffer_2
1281   (JNIEnv *_env, jobject _this, jint sampler, jint pname, jobject params_buf) {
1282     jarray _array = (jarray) 0;
1283     jint _bufferOffset = (jint) 0;
1284     jint _remaining;
1285     GLuint *params = (GLuint *) 0;
1286
1287     params = (GLuint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
1288     if (params == NULL) {
1289         char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
1290         params = (GLuint *) (_paramsBase + _bufferOffset);
1291     }
1292     glGetSamplerParameterIuivEXT(
1293         (GLuint)sampler,
1294         (GLenum)pname,
1295         (GLuint *)params
1296     );
1297     if (_array) {
1298         releasePointer(_env, _array, params, JNI_TRUE);
1299     }
1300 }
1301
1302 /* void glTexBufferEXT ( GLenum target, GLenum internalformat, GLuint buffer ) */
1303 static void
1304 android_glTexBufferEXT__III
1305   (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint buffer) {
1306     glTexBufferEXT(
1307         (GLenum)target,
1308         (GLenum)internalformat,
1309         (GLuint)buffer
1310     );
1311 }
1312
1313 /* void glTexBufferRangeEXT ( GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size ) */
1314 static void
1315 android_glTexBufferRangeEXT__IIIII
1316   (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint buffer, jint offset, jint size) {
1317     glTexBufferRangeEXT(
1318         (GLenum)target,
1319         (GLenum)internalformat,
1320         (GLuint)buffer,
1321         (GLintptr)offset,
1322         (GLsizeiptr)size
1323     );
1324 }
1325
1326 static const char *classPathName = "android/opengl/GLES31Ext";
1327
1328 static JNINativeMethod methods[] = {
1329 {"_nativeClassInit", "()V", (void*)nativeClassInit },
1330 {"glBlendBarrierKHR", "()V", (void *) android_glBlendBarrierKHR__ },
1331 {"glDebugMessageControlKHR", "(IIII[IIZ)V", (void *) android_glDebugMessageControlKHR__IIII_3IIZ },
1332 {"glDebugMessageControlKHR", "(IIIILjava/nio/IntBuffer;Z)V", (void *) android_glDebugMessageControlKHR__IIIILjava_nio_IntBuffer_2Z },
1333 {"glDebugMessageInsertKHR", "(IIIILjava/lang/String;)V", (void *) android_glDebugMessageInsertKHR__IIIILjava_lang_String_2 },
1334 {"glDebugMessageCallbackKHR", "(Landroid/opengl/GLES31Ext$DebugProcKHR;)V", (void *) android_glDebugMessageCallbackKHR },
1335 {"glGetDebugMessageLogKHR", "(II[II[II[II[II[II[BI)I", (void *) android_glGetDebugMessageLogKHR__II_3II_3II_3II_3II_3II_3BI },
1336 {"glGetDebugMessageLogKHR", "(ILjava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/ByteBuffer;)I", (void *) android_glGetDebugMessageLogKHR__ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_ByteBuffer_2 },
1337 {"glGetDebugMessageLogKHR", "(I[II[II[II[II)[Ljava/lang/String;", (void *) android_glGetDebugMessageLogKHR__I_3II_3II_3II_3II },
1338 {"glGetDebugMessageLogKHR", "(ILjava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;)[Ljava/lang/String;", (void *) android_glGetDebugMessageLogKHR__ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 },
1339 {"glPushDebugGroupKHR", "(IIILjava/lang/String;)V", (void *) android_glPushDebugGroupKHR__IIILjava_lang_String_2 },
1340 {"glPopDebugGroupKHR", "()V", (void *) android_glPopDebugGroupKHR__ },
1341 {"glObjectLabelKHR", "(IIILjava/lang/String;)V", (void *) android_glObjectLabelKHR__IIILjava_lang_String_2 },
1342 {"glGetObjectLabelKHR", "(II)Ljava/lang/String;", (void *) android_glGetObjectLabelKHR },
1343 {"glObjectPtrLabelKHR", "(JLjava/lang/String;)V", (void *) android_glObjectPtrLabelKHR },
1344 {"glGetObjectPtrLabelKHR", "(J)Ljava/lang/String;", (void *) android_glGetObjectPtrLabelKHR },
1345 {"glGetDebugMessageCallbackKHR", "()Landroid/opengl/GLES31Ext$DebugProcKHR;", (void *) android_glGetDebugMessageCallbackKHR },
1346 {"glMinSampleShadingOES", "(F)V", (void *) android_glMinSampleShadingOES__F },
1347 {"glTexStorage3DMultisampleOES", "(IIIIIIZ)V", (void *) android_glTexStorage3DMultisampleOES__IIIIIIZ },
1348 {"glCopyImageSubDataEXT", "(IIIIIIIIIIIIIII)V", (void *) android_glCopyImageSubDataEXT__IIIIIIIIIIIIIII },
1349 {"glEnableiEXT", "(II)V", (void *) android_glEnableiEXT__II },
1350 {"glDisableiEXT", "(II)V", (void *) android_glDisableiEXT__II },
1351 {"glBlendEquationiEXT", "(II)V", (void *) android_glBlendEquationiEXT__II },
1352 {"glBlendEquationSeparateiEXT", "(III)V", (void *) android_glBlendEquationSeparateiEXT__III },
1353 {"glBlendFunciEXT", "(III)V", (void *) android_glBlendFunciEXT__III },
1354 {"glBlendFuncSeparateiEXT", "(IIIII)V", (void *) android_glBlendFuncSeparateiEXT__IIIII },
1355 {"glColorMaskiEXT", "(IZZZZ)V", (void *) android_glColorMaskiEXT__IZZZZ },
1356 {"glIsEnablediEXT", "(II)Z", (void *) android_glIsEnablediEXT__II },
1357 {"glFramebufferTextureEXT", "(IIII)V", (void *) android_glFramebufferTextureEXT__IIII },
1358 {"glPrimitiveBoundingBoxEXT", "(FFFFFFFF)V", (void *) android_glPrimitiveBoundingBoxEXT__FFFFFFFF },
1359 {"glPatchParameteriEXT", "(II)V", (void *) android_glPatchParameteriEXT__II },
1360 {"glTexParameterIivEXT", "(II[II)V", (void *) android_glTexParameterIivEXT__II_3II },
1361 {"glTexParameterIivEXT", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameterIivEXT__IILjava_nio_IntBuffer_2 },
1362 {"glTexParameterIuivEXT", "(II[II)V", (void *) android_glTexParameterIuivEXT__II_3II },
1363 {"glTexParameterIuivEXT", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameterIuivEXT__IILjava_nio_IntBuffer_2 },
1364 {"glGetTexParameterIivEXT", "(II[II)V", (void *) android_glGetTexParameterIivEXT__II_3II },
1365 {"glGetTexParameterIivEXT", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameterIivEXT__IILjava_nio_IntBuffer_2 },
1366 {"glGetTexParameterIuivEXT", "(II[II)V", (void *) android_glGetTexParameterIuivEXT__II_3II },
1367 {"glGetTexParameterIuivEXT", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameterIuivEXT__IILjava_nio_IntBuffer_2 },
1368 {"glSamplerParameterIivEXT", "(II[II)V", (void *) android_glSamplerParameterIivEXT__II_3II },
1369 {"glSamplerParameterIivEXT", "(IILjava/nio/IntBuffer;)V", (void *) android_glSamplerParameterIivEXT__IILjava_nio_IntBuffer_2 },
1370 {"glSamplerParameterIuivEXT", "(II[II)V", (void *) android_glSamplerParameterIuivEXT__II_3II },
1371 {"glSamplerParameterIuivEXT", "(IILjava/nio/IntBuffer;)V", (void *) android_glSamplerParameterIuivEXT__IILjava_nio_IntBuffer_2 },
1372 {"glGetSamplerParameterIivEXT", "(II[II)V", (void *) android_glGetSamplerParameterIivEXT__II_3II },
1373 {"glGetSamplerParameterIivEXT", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetSamplerParameterIivEXT__IILjava_nio_IntBuffer_2 },
1374 {"glGetSamplerParameterIuivEXT", "(II[II)V", (void *) android_glGetSamplerParameterIuivEXT__II_3II },
1375 {"glGetSamplerParameterIuivEXT", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetSamplerParameterIuivEXT__IILjava_nio_IntBuffer_2 },
1376 {"glTexBufferEXT", "(III)V", (void *) android_glTexBufferEXT__III },
1377 {"glTexBufferRangeEXT", "(IIIII)V", (void *) android_glTexBufferRangeEXT__IIIII },
1378 };
1379
1380 int register_android_opengl_jni_GLES31Ext(JNIEnv *_env)
1381 {
1382     int err;
1383     err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));
1384     return err;
1385 }