frameworks/base/core/jni/android_opengl_GLES20.cpp

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