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