Add a Java API for OpenGL ES 2.0.
Currently this API is hidden.
Add a test program.
diff --git a/core/jni/Android.mk b/core/jni/Android.mk
index 015268b..a11ee1a 100644
--- a/core/jni/Android.mk
+++ b/core/jni/Android.mk
@@ -32,6 +32,7 @@
android_opengl_GLES10Ext.cpp \
android_opengl_GLES11.cpp \
android_opengl_GLES11Ext.cpp \
+ android_opengl_GLES20.cpp \
android_database_CursorWindow.cpp \
android_database_SQLiteDebug.cpp \
android_database_SQLiteDatabase.cpp \
@@ -163,6 +164,7 @@
libdvm \
libEGL \
libGLESv1_CM \
+ libGLESv2 \
libhardware \
libhardware_legacy \
libsonivox \
diff --git a/core/jni/AndroidRuntime.cpp b/core/jni/AndroidRuntime.cpp
index 82fa93e..3d3baa1 100644
--- a/core/jni/AndroidRuntime.cpp
+++ b/core/jni/AndroidRuntime.cpp
@@ -71,6 +71,7 @@
extern int register_android_opengl_jni_GLES10Ext(JNIEnv* env);
extern int register_android_opengl_jni_GLES11(JNIEnv* env);
extern int register_android_opengl_jni_GLES11Ext(JNIEnv* env);
+extern int register_android_opengl_jni_GLES20(JNIEnv* env);
extern int register_android_hardware_Camera(JNIEnv *env);
@@ -1190,6 +1191,7 @@
REG_JNI(register_android_opengl_jni_GLES10Ext),
REG_JNI(register_android_opengl_jni_GLES11),
REG_JNI(register_android_opengl_jni_GLES11Ext),
+ REG_JNI(register_android_opengl_jni_GLES20),
REG_JNI(register_android_graphics_Bitmap),
REG_JNI(register_android_graphics_BitmapFactory),
diff --git a/core/jni/android_opengl_GLES20.cpp b/core/jni/android_opengl_GLES20.cpp
new file mode 100644
index 0000000..fd1c8fd
--- /dev/null
+++ b/core/jni/android_opengl_GLES20.cpp
@@ -0,0 +1,5023 @@
+/*
+**
+** Copyright 2009, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+// This source file is automatically generated
+
+#include <android_runtime/AndroidRuntime.h>
+#include <utils/misc.h>
+
+#include <assert.h>
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+static int initialized = 0;
+
+static jclass nioAccessClass;
+static jclass bufferClass;
+static jclass OOMEClass;
+static jclass UOEClass;
+static jclass IAEClass;
+static jclass AIOOBEClass;
+static jmethodID getBasePointerID;
+static jmethodID getBaseArrayID;
+static jmethodID getBaseArrayOffsetID;
+static jfieldID positionID;
+static jfieldID limitID;
+static jfieldID elementSizeShiftID;
+
+/* Cache method IDs each time the class is loaded. */
+
+static void
+nativeClassInitBuffer(JNIEnv *_env)
+{
+ jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess");
+ nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal);
+
+ jclass bufferClassLocal = _env->FindClass("java/nio/Buffer");
+ bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal);
+
+ getBasePointerID = _env->GetStaticMethodID(nioAccessClass,
+ "getBasePointer", "(Ljava/nio/Buffer;)J");
+ getBaseArrayID = _env->GetStaticMethodID(nioAccessClass,
+ "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;");
+ getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass,
+ "getBaseArrayOffset", "(Ljava/nio/Buffer;)I");
+
+ positionID = _env->GetFieldID(bufferClass, "position", "I");
+ limitID = _env->GetFieldID(bufferClass, "limit", "I");
+ elementSizeShiftID =
+ _env->GetFieldID(bufferClass, "_elementSizeShift", "I");
+}
+
+
+static void
+nativeClassInit(JNIEnv *_env, jclass glImplClass)
+{
+ nativeClassInitBuffer(_env);
+
+ jclass IAEClassLocal =
+ _env->FindClass("java/lang/IllegalArgumentException");
+ jclass OOMEClassLocal =
+ _env->FindClass("java/lang/OutOfMemoryError");
+ jclass UOEClassLocal =
+ _env->FindClass("java/lang/UnsupportedOperationException");
+ jclass AIOOBEClassLocal =
+ _env->FindClass("java/lang/ArrayIndexOutOfBoundsException");
+
+ IAEClass = (jclass) _env->NewGlobalRef(IAEClassLocal);
+ OOMEClass = (jclass) _env->NewGlobalRef(OOMEClassLocal);
+ UOEClass = (jclass) _env->NewGlobalRef(UOEClassLocal);
+ AIOOBEClass = (jclass) _env->NewGlobalRef(AIOOBEClassLocal);
+}
+
+static void *
+getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining)
+{
+ jint position;
+ jint limit;
+ jint elementSizeShift;
+ jlong pointer;
+ jint offset;
+ void *data;
+
+ position = _env->GetIntField(buffer, positionID);
+ limit = _env->GetIntField(buffer, limitID);
+ elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
+ *remaining = (limit - position) << elementSizeShift;
+ pointer = _env->CallStaticLongMethod(nioAccessClass,
+ getBasePointerID, buffer);
+ if (pointer != 0L) {
+ *array = NULL;
+ return (void *) (jint) pointer;
+ }
+
+ *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass,
+ getBaseArrayID, buffer);
+ offset = _env->CallStaticIntMethod(nioAccessClass,
+ getBaseArrayOffsetID, buffer);
+ data = _env->GetPrimitiveArrayCritical(*array, (jboolean *) 0);
+
+ return (void *) ((char *) data + offset);
+}
+
+
+static void
+releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit)
+{
+ _env->ReleasePrimitiveArrayCritical(array, data,
+ commit ? 0 : JNI_ABORT);
+}
+
+static void *
+getDirectBufferPointer(JNIEnv *_env, jobject buffer) {
+ char* buf = (char*) _env->GetDirectBufferAddress(buffer);
+ if (buf) {
+ jint position = _env->GetIntField(buffer, positionID);
+ jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
+ buf += position << elementSizeShift;
+ } else {
+ _env->ThrowNew(IAEClass, "Must use a native order direct Buffer");
+ }
+ return (void*) buf;
+}
+
+static int
+getNumCompressedTextureFormats() {
+ int numCompressedTextureFormats = 0;
+ glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numCompressedTextureFormats);
+ return numCompressedTextureFormats;
+}
+
+static void glVertexAttribPointerBounds(GLuint indx, GLint size, GLenum type,
+ GLboolean normalized, GLsizei stride, const GLvoid *pointer, GLsizei count) {
+ glVertexAttribPointer(indx, size, type, normalized, stride, pointer);
+}
+
+// --------------------------------------------------------------------------
+
+/* void glActiveTexture ( GLenum texture ) */
+static void
+android_glActiveTexture__I
+ (JNIEnv *_env, jobject _this, jint texture) {
+ glActiveTexture(
+ (GLenum)texture
+ );
+}
+
+/* void glAttachShader ( GLuint program, GLuint shader ) */
+static void
+android_glAttachShader__II
+ (JNIEnv *_env, jobject _this, jint program, jint shader) {
+ glAttachShader(
+ (GLuint)program,
+ (GLuint)shader
+ );
+}
+
+/* void glBindAttribLocation ( GLuint program, GLuint index, const char *name ) */
+static void
+android_glBindAttribLocation__IILjava_lang_String_2
+ (JNIEnv *_env, jobject _this, jint program, jint index, jstring name) {
+ const char* _nativename = 0;
+
+ if (!name) {
+ _env->ThrowNew(IAEClass, "name == null");
+ goto exit;
+ }
+ _nativename = _env->GetStringUTFChars(name, 0);
+
+ glBindAttribLocation(
+ (GLuint)program,
+ (GLuint)index,
+ (char *)_nativename
+ );
+
+exit:
+ if (_nativename) {
+ _env->ReleaseStringUTFChars(name, _nativename);
+ }
+
+}
+
+/* void glBindBuffer ( GLenum target, GLuint buffer ) */
+static void
+android_glBindBuffer__II
+ (JNIEnv *_env, jobject _this, jint target, jint buffer) {
+ glBindBuffer(
+ (GLenum)target,
+ (GLuint)buffer
+ );
+}
+
+/* void glBindFramebuffer ( GLenum target, GLuint framebuffer ) */
+static void
+android_glBindFramebuffer__II
+ (JNIEnv *_env, jobject _this, jint target, jint framebuffer) {
+ glBindFramebuffer(
+ (GLenum)target,
+ (GLuint)framebuffer
+ );
+}
+
+/* void glBindRenderbuffer ( GLenum target, GLuint renderbuffer ) */
+static void
+android_glBindRenderbuffer__II
+ (JNIEnv *_env, jobject _this, jint target, jint renderbuffer) {
+ glBindRenderbuffer(
+ (GLenum)target,
+ (GLuint)renderbuffer
+ );
+}
+
+/* void glBindTexture ( GLenum target, GLuint texture ) */
+static void
+android_glBindTexture__II
+ (JNIEnv *_env, jobject _this, jint target, jint texture) {
+ glBindTexture(
+ (GLenum)target,
+ (GLuint)texture
+ );
+}
+
+/* void glBlendColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) */
+static void
+android_glBlendColor__FFFF
+ (JNIEnv *_env, jobject _this, jfloat red, jfloat green, jfloat blue, jfloat alpha) {
+ glBlendColor(
+ (GLclampf)red,
+ (GLclampf)green,
+ (GLclampf)blue,
+ (GLclampf)alpha
+ );
+}
+
+/* void glBlendEquation ( GLenum mode ) */
+static void
+android_glBlendEquation__I
+ (JNIEnv *_env, jobject _this, jint mode) {
+ _env->ThrowNew(UOEClass,
+ "glBlendEquation");
+}
+
+/* void glBlendEquationSeparate ( GLenum modeRGB, GLenum modeAlpha ) */
+static void
+android_glBlendEquationSeparate__II
+ (JNIEnv *_env, jobject _this, jint modeRGB, jint modeAlpha) {
+ _env->ThrowNew(UOEClass,
+ "glBlendEquationSeparate");
+}
+
+/* void glBlendFunc ( GLenum sfactor, GLenum dfactor ) */
+static void
+android_glBlendFunc__II
+ (JNIEnv *_env, jobject _this, jint sfactor, jint dfactor) {
+ glBlendFunc(
+ (GLenum)sfactor,
+ (GLenum)dfactor
+ );
+}
+
+/* void glBlendFuncSeparate ( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) */
+static void
+android_glBlendFuncSeparate__IIII
+ (JNIEnv *_env, jobject _this, jint srcRGB, jint dstRGB, jint srcAlpha, jint dstAlpha) {
+ _env->ThrowNew(UOEClass,
+ "glBlendFuncSeparate");
+}
+
+/* void glBufferData ( GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage ) */
+static void
+android_glBufferData__IILjava_nio_Buffer_2I
+ (JNIEnv *_env, jobject _this, jint target, jint size, jobject data_buf, jint usage) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLvoid *data = (GLvoid *) 0;
+
+ if (data_buf) {
+ data = (GLvoid *)getPointer(_env, data_buf, &_array, &_remaining);
+ if (_remaining < size) {
+ _env->ThrowNew(IAEClass, "remaining() < size");
+ goto exit;
+ }
+ }
+ glBufferData(
+ (GLenum)target,
+ (GLsizeiptr)size,
+ (GLvoid *)data,
+ (GLenum)usage
+ );
+
+exit:
+ if (_array) {
+ releasePointer(_env, _array, data, JNI_FALSE);
+ }
+}
+
+/* void glBufferSubData ( GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data ) */
+static void
+android_glBufferSubData__IIILjava_nio_Buffer_2
+ (JNIEnv *_env, jobject _this, jint target, jint offset, jint size, jobject data_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLvoid *data = (GLvoid *) 0;
+
+ data = (GLvoid *)getPointer(_env, data_buf, &_array, &_remaining);
+ if (_remaining < size) {
+ _env->ThrowNew(IAEClass, "remaining() < size");
+ goto exit;
+ }
+ glBufferSubData(
+ (GLenum)target,
+ (GLintptr)offset,
+ (GLsizeiptr)size,
+ (GLvoid *)data
+ );
+
+exit:
+ if (_array) {
+ releasePointer(_env, _array, data, JNI_FALSE);
+ }
+}
+
+/* GLenum glCheckFramebufferStatus ( GLenum target ) */
+static jint
+android_glCheckFramebufferStatus__I
+ (JNIEnv *_env, jobject _this, jint target) {
+ GLenum _returnValue;
+ _returnValue = glCheckFramebufferStatus(
+ (GLenum)target
+ );
+ return _returnValue;
+}
+
+/* void glClear ( GLbitfield mask ) */
+static void
+android_glClear__I
+ (JNIEnv *_env, jobject _this, jint mask) {
+ glClear(
+ (GLbitfield)mask
+ );
+}
+
+/* void glClearColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) */
+static void
+android_glClearColor__FFFF
+ (JNIEnv *_env, jobject _this, jfloat red, jfloat green, jfloat blue, jfloat alpha) {
+ glClearColor(
+ (GLclampf)red,
+ (GLclampf)green,
+ (GLclampf)blue,
+ (GLclampf)alpha
+ );
+}
+
+/* void glClearDepthf ( GLclampf depth ) */
+static void
+android_glClearDepthf__F
+ (JNIEnv *_env, jobject _this, jfloat depth) {
+ glClearDepthf(
+ (GLclampf)depth
+ );
+}
+
+/* void glClearStencil ( GLint s ) */
+static void
+android_glClearStencil__I
+ (JNIEnv *_env, jobject _this, jint s) {
+ glClearStencil(
+ (GLint)s
+ );
+}
+
+/* void glColorMask ( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) */
+static void
+android_glColorMask__ZZZZ
+ (JNIEnv *_env, jobject _this, jboolean red, jboolean green, jboolean blue, jboolean alpha) {
+ glColorMask(
+ (GLboolean)red,
+ (GLboolean)green,
+ (GLboolean)blue,
+ (GLboolean)alpha
+ );
+}
+
+/* void glCompileShader ( GLuint shader ) */
+static void
+android_glCompileShader__I
+ (JNIEnv *_env, jobject _this, jint shader) {
+ glCompileShader(
+ (GLuint)shader
+ );
+}
+
+/* void glCompressedTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data ) */
+static void
+android_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2
+ (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint imageSize, jobject data_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLvoid *data = (GLvoid *) 0;
+
+ data = (GLvoid *)getPointer(_env, data_buf, &_array, &_remaining);
+ glCompressedTexImage2D(
+ (GLenum)target,
+ (GLint)level,
+ (GLenum)internalformat,
+ (GLsizei)width,
+ (GLsizei)height,
+ (GLint)border,
+ (GLsizei)imageSize,
+ (GLvoid *)data
+ );
+ if (_array) {
+ releasePointer(_env, _array, data, JNI_FALSE);
+ }
+}
+
+/* void glCompressedTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data ) */
+static void
+android_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2
+ (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint imageSize, jobject data_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLvoid *data = (GLvoid *) 0;
+
+ data = (GLvoid *)getPointer(_env, data_buf, &_array, &_remaining);
+ glCompressedTexSubImage2D(
+ (GLenum)target,
+ (GLint)level,
+ (GLint)xoffset,
+ (GLint)yoffset,
+ (GLsizei)width,
+ (GLsizei)height,
+ (GLenum)format,
+ (GLsizei)imageSize,
+ (GLvoid *)data
+ );
+ if (_array) {
+ releasePointer(_env, _array, data, JNI_FALSE);
+ }
+}
+
+/* void glCopyTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) */
+static void
+android_glCopyTexImage2D__IIIIIIII
+ (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint x, jint y, jint width, jint height, jint border) {
+ glCopyTexImage2D(
+ (GLenum)target,
+ (GLint)level,
+ (GLenum)internalformat,
+ (GLint)x,
+ (GLint)y,
+ (GLsizei)width,
+ (GLsizei)height,
+ (GLint)border
+ );
+}
+
+/* void glCopyTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) */
+static void
+android_glCopyTexSubImage2D__IIIIIIII
+ (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint x, jint y, jint width, jint height) {
+ glCopyTexSubImage2D(
+ (GLenum)target,
+ (GLint)level,
+ (GLint)xoffset,
+ (GLint)yoffset,
+ (GLint)x,
+ (GLint)y,
+ (GLsizei)width,
+ (GLsizei)height
+ );
+}
+
+/* GLuint glCreateProgram ( void ) */
+static jint
+android_glCreateProgram__
+ (JNIEnv *_env, jobject _this) {
+ GLuint _returnValue;
+ _returnValue = glCreateProgram();
+ return _returnValue;
+}
+
+/* GLuint glCreateShader ( GLenum type ) */
+static jint
+android_glCreateShader__I
+ (JNIEnv *_env, jobject _this, jint type) {
+ GLuint _returnValue;
+ _returnValue = glCreateShader(
+ (GLenum)type
+ );
+ return _returnValue;
+}
+
+/* void glCullFace ( GLenum mode ) */
+static void
+android_glCullFace__I
+ (JNIEnv *_env, jobject _this, jint mode) {
+ glCullFace(
+ (GLenum)mode
+ );
+}
+
+/* void glDeleteBuffers ( GLsizei n, const GLuint *buffers ) */
+static void
+android_glDeleteBuffers__I_3II
+ (JNIEnv *_env, jobject _this, jint n, jintArray buffers_ref, jint offset) {
+ GLuint *buffers_base = (GLuint *) 0;
+ jint _remaining;
+ GLuint *buffers = (GLuint *) 0;
+
+ if (!buffers_ref) {
+ _env->ThrowNew(IAEClass, "buffers == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(buffers_ref) - offset;
+ if (_remaining < n) {
+ _env->ThrowNew(IAEClass, "length - offset < n");
+ goto exit;
+ }
+ buffers_base = (GLuint *)
+ _env->GetPrimitiveArrayCritical(buffers_ref, (jboolean *)0);
+ buffers = buffers_base + offset;
+
+ glDeleteBuffers(
+ (GLsizei)n,
+ (GLuint *)buffers
+ );
+
+exit:
+ if (buffers_base) {
+ _env->ReleasePrimitiveArrayCritical(buffers_ref, buffers_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glDeleteBuffers ( GLsizei n, const GLuint *buffers ) */
+static void
+android_glDeleteBuffers__ILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint n, jobject buffers_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLuint *buffers = (GLuint *) 0;
+
+ buffers = (GLuint *)getPointer(_env, buffers_buf, &_array, &_remaining);
+ if (_remaining < n) {
+ _env->ThrowNew(IAEClass, "remaining() < n");
+ goto exit;
+ }
+ glDeleteBuffers(
+ (GLsizei)n,
+ (GLuint *)buffers
+ );
+
+exit:
+ if (_array) {
+ releasePointer(_env, _array, buffers, JNI_FALSE);
+ }
+}
+
+/* void glDeleteFramebuffers ( GLsizei n, const GLuint *framebuffers ) */
+static void
+android_glDeleteFramebuffers__I_3II
+ (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) {
+ GLuint *framebuffers_base = (GLuint *) 0;
+ jint _remaining;
+ GLuint *framebuffers = (GLuint *) 0;
+
+ if (!framebuffers_ref) {
+ _env->ThrowNew(IAEClass, "framebuffers == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(framebuffers_ref) - offset;
+ framebuffers_base = (GLuint *)
+ _env->GetPrimitiveArrayCritical(framebuffers_ref, (jboolean *)0);
+ framebuffers = framebuffers_base + offset;
+
+ glDeleteFramebuffers(
+ (GLsizei)n,
+ (GLuint *)framebuffers
+ );
+
+exit:
+ if (framebuffers_base) {
+ _env->ReleasePrimitiveArrayCritical(framebuffers_ref, framebuffers_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glDeleteFramebuffers ( GLsizei n, const GLuint *framebuffers ) */
+static void
+android_glDeleteFramebuffers__ILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLuint *framebuffers = (GLuint *) 0;
+
+ framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, &_array, &_remaining);
+ glDeleteFramebuffers(
+ (GLsizei)n,
+ (GLuint *)framebuffers
+ );
+ if (_array) {
+ releasePointer(_env, _array, framebuffers, JNI_FALSE);
+ }
+}
+
+/* void glDeleteProgram ( GLuint program ) */
+static void
+android_glDeleteProgram__I
+ (JNIEnv *_env, jobject _this, jint program) {
+ glDeleteProgram(
+ (GLuint)program
+ );
+}
+
+/* void glDeleteRenderbuffers ( GLsizei n, const GLuint *renderbuffers ) */
+static void
+android_glDeleteRenderbuffers__I_3II
+ (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) {
+ GLuint *renderbuffers_base = (GLuint *) 0;
+ jint _remaining;
+ GLuint *renderbuffers = (GLuint *) 0;
+
+ if (!renderbuffers_ref) {
+ _env->ThrowNew(IAEClass, "renderbuffers == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(renderbuffers_ref) - offset;
+ renderbuffers_base = (GLuint *)
+ _env->GetPrimitiveArrayCritical(renderbuffers_ref, (jboolean *)0);
+ renderbuffers = renderbuffers_base + offset;
+
+ glDeleteRenderbuffers(
+ (GLsizei)n,
+ (GLuint *)renderbuffers
+ );
+
+exit:
+ if (renderbuffers_base) {
+ _env->ReleasePrimitiveArrayCritical(renderbuffers_ref, renderbuffers_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glDeleteRenderbuffers ( GLsizei n, const GLuint *renderbuffers ) */
+static void
+android_glDeleteRenderbuffers__ILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLuint *renderbuffers = (GLuint *) 0;
+
+ renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, &_array, &_remaining);
+ glDeleteRenderbuffers(
+ (GLsizei)n,
+ (GLuint *)renderbuffers
+ );
+ if (_array) {
+ releasePointer(_env, _array, renderbuffers, JNI_FALSE);
+ }
+}
+
+/* void glDeleteShader ( GLuint shader ) */
+static void
+android_glDeleteShader__I
+ (JNIEnv *_env, jobject _this, jint shader) {
+ glDeleteShader(
+ (GLuint)shader
+ );
+}
+
+/* void glDeleteTextures ( GLsizei n, const GLuint *textures ) */
+static void
+android_glDeleteTextures__I_3II
+ (JNIEnv *_env, jobject _this, jint n, jintArray textures_ref, jint offset) {
+ GLuint *textures_base = (GLuint *) 0;
+ jint _remaining;
+ GLuint *textures = (GLuint *) 0;
+
+ if (!textures_ref) {
+ _env->ThrowNew(IAEClass, "textures == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(textures_ref) - offset;
+ if (_remaining < n) {
+ _env->ThrowNew(IAEClass, "length - offset < n");
+ goto exit;
+ }
+ textures_base = (GLuint *)
+ _env->GetPrimitiveArrayCritical(textures_ref, (jboolean *)0);
+ textures = textures_base + offset;
+
+ glDeleteTextures(
+ (GLsizei)n,
+ (GLuint *)textures
+ );
+
+exit:
+ if (textures_base) {
+ _env->ReleasePrimitiveArrayCritical(textures_ref, textures_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glDeleteTextures ( GLsizei n, const GLuint *textures ) */
+static void
+android_glDeleteTextures__ILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint n, jobject textures_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLuint *textures = (GLuint *) 0;
+
+ textures = (GLuint *)getPointer(_env, textures_buf, &_array, &_remaining);
+ if (_remaining < n) {
+ _env->ThrowNew(IAEClass, "remaining() < n");
+ goto exit;
+ }
+ glDeleteTextures(
+ (GLsizei)n,
+ (GLuint *)textures
+ );
+
+exit:
+ if (_array) {
+ releasePointer(_env, _array, textures, JNI_FALSE);
+ }
+}
+
+/* void glDepthFunc ( GLenum func ) */
+static void
+android_glDepthFunc__I
+ (JNIEnv *_env, jobject _this, jint func) {
+ glDepthFunc(
+ (GLenum)func
+ );
+}
+
+/* void glDepthMask ( GLboolean flag ) */
+static void
+android_glDepthMask__Z
+ (JNIEnv *_env, jobject _this, jboolean flag) {
+ glDepthMask(
+ (GLboolean)flag
+ );
+}
+
+/* void glDepthRangef ( GLclampf zNear, GLclampf zFar ) */
+static void
+android_glDepthRangef__FF
+ (JNIEnv *_env, jobject _this, jfloat zNear, jfloat zFar) {
+ glDepthRangef(
+ (GLclampf)zNear,
+ (GLclampf)zFar
+ );
+}
+
+/* void glDetachShader ( GLuint program, GLuint shader ) */
+static void
+android_glDetachShader__II
+ (JNIEnv *_env, jobject _this, jint program, jint shader) {
+ glDetachShader(
+ (GLuint)program,
+ (GLuint)shader
+ );
+}
+
+/* void glDisable ( GLenum cap ) */
+static void
+android_glDisable__I
+ (JNIEnv *_env, jobject _this, jint cap) {
+ glDisable(
+ (GLenum)cap
+ );
+}
+
+/* void glDisableVertexAttribArray ( GLuint index ) */
+static void
+android_glDisableVertexAttribArray__I
+ (JNIEnv *_env, jobject _this, jint index) {
+ glDisableVertexAttribArray(
+ (GLuint)index
+ );
+}
+
+/* void glDrawArrays ( GLenum mode, GLint first, GLsizei count ) */
+static void
+android_glDrawArrays__III
+ (JNIEnv *_env, jobject _this, jint mode, jint first, jint count) {
+ glDrawArrays(
+ (GLenum)mode,
+ (GLint)first,
+ (GLsizei)count
+ );
+}
+
+/* void glDrawElements ( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices ) */
+static void
+android_glDrawElements__IIILjava_nio_Buffer_2
+ (JNIEnv *_env, jobject _this, jint mode, jint count, jint type, jobject indices_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLvoid *indices = (GLvoid *) 0;
+
+ indices = (GLvoid *)getPointer(_env, indices_buf, &_array, &_remaining);
+ if (_remaining < count) {
+ _env->ThrowNew(AIOOBEClass, "remaining() < count");
+ goto exit;
+ }
+ glDrawElements(
+ (GLenum)mode,
+ (GLsizei)count,
+ (GLenum)type,
+ (GLvoid *)indices
+ );
+
+exit:
+ if (_array) {
+ releasePointer(_env, _array, indices, JNI_FALSE);
+ }
+}
+
+/* void glEnable ( GLenum cap ) */
+static void
+android_glEnable__I
+ (JNIEnv *_env, jobject _this, jint cap) {
+ glEnable(
+ (GLenum)cap
+ );
+}
+
+/* void glEnableVertexAttribArray ( GLuint index ) */
+static void
+android_glEnableVertexAttribArray__I
+ (JNIEnv *_env, jobject _this, jint index) {
+ glEnableVertexAttribArray(
+ (GLuint)index
+ );
+}
+
+/* void glFinish ( void ) */
+static void
+android_glFinish__
+ (JNIEnv *_env, jobject _this) {
+ glFinish();
+}
+
+/* void glFlush ( void ) */
+static void
+android_glFlush__
+ (JNIEnv *_env, jobject _this) {
+ glFlush();
+}
+
+/* void glFramebufferRenderbuffer ( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) */
+static void
+android_glFramebufferRenderbuffer__IIII
+ (JNIEnv *_env, jobject _this, jint target, jint attachment, jint renderbuffertarget, jint renderbuffer) {
+ glFramebufferRenderbuffer(
+ (GLenum)target,
+ (GLenum)attachment,
+ (GLenum)renderbuffertarget,
+ (GLuint)renderbuffer
+ );
+}
+
+/* void glFramebufferTexture2D ( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) */
+static void
+android_glFramebufferTexture2D__IIIII
+ (JNIEnv *_env, jobject _this, jint target, jint attachment, jint textarget, jint texture, jint level) {
+ glFramebufferTexture2D(
+ (GLenum)target,
+ (GLenum)attachment,
+ (GLenum)textarget,
+ (GLuint)texture,
+ (GLint)level
+ );
+}
+
+/* void glFrontFace ( GLenum mode ) */
+static void
+android_glFrontFace__I
+ (JNIEnv *_env, jobject _this, jint mode) {
+ glFrontFace(
+ (GLenum)mode
+ );
+}
+
+/* void glGenBuffers ( GLsizei n, GLuint *buffers ) */
+static void
+android_glGenBuffers__I_3II
+ (JNIEnv *_env, jobject _this, jint n, jintArray buffers_ref, jint offset) {
+ jint _exception = 0;
+ GLuint *buffers_base = (GLuint *) 0;
+ jint _remaining;
+ GLuint *buffers = (GLuint *) 0;
+
+ if (!buffers_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "buffers == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(buffers_ref) - offset;
+ if (_remaining < n) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "length - offset < n");
+ goto exit;
+ }
+ buffers_base = (GLuint *)
+ _env->GetPrimitiveArrayCritical(buffers_ref, (jboolean *)0);
+ buffers = buffers_base + offset;
+
+ glGenBuffers(
+ (GLsizei)n,
+ (GLuint *)buffers
+ );
+
+exit:
+ if (buffers_base) {
+ _env->ReleasePrimitiveArrayCritical(buffers_ref, buffers_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGenBuffers ( GLsizei n, GLuint *buffers ) */
+static void
+android_glGenBuffers__ILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint n, jobject buffers_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLuint *buffers = (GLuint *) 0;
+
+ buffers = (GLuint *)getPointer(_env, buffers_buf, &_array, &_remaining);
+ if (_remaining < n) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "remaining() < n");
+ goto exit;
+ }
+ glGenBuffers(
+ (GLsizei)n,
+ (GLuint *)buffers
+ );
+
+exit:
+ if (_array) {
+ releasePointer(_env, _array, buffers, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glGenerateMipmap ( GLenum target ) */
+static void
+android_glGenerateMipmap__I
+ (JNIEnv *_env, jobject _this, jint target) {
+ glGenerateMipmap(
+ (GLenum)target
+ );
+}
+
+/* void glGenFramebuffers ( GLsizei n, GLuint *framebuffers ) */
+static void
+android_glGenFramebuffers__I_3II
+ (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) {
+ jint _exception = 0;
+ GLuint *framebuffers_base = (GLuint *) 0;
+ jint _remaining;
+ GLuint *framebuffers = (GLuint *) 0;
+
+ if (!framebuffers_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "framebuffers == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(framebuffers_ref) - offset;
+ framebuffers_base = (GLuint *)
+ _env->GetPrimitiveArrayCritical(framebuffers_ref, (jboolean *)0);
+ framebuffers = framebuffers_base + offset;
+
+ glGenFramebuffers(
+ (GLsizei)n,
+ (GLuint *)framebuffers
+ );
+
+exit:
+ if (framebuffers_base) {
+ _env->ReleasePrimitiveArrayCritical(framebuffers_ref, framebuffers_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGenFramebuffers ( GLsizei n, GLuint *framebuffers ) */
+static void
+android_glGenFramebuffers__ILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLuint *framebuffers = (GLuint *) 0;
+
+ framebuffers = (GLuint *)getPointer(_env, framebuffers_buf, &_array, &_remaining);
+ glGenFramebuffers(
+ (GLsizei)n,
+ (GLuint *)framebuffers
+ );
+ if (_array) {
+ releasePointer(_env, _array, framebuffers, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glGenRenderbuffers ( GLsizei n, GLuint *renderbuffers ) */
+static void
+android_glGenRenderbuffers__I_3II
+ (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) {
+ jint _exception = 0;
+ GLuint *renderbuffers_base = (GLuint *) 0;
+ jint _remaining;
+ GLuint *renderbuffers = (GLuint *) 0;
+
+ if (!renderbuffers_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "renderbuffers == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(renderbuffers_ref) - offset;
+ renderbuffers_base = (GLuint *)
+ _env->GetPrimitiveArrayCritical(renderbuffers_ref, (jboolean *)0);
+ renderbuffers = renderbuffers_base + offset;
+
+ glGenRenderbuffers(
+ (GLsizei)n,
+ (GLuint *)renderbuffers
+ );
+
+exit:
+ if (renderbuffers_base) {
+ _env->ReleasePrimitiveArrayCritical(renderbuffers_ref, renderbuffers_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGenRenderbuffers ( GLsizei n, GLuint *renderbuffers ) */
+static void
+android_glGenRenderbuffers__ILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLuint *renderbuffers = (GLuint *) 0;
+
+ renderbuffers = (GLuint *)getPointer(_env, renderbuffers_buf, &_array, &_remaining);
+ glGenRenderbuffers(
+ (GLsizei)n,
+ (GLuint *)renderbuffers
+ );
+ if (_array) {
+ releasePointer(_env, _array, renderbuffers, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glGenTextures ( GLsizei n, GLuint *textures ) */
+static void
+android_glGenTextures__I_3II
+ (JNIEnv *_env, jobject _this, jint n, jintArray textures_ref, jint offset) {
+ jint _exception = 0;
+ GLuint *textures_base = (GLuint *) 0;
+ jint _remaining;
+ GLuint *textures = (GLuint *) 0;
+
+ if (!textures_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "textures == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(textures_ref) - offset;
+ if (_remaining < n) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "length - offset < n");
+ goto exit;
+ }
+ textures_base = (GLuint *)
+ _env->GetPrimitiveArrayCritical(textures_ref, (jboolean *)0);
+ textures = textures_base + offset;
+
+ glGenTextures(
+ (GLsizei)n,
+ (GLuint *)textures
+ );
+
+exit:
+ if (textures_base) {
+ _env->ReleasePrimitiveArrayCritical(textures_ref, textures_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGenTextures ( GLsizei n, GLuint *textures ) */
+static void
+android_glGenTextures__ILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint n, jobject textures_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLuint *textures = (GLuint *) 0;
+
+ textures = (GLuint *)getPointer(_env, textures_buf, &_array, &_remaining);
+ if (_remaining < n) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "remaining() < n");
+ goto exit;
+ }
+ glGenTextures(
+ (GLsizei)n,
+ (GLuint *)textures
+ );
+
+exit:
+ if (_array) {
+ releasePointer(_env, _array, textures, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */
+static void
+android_glGetActiveAttrib__III_3II_3II_3II_3BI
+ (JNIEnv *_env, jobject _this, jint program, jint index, jint bufsize, jintArray length_ref, jint lengthOffset, jintArray size_ref, jint sizeOffset, jintArray type_ref, jint typeOffset, jbyteArray name_ref, jint nameOffset) {
+ jint _exception = 0;
+ GLsizei *length_base = (GLsizei *) 0;
+ jint _lengthRemaining;
+ GLsizei *length = (GLsizei *) 0;
+ GLint *size_base = (GLint *) 0;
+ jint _sizeRemaining;
+ GLint *size = (GLint *) 0;
+ GLenum *type_base = (GLenum *) 0;
+ jint _typeRemaining;
+ GLenum *type = (GLenum *) 0;
+ char *name_base = (char *) 0;
+ jint _nameRemaining;
+ char *name = (char *) 0;
+
+ if (!length_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "length == null");
+ goto exit;
+ }
+ if (lengthOffset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "lengthOffset < 0");
+ goto exit;
+ }
+ _lengthRemaining = _env->GetArrayLength(length_ref) - lengthOffset;
+ length_base = (GLsizei *)
+ _env->GetPrimitiveArrayCritical(length_ref, (jboolean *)0);
+ length = length_base + lengthOffset;
+
+ if (!size_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "size == null");
+ goto exit;
+ }
+ if (sizeOffset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "sizeOffset < 0");
+ goto exit;
+ }
+ _sizeRemaining = _env->GetArrayLength(size_ref) - sizeOffset;
+ size_base = (GLint *)
+ _env->GetPrimitiveArrayCritical(size_ref, (jboolean *)0);
+ size = size_base + sizeOffset;
+
+ if (!type_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "type == null");
+ goto exit;
+ }
+ if (typeOffset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "typeOffset < 0");
+ goto exit;
+ }
+ _typeRemaining = _env->GetArrayLength(type_ref) - typeOffset;
+ type_base = (GLenum *)
+ _env->GetPrimitiveArrayCritical(type_ref, (jboolean *)0);
+ type = type_base + typeOffset;
+
+ if (!name_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "name == null");
+ goto exit;
+ }
+ if (nameOffset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "nameOffset < 0");
+ goto exit;
+ }
+ _nameRemaining = _env->GetArrayLength(name_ref) - nameOffset;
+ name_base = (char *)
+ _env->GetPrimitiveArrayCritical(name_ref, (jboolean *)0);
+ name = name_base + nameOffset;
+
+ glGetActiveAttrib(
+ (GLuint)program,
+ (GLuint)index,
+ (GLsizei)bufsize,
+ (GLsizei *)length,
+ (GLint *)size,
+ (GLenum *)type,
+ (char *)name
+ );
+
+exit:
+ if (name_base) {
+ _env->ReleasePrimitiveArrayCritical(name_ref, name_base,
+ _exception ? JNI_ABORT: 0);
+ }
+ if (type_base) {
+ _env->ReleasePrimitiveArrayCritical(type_ref, type_base,
+ _exception ? JNI_ABORT: 0);
+ }
+ if (size_base) {
+ _env->ReleasePrimitiveArrayCritical(size_ref, size_base,
+ _exception ? JNI_ABORT: 0);
+ }
+ if (length_base) {
+ _env->ReleasePrimitiveArrayCritical(length_ref, length_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */
+static void
+android_glGetActiveAttrib__IIILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2B
+ (JNIEnv *_env, jobject _this, jint program, jint index, jint bufsize, jobject length_buf, jobject size_buf, jobject type_buf, jbyte name) {
+ jint _exception = 0;
+ jarray _lengthArray = (jarray) 0;
+ jarray _sizeArray = (jarray) 0;
+ jarray _typeArray = (jarray) 0;
+ jint _lengthRemaining;
+ GLsizei *length = (GLsizei *) 0;
+ jint _sizeRemaining;
+ GLint *size = (GLint *) 0;
+ jint _typeRemaining;
+ GLenum *type = (GLenum *) 0;
+
+ length = (GLsizei *)getPointer(_env, length_buf, &_lengthArray, &_lengthRemaining);
+ size = (GLint *)getPointer(_env, size_buf, &_sizeArray, &_sizeRemaining);
+ type = (GLenum *)getPointer(_env, type_buf, &_typeArray, &_typeRemaining);
+ glGetActiveAttrib(
+ (GLuint)program,
+ (GLuint)index,
+ (GLsizei)bufsize,
+ (GLsizei *)length,
+ (GLint *)size,
+ (GLenum *)type,
+ (char *)name
+ );
+ if (_lengthArray) {
+ releasePointer(_env, _lengthArray, type, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+ if (_sizeArray) {
+ releasePointer(_env, _sizeArray, size, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+ if (_typeArray) {
+ releasePointer(_env, _typeArray, length, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */
+static void
+android_glGetActiveUniform__III_3II_3II_3II_3BI
+ (JNIEnv *_env, jobject _this, jint program, jint index, jint bufsize, jintArray length_ref, jint lengthOffset, jintArray size_ref, jint sizeOffset, jintArray type_ref, jint typeOffset, jbyteArray name_ref, jint nameOffset) {
+ jint _exception = 0;
+ GLsizei *length_base = (GLsizei *) 0;
+ jint _lengthRemaining;
+ GLsizei *length = (GLsizei *) 0;
+ GLint *size_base = (GLint *) 0;
+ jint _sizeRemaining;
+ GLint *size = (GLint *) 0;
+ GLenum *type_base = (GLenum *) 0;
+ jint _typeRemaining;
+ GLenum *type = (GLenum *) 0;
+ char *name_base = (char *) 0;
+ jint _nameRemaining;
+ char *name = (char *) 0;
+
+ if (!length_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "length == null");
+ goto exit;
+ }
+ if (lengthOffset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "lengthOffset < 0");
+ goto exit;
+ }
+ _lengthRemaining = _env->GetArrayLength(length_ref) - lengthOffset;
+ length_base = (GLsizei *)
+ _env->GetPrimitiveArrayCritical(length_ref, (jboolean *)0);
+ length = length_base + lengthOffset;
+
+ if (!size_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "size == null");
+ goto exit;
+ }
+ if (sizeOffset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "sizeOffset < 0");
+ goto exit;
+ }
+ _sizeRemaining = _env->GetArrayLength(size_ref) - sizeOffset;
+ size_base = (GLint *)
+ _env->GetPrimitiveArrayCritical(size_ref, (jboolean *)0);
+ size = size_base + sizeOffset;
+
+ if (!type_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "type == null");
+ goto exit;
+ }
+ if (typeOffset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "typeOffset < 0");
+ goto exit;
+ }
+ _typeRemaining = _env->GetArrayLength(type_ref) - typeOffset;
+ type_base = (GLenum *)
+ _env->GetPrimitiveArrayCritical(type_ref, (jboolean *)0);
+ type = type_base + typeOffset;
+
+ if (!name_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "name == null");
+ goto exit;
+ }
+ if (nameOffset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "nameOffset < 0");
+ goto exit;
+ }
+ _nameRemaining = _env->GetArrayLength(name_ref) - nameOffset;
+ name_base = (char *)
+ _env->GetPrimitiveArrayCritical(name_ref, (jboolean *)0);
+ name = name_base + nameOffset;
+
+ glGetActiveUniform(
+ (GLuint)program,
+ (GLuint)index,
+ (GLsizei)bufsize,
+ (GLsizei *)length,
+ (GLint *)size,
+ (GLenum *)type,
+ (char *)name
+ );
+
+exit:
+ if (name_base) {
+ _env->ReleasePrimitiveArrayCritical(name_ref, name_base,
+ _exception ? JNI_ABORT: 0);
+ }
+ if (type_base) {
+ _env->ReleasePrimitiveArrayCritical(type_ref, type_base,
+ _exception ? JNI_ABORT: 0);
+ }
+ if (size_base) {
+ _env->ReleasePrimitiveArrayCritical(size_ref, size_base,
+ _exception ? JNI_ABORT: 0);
+ }
+ if (length_base) {
+ _env->ReleasePrimitiveArrayCritical(length_ref, length_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */
+static void
+android_glGetActiveUniform__IIILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2B
+ (JNIEnv *_env, jobject _this, jint program, jint index, jint bufsize, jobject length_buf, jobject size_buf, jobject type_buf, jbyte name) {
+ jint _exception = 0;
+ jarray _lengthArray = (jarray) 0;
+ jarray _sizeArray = (jarray) 0;
+ jarray _typeArray = (jarray) 0;
+ jint _lengthRemaining;
+ GLsizei *length = (GLsizei *) 0;
+ jint _sizeRemaining;
+ GLint *size = (GLint *) 0;
+ jint _typeRemaining;
+ GLenum *type = (GLenum *) 0;
+
+ length = (GLsizei *)getPointer(_env, length_buf, &_lengthArray, &_lengthRemaining);
+ size = (GLint *)getPointer(_env, size_buf, &_sizeArray, &_sizeRemaining);
+ type = (GLenum *)getPointer(_env, type_buf, &_typeArray, &_typeRemaining);
+ glGetActiveUniform(
+ (GLuint)program,
+ (GLuint)index,
+ (GLsizei)bufsize,
+ (GLsizei *)length,
+ (GLint *)size,
+ (GLenum *)type,
+ (char *)name
+ );
+ if (_lengthArray) {
+ releasePointer(_env, _lengthArray, type, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+ if (_sizeArray) {
+ releasePointer(_env, _sizeArray, size, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+ if (_typeArray) {
+ releasePointer(_env, _typeArray, length, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glGetAttachedShaders ( GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders ) */
+static void
+android_glGetAttachedShaders__II_3II_3II
+ (JNIEnv *_env, jobject _this, jint program, jint maxcount, jintArray count_ref, jint countOffset, jintArray shaders_ref, jint shadersOffset) {
+ jint _exception = 0;
+ GLsizei *count_base = (GLsizei *) 0;
+ jint _countRemaining;
+ GLsizei *count = (GLsizei *) 0;
+ GLuint *shaders_base = (GLuint *) 0;
+ jint _shadersRemaining;
+ GLuint *shaders = (GLuint *) 0;
+
+ if (!count_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "count == null");
+ goto exit;
+ }
+ if (countOffset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "countOffset < 0");
+ goto exit;
+ }
+ _countRemaining = _env->GetArrayLength(count_ref) - countOffset;
+ count_base = (GLsizei *)
+ _env->GetPrimitiveArrayCritical(count_ref, (jboolean *)0);
+ count = count_base + countOffset;
+
+ if (!shaders_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "shaders == null");
+ goto exit;
+ }
+ if (shadersOffset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "shadersOffset < 0");
+ goto exit;
+ }
+ _shadersRemaining = _env->GetArrayLength(shaders_ref) - shadersOffset;
+ shaders_base = (GLuint *)
+ _env->GetPrimitiveArrayCritical(shaders_ref, (jboolean *)0);
+ shaders = shaders_base + shadersOffset;
+
+ glGetAttachedShaders(
+ (GLuint)program,
+ (GLsizei)maxcount,
+ (GLsizei *)count,
+ (GLuint *)shaders
+ );
+
+exit:
+ if (shaders_base) {
+ _env->ReleasePrimitiveArrayCritical(shaders_ref, shaders_base,
+ _exception ? JNI_ABORT: 0);
+ }
+ if (count_base) {
+ _env->ReleasePrimitiveArrayCritical(count_ref, count_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetAttachedShaders ( GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders ) */
+static void
+android_glGetAttachedShaders__IILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint program, jint maxcount, jobject count_buf, jobject shaders_buf) {
+ jint _exception = 0;
+ jarray _countArray = (jarray) 0;
+ jarray _shadersArray = (jarray) 0;
+ jint _countRemaining;
+ GLsizei *count = (GLsizei *) 0;
+ jint _shadersRemaining;
+ GLuint *shaders = (GLuint *) 0;
+
+ count = (GLsizei *)getPointer(_env, count_buf, &_countArray, &_countRemaining);
+ shaders = (GLuint *)getPointer(_env, shaders_buf, &_shadersArray, &_shadersRemaining);
+ glGetAttachedShaders(
+ (GLuint)program,
+ (GLsizei)maxcount,
+ (GLsizei *)count,
+ (GLuint *)shaders
+ );
+ if (_countArray) {
+ releasePointer(_env, _countArray, shaders, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+ if (_shadersArray) {
+ releasePointer(_env, _shadersArray, count, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* int glGetAttribLocation ( GLuint program, const char *name ) */
+static jint
+android_glGetAttribLocation__ILjava_lang_String_2
+ (JNIEnv *_env, jobject _this, jint program, jstring name) {
+ int _returnValue = 0;
+ const char* _nativename = 0;
+
+ if (!name) {
+ _env->ThrowNew(IAEClass, "name == null");
+ goto exit;
+ }
+ _nativename = _env->GetStringUTFChars(name, 0);
+
+ _returnValue = glGetAttribLocation(
+ (GLuint)program,
+ (char *)_nativename
+ );
+
+exit:
+ if (_nativename) {
+ _env->ReleaseStringUTFChars(name, _nativename);
+ }
+
+ return _returnValue;
+}
+
+/* void glGetBooleanv ( GLenum pname, GLboolean *params ) */
+static void
+android_glGetBooleanv__I_3ZI
+ (JNIEnv *_env, jobject _this, jint pname, jbooleanArray params_ref, jint offset) {
+ jint _exception = 0;
+ GLboolean *params_base = (GLboolean *) 0;
+ jint _remaining;
+ GLboolean *params = (GLboolean *) 0;
+
+ if (!params_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "params == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(params_ref) - offset;
+ params_base = (GLboolean *)
+ _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
+ params = params_base + offset;
+
+ glGetBooleanv(
+ (GLenum)pname,
+ (GLboolean *)params
+ );
+
+exit:
+ if (params_base) {
+ _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetBooleanv ( GLenum pname, GLboolean *params ) */
+static void
+android_glGetBooleanv__ILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLboolean *params = (GLboolean *) 0;
+
+ params = (GLboolean *)getPointer(_env, params_buf, &_array, &_remaining);
+ glGetBooleanv(
+ (GLenum)pname,
+ (GLboolean *)params
+ );
+ if (_array) {
+ releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */
+static void
+android_glGetBufferParameteriv__II_3II
+ (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
+ _env->ThrowNew(UOEClass,
+ "glGetBufferParameteriv");
+}
+
+/* void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */
+static void
+android_glGetBufferParameteriv__IILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
+ _env->ThrowNew(UOEClass,
+ "glGetBufferParameteriv");
+}
+
+/* GLenum glGetError ( void ) */
+static jint
+android_glGetError__
+ (JNIEnv *_env, jobject _this) {
+ GLenum _returnValue;
+ _returnValue = glGetError();
+ return _returnValue;
+}
+
+/* void glGetFloatv ( GLenum pname, GLfloat *params ) */
+static void
+android_glGetFloatv__I_3FI
+ (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) {
+ jint _exception = 0;
+ GLfloat *params_base = (GLfloat *) 0;
+ jint _remaining;
+ GLfloat *params = (GLfloat *) 0;
+
+ if (!params_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "params == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(params_ref) - offset;
+ params_base = (GLfloat *)
+ _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
+ params = params_base + offset;
+
+ glGetFloatv(
+ (GLenum)pname,
+ (GLfloat *)params
+ );
+
+exit:
+ if (params_base) {
+ _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetFloatv ( GLenum pname, GLfloat *params ) */
+static void
+android_glGetFloatv__ILjava_nio_FloatBuffer_2
+ (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLfloat *params = (GLfloat *) 0;
+
+ params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining);
+ glGetFloatv(
+ (GLenum)pname,
+ (GLfloat *)params
+ );
+ if (_array) {
+ releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glGetFramebufferAttachmentParameteriv ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */
+static void
+android_glGetFramebufferAttachmentParameteriv__III_3II
+ (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jintArray params_ref, jint offset) {
+ jint _exception = 0;
+ GLint *params_base = (GLint *) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ if (!params_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "params == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(params_ref) - offset;
+ params_base = (GLint *)
+ _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
+ params = params_base + offset;
+
+ glGetFramebufferAttachmentParameteriv(
+ (GLenum)target,
+ (GLenum)attachment,
+ (GLenum)pname,
+ (GLint *)params
+ );
+
+exit:
+ if (params_base) {
+ _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetFramebufferAttachmentParameteriv ( GLenum target, GLenum attachment, GLenum pname, GLint *params ) */
+static void
+android_glGetFramebufferAttachmentParameteriv__IIILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jobject params_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
+ glGetFramebufferAttachmentParameteriv(
+ (GLenum)target,
+ (GLenum)attachment,
+ (GLenum)pname,
+ (GLint *)params
+ );
+ if (_array) {
+ releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glGetIntegerv ( GLenum pname, GLint *params ) */
+static void
+android_glGetIntegerv__I_3II
+ (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) {
+ jint _exception = 0;
+ GLint *params_base = (GLint *) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ if (!params_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "params == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(params_ref) - offset;
+ int _needed;
+ switch (pname) {
+#if defined(GL_ALPHA_BITS)
+ case GL_ALPHA_BITS:
+#endif // defined(GL_ALPHA_BITS)
+#if defined(GL_ALPHA_TEST_FUNC)
+ case GL_ALPHA_TEST_FUNC:
+#endif // defined(GL_ALPHA_TEST_FUNC)
+#if defined(GL_ALPHA_TEST_REF)
+ case GL_ALPHA_TEST_REF:
+#endif // defined(GL_ALPHA_TEST_REF)
+#if defined(GL_BLEND_DST)
+ case GL_BLEND_DST:
+#endif // defined(GL_BLEND_DST)
+#if defined(GL_BLUE_BITS)
+ case GL_BLUE_BITS:
+#endif // defined(GL_BLUE_BITS)
+#if defined(GL_COLOR_ARRAY_BUFFER_BINDING)
+ case GL_COLOR_ARRAY_BUFFER_BINDING:
+#endif // defined(GL_COLOR_ARRAY_BUFFER_BINDING)
+#if defined(GL_COLOR_ARRAY_SIZE)
+ case GL_COLOR_ARRAY_SIZE:
+#endif // defined(GL_COLOR_ARRAY_SIZE)
+#if defined(GL_COLOR_ARRAY_STRIDE)
+ case GL_COLOR_ARRAY_STRIDE:
+#endif // defined(GL_COLOR_ARRAY_STRIDE)
+#if defined(GL_COLOR_ARRAY_TYPE)
+ case GL_COLOR_ARRAY_TYPE:
+#endif // defined(GL_COLOR_ARRAY_TYPE)
+#if defined(GL_CULL_FACE)
+ case GL_CULL_FACE:
+#endif // defined(GL_CULL_FACE)
+#if defined(GL_DEPTH_BITS)
+ case GL_DEPTH_BITS:
+#endif // defined(GL_DEPTH_BITS)
+#if defined(GL_DEPTH_CLEAR_VALUE)
+ case GL_DEPTH_CLEAR_VALUE:
+#endif // defined(GL_DEPTH_CLEAR_VALUE)
+#if defined(GL_DEPTH_FUNC)
+ case GL_DEPTH_FUNC:
+#endif // defined(GL_DEPTH_FUNC)
+#if defined(GL_DEPTH_WRITEMASK)
+ case GL_DEPTH_WRITEMASK:
+#endif // defined(GL_DEPTH_WRITEMASK)
+#if defined(GL_FOG_DENSITY)
+ case GL_FOG_DENSITY:
+#endif // defined(GL_FOG_DENSITY)
+#if defined(GL_FOG_END)
+ case GL_FOG_END:
+#endif // defined(GL_FOG_END)
+#if defined(GL_FOG_MODE)
+ case GL_FOG_MODE:
+#endif // defined(GL_FOG_MODE)
+#if defined(GL_FOG_START)
+ case GL_FOG_START:
+#endif // defined(GL_FOG_START)
+#if defined(GL_FRONT_FACE)
+ case GL_FRONT_FACE:
+#endif // defined(GL_FRONT_FACE)
+#if defined(GL_GREEN_BITS)
+ case GL_GREEN_BITS:
+#endif // defined(GL_GREEN_BITS)
+#if defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES)
+ case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
+#endif // defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES)
+#if defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES)
+ case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
+#endif // defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES)
+#if defined(GL_LIGHT_MODEL_COLOR_CONTROL)
+ case GL_LIGHT_MODEL_COLOR_CONTROL:
+#endif // defined(GL_LIGHT_MODEL_COLOR_CONTROL)
+#if defined(GL_LIGHT_MODEL_LOCAL_VIEWER)
+ case GL_LIGHT_MODEL_LOCAL_VIEWER:
+#endif // defined(GL_LIGHT_MODEL_LOCAL_VIEWER)
+#if defined(GL_LIGHT_MODEL_TWO_SIDE)
+ case GL_LIGHT_MODEL_TWO_SIDE:
+#endif // defined(GL_LIGHT_MODEL_TWO_SIDE)
+#if defined(GL_LINE_SMOOTH_HINT)
+ case GL_LINE_SMOOTH_HINT:
+#endif // defined(GL_LINE_SMOOTH_HINT)
+#if defined(GL_LINE_WIDTH)
+ case GL_LINE_WIDTH:
+#endif // defined(GL_LINE_WIDTH)
+#if defined(GL_LOGIC_OP_MODE)
+ case GL_LOGIC_OP_MODE:
+#endif // defined(GL_LOGIC_OP_MODE)
+#if defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES)
+ case GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES:
+#endif // defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES)
+#if defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES)
+ case GL_MATRIX_INDEX_ARRAY_SIZE_OES:
+#endif // defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES)
+#if defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES)
+ case GL_MATRIX_INDEX_ARRAY_STRIDE_OES:
+#endif // defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES)
+#if defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES)
+ case GL_MATRIX_INDEX_ARRAY_TYPE_OES:
+#endif // defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES)
+#if defined(GL_MATRIX_MODE)
+ case GL_MATRIX_MODE:
+#endif // defined(GL_MATRIX_MODE)
+#if defined(GL_MAX_CLIP_PLANES)
+ case GL_MAX_CLIP_PLANES:
+#endif // defined(GL_MAX_CLIP_PLANES)
+#if defined(GL_MAX_ELEMENTS_INDICES)
+ case GL_MAX_ELEMENTS_INDICES:
+#endif // defined(GL_MAX_ELEMENTS_INDICES)
+#if defined(GL_MAX_ELEMENTS_VERTICES)
+ case GL_MAX_ELEMENTS_VERTICES:
+#endif // defined(GL_MAX_ELEMENTS_VERTICES)
+#if defined(GL_MAX_LIGHTS)
+ case GL_MAX_LIGHTS:
+#endif // defined(GL_MAX_LIGHTS)
+#if defined(GL_MAX_MODELVIEW_STACK_DEPTH)
+ case GL_MAX_MODELVIEW_STACK_DEPTH:
+#endif // defined(GL_MAX_MODELVIEW_STACK_DEPTH)
+#if defined(GL_MAX_PALETTE_MATRICES_OES)
+ case GL_MAX_PALETTE_MATRICES_OES:
+#endif // defined(GL_MAX_PALETTE_MATRICES_OES)
+#if defined(GL_MAX_PROJECTION_STACK_DEPTH)
+ case GL_MAX_PROJECTION_STACK_DEPTH:
+#endif // defined(GL_MAX_PROJECTION_STACK_DEPTH)
+#if defined(GL_MAX_TEXTURE_SIZE)
+ case GL_MAX_TEXTURE_SIZE:
+#endif // defined(GL_MAX_TEXTURE_SIZE)
+#if defined(GL_MAX_TEXTURE_STACK_DEPTH)
+ case GL_MAX_TEXTURE_STACK_DEPTH:
+#endif // defined(GL_MAX_TEXTURE_STACK_DEPTH)
+#if defined(GL_MAX_TEXTURE_UNITS)
+ case GL_MAX_TEXTURE_UNITS:
+#endif // defined(GL_MAX_TEXTURE_UNITS)
+#if defined(GL_MAX_VERTEX_UNITS_OES)
+ case GL_MAX_VERTEX_UNITS_OES:
+#endif // defined(GL_MAX_VERTEX_UNITS_OES)
+#if defined(GL_MODELVIEW_STACK_DEPTH)
+ case GL_MODELVIEW_STACK_DEPTH:
+#endif // defined(GL_MODELVIEW_STACK_DEPTH)
+#if defined(GL_NORMAL_ARRAY_BUFFER_BINDING)
+ case GL_NORMAL_ARRAY_BUFFER_BINDING:
+#endif // defined(GL_NORMAL_ARRAY_BUFFER_BINDING)
+#if defined(GL_NORMAL_ARRAY_STRIDE)
+ case GL_NORMAL_ARRAY_STRIDE:
+#endif // defined(GL_NORMAL_ARRAY_STRIDE)
+#if defined(GL_NORMAL_ARRAY_TYPE)
+ case GL_NORMAL_ARRAY_TYPE:
+#endif // defined(GL_NORMAL_ARRAY_TYPE)
+#if defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS)
+ case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
+#endif // defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS)
+#if defined(GL_PACK_ALIGNMENT)
+ case GL_PACK_ALIGNMENT:
+#endif // defined(GL_PACK_ALIGNMENT)
+#if defined(GL_PERSPECTIVE_CORRECTION_HINT)
+ case GL_PERSPECTIVE_CORRECTION_HINT:
+#endif // defined(GL_PERSPECTIVE_CORRECTION_HINT)
+#if defined(GL_POINT_SIZE)
+ case GL_POINT_SIZE:
+#endif // defined(GL_POINT_SIZE)
+#if defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES)
+ case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
+#endif // defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES)
+#if defined(GL_POINT_SIZE_ARRAY_STRIDE_OES)
+ case GL_POINT_SIZE_ARRAY_STRIDE_OES:
+#endif // defined(GL_POINT_SIZE_ARRAY_STRIDE_OES)
+#if defined(GL_POINT_SIZE_ARRAY_TYPE_OES)
+ case GL_POINT_SIZE_ARRAY_TYPE_OES:
+#endif // defined(GL_POINT_SIZE_ARRAY_TYPE_OES)
+#if defined(GL_POINT_SMOOTH_HINT)
+ case GL_POINT_SMOOTH_HINT:
+#endif // defined(GL_POINT_SMOOTH_HINT)
+#if defined(GL_POLYGON_OFFSET_FACTOR)
+ case GL_POLYGON_OFFSET_FACTOR:
+#endif // defined(GL_POLYGON_OFFSET_FACTOR)
+#if defined(GL_POLYGON_OFFSET_UNITS)
+ case GL_POLYGON_OFFSET_UNITS:
+#endif // defined(GL_POLYGON_OFFSET_UNITS)
+#if defined(GL_PROJECTION_STACK_DEPTH)
+ case GL_PROJECTION_STACK_DEPTH:
+#endif // defined(GL_PROJECTION_STACK_DEPTH)
+#if defined(GL_RED_BITS)
+ case GL_RED_BITS:
+#endif // defined(GL_RED_BITS)
+#if defined(GL_SHADE_MODEL)
+ case GL_SHADE_MODEL:
+#endif // defined(GL_SHADE_MODEL)
+#if defined(GL_STENCIL_BITS)
+ case GL_STENCIL_BITS:
+#endif // defined(GL_STENCIL_BITS)
+#if defined(GL_STENCIL_CLEAR_VALUE)
+ case GL_STENCIL_CLEAR_VALUE:
+#endif // defined(GL_STENCIL_CLEAR_VALUE)
+#if defined(GL_STENCIL_FAIL)
+ case GL_STENCIL_FAIL:
+#endif // defined(GL_STENCIL_FAIL)
+#if defined(GL_STENCIL_FUNC)
+ case GL_STENCIL_FUNC:
+#endif // defined(GL_STENCIL_FUNC)
+#if defined(GL_STENCIL_PASS_DEPTH_FAIL)
+ case GL_STENCIL_PASS_DEPTH_FAIL:
+#endif // defined(GL_STENCIL_PASS_DEPTH_FAIL)
+#if defined(GL_STENCIL_PASS_DEPTH_PASS)
+ case GL_STENCIL_PASS_DEPTH_PASS:
+#endif // defined(GL_STENCIL_PASS_DEPTH_PASS)
+#if defined(GL_STENCIL_REF)
+ case GL_STENCIL_REF:
+#endif // defined(GL_STENCIL_REF)
+#if defined(GL_STENCIL_VALUE_MASK)
+ case GL_STENCIL_VALUE_MASK:
+#endif // defined(GL_STENCIL_VALUE_MASK)
+#if defined(GL_STENCIL_WRITEMASK)
+ case GL_STENCIL_WRITEMASK:
+#endif // defined(GL_STENCIL_WRITEMASK)
+#if defined(GL_SUBPIXEL_BITS)
+ case GL_SUBPIXEL_BITS:
+#endif // defined(GL_SUBPIXEL_BITS)
+#if defined(GL_TEXTURE_BINDING_2D)
+ case GL_TEXTURE_BINDING_2D:
+#endif // defined(GL_TEXTURE_BINDING_2D)
+#if defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING)
+ case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:
+#endif // defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING)
+#if defined(GL_TEXTURE_COORD_ARRAY_SIZE)
+ case GL_TEXTURE_COORD_ARRAY_SIZE:
+#endif // defined(GL_TEXTURE_COORD_ARRAY_SIZE)
+#if defined(GL_TEXTURE_COORD_ARRAY_STRIDE)
+ case GL_TEXTURE_COORD_ARRAY_STRIDE:
+#endif // defined(GL_TEXTURE_COORD_ARRAY_STRIDE)
+#if defined(GL_TEXTURE_COORD_ARRAY_TYPE)
+ case GL_TEXTURE_COORD_ARRAY_TYPE:
+#endif // defined(GL_TEXTURE_COORD_ARRAY_TYPE)
+#if defined(GL_TEXTURE_STACK_DEPTH)
+ case GL_TEXTURE_STACK_DEPTH:
+#endif // defined(GL_TEXTURE_STACK_DEPTH)
+#if defined(GL_UNPACK_ALIGNMENT)
+ case GL_UNPACK_ALIGNMENT:
+#endif // defined(GL_UNPACK_ALIGNMENT)
+#if defined(GL_VERTEX_ARRAY_BUFFER_BINDING)
+ case GL_VERTEX_ARRAY_BUFFER_BINDING:
+#endif // defined(GL_VERTEX_ARRAY_BUFFER_BINDING)
+#if defined(GL_VERTEX_ARRAY_SIZE)
+ case GL_VERTEX_ARRAY_SIZE:
+#endif // defined(GL_VERTEX_ARRAY_SIZE)
+#if defined(GL_VERTEX_ARRAY_STRIDE)
+ case GL_VERTEX_ARRAY_STRIDE:
+#endif // defined(GL_VERTEX_ARRAY_STRIDE)
+#if defined(GL_VERTEX_ARRAY_TYPE)
+ case GL_VERTEX_ARRAY_TYPE:
+#endif // defined(GL_VERTEX_ARRAY_TYPE)
+#if defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES)
+ case GL_WEIGHT_ARRAY_BUFFER_BINDING_OES:
+#endif // defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES)
+#if defined(GL_WEIGHT_ARRAY_SIZE_OES)
+ case GL_WEIGHT_ARRAY_SIZE_OES:
+#endif // defined(GL_WEIGHT_ARRAY_SIZE_OES)
+#if defined(GL_WEIGHT_ARRAY_STRIDE_OES)
+ case GL_WEIGHT_ARRAY_STRIDE_OES:
+#endif // defined(GL_WEIGHT_ARRAY_STRIDE_OES)
+#if defined(GL_WEIGHT_ARRAY_TYPE_OES)
+ case GL_WEIGHT_ARRAY_TYPE_OES:
+#endif // defined(GL_WEIGHT_ARRAY_TYPE_OES)
+ _needed = 1;
+ break;
+#if defined(GL_ALIASED_POINT_SIZE_RANGE)
+ case GL_ALIASED_POINT_SIZE_RANGE:
+#endif // defined(GL_ALIASED_POINT_SIZE_RANGE)
+#if defined(GL_ALIASED_LINE_WIDTH_RANGE)
+ case GL_ALIASED_LINE_WIDTH_RANGE:
+#endif // defined(GL_ALIASED_LINE_WIDTH_RANGE)
+#if defined(GL_DEPTH_RANGE)
+ case GL_DEPTH_RANGE:
+#endif // defined(GL_DEPTH_RANGE)
+#if defined(GL_MAX_VIEWPORT_DIMS)
+ case GL_MAX_VIEWPORT_DIMS:
+#endif // defined(GL_MAX_VIEWPORT_DIMS)
+#if defined(GL_SMOOTH_LINE_WIDTH_RANGE)
+ case GL_SMOOTH_LINE_WIDTH_RANGE:
+#endif // defined(GL_SMOOTH_LINE_WIDTH_RANGE)
+#if defined(GL_SMOOTH_POINT_SIZE_RANGE)
+ case GL_SMOOTH_POINT_SIZE_RANGE:
+#endif // defined(GL_SMOOTH_POINT_SIZE_RANGE)
+ _needed = 2;
+ break;
+#if defined(GL_COLOR_CLEAR_VALUE)
+ case GL_COLOR_CLEAR_VALUE:
+#endif // defined(GL_COLOR_CLEAR_VALUE)
+#if defined(GL_COLOR_WRITEMASK)
+ case GL_COLOR_WRITEMASK:
+#endif // defined(GL_COLOR_WRITEMASK)
+#if defined(GL_FOG_COLOR)
+ case GL_FOG_COLOR:
+#endif // defined(GL_FOG_COLOR)
+#if defined(GL_LIGHT_MODEL_AMBIENT)
+ case GL_LIGHT_MODEL_AMBIENT:
+#endif // defined(GL_LIGHT_MODEL_AMBIENT)
+#if defined(GL_SCISSOR_BOX)
+ case GL_SCISSOR_BOX:
+#endif // defined(GL_SCISSOR_BOX)
+#if defined(GL_VIEWPORT)
+ case GL_VIEWPORT:
+#endif // defined(GL_VIEWPORT)
+ _needed = 4;
+ break;
+#if defined(GL_MODELVIEW_MATRIX)
+ case GL_MODELVIEW_MATRIX:
+#endif // defined(GL_MODELVIEW_MATRIX)
+#if defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES)
+ case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES:
+#endif // defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES)
+#if defined(GL_PROJECTION_MATRIX)
+ case GL_PROJECTION_MATRIX:
+#endif // defined(GL_PROJECTION_MATRIX)
+#if defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES)
+ case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES:
+#endif // defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES)
+#if defined(GL_TEXTURE_MATRIX)
+ case GL_TEXTURE_MATRIX:
+#endif // defined(GL_TEXTURE_MATRIX)
+#if defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES)
+ case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES:
+#endif // defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES)
+ _needed = 16;
+ break;
+#if defined(GL_COMPRESSED_TEXTURE_FORMATS)
+ case GL_COMPRESSED_TEXTURE_FORMATS:
+#endif // defined(GL_COMPRESSED_TEXTURE_FORMATS)
+ _needed = getNumCompressedTextureFormats();
+ break;
+ default:
+ _needed = 0;
+ break;
+ }
+ if (_remaining < _needed) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "length - offset < needed");
+ goto exit;
+ }
+ params_base = (GLint *)
+ _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
+ params = params_base + offset;
+
+ glGetIntegerv(
+ (GLenum)pname,
+ (GLint *)params
+ );
+
+exit:
+ if (params_base) {
+ _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetIntegerv ( GLenum pname, GLint *params ) */
+static void
+android_glGetIntegerv__ILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
+ int _needed;
+ switch (pname) {
+#if defined(GL_ALPHA_BITS)
+ case GL_ALPHA_BITS:
+#endif // defined(GL_ALPHA_BITS)
+#if defined(GL_ALPHA_TEST_FUNC)
+ case GL_ALPHA_TEST_FUNC:
+#endif // defined(GL_ALPHA_TEST_FUNC)
+#if defined(GL_ALPHA_TEST_REF)
+ case GL_ALPHA_TEST_REF:
+#endif // defined(GL_ALPHA_TEST_REF)
+#if defined(GL_BLEND_DST)
+ case GL_BLEND_DST:
+#endif // defined(GL_BLEND_DST)
+#if defined(GL_BLUE_BITS)
+ case GL_BLUE_BITS:
+#endif // defined(GL_BLUE_BITS)
+#if defined(GL_COLOR_ARRAY_BUFFER_BINDING)
+ case GL_COLOR_ARRAY_BUFFER_BINDING:
+#endif // defined(GL_COLOR_ARRAY_BUFFER_BINDING)
+#if defined(GL_COLOR_ARRAY_SIZE)
+ case GL_COLOR_ARRAY_SIZE:
+#endif // defined(GL_COLOR_ARRAY_SIZE)
+#if defined(GL_COLOR_ARRAY_STRIDE)
+ case GL_COLOR_ARRAY_STRIDE:
+#endif // defined(GL_COLOR_ARRAY_STRIDE)
+#if defined(GL_COLOR_ARRAY_TYPE)
+ case GL_COLOR_ARRAY_TYPE:
+#endif // defined(GL_COLOR_ARRAY_TYPE)
+#if defined(GL_CULL_FACE)
+ case GL_CULL_FACE:
+#endif // defined(GL_CULL_FACE)
+#if defined(GL_DEPTH_BITS)
+ case GL_DEPTH_BITS:
+#endif // defined(GL_DEPTH_BITS)
+#if defined(GL_DEPTH_CLEAR_VALUE)
+ case GL_DEPTH_CLEAR_VALUE:
+#endif // defined(GL_DEPTH_CLEAR_VALUE)
+#if defined(GL_DEPTH_FUNC)
+ case GL_DEPTH_FUNC:
+#endif // defined(GL_DEPTH_FUNC)
+#if defined(GL_DEPTH_WRITEMASK)
+ case GL_DEPTH_WRITEMASK:
+#endif // defined(GL_DEPTH_WRITEMASK)
+#if defined(GL_FOG_DENSITY)
+ case GL_FOG_DENSITY:
+#endif // defined(GL_FOG_DENSITY)
+#if defined(GL_FOG_END)
+ case GL_FOG_END:
+#endif // defined(GL_FOG_END)
+#if defined(GL_FOG_MODE)
+ case GL_FOG_MODE:
+#endif // defined(GL_FOG_MODE)
+#if defined(GL_FOG_START)
+ case GL_FOG_START:
+#endif // defined(GL_FOG_START)
+#if defined(GL_FRONT_FACE)
+ case GL_FRONT_FACE:
+#endif // defined(GL_FRONT_FACE)
+#if defined(GL_GREEN_BITS)
+ case GL_GREEN_BITS:
+#endif // defined(GL_GREEN_BITS)
+#if defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES)
+ case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
+#endif // defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES)
+#if defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES)
+ case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
+#endif // defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES)
+#if defined(GL_LIGHT_MODEL_COLOR_CONTROL)
+ case GL_LIGHT_MODEL_COLOR_CONTROL:
+#endif // defined(GL_LIGHT_MODEL_COLOR_CONTROL)
+#if defined(GL_LIGHT_MODEL_LOCAL_VIEWER)
+ case GL_LIGHT_MODEL_LOCAL_VIEWER:
+#endif // defined(GL_LIGHT_MODEL_LOCAL_VIEWER)
+#if defined(GL_LIGHT_MODEL_TWO_SIDE)
+ case GL_LIGHT_MODEL_TWO_SIDE:
+#endif // defined(GL_LIGHT_MODEL_TWO_SIDE)
+#if defined(GL_LINE_SMOOTH_HINT)
+ case GL_LINE_SMOOTH_HINT:
+#endif // defined(GL_LINE_SMOOTH_HINT)
+#if defined(GL_LINE_WIDTH)
+ case GL_LINE_WIDTH:
+#endif // defined(GL_LINE_WIDTH)
+#if defined(GL_LOGIC_OP_MODE)
+ case GL_LOGIC_OP_MODE:
+#endif // defined(GL_LOGIC_OP_MODE)
+#if defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES)
+ case GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES:
+#endif // defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES)
+#if defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES)
+ case GL_MATRIX_INDEX_ARRAY_SIZE_OES:
+#endif // defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES)
+#if defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES)
+ case GL_MATRIX_INDEX_ARRAY_STRIDE_OES:
+#endif // defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES)
+#if defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES)
+ case GL_MATRIX_INDEX_ARRAY_TYPE_OES:
+#endif // defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES)
+#if defined(GL_MATRIX_MODE)
+ case GL_MATRIX_MODE:
+#endif // defined(GL_MATRIX_MODE)
+#if defined(GL_MAX_CLIP_PLANES)
+ case GL_MAX_CLIP_PLANES:
+#endif // defined(GL_MAX_CLIP_PLANES)
+#if defined(GL_MAX_ELEMENTS_INDICES)
+ case GL_MAX_ELEMENTS_INDICES:
+#endif // defined(GL_MAX_ELEMENTS_INDICES)
+#if defined(GL_MAX_ELEMENTS_VERTICES)
+ case GL_MAX_ELEMENTS_VERTICES:
+#endif // defined(GL_MAX_ELEMENTS_VERTICES)
+#if defined(GL_MAX_LIGHTS)
+ case GL_MAX_LIGHTS:
+#endif // defined(GL_MAX_LIGHTS)
+#if defined(GL_MAX_MODELVIEW_STACK_DEPTH)
+ case GL_MAX_MODELVIEW_STACK_DEPTH:
+#endif // defined(GL_MAX_MODELVIEW_STACK_DEPTH)
+#if defined(GL_MAX_PALETTE_MATRICES_OES)
+ case GL_MAX_PALETTE_MATRICES_OES:
+#endif // defined(GL_MAX_PALETTE_MATRICES_OES)
+#if defined(GL_MAX_PROJECTION_STACK_DEPTH)
+ case GL_MAX_PROJECTION_STACK_DEPTH:
+#endif // defined(GL_MAX_PROJECTION_STACK_DEPTH)
+#if defined(GL_MAX_TEXTURE_SIZE)
+ case GL_MAX_TEXTURE_SIZE:
+#endif // defined(GL_MAX_TEXTURE_SIZE)
+#if defined(GL_MAX_TEXTURE_STACK_DEPTH)
+ case GL_MAX_TEXTURE_STACK_DEPTH:
+#endif // defined(GL_MAX_TEXTURE_STACK_DEPTH)
+#if defined(GL_MAX_TEXTURE_UNITS)
+ case GL_MAX_TEXTURE_UNITS:
+#endif // defined(GL_MAX_TEXTURE_UNITS)
+#if defined(GL_MAX_VERTEX_UNITS_OES)
+ case GL_MAX_VERTEX_UNITS_OES:
+#endif // defined(GL_MAX_VERTEX_UNITS_OES)
+#if defined(GL_MODELVIEW_STACK_DEPTH)
+ case GL_MODELVIEW_STACK_DEPTH:
+#endif // defined(GL_MODELVIEW_STACK_DEPTH)
+#if defined(GL_NORMAL_ARRAY_BUFFER_BINDING)
+ case GL_NORMAL_ARRAY_BUFFER_BINDING:
+#endif // defined(GL_NORMAL_ARRAY_BUFFER_BINDING)
+#if defined(GL_NORMAL_ARRAY_STRIDE)
+ case GL_NORMAL_ARRAY_STRIDE:
+#endif // defined(GL_NORMAL_ARRAY_STRIDE)
+#if defined(GL_NORMAL_ARRAY_TYPE)
+ case GL_NORMAL_ARRAY_TYPE:
+#endif // defined(GL_NORMAL_ARRAY_TYPE)
+#if defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS)
+ case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
+#endif // defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS)
+#if defined(GL_PACK_ALIGNMENT)
+ case GL_PACK_ALIGNMENT:
+#endif // defined(GL_PACK_ALIGNMENT)
+#if defined(GL_PERSPECTIVE_CORRECTION_HINT)
+ case GL_PERSPECTIVE_CORRECTION_HINT:
+#endif // defined(GL_PERSPECTIVE_CORRECTION_HINT)
+#if defined(GL_POINT_SIZE)
+ case GL_POINT_SIZE:
+#endif // defined(GL_POINT_SIZE)
+#if defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES)
+ case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
+#endif // defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES)
+#if defined(GL_POINT_SIZE_ARRAY_STRIDE_OES)
+ case GL_POINT_SIZE_ARRAY_STRIDE_OES:
+#endif // defined(GL_POINT_SIZE_ARRAY_STRIDE_OES)
+#if defined(GL_POINT_SIZE_ARRAY_TYPE_OES)
+ case GL_POINT_SIZE_ARRAY_TYPE_OES:
+#endif // defined(GL_POINT_SIZE_ARRAY_TYPE_OES)
+#if defined(GL_POINT_SMOOTH_HINT)
+ case GL_POINT_SMOOTH_HINT:
+#endif // defined(GL_POINT_SMOOTH_HINT)
+#if defined(GL_POLYGON_OFFSET_FACTOR)
+ case GL_POLYGON_OFFSET_FACTOR:
+#endif // defined(GL_POLYGON_OFFSET_FACTOR)
+#if defined(GL_POLYGON_OFFSET_UNITS)
+ case GL_POLYGON_OFFSET_UNITS:
+#endif // defined(GL_POLYGON_OFFSET_UNITS)
+#if defined(GL_PROJECTION_STACK_DEPTH)
+ case GL_PROJECTION_STACK_DEPTH:
+#endif // defined(GL_PROJECTION_STACK_DEPTH)
+#if defined(GL_RED_BITS)
+ case GL_RED_BITS:
+#endif // defined(GL_RED_BITS)
+#if defined(GL_SHADE_MODEL)
+ case GL_SHADE_MODEL:
+#endif // defined(GL_SHADE_MODEL)
+#if defined(GL_STENCIL_BITS)
+ case GL_STENCIL_BITS:
+#endif // defined(GL_STENCIL_BITS)
+#if defined(GL_STENCIL_CLEAR_VALUE)
+ case GL_STENCIL_CLEAR_VALUE:
+#endif // defined(GL_STENCIL_CLEAR_VALUE)
+#if defined(GL_STENCIL_FAIL)
+ case GL_STENCIL_FAIL:
+#endif // defined(GL_STENCIL_FAIL)
+#if defined(GL_STENCIL_FUNC)
+ case GL_STENCIL_FUNC:
+#endif // defined(GL_STENCIL_FUNC)
+#if defined(GL_STENCIL_PASS_DEPTH_FAIL)
+ case GL_STENCIL_PASS_DEPTH_FAIL:
+#endif // defined(GL_STENCIL_PASS_DEPTH_FAIL)
+#if defined(GL_STENCIL_PASS_DEPTH_PASS)
+ case GL_STENCIL_PASS_DEPTH_PASS:
+#endif // defined(GL_STENCIL_PASS_DEPTH_PASS)
+#if defined(GL_STENCIL_REF)
+ case GL_STENCIL_REF:
+#endif // defined(GL_STENCIL_REF)
+#if defined(GL_STENCIL_VALUE_MASK)
+ case GL_STENCIL_VALUE_MASK:
+#endif // defined(GL_STENCIL_VALUE_MASK)
+#if defined(GL_STENCIL_WRITEMASK)
+ case GL_STENCIL_WRITEMASK:
+#endif // defined(GL_STENCIL_WRITEMASK)
+#if defined(GL_SUBPIXEL_BITS)
+ case GL_SUBPIXEL_BITS:
+#endif // defined(GL_SUBPIXEL_BITS)
+#if defined(GL_TEXTURE_BINDING_2D)
+ case GL_TEXTURE_BINDING_2D:
+#endif // defined(GL_TEXTURE_BINDING_2D)
+#if defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING)
+ case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:
+#endif // defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING)
+#if defined(GL_TEXTURE_COORD_ARRAY_SIZE)
+ case GL_TEXTURE_COORD_ARRAY_SIZE:
+#endif // defined(GL_TEXTURE_COORD_ARRAY_SIZE)
+#if defined(GL_TEXTURE_COORD_ARRAY_STRIDE)
+ case GL_TEXTURE_COORD_ARRAY_STRIDE:
+#endif // defined(GL_TEXTURE_COORD_ARRAY_STRIDE)
+#if defined(GL_TEXTURE_COORD_ARRAY_TYPE)
+ case GL_TEXTURE_COORD_ARRAY_TYPE:
+#endif // defined(GL_TEXTURE_COORD_ARRAY_TYPE)
+#if defined(GL_TEXTURE_STACK_DEPTH)
+ case GL_TEXTURE_STACK_DEPTH:
+#endif // defined(GL_TEXTURE_STACK_DEPTH)
+#if defined(GL_UNPACK_ALIGNMENT)
+ case GL_UNPACK_ALIGNMENT:
+#endif // defined(GL_UNPACK_ALIGNMENT)
+#if defined(GL_VERTEX_ARRAY_BUFFER_BINDING)
+ case GL_VERTEX_ARRAY_BUFFER_BINDING:
+#endif // defined(GL_VERTEX_ARRAY_BUFFER_BINDING)
+#if defined(GL_VERTEX_ARRAY_SIZE)
+ case GL_VERTEX_ARRAY_SIZE:
+#endif // defined(GL_VERTEX_ARRAY_SIZE)
+#if defined(GL_VERTEX_ARRAY_STRIDE)
+ case GL_VERTEX_ARRAY_STRIDE:
+#endif // defined(GL_VERTEX_ARRAY_STRIDE)
+#if defined(GL_VERTEX_ARRAY_TYPE)
+ case GL_VERTEX_ARRAY_TYPE:
+#endif // defined(GL_VERTEX_ARRAY_TYPE)
+#if defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES)
+ case GL_WEIGHT_ARRAY_BUFFER_BINDING_OES:
+#endif // defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES)
+#if defined(GL_WEIGHT_ARRAY_SIZE_OES)
+ case GL_WEIGHT_ARRAY_SIZE_OES:
+#endif // defined(GL_WEIGHT_ARRAY_SIZE_OES)
+#if defined(GL_WEIGHT_ARRAY_STRIDE_OES)
+ case GL_WEIGHT_ARRAY_STRIDE_OES:
+#endif // defined(GL_WEIGHT_ARRAY_STRIDE_OES)
+#if defined(GL_WEIGHT_ARRAY_TYPE_OES)
+ case GL_WEIGHT_ARRAY_TYPE_OES:
+#endif // defined(GL_WEIGHT_ARRAY_TYPE_OES)
+ _needed = 1;
+ break;
+#if defined(GL_ALIASED_POINT_SIZE_RANGE)
+ case GL_ALIASED_POINT_SIZE_RANGE:
+#endif // defined(GL_ALIASED_POINT_SIZE_RANGE)
+#if defined(GL_ALIASED_LINE_WIDTH_RANGE)
+ case GL_ALIASED_LINE_WIDTH_RANGE:
+#endif // defined(GL_ALIASED_LINE_WIDTH_RANGE)
+#if defined(GL_DEPTH_RANGE)
+ case GL_DEPTH_RANGE:
+#endif // defined(GL_DEPTH_RANGE)
+#if defined(GL_MAX_VIEWPORT_DIMS)
+ case GL_MAX_VIEWPORT_DIMS:
+#endif // defined(GL_MAX_VIEWPORT_DIMS)
+#if defined(GL_SMOOTH_LINE_WIDTH_RANGE)
+ case GL_SMOOTH_LINE_WIDTH_RANGE:
+#endif // defined(GL_SMOOTH_LINE_WIDTH_RANGE)
+#if defined(GL_SMOOTH_POINT_SIZE_RANGE)
+ case GL_SMOOTH_POINT_SIZE_RANGE:
+#endif // defined(GL_SMOOTH_POINT_SIZE_RANGE)
+ _needed = 2;
+ break;
+#if defined(GL_COLOR_CLEAR_VALUE)
+ case GL_COLOR_CLEAR_VALUE:
+#endif // defined(GL_COLOR_CLEAR_VALUE)
+#if defined(GL_COLOR_WRITEMASK)
+ case GL_COLOR_WRITEMASK:
+#endif // defined(GL_COLOR_WRITEMASK)
+#if defined(GL_FOG_COLOR)
+ case GL_FOG_COLOR:
+#endif // defined(GL_FOG_COLOR)
+#if defined(GL_LIGHT_MODEL_AMBIENT)
+ case GL_LIGHT_MODEL_AMBIENT:
+#endif // defined(GL_LIGHT_MODEL_AMBIENT)
+#if defined(GL_SCISSOR_BOX)
+ case GL_SCISSOR_BOX:
+#endif // defined(GL_SCISSOR_BOX)
+#if defined(GL_VIEWPORT)
+ case GL_VIEWPORT:
+#endif // defined(GL_VIEWPORT)
+ _needed = 4;
+ break;
+#if defined(GL_MODELVIEW_MATRIX)
+ case GL_MODELVIEW_MATRIX:
+#endif // defined(GL_MODELVIEW_MATRIX)
+#if defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES)
+ case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES:
+#endif // defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES)
+#if defined(GL_PROJECTION_MATRIX)
+ case GL_PROJECTION_MATRIX:
+#endif // defined(GL_PROJECTION_MATRIX)
+#if defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES)
+ case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES:
+#endif // defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES)
+#if defined(GL_TEXTURE_MATRIX)
+ case GL_TEXTURE_MATRIX:
+#endif // defined(GL_TEXTURE_MATRIX)
+#if defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES)
+ case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES:
+#endif // defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES)
+ _needed = 16;
+ break;
+#if defined(GL_COMPRESSED_TEXTURE_FORMATS)
+ case GL_COMPRESSED_TEXTURE_FORMATS:
+#endif // defined(GL_COMPRESSED_TEXTURE_FORMATS)
+ _needed = getNumCompressedTextureFormats();
+ break;
+ default:
+ _needed = 0;
+ break;
+ }
+ if (_remaining < _needed) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "remaining() < needed");
+ goto exit;
+ }
+ glGetIntegerv(
+ (GLenum)pname,
+ (GLint *)params
+ );
+
+exit:
+ if (_array) {
+ releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glGetProgramiv ( GLuint program, GLenum pname, GLint *params ) */
+static void
+android_glGetProgramiv__II_3II
+ (JNIEnv *_env, jobject _this, jint program, jint pname, jintArray params_ref, jint offset) {
+ jint _exception = 0;
+ GLint *params_base = (GLint *) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ if (!params_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "params == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(params_ref) - offset;
+ params_base = (GLint *)
+ _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
+ params = params_base + offset;
+
+ glGetProgramiv(
+ (GLuint)program,
+ (GLenum)pname,
+ (GLint *)params
+ );
+
+exit:
+ if (params_base) {
+ _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetProgramiv ( GLuint program, GLenum pname, GLint *params ) */
+static void
+android_glGetProgramiv__IILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint program, jint pname, jobject params_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
+ glGetProgramiv(
+ (GLuint)program,
+ (GLenum)pname,
+ (GLint *)params
+ );
+ if (_array) {
+ releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+#include <string.h>
+
+/* void glGetProgramInfoLog ( GLuint shader, GLsizei maxLength, GLsizei* length, GLchar* infoLog ) */
+static
+jstring
+android_glGetProgramInfoLog (JNIEnv *_env, jobject _this, jint shader) {
+ GLint infoLen = 0;
+ jstring _result = 0;
+ char* buf = 0;
+ glGetProgramiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
+ if (infoLen) {
+ char* buf = (char*) malloc(infoLen);
+ if (buf == 0) {
+ _env->ThrowNew(IAEClass, "out of memory");
+ goto exit;
+ }
+ glGetProgramInfoLog(shader, infoLen, NULL, buf);
+ _result = _env->NewStringUTF(buf);
+ } else {
+ _result = _env->NewStringUTF("");
+ }
+exit:
+ if (buf) {
+ free(buf);
+ }
+ return _result;
+}
+/* void glGetRenderbufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */
+static void
+android_glGetRenderbufferParameteriv__II_3II
+ (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
+ jint _exception = 0;
+ GLint *params_base = (GLint *) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ if (!params_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "params == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(params_ref) - offset;
+ params_base = (GLint *)
+ _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
+ params = params_base + offset;
+
+ glGetRenderbufferParameteriv(
+ (GLenum)target,
+ (GLenum)pname,
+ (GLint *)params
+ );
+
+exit:
+ if (params_base) {
+ _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetRenderbufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */
+static void
+android_glGetRenderbufferParameteriv__IILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
+ glGetRenderbufferParameteriv(
+ (GLenum)target,
+ (GLenum)pname,
+ (GLint *)params
+ );
+ if (_array) {
+ releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glGetShaderiv ( GLuint shader, GLenum pname, GLint *params ) */
+static void
+android_glGetShaderiv__II_3II
+ (JNIEnv *_env, jobject _this, jint shader, jint pname, jintArray params_ref, jint offset) {
+ jint _exception = 0;
+ GLint *params_base = (GLint *) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ if (!params_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "params == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(params_ref) - offset;
+ params_base = (GLint *)
+ _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
+ params = params_base + offset;
+
+ glGetShaderiv(
+ (GLuint)shader,
+ (GLenum)pname,
+ (GLint *)params
+ );
+
+exit:
+ if (params_base) {
+ _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetShaderiv ( GLuint shader, GLenum pname, GLint *params ) */
+static void
+android_glGetShaderiv__IILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint shader, jint pname, jobject params_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
+ glGetShaderiv(
+ (GLuint)shader,
+ (GLenum)pname,
+ (GLint *)params
+ );
+ if (_array) {
+ releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+#include <string.h>
+
+/* void glGetShaderInfoLog ( GLuint shader, GLsizei maxLength, GLsizei* length, GLchar* infoLog ) */
+static
+jstring
+android_glGetShaderInfoLog (JNIEnv *_env, jobject _this, jint shader) {
+ GLint infoLen = 0;
+ jstring _result = 0;
+ char* buf = 0;
+ glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
+ if (infoLen) {
+ char* buf = (char*) malloc(infoLen);
+ if (buf == 0) {
+ _env->ThrowNew(IAEClass, "out of memory");
+ goto exit;
+ }
+ glGetShaderInfoLog(shader, infoLen, NULL, buf);
+ _result = _env->NewStringUTF(buf);
+ } else {
+ _result = _env->NewStringUTF("");
+ }
+exit:
+ if (buf) {
+ free(buf);
+ }
+ return _result;
+}
+/* void glGetShaderPrecisionFormat ( GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision ) */
+static void
+android_glGetShaderPrecisionFormat__II_3II_3II
+ (JNIEnv *_env, jobject _this, jint shadertype, jint precisiontype, jintArray range_ref, jint rangeOffset, jintArray precision_ref, jint precisionOffset) {
+ jint _exception = 0;
+ GLint *range_base = (GLint *) 0;
+ jint _rangeRemaining;
+ GLint *range = (GLint *) 0;
+ GLint *precision_base = (GLint *) 0;
+ jint _precisionRemaining;
+ GLint *precision = (GLint *) 0;
+
+ if (!range_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "range == null");
+ goto exit;
+ }
+ if (rangeOffset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "rangeOffset < 0");
+ goto exit;
+ }
+ _rangeRemaining = _env->GetArrayLength(range_ref) - rangeOffset;
+ range_base = (GLint *)
+ _env->GetPrimitiveArrayCritical(range_ref, (jboolean *)0);
+ range = range_base + rangeOffset;
+
+ if (!precision_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "precision == null");
+ goto exit;
+ }
+ if (precisionOffset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "precisionOffset < 0");
+ goto exit;
+ }
+ _precisionRemaining = _env->GetArrayLength(precision_ref) - precisionOffset;
+ precision_base = (GLint *)
+ _env->GetPrimitiveArrayCritical(precision_ref, (jboolean *)0);
+ precision = precision_base + precisionOffset;
+
+ glGetShaderPrecisionFormat(
+ (GLenum)shadertype,
+ (GLenum)precisiontype,
+ (GLint *)range,
+ (GLint *)precision
+ );
+
+exit:
+ if (precision_base) {
+ _env->ReleasePrimitiveArrayCritical(precision_ref, precision_base,
+ _exception ? JNI_ABORT: 0);
+ }
+ if (range_base) {
+ _env->ReleasePrimitiveArrayCritical(range_ref, range_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetShaderPrecisionFormat ( GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision ) */
+static void
+android_glGetShaderPrecisionFormat__IILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint shadertype, jint precisiontype, jobject range_buf, jobject precision_buf) {
+ jint _exception = 0;
+ jarray _rangeArray = (jarray) 0;
+ jarray _precisionArray = (jarray) 0;
+ jint _rangeRemaining;
+ GLint *range = (GLint *) 0;
+ jint _precisionRemaining;
+ GLint *precision = (GLint *) 0;
+
+ range = (GLint *)getPointer(_env, range_buf, &_rangeArray, &_rangeRemaining);
+ precision = (GLint *)getPointer(_env, precision_buf, &_precisionArray, &_precisionRemaining);
+ glGetShaderPrecisionFormat(
+ (GLenum)shadertype,
+ (GLenum)precisiontype,
+ (GLint *)range,
+ (GLint *)precision
+ );
+ if (_rangeArray) {
+ releasePointer(_env, _rangeArray, precision, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+ if (_precisionArray) {
+ releasePointer(_env, _precisionArray, range, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glGetShaderSource ( GLuint shader, GLsizei bufsize, GLsizei *length, char *source ) */
+static void
+android_glGetShaderSource__II_3II_3BI
+ (JNIEnv *_env, jobject _this, jint shader, jint bufsize, jintArray length_ref, jint lengthOffset, jbyteArray source_ref, jint sourceOffset) {
+ jint _exception = 0;
+ GLsizei *length_base = (GLsizei *) 0;
+ jint _lengthRemaining;
+ GLsizei *length = (GLsizei *) 0;
+ char *source_base = (char *) 0;
+ jint _sourceRemaining;
+ char *source = (char *) 0;
+
+ if (!length_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "length == null");
+ goto exit;
+ }
+ if (lengthOffset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "lengthOffset < 0");
+ goto exit;
+ }
+ _lengthRemaining = _env->GetArrayLength(length_ref) - lengthOffset;
+ length_base = (GLsizei *)
+ _env->GetPrimitiveArrayCritical(length_ref, (jboolean *)0);
+ length = length_base + lengthOffset;
+
+ if (!source_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "source == null");
+ goto exit;
+ }
+ if (sourceOffset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "sourceOffset < 0");
+ goto exit;
+ }
+ _sourceRemaining = _env->GetArrayLength(source_ref) - sourceOffset;
+ source_base = (char *)
+ _env->GetPrimitiveArrayCritical(source_ref, (jboolean *)0);
+ source = source_base + sourceOffset;
+
+ glGetShaderSource(
+ (GLuint)shader,
+ (GLsizei)bufsize,
+ (GLsizei *)length,
+ (char *)source
+ );
+
+exit:
+ if (source_base) {
+ _env->ReleasePrimitiveArrayCritical(source_ref, source_base,
+ _exception ? JNI_ABORT: 0);
+ }
+ if (length_base) {
+ _env->ReleasePrimitiveArrayCritical(length_ref, length_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetShaderSource ( GLuint shader, GLsizei bufsize, GLsizei *length, char *source ) */
+static void
+android_glGetShaderSource__IILjava_nio_IntBuffer_2B
+ (JNIEnv *_env, jobject _this, jint shader, jint bufsize, jobject length_buf, jbyte source) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLsizei *length = (GLsizei *) 0;
+
+ length = (GLsizei *)getPointer(_env, length_buf, &_array, &_remaining);
+ glGetShaderSource(
+ (GLuint)shader,
+ (GLsizei)bufsize,
+ (GLsizei *)length,
+ (char *)source
+ );
+ if (_array) {
+ releasePointer(_env, _array, length, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+#include <string.h>
+
+/* const GLubyte * glGetString ( GLenum name ) */
+static
+jstring
+android_glGetString
+ (JNIEnv *_env, jobject _this, jint name) {
+ const char * chars = (const char *)glGetString((GLenum)name);
+ jstring output = _env->NewStringUTF(chars);
+ return output;
+}
+/* void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) */
+static void
+android_glGetTexParameterfv__II_3FI
+ (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) {
+ jint _exception = 0;
+ GLfloat *params_base = (GLfloat *) 0;
+ jint _remaining;
+ GLfloat *params = (GLfloat *) 0;
+
+ if (!params_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "params == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(params_ref) - offset;
+ if (_remaining < 1) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "length - offset < 1");
+ goto exit;
+ }
+ params_base = (GLfloat *)
+ _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
+ params = params_base + offset;
+
+ glGetTexParameterfv(
+ (GLenum)target,
+ (GLenum)pname,
+ (GLfloat *)params
+ );
+
+exit:
+ if (params_base) {
+ _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) */
+static void
+android_glGetTexParameterfv__IILjava_nio_FloatBuffer_2
+ (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLfloat *params = (GLfloat *) 0;
+
+ params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining);
+ if (_remaining < 1) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "remaining() < 1");
+ goto exit;
+ }
+ glGetTexParameterfv(
+ (GLenum)target,
+ (GLenum)pname,
+ (GLfloat *)params
+ );
+
+exit:
+ if (_array) {
+ releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) */
+static void
+android_glGetTexParameteriv__II_3II
+ (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
+ jint _exception = 0;
+ GLint *params_base = (GLint *) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ if (!params_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "params == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(params_ref) - offset;
+ if (_remaining < 1) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "length - offset < 1");
+ goto exit;
+ }
+ params_base = (GLint *)
+ _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
+ params = params_base + offset;
+
+ glGetTexParameteriv(
+ (GLenum)target,
+ (GLenum)pname,
+ (GLint *)params
+ );
+
+exit:
+ if (params_base) {
+ _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) */
+static void
+android_glGetTexParameteriv__IILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
+ if (_remaining < 1) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "remaining() < 1");
+ goto exit;
+ }
+ glGetTexParameteriv(
+ (GLenum)target,
+ (GLenum)pname,
+ (GLint *)params
+ );
+
+exit:
+ if (_array) {
+ releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glGetUniformfv ( GLuint program, GLint location, GLfloat *params ) */
+static void
+android_glGetUniformfv__II_3FI
+ (JNIEnv *_env, jobject _this, jint program, jint location, jfloatArray params_ref, jint offset) {
+ jint _exception = 0;
+ GLfloat *params_base = (GLfloat *) 0;
+ jint _remaining;
+ GLfloat *params = (GLfloat *) 0;
+
+ if (!params_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "params == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(params_ref) - offset;
+ params_base = (GLfloat *)
+ _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
+ params = params_base + offset;
+
+ glGetUniformfv(
+ (GLuint)program,
+ (GLint)location,
+ (GLfloat *)params
+ );
+
+exit:
+ if (params_base) {
+ _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetUniformfv ( GLuint program, GLint location, GLfloat *params ) */
+static void
+android_glGetUniformfv__IILjava_nio_FloatBuffer_2
+ (JNIEnv *_env, jobject _this, jint program, jint location, jobject params_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLfloat *params = (GLfloat *) 0;
+
+ params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining);
+ glGetUniformfv(
+ (GLuint)program,
+ (GLint)location,
+ (GLfloat *)params
+ );
+ if (_array) {
+ releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glGetUniformiv ( GLuint program, GLint location, GLint *params ) */
+static void
+android_glGetUniformiv__II_3II
+ (JNIEnv *_env, jobject _this, jint program, jint location, jintArray params_ref, jint offset) {
+ jint _exception = 0;
+ GLint *params_base = (GLint *) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ if (!params_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "params == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(params_ref) - offset;
+ params_base = (GLint *)
+ _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
+ params = params_base + offset;
+
+ glGetUniformiv(
+ (GLuint)program,
+ (GLint)location,
+ (GLint *)params
+ );
+
+exit:
+ if (params_base) {
+ _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetUniformiv ( GLuint program, GLint location, GLint *params ) */
+static void
+android_glGetUniformiv__IILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint program, jint location, jobject params_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
+ glGetUniformiv(
+ (GLuint)program,
+ (GLint)location,
+ (GLint *)params
+ );
+ if (_array) {
+ releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* int glGetUniformLocation ( GLuint program, const char *name ) */
+static jint
+android_glGetUniformLocation__ILjava_lang_String_2
+ (JNIEnv *_env, jobject _this, jint program, jstring name) {
+ int _returnValue = 0;
+ const char* _nativename = 0;
+
+ if (!name) {
+ _env->ThrowNew(IAEClass, "name == null");
+ goto exit;
+ }
+ _nativename = _env->GetStringUTFChars(name, 0);
+
+ _returnValue = glGetUniformLocation(
+ (GLuint)program,
+ (char *)_nativename
+ );
+
+exit:
+ if (_nativename) {
+ _env->ReleaseStringUTFChars(name, _nativename);
+ }
+
+ return _returnValue;
+}
+
+/* void glGetVertexAttribfv ( GLuint index, GLenum pname, GLfloat *params ) */
+static void
+android_glGetVertexAttribfv__II_3FI
+ (JNIEnv *_env, jobject _this, jint index, jint pname, jfloatArray params_ref, jint offset) {
+ jint _exception = 0;
+ GLfloat *params_base = (GLfloat *) 0;
+ jint _remaining;
+ GLfloat *params = (GLfloat *) 0;
+
+ if (!params_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "params == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(params_ref) - offset;
+ params_base = (GLfloat *)
+ _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
+ params = params_base + offset;
+
+ glGetVertexAttribfv(
+ (GLuint)index,
+ (GLenum)pname,
+ (GLfloat *)params
+ );
+
+exit:
+ if (params_base) {
+ _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetVertexAttribfv ( GLuint index, GLenum pname, GLfloat *params ) */
+static void
+android_glGetVertexAttribfv__IILjava_nio_FloatBuffer_2
+ (JNIEnv *_env, jobject _this, jint index, jint pname, jobject params_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLfloat *params = (GLfloat *) 0;
+
+ params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining);
+ glGetVertexAttribfv(
+ (GLuint)index,
+ (GLenum)pname,
+ (GLfloat *)params
+ );
+ if (_array) {
+ releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glGetVertexAttribiv ( GLuint index, GLenum pname, GLint *params ) */
+static void
+android_glGetVertexAttribiv__II_3II
+ (JNIEnv *_env, jobject _this, jint index, jint pname, jintArray params_ref, jint offset) {
+ jint _exception = 0;
+ GLint *params_base = (GLint *) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ if (!params_ref) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "params == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _exception = 1;
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(params_ref) - offset;
+ params_base = (GLint *)
+ _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
+ params = params_base + offset;
+
+ glGetVertexAttribiv(
+ (GLuint)index,
+ (GLenum)pname,
+ (GLint *)params
+ );
+
+exit:
+ if (params_base) {
+ _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
+ _exception ? JNI_ABORT: 0);
+ }
+}
+
+/* void glGetVertexAttribiv ( GLuint index, GLenum pname, GLint *params ) */
+static void
+android_glGetVertexAttribiv__IILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint index, jint pname, jobject params_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
+ glGetVertexAttribiv(
+ (GLuint)index,
+ (GLenum)pname,
+ (GLint *)params
+ );
+ if (_array) {
+ releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glHint ( GLenum target, GLenum mode ) */
+static void
+android_glHint__II
+ (JNIEnv *_env, jobject _this, jint target, jint mode) {
+ glHint(
+ (GLenum)target,
+ (GLenum)mode
+ );
+}
+
+/* GLboolean glIsBuffer ( GLuint buffer ) */
+static jboolean
+android_glIsBuffer__I
+ (JNIEnv *_env, jobject _this, jint buffer) {
+ GLboolean _returnValue;
+ _returnValue = glIsBuffer(
+ (GLuint)buffer
+ );
+ return _returnValue;
+}
+
+/* GLboolean glIsEnabled ( GLenum cap ) */
+static jboolean
+android_glIsEnabled__I
+ (JNIEnv *_env, jobject _this, jint cap) {
+ GLboolean _returnValue;
+ _returnValue = glIsEnabled(
+ (GLenum)cap
+ );
+ return _returnValue;
+}
+
+/* GLboolean glIsFramebuffer ( GLuint framebuffer ) */
+static jboolean
+android_glIsFramebuffer__I
+ (JNIEnv *_env, jobject _this, jint framebuffer) {
+ GLboolean _returnValue;
+ _returnValue = glIsFramebuffer(
+ (GLuint)framebuffer
+ );
+ return _returnValue;
+}
+
+/* GLboolean glIsProgram ( GLuint program ) */
+static jboolean
+android_glIsProgram__I
+ (JNIEnv *_env, jobject _this, jint program) {
+ GLboolean _returnValue;
+ _returnValue = glIsProgram(
+ (GLuint)program
+ );
+ return _returnValue;
+}
+
+/* GLboolean glIsRenderbuffer ( GLuint renderbuffer ) */
+static jboolean
+android_glIsRenderbuffer__I
+ (JNIEnv *_env, jobject _this, jint renderbuffer) {
+ GLboolean _returnValue;
+ _returnValue = glIsRenderbuffer(
+ (GLuint)renderbuffer
+ );
+ return _returnValue;
+}
+
+/* GLboolean glIsShader ( GLuint shader ) */
+static jboolean
+android_glIsShader__I
+ (JNIEnv *_env, jobject _this, jint shader) {
+ GLboolean _returnValue;
+ _returnValue = glIsShader(
+ (GLuint)shader
+ );
+ return _returnValue;
+}
+
+/* GLboolean glIsTexture ( GLuint texture ) */
+static jboolean
+android_glIsTexture__I
+ (JNIEnv *_env, jobject _this, jint texture) {
+ GLboolean _returnValue;
+ _returnValue = glIsTexture(
+ (GLuint)texture
+ );
+ return _returnValue;
+}
+
+/* void glLineWidth ( GLfloat width ) */
+static void
+android_glLineWidth__F
+ (JNIEnv *_env, jobject _this, jfloat width) {
+ glLineWidth(
+ (GLfloat)width
+ );
+}
+
+/* void glLinkProgram ( GLuint program ) */
+static void
+android_glLinkProgram__I
+ (JNIEnv *_env, jobject _this, jint program) {
+ glLinkProgram(
+ (GLuint)program
+ );
+}
+
+/* void glPixelStorei ( GLenum pname, GLint param ) */
+static void
+android_glPixelStorei__II
+ (JNIEnv *_env, jobject _this, jint pname, jint param) {
+ glPixelStorei(
+ (GLenum)pname,
+ (GLint)param
+ );
+}
+
+/* void glPolygonOffset ( GLfloat factor, GLfloat units ) */
+static void
+android_glPolygonOffset__FF
+ (JNIEnv *_env, jobject _this, jfloat factor, jfloat units) {
+ glPolygonOffset(
+ (GLfloat)factor,
+ (GLfloat)units
+ );
+}
+
+/* void glReadPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) */
+static void
+android_glReadPixels__IIIIIILjava_nio_Buffer_2
+ (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height, jint format, jint type, jobject pixels_buf) {
+ jint _exception = 0;
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLvoid *pixels = (GLvoid *) 0;
+
+ pixels = (GLvoid *)getPointer(_env, pixels_buf, &_array, &_remaining);
+ glReadPixels(
+ (GLint)x,
+ (GLint)y,
+ (GLsizei)width,
+ (GLsizei)height,
+ (GLenum)format,
+ (GLenum)type,
+ (GLvoid *)pixels
+ );
+ if (_array) {
+ releasePointer(_env, _array, pixels, _exception ? JNI_FALSE : JNI_TRUE);
+ }
+}
+
+/* void glReleaseShaderCompiler ( void ) */
+static void
+android_glReleaseShaderCompiler__
+ (JNIEnv *_env, jobject _this) {
+ glReleaseShaderCompiler();
+}
+
+/* void glRenderbufferStorage ( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) */
+static void
+android_glRenderbufferStorage__IIII
+ (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint width, jint height) {
+ glRenderbufferStorage(
+ (GLenum)target,
+ (GLenum)internalformat,
+ (GLsizei)width,
+ (GLsizei)height
+ );
+}
+
+/* void glSampleCoverage ( GLclampf value, GLboolean invert ) */
+static void
+android_glSampleCoverage__FZ
+ (JNIEnv *_env, jobject _this, jfloat value, jboolean invert) {
+ glSampleCoverage(
+ (GLclampf)value,
+ (GLboolean)invert
+ );
+}
+
+/* void glScissor ( GLint x, GLint y, GLsizei width, GLsizei height ) */
+static void
+android_glScissor__IIII
+ (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height) {
+ glScissor(
+ (GLint)x,
+ (GLint)y,
+ (GLsizei)width,
+ (GLsizei)height
+ );
+}
+
+/* void glShaderBinary ( GLsizei n, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length ) */
+static void
+android_glShaderBinary__I_3IIILjava_nio_Buffer_2I
+ (JNIEnv *_env, jobject _this, jint n, jintArray shaders_ref, jint offset, jint binaryformat, jobject binary_buf, jint length) {
+ jarray _array = (jarray) 0;
+ GLuint *shaders_base = (GLuint *) 0;
+ jint _shadersRemaining;
+ GLuint *shaders = (GLuint *) 0;
+ jint _binaryRemaining;
+ GLvoid *binary = (GLvoid *) 0;
+
+ if (!shaders_ref) {
+ _env->ThrowNew(IAEClass, "shaders == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _shadersRemaining = _env->GetArrayLength(shaders_ref) - offset;
+ shaders_base = (GLuint *)
+ _env->GetPrimitiveArrayCritical(shaders_ref, (jboolean *)0);
+ shaders = shaders_base + offset;
+
+ binary = (GLvoid *)getPointer(_env, binary_buf, &_array, &_binaryRemaining);
+ glShaderBinary(
+ (GLsizei)n,
+ (GLuint *)shaders,
+ (GLenum)binaryformat,
+ (GLvoid *)binary,
+ (GLsizei)length
+ );
+
+exit:
+ if (_array) {
+ releasePointer(_env, _array, binary, JNI_FALSE);
+ }
+ if (shaders_base) {
+ _env->ReleasePrimitiveArrayCritical(shaders_ref, shaders_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glShaderBinary ( GLsizei n, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length ) */
+static void
+android_glShaderBinary__ILjava_nio_IntBuffer_2ILjava_nio_Buffer_2I
+ (JNIEnv *_env, jobject _this, jint n, jobject shaders_buf, jint binaryformat, jobject binary_buf, jint length) {
+ jarray _shadersArray = (jarray) 0;
+ jarray _binaryArray = (jarray) 0;
+ jint _shadersRemaining;
+ GLuint *shaders = (GLuint *) 0;
+ jint _binaryRemaining;
+ GLvoid *binary = (GLvoid *) 0;
+
+ shaders = (GLuint *)getPointer(_env, shaders_buf, &_shadersArray, &_shadersRemaining);
+ binary = (GLvoid *)getPointer(_env, binary_buf, &_binaryArray, &_binaryRemaining);
+ glShaderBinary(
+ (GLsizei)n,
+ (GLuint *)shaders,
+ (GLenum)binaryformat,
+ (GLvoid *)binary,
+ (GLsizei)length
+ );
+ if (_shadersArray) {
+ releasePointer(_env, _shadersArray, binary, JNI_FALSE);
+ }
+ if (_binaryArray) {
+ releasePointer(_env, _binaryArray, shaders, JNI_FALSE);
+ }
+}
+
+
+/* void glShaderSource ( GLuint shader, GLsizei count, const GLchar ** string, const GLint * length ) */
+static
+void
+android_glShaderSource
+ (JNIEnv *_env, jobject _this, jint shader, jstring string) {
+
+ if (!string) {
+ _env->ThrowNew(IAEClass, "string == null");
+ return;
+ }
+
+ const char* nativeString = _env->GetStringUTFChars(string, 0);
+ const char* strings[] = {nativeString};
+ glShaderSource(shader, 1, strings, 0);
+ _env->ReleaseStringUTFChars(string, nativeString);
+}
+/* void glStencilFunc ( GLenum func, GLint ref, GLuint mask ) */
+static void
+android_glStencilFunc__III
+ (JNIEnv *_env, jobject _this, jint func, jint ref, jint mask) {
+ glStencilFunc(
+ (GLenum)func,
+ (GLint)ref,
+ (GLuint)mask
+ );
+}
+
+/* void glStencilFuncSeparate ( GLenum face, GLenum func, GLint ref, GLuint mask ) */
+static void
+android_glStencilFuncSeparate__IIII
+ (JNIEnv *_env, jobject _this, jint face, jint func, jint ref, jint mask) {
+ glStencilFuncSeparate(
+ (GLenum)face,
+ (GLenum)func,
+ (GLint)ref,
+ (GLuint)mask
+ );
+}
+
+/* void glStencilMask ( GLuint mask ) */
+static void
+android_glStencilMask__I
+ (JNIEnv *_env, jobject _this, jint mask) {
+ glStencilMask(
+ (GLuint)mask
+ );
+}
+
+/* void glStencilMaskSeparate ( GLenum face, GLuint mask ) */
+static void
+android_glStencilMaskSeparate__II
+ (JNIEnv *_env, jobject _this, jint face, jint mask) {
+ glStencilMaskSeparate(
+ (GLenum)face,
+ (GLuint)mask
+ );
+}
+
+/* void glStencilOp ( GLenum fail, GLenum zfail, GLenum zpass ) */
+static void
+android_glStencilOp__III
+ (JNIEnv *_env, jobject _this, jint fail, jint zfail, jint zpass) {
+ glStencilOp(
+ (GLenum)fail,
+ (GLenum)zfail,
+ (GLenum)zpass
+ );
+}
+
+/* void glStencilOpSeparate ( GLenum face, GLenum fail, GLenum zfail, GLenum zpass ) */
+static void
+android_glStencilOpSeparate__IIII
+ (JNIEnv *_env, jobject _this, jint face, jint fail, jint zfail, jint zpass) {
+ glStencilOpSeparate(
+ (GLenum)face,
+ (GLenum)fail,
+ (GLenum)zfail,
+ (GLenum)zpass
+ );
+}
+
+/* void glTexImage2D ( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) */
+static void
+android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2
+ (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint format, jint type, jobject pixels_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLvoid *pixels = (GLvoid *) 0;
+
+ if (pixels_buf) {
+ pixels = (GLvoid *)getPointer(_env, pixels_buf, &_array, &_remaining);
+ }
+ glTexImage2D(
+ (GLenum)target,
+ (GLint)level,
+ (GLint)internalformat,
+ (GLsizei)width,
+ (GLsizei)height,
+ (GLint)border,
+ (GLenum)format,
+ (GLenum)type,
+ (GLvoid *)pixels
+ );
+ if (_array) {
+ releasePointer(_env, _array, pixels, JNI_FALSE);
+ }
+}
+
+/* void glTexParameterf ( GLenum target, GLenum pname, GLfloat param ) */
+static void
+android_glTexParameterf__IIF
+ (JNIEnv *_env, jobject _this, jint target, jint pname, jfloat param) {
+ glTexParameterf(
+ (GLenum)target,
+ (GLenum)pname,
+ (GLfloat)param
+ );
+}
+
+/* void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params ) */
+static void
+android_glTexParameterfv__II_3FI
+ (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) {
+ GLfloat *params_base = (GLfloat *) 0;
+ jint _remaining;
+ GLfloat *params = (GLfloat *) 0;
+
+ if (!params_ref) {
+ _env->ThrowNew(IAEClass, "params == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(params_ref) - offset;
+ if (_remaining < 1) {
+ _env->ThrowNew(IAEClass, "length - offset < 1");
+ goto exit;
+ }
+ params_base = (GLfloat *)
+ _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
+ params = params_base + offset;
+
+ glTexParameterfv(
+ (GLenum)target,
+ (GLenum)pname,
+ (GLfloat *)params
+ );
+
+exit:
+ if (params_base) {
+ _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params ) */
+static void
+android_glTexParameterfv__IILjava_nio_FloatBuffer_2
+ (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLfloat *params = (GLfloat *) 0;
+
+ params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining);
+ if (_remaining < 1) {
+ _env->ThrowNew(IAEClass, "remaining() < 1");
+ goto exit;
+ }
+ glTexParameterfv(
+ (GLenum)target,
+ (GLenum)pname,
+ (GLfloat *)params
+ );
+
+exit:
+ if (_array) {
+ releasePointer(_env, _array, params, JNI_FALSE);
+ }
+}
+
+/* void glTexParameteri ( GLenum target, GLenum pname, GLint param ) */
+static void
+android_glTexParameteri__III
+ (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) {
+ glTexParameteri(
+ (GLenum)target,
+ (GLenum)pname,
+ (GLint)param
+ );
+}
+
+/* void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params ) */
+static void
+android_glTexParameteriv__II_3II
+ (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) {
+ GLint *params_base = (GLint *) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ if (!params_ref) {
+ _env->ThrowNew(IAEClass, "params == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(params_ref) - offset;
+ if (_remaining < 1) {
+ _env->ThrowNew(IAEClass, "length - offset < 1");
+ goto exit;
+ }
+ params_base = (GLint *)
+ _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
+ params = params_base + offset;
+
+ glTexParameteriv(
+ (GLenum)target,
+ (GLenum)pname,
+ (GLint *)params
+ );
+
+exit:
+ if (params_base) {
+ _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params ) */
+static void
+android_glTexParameteriv__IILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLint *params = (GLint *) 0;
+
+ params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining);
+ if (_remaining < 1) {
+ _env->ThrowNew(IAEClass, "remaining() < 1");
+ goto exit;
+ }
+ glTexParameteriv(
+ (GLenum)target,
+ (GLenum)pname,
+ (GLint *)params
+ );
+
+exit:
+ if (_array) {
+ releasePointer(_env, _array, params, JNI_FALSE);
+ }
+}
+
+/* void glTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels ) */
+static void
+android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2
+ (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint type, jobject pixels_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLvoid *pixels = (GLvoid *) 0;
+
+ if (pixels_buf) {
+ pixels = (GLvoid *)getPointer(_env, pixels_buf, &_array, &_remaining);
+ }
+ glTexSubImage2D(
+ (GLenum)target,
+ (GLint)level,
+ (GLint)xoffset,
+ (GLint)yoffset,
+ (GLsizei)width,
+ (GLsizei)height,
+ (GLenum)format,
+ (GLenum)type,
+ (GLvoid *)pixels
+ );
+ if (_array) {
+ releasePointer(_env, _array, pixels, JNI_FALSE);
+ }
+}
+
+/* void glUniform1f ( GLint location, GLfloat x ) */
+static void
+android_glUniform1f__IF
+ (JNIEnv *_env, jobject _this, jint location, jfloat x) {
+ glUniform1f(
+ (GLint)location,
+ (GLfloat)x
+ );
+}
+
+/* void glUniform1fv ( GLint location, GLsizei count, const GLfloat *v ) */
+static void
+android_glUniform1fv__II_3FI
+ (JNIEnv *_env, jobject _this, jint location, jint count, jfloatArray v_ref, jint offset) {
+ GLfloat *v_base = (GLfloat *) 0;
+ jint _remaining;
+ GLfloat *v = (GLfloat *) 0;
+
+ if (!v_ref) {
+ _env->ThrowNew(IAEClass, "v == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(v_ref) - offset;
+ v_base = (GLfloat *)
+ _env->GetPrimitiveArrayCritical(v_ref, (jboolean *)0);
+ v = v_base + offset;
+
+ glUniform1fv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLfloat *)v
+ );
+
+exit:
+ if (v_base) {
+ _env->ReleasePrimitiveArrayCritical(v_ref, v_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glUniform1fv ( GLint location, GLsizei count, const GLfloat *v ) */
+static void
+android_glUniform1fv__IILjava_nio_FloatBuffer_2
+ (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLfloat *v = (GLfloat *) 0;
+
+ v = (GLfloat *)getPointer(_env, v_buf, &_array, &_remaining);
+ glUniform1fv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLfloat *)v
+ );
+ if (_array) {
+ releasePointer(_env, _array, v, JNI_FALSE);
+ }
+}
+
+/* void glUniform1i ( GLint location, GLint x ) */
+static void
+android_glUniform1i__II
+ (JNIEnv *_env, jobject _this, jint location, jint x) {
+ glUniform1i(
+ (GLint)location,
+ (GLint)x
+ );
+}
+
+/* void glUniform1iv ( GLint location, GLsizei count, const GLint *v ) */
+static void
+android_glUniform1iv__II_3II
+ (JNIEnv *_env, jobject _this, jint location, jint count, jintArray v_ref, jint offset) {
+ GLint *v_base = (GLint *) 0;
+ jint _remaining;
+ GLint *v = (GLint *) 0;
+
+ if (!v_ref) {
+ _env->ThrowNew(IAEClass, "v == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(v_ref) - offset;
+ v_base = (GLint *)
+ _env->GetPrimitiveArrayCritical(v_ref, (jboolean *)0);
+ v = v_base + offset;
+
+ glUniform1iv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLint *)v
+ );
+
+exit:
+ if (v_base) {
+ _env->ReleasePrimitiveArrayCritical(v_ref, v_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glUniform1iv ( GLint location, GLsizei count, const GLint *v ) */
+static void
+android_glUniform1iv__IILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLint *v = (GLint *) 0;
+
+ v = (GLint *)getPointer(_env, v_buf, &_array, &_remaining);
+ glUniform1iv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLint *)v
+ );
+ if (_array) {
+ releasePointer(_env, _array, v, JNI_FALSE);
+ }
+}
+
+/* void glUniform2f ( GLint location, GLfloat x, GLfloat y ) */
+static void
+android_glUniform2f__IFF
+ (JNIEnv *_env, jobject _this, jint location, jfloat x, jfloat y) {
+ glUniform2f(
+ (GLint)location,
+ (GLfloat)x,
+ (GLfloat)y
+ );
+}
+
+/* void glUniform2fv ( GLint location, GLsizei count, const GLfloat *v ) */
+static void
+android_glUniform2fv__II_3FI
+ (JNIEnv *_env, jobject _this, jint location, jint count, jfloatArray v_ref, jint offset) {
+ GLfloat *v_base = (GLfloat *) 0;
+ jint _remaining;
+ GLfloat *v = (GLfloat *) 0;
+
+ if (!v_ref) {
+ _env->ThrowNew(IAEClass, "v == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(v_ref) - offset;
+ v_base = (GLfloat *)
+ _env->GetPrimitiveArrayCritical(v_ref, (jboolean *)0);
+ v = v_base + offset;
+
+ glUniform2fv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLfloat *)v
+ );
+
+exit:
+ if (v_base) {
+ _env->ReleasePrimitiveArrayCritical(v_ref, v_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glUniform2fv ( GLint location, GLsizei count, const GLfloat *v ) */
+static void
+android_glUniform2fv__IILjava_nio_FloatBuffer_2
+ (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLfloat *v = (GLfloat *) 0;
+
+ v = (GLfloat *)getPointer(_env, v_buf, &_array, &_remaining);
+ glUniform2fv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLfloat *)v
+ );
+ if (_array) {
+ releasePointer(_env, _array, v, JNI_FALSE);
+ }
+}
+
+/* void glUniform2i ( GLint location, GLint x, GLint y ) */
+static void
+android_glUniform2i__III
+ (JNIEnv *_env, jobject _this, jint location, jint x, jint y) {
+ glUniform2i(
+ (GLint)location,
+ (GLint)x,
+ (GLint)y
+ );
+}
+
+/* void glUniform2iv ( GLint location, GLsizei count, const GLint *v ) */
+static void
+android_glUniform2iv__II_3II
+ (JNIEnv *_env, jobject _this, jint location, jint count, jintArray v_ref, jint offset) {
+ GLint *v_base = (GLint *) 0;
+ jint _remaining;
+ GLint *v = (GLint *) 0;
+
+ if (!v_ref) {
+ _env->ThrowNew(IAEClass, "v == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(v_ref) - offset;
+ v_base = (GLint *)
+ _env->GetPrimitiveArrayCritical(v_ref, (jboolean *)0);
+ v = v_base + offset;
+
+ glUniform2iv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLint *)v
+ );
+
+exit:
+ if (v_base) {
+ _env->ReleasePrimitiveArrayCritical(v_ref, v_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glUniform2iv ( GLint location, GLsizei count, const GLint *v ) */
+static void
+android_glUniform2iv__IILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLint *v = (GLint *) 0;
+
+ v = (GLint *)getPointer(_env, v_buf, &_array, &_remaining);
+ glUniform2iv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLint *)v
+ );
+ if (_array) {
+ releasePointer(_env, _array, v, JNI_FALSE);
+ }
+}
+
+/* void glUniform3f ( GLint location, GLfloat x, GLfloat y, GLfloat z ) */
+static void
+android_glUniform3f__IFFF
+ (JNIEnv *_env, jobject _this, jint location, jfloat x, jfloat y, jfloat z) {
+ glUniform3f(
+ (GLint)location,
+ (GLfloat)x,
+ (GLfloat)y,
+ (GLfloat)z
+ );
+}
+
+/* void glUniform3fv ( GLint location, GLsizei count, const GLfloat *v ) */
+static void
+android_glUniform3fv__II_3FI
+ (JNIEnv *_env, jobject _this, jint location, jint count, jfloatArray v_ref, jint offset) {
+ GLfloat *v_base = (GLfloat *) 0;
+ jint _remaining;
+ GLfloat *v = (GLfloat *) 0;
+
+ if (!v_ref) {
+ _env->ThrowNew(IAEClass, "v == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(v_ref) - offset;
+ v_base = (GLfloat *)
+ _env->GetPrimitiveArrayCritical(v_ref, (jboolean *)0);
+ v = v_base + offset;
+
+ glUniform3fv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLfloat *)v
+ );
+
+exit:
+ if (v_base) {
+ _env->ReleasePrimitiveArrayCritical(v_ref, v_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glUniform3fv ( GLint location, GLsizei count, const GLfloat *v ) */
+static void
+android_glUniform3fv__IILjava_nio_FloatBuffer_2
+ (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLfloat *v = (GLfloat *) 0;
+
+ v = (GLfloat *)getPointer(_env, v_buf, &_array, &_remaining);
+ glUniform3fv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLfloat *)v
+ );
+ if (_array) {
+ releasePointer(_env, _array, v, JNI_FALSE);
+ }
+}
+
+/* void glUniform3i ( GLint location, GLint x, GLint y, GLint z ) */
+static void
+android_glUniform3i__IIII
+ (JNIEnv *_env, jobject _this, jint location, jint x, jint y, jint z) {
+ glUniform3i(
+ (GLint)location,
+ (GLint)x,
+ (GLint)y,
+ (GLint)z
+ );
+}
+
+/* void glUniform3iv ( GLint location, GLsizei count, const GLint *v ) */
+static void
+android_glUniform3iv__II_3II
+ (JNIEnv *_env, jobject _this, jint location, jint count, jintArray v_ref, jint offset) {
+ GLint *v_base = (GLint *) 0;
+ jint _remaining;
+ GLint *v = (GLint *) 0;
+
+ if (!v_ref) {
+ _env->ThrowNew(IAEClass, "v == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(v_ref) - offset;
+ v_base = (GLint *)
+ _env->GetPrimitiveArrayCritical(v_ref, (jboolean *)0);
+ v = v_base + offset;
+
+ glUniform3iv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLint *)v
+ );
+
+exit:
+ if (v_base) {
+ _env->ReleasePrimitiveArrayCritical(v_ref, v_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glUniform3iv ( GLint location, GLsizei count, const GLint *v ) */
+static void
+android_glUniform3iv__IILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLint *v = (GLint *) 0;
+
+ v = (GLint *)getPointer(_env, v_buf, &_array, &_remaining);
+ glUniform3iv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLint *)v
+ );
+ if (_array) {
+ releasePointer(_env, _array, v, JNI_FALSE);
+ }
+}
+
+/* void glUniform4f ( GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) */
+static void
+android_glUniform4f__IFFFF
+ (JNIEnv *_env, jobject _this, jint location, jfloat x, jfloat y, jfloat z, jfloat w) {
+ glUniform4f(
+ (GLint)location,
+ (GLfloat)x,
+ (GLfloat)y,
+ (GLfloat)z,
+ (GLfloat)w
+ );
+}
+
+/* void glUniform4fv ( GLint location, GLsizei count, const GLfloat *v ) */
+static void
+android_glUniform4fv__II_3FI
+ (JNIEnv *_env, jobject _this, jint location, jint count, jfloatArray v_ref, jint offset) {
+ GLfloat *v_base = (GLfloat *) 0;
+ jint _remaining;
+ GLfloat *v = (GLfloat *) 0;
+
+ if (!v_ref) {
+ _env->ThrowNew(IAEClass, "v == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(v_ref) - offset;
+ v_base = (GLfloat *)
+ _env->GetPrimitiveArrayCritical(v_ref, (jboolean *)0);
+ v = v_base + offset;
+
+ glUniform4fv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLfloat *)v
+ );
+
+exit:
+ if (v_base) {
+ _env->ReleasePrimitiveArrayCritical(v_ref, v_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glUniform4fv ( GLint location, GLsizei count, const GLfloat *v ) */
+static void
+android_glUniform4fv__IILjava_nio_FloatBuffer_2
+ (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLfloat *v = (GLfloat *) 0;
+
+ v = (GLfloat *)getPointer(_env, v_buf, &_array, &_remaining);
+ glUniform4fv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLfloat *)v
+ );
+ if (_array) {
+ releasePointer(_env, _array, v, JNI_FALSE);
+ }
+}
+
+/* void glUniform4i ( GLint location, GLint x, GLint y, GLint z, GLint w ) */
+static void
+android_glUniform4i__IIIII
+ (JNIEnv *_env, jobject _this, jint location, jint x, jint y, jint z, jint w) {
+ glUniform4i(
+ (GLint)location,
+ (GLint)x,
+ (GLint)y,
+ (GLint)z,
+ (GLint)w
+ );
+}
+
+/* void glUniform4iv ( GLint location, GLsizei count, const GLint *v ) */
+static void
+android_glUniform4iv__II_3II
+ (JNIEnv *_env, jobject _this, jint location, jint count, jintArray v_ref, jint offset) {
+ GLint *v_base = (GLint *) 0;
+ jint _remaining;
+ GLint *v = (GLint *) 0;
+
+ if (!v_ref) {
+ _env->ThrowNew(IAEClass, "v == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(v_ref) - offset;
+ v_base = (GLint *)
+ _env->GetPrimitiveArrayCritical(v_ref, (jboolean *)0);
+ v = v_base + offset;
+
+ glUniform4iv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLint *)v
+ );
+
+exit:
+ if (v_base) {
+ _env->ReleasePrimitiveArrayCritical(v_ref, v_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glUniform4iv ( GLint location, GLsizei count, const GLint *v ) */
+static void
+android_glUniform4iv__IILjava_nio_IntBuffer_2
+ (JNIEnv *_env, jobject _this, jint location, jint count, jobject v_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLint *v = (GLint *) 0;
+
+ v = (GLint *)getPointer(_env, v_buf, &_array, &_remaining);
+ glUniform4iv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLint *)v
+ );
+ if (_array) {
+ releasePointer(_env, _array, v, JNI_FALSE);
+ }
+}
+
+/* void glUniformMatrix2fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
+static void
+android_glUniformMatrix2fv__IIZ_3FI
+ (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) {
+ GLfloat *value_base = (GLfloat *) 0;
+ jint _remaining;
+ GLfloat *value = (GLfloat *) 0;
+
+ if (!value_ref) {
+ _env->ThrowNew(IAEClass, "value == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(value_ref) - offset;
+ value_base = (GLfloat *)
+ _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0);
+ value = value_base + offset;
+
+ glUniformMatrix2fv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLboolean)transpose,
+ (GLfloat *)value
+ );
+
+exit:
+ if (value_base) {
+ _env->ReleasePrimitiveArrayCritical(value_ref, value_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glUniformMatrix2fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
+static void
+android_glUniformMatrix2fv__IIZLjava_nio_FloatBuffer_2
+ (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jobject value_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLfloat *value = (GLfloat *) 0;
+
+ value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining);
+ glUniformMatrix2fv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLboolean)transpose,
+ (GLfloat *)value
+ );
+ if (_array) {
+ releasePointer(_env, _array, value, JNI_FALSE);
+ }
+}
+
+/* void glUniformMatrix3fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
+static void
+android_glUniformMatrix3fv__IIZ_3FI
+ (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) {
+ GLfloat *value_base = (GLfloat *) 0;
+ jint _remaining;
+ GLfloat *value = (GLfloat *) 0;
+
+ if (!value_ref) {
+ _env->ThrowNew(IAEClass, "value == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(value_ref) - offset;
+ value_base = (GLfloat *)
+ _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0);
+ value = value_base + offset;
+
+ glUniformMatrix3fv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLboolean)transpose,
+ (GLfloat *)value
+ );
+
+exit:
+ if (value_base) {
+ _env->ReleasePrimitiveArrayCritical(value_ref, value_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glUniformMatrix3fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
+static void
+android_glUniformMatrix3fv__IIZLjava_nio_FloatBuffer_2
+ (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jobject value_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLfloat *value = (GLfloat *) 0;
+
+ value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining);
+ glUniformMatrix3fv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLboolean)transpose,
+ (GLfloat *)value
+ );
+ if (_array) {
+ releasePointer(_env, _array, value, JNI_FALSE);
+ }
+}
+
+/* void glUniformMatrix4fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
+static void
+android_glUniformMatrix4fv__IIZ_3FI
+ (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) {
+ GLfloat *value_base = (GLfloat *) 0;
+ jint _remaining;
+ GLfloat *value = (GLfloat *) 0;
+
+ if (!value_ref) {
+ _env->ThrowNew(IAEClass, "value == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(value_ref) - offset;
+ value_base = (GLfloat *)
+ _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0);
+ value = value_base + offset;
+
+ glUniformMatrix4fv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLboolean)transpose,
+ (GLfloat *)value
+ );
+
+exit:
+ if (value_base) {
+ _env->ReleasePrimitiveArrayCritical(value_ref, value_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glUniformMatrix4fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */
+static void
+android_glUniformMatrix4fv__IIZLjava_nio_FloatBuffer_2
+ (JNIEnv *_env, jobject _this, jint location, jint count, jboolean transpose, jobject value_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLfloat *value = (GLfloat *) 0;
+
+ value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining);
+ glUniformMatrix4fv(
+ (GLint)location,
+ (GLsizei)count,
+ (GLboolean)transpose,
+ (GLfloat *)value
+ );
+ if (_array) {
+ releasePointer(_env, _array, value, JNI_FALSE);
+ }
+}
+
+/* void glUseProgram ( GLuint program ) */
+static void
+android_glUseProgram__I
+ (JNIEnv *_env, jobject _this, jint program) {
+ glUseProgram(
+ (GLuint)program
+ );
+}
+
+/* void glValidateProgram ( GLuint program ) */
+static void
+android_glValidateProgram__I
+ (JNIEnv *_env, jobject _this, jint program) {
+ glValidateProgram(
+ (GLuint)program
+ );
+}
+
+/* void glVertexAttrib1f ( GLuint indx, GLfloat x ) */
+static void
+android_glVertexAttrib1f__IF
+ (JNIEnv *_env, jobject _this, jint indx, jfloat x) {
+ glVertexAttrib1f(
+ (GLuint)indx,
+ (GLfloat)x
+ );
+}
+
+/* void glVertexAttrib1fv ( GLuint indx, const GLfloat *values ) */
+static void
+android_glVertexAttrib1fv__I_3FI
+ (JNIEnv *_env, jobject _this, jint indx, jfloatArray values_ref, jint offset) {
+ GLfloat *values_base = (GLfloat *) 0;
+ jint _remaining;
+ GLfloat *values = (GLfloat *) 0;
+
+ if (!values_ref) {
+ _env->ThrowNew(IAEClass, "values == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(values_ref) - offset;
+ values_base = (GLfloat *)
+ _env->GetPrimitiveArrayCritical(values_ref, (jboolean *)0);
+ values = values_base + offset;
+
+ glVertexAttrib1fv(
+ (GLuint)indx,
+ (GLfloat *)values
+ );
+
+exit:
+ if (values_base) {
+ _env->ReleasePrimitiveArrayCritical(values_ref, values_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glVertexAttrib1fv ( GLuint indx, const GLfloat *values ) */
+static void
+android_glVertexAttrib1fv__ILjava_nio_FloatBuffer_2
+ (JNIEnv *_env, jobject _this, jint indx, jobject values_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLfloat *values = (GLfloat *) 0;
+
+ values = (GLfloat *)getPointer(_env, values_buf, &_array, &_remaining);
+ glVertexAttrib1fv(
+ (GLuint)indx,
+ (GLfloat *)values
+ );
+ if (_array) {
+ releasePointer(_env, _array, values, JNI_FALSE);
+ }
+}
+
+/* void glVertexAttrib2f ( GLuint indx, GLfloat x, GLfloat y ) */
+static void
+android_glVertexAttrib2f__IFF
+ (JNIEnv *_env, jobject _this, jint indx, jfloat x, jfloat y) {
+ glVertexAttrib2f(
+ (GLuint)indx,
+ (GLfloat)x,
+ (GLfloat)y
+ );
+}
+
+/* void glVertexAttrib2fv ( GLuint indx, const GLfloat *values ) */
+static void
+android_glVertexAttrib2fv__I_3FI
+ (JNIEnv *_env, jobject _this, jint indx, jfloatArray values_ref, jint offset) {
+ GLfloat *values_base = (GLfloat *) 0;
+ jint _remaining;
+ GLfloat *values = (GLfloat *) 0;
+
+ if (!values_ref) {
+ _env->ThrowNew(IAEClass, "values == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(values_ref) - offset;
+ values_base = (GLfloat *)
+ _env->GetPrimitiveArrayCritical(values_ref, (jboolean *)0);
+ values = values_base + offset;
+
+ glVertexAttrib2fv(
+ (GLuint)indx,
+ (GLfloat *)values
+ );
+
+exit:
+ if (values_base) {
+ _env->ReleasePrimitiveArrayCritical(values_ref, values_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glVertexAttrib2fv ( GLuint indx, const GLfloat *values ) */
+static void
+android_glVertexAttrib2fv__ILjava_nio_FloatBuffer_2
+ (JNIEnv *_env, jobject _this, jint indx, jobject values_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLfloat *values = (GLfloat *) 0;
+
+ values = (GLfloat *)getPointer(_env, values_buf, &_array, &_remaining);
+ glVertexAttrib2fv(
+ (GLuint)indx,
+ (GLfloat *)values
+ );
+ if (_array) {
+ releasePointer(_env, _array, values, JNI_FALSE);
+ }
+}
+
+/* void glVertexAttrib3f ( GLuint indx, GLfloat x, GLfloat y, GLfloat z ) */
+static void
+android_glVertexAttrib3f__IFFF
+ (JNIEnv *_env, jobject _this, jint indx, jfloat x, jfloat y, jfloat z) {
+ glVertexAttrib3f(
+ (GLuint)indx,
+ (GLfloat)x,
+ (GLfloat)y,
+ (GLfloat)z
+ );
+}
+
+/* void glVertexAttrib3fv ( GLuint indx, const GLfloat *values ) */
+static void
+android_glVertexAttrib3fv__I_3FI
+ (JNIEnv *_env, jobject _this, jint indx, jfloatArray values_ref, jint offset) {
+ GLfloat *values_base = (GLfloat *) 0;
+ jint _remaining;
+ GLfloat *values = (GLfloat *) 0;
+
+ if (!values_ref) {
+ _env->ThrowNew(IAEClass, "values == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(values_ref) - offset;
+ values_base = (GLfloat *)
+ _env->GetPrimitiveArrayCritical(values_ref, (jboolean *)0);
+ values = values_base + offset;
+
+ glVertexAttrib3fv(
+ (GLuint)indx,
+ (GLfloat *)values
+ );
+
+exit:
+ if (values_base) {
+ _env->ReleasePrimitiveArrayCritical(values_ref, values_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glVertexAttrib3fv ( GLuint indx, const GLfloat *values ) */
+static void
+android_glVertexAttrib3fv__ILjava_nio_FloatBuffer_2
+ (JNIEnv *_env, jobject _this, jint indx, jobject values_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLfloat *values = (GLfloat *) 0;
+
+ values = (GLfloat *)getPointer(_env, values_buf, &_array, &_remaining);
+ glVertexAttrib3fv(
+ (GLuint)indx,
+ (GLfloat *)values
+ );
+ if (_array) {
+ releasePointer(_env, _array, values, JNI_FALSE);
+ }
+}
+
+/* void glVertexAttrib4f ( GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) */
+static void
+android_glVertexAttrib4f__IFFFF
+ (JNIEnv *_env, jobject _this, jint indx, jfloat x, jfloat y, jfloat z, jfloat w) {
+ glVertexAttrib4f(
+ (GLuint)indx,
+ (GLfloat)x,
+ (GLfloat)y,
+ (GLfloat)z,
+ (GLfloat)w
+ );
+}
+
+/* void glVertexAttrib4fv ( GLuint indx, const GLfloat *values ) */
+static void
+android_glVertexAttrib4fv__I_3FI
+ (JNIEnv *_env, jobject _this, jint indx, jfloatArray values_ref, jint offset) {
+ GLfloat *values_base = (GLfloat *) 0;
+ jint _remaining;
+ GLfloat *values = (GLfloat *) 0;
+
+ if (!values_ref) {
+ _env->ThrowNew(IAEClass, "values == null");
+ goto exit;
+ }
+ if (offset < 0) {
+ _env->ThrowNew(IAEClass, "offset < 0");
+ goto exit;
+ }
+ _remaining = _env->GetArrayLength(values_ref) - offset;
+ values_base = (GLfloat *)
+ _env->GetPrimitiveArrayCritical(values_ref, (jboolean *)0);
+ values = values_base + offset;
+
+ glVertexAttrib4fv(
+ (GLuint)indx,
+ (GLfloat *)values
+ );
+
+exit:
+ if (values_base) {
+ _env->ReleasePrimitiveArrayCritical(values_ref, values_base,
+ JNI_ABORT);
+ }
+}
+
+/* void glVertexAttrib4fv ( GLuint indx, const GLfloat *values ) */
+static void
+android_glVertexAttrib4fv__ILjava_nio_FloatBuffer_2
+ (JNIEnv *_env, jobject _this, jint indx, jobject values_buf) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLfloat *values = (GLfloat *) 0;
+
+ values = (GLfloat *)getPointer(_env, values_buf, &_array, &_remaining);
+ glVertexAttrib4fv(
+ (GLuint)indx,
+ (GLfloat *)values
+ );
+ if (_array) {
+ releasePointer(_env, _array, values, JNI_FALSE);
+ }
+}
+
+/* void glVertexAttribPointer ( GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *ptr ) */
+static void
+android_glVertexAttribPointerBounds__IIIZILjava_nio_Buffer_2I
+ (JNIEnv *_env, jobject _this, jint indx, jint size, jint type, jboolean normalized, jint stride, jobject ptr_buf, jint remaining) {
+ jarray _array = (jarray) 0;
+ jint _remaining;
+ GLvoid *ptr = (GLvoid *) 0;
+
+ if (ptr_buf) {
+ ptr = (GLvoid *) getDirectBufferPointer(_env, ptr_buf);
+ if ( ! ptr ) {
+ return;
+ }
+ }
+ glVertexAttribPointerBounds(
+ (GLuint)indx,
+ (GLint)size,
+ (GLenum)type,
+ (GLboolean)normalized,
+ (GLsizei)stride,
+ (GLvoid *)ptr,
+ (GLsizei)remaining
+ );
+}
+
+/* void glViewport ( GLint x, GLint y, GLsizei width, GLsizei height ) */
+static void
+android_glViewport__IIII
+ (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height) {
+ glViewport(
+ (GLint)x,
+ (GLint)y,
+ (GLsizei)width,
+ (GLsizei)height
+ );
+}
+
+static const char *classPathName = "android/opengl/GLES20";
+
+static JNINativeMethod methods[] = {
+{"_nativeClassInit", "()V", (void*)nativeClassInit },
+{"glActiveTexture", "(I)V", (void *) android_glActiveTexture__I },
+{"glAttachShader", "(II)V", (void *) android_glAttachShader__II },
+{"glBindAttribLocation", "(IILjava/lang/String;)V", (void *) android_glBindAttribLocation__IILjava_lang_String_2 },
+{"glBindBuffer", "(II)V", (void *) android_glBindBuffer__II },
+{"glBindFramebuffer", "(II)V", (void *) android_glBindFramebuffer__II },
+{"glBindRenderbuffer", "(II)V", (void *) android_glBindRenderbuffer__II },
+{"glBindTexture", "(II)V", (void *) android_glBindTexture__II },
+{"glBlendColor", "(FFFF)V", (void *) android_glBlendColor__FFFF },
+{"glBlendEquation", "(I)V", (void *) android_glBlendEquation__I },
+{"glBlendEquationSeparate", "(II)V", (void *) android_glBlendEquationSeparate__II },
+{"glBlendFunc", "(II)V", (void *) android_glBlendFunc__II },
+{"glBlendFuncSeparate", "(IIII)V", (void *) android_glBlendFuncSeparate__IIII },
+{"glBufferData", "(IILjava/nio/Buffer;I)V", (void *) android_glBufferData__IILjava_nio_Buffer_2I },
+{"glBufferSubData", "(IIILjava/nio/Buffer;)V", (void *) android_glBufferSubData__IIILjava_nio_Buffer_2 },
+{"glCheckFramebufferStatus", "(I)I", (void *) android_glCheckFramebufferStatus__I },
+{"glClear", "(I)V", (void *) android_glClear__I },
+{"glClearColor", "(FFFF)V", (void *) android_glClearColor__FFFF },
+{"glClearDepthf", "(F)V", (void *) android_glClearDepthf__F },
+{"glClearStencil", "(I)V", (void *) android_glClearStencil__I },
+{"glColorMask", "(ZZZZ)V", (void *) android_glColorMask__ZZZZ },
+{"glCompileShader", "(I)V", (void *) android_glCompileShader__I },
+{"glCompressedTexImage2D", "(IIIIIIILjava/nio/Buffer;)V", (void *) android_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2 },
+{"glCompressedTexSubImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 },
+{"glCopyTexImage2D", "(IIIIIIII)V", (void *) android_glCopyTexImage2D__IIIIIIII },
+{"glCopyTexSubImage2D", "(IIIIIIII)V", (void *) android_glCopyTexSubImage2D__IIIIIIII },
+{"glCreateProgram", "()I", (void *) android_glCreateProgram__ },
+{"glCreateShader", "(I)I", (void *) android_glCreateShader__I },
+{"glCullFace", "(I)V", (void *) android_glCullFace__I },
+{"glDeleteBuffers", "(I[II)V", (void *) android_glDeleteBuffers__I_3II },
+{"glDeleteBuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteBuffers__ILjava_nio_IntBuffer_2 },
+{"glDeleteFramebuffers", "(I[II)V", (void *) android_glDeleteFramebuffers__I_3II },
+{"glDeleteFramebuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteFramebuffers__ILjava_nio_IntBuffer_2 },
+{"glDeleteProgram", "(I)V", (void *) android_glDeleteProgram__I },
+{"glDeleteRenderbuffers", "(I[II)V", (void *) android_glDeleteRenderbuffers__I_3II },
+{"glDeleteRenderbuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteRenderbuffers__ILjava_nio_IntBuffer_2 },
+{"glDeleteShader", "(I)V", (void *) android_glDeleteShader__I },
+{"glDeleteTextures", "(I[II)V", (void *) android_glDeleteTextures__I_3II },
+{"glDeleteTextures", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteTextures__ILjava_nio_IntBuffer_2 },
+{"glDepthFunc", "(I)V", (void *) android_glDepthFunc__I },
+{"glDepthMask", "(Z)V", (void *) android_glDepthMask__Z },
+{"glDepthRangef", "(FF)V", (void *) android_glDepthRangef__FF },
+{"glDetachShader", "(II)V", (void *) android_glDetachShader__II },
+{"glDisable", "(I)V", (void *) android_glDisable__I },
+{"glDisableVertexAttribArray", "(I)V", (void *) android_glDisableVertexAttribArray__I },
+{"glDrawArrays", "(III)V", (void *) android_glDrawArrays__III },
+{"glDrawElements", "(IIILjava/nio/Buffer;)V", (void *) android_glDrawElements__IIILjava_nio_Buffer_2 },
+{"glEnable", "(I)V", (void *) android_glEnable__I },
+{"glEnableVertexAttribArray", "(I)V", (void *) android_glEnableVertexAttribArray__I },
+{"glFinish", "()V", (void *) android_glFinish__ },
+{"glFlush", "()V", (void *) android_glFlush__ },
+{"glFramebufferRenderbuffer", "(IIII)V", (void *) android_glFramebufferRenderbuffer__IIII },
+{"glFramebufferTexture2D", "(IIIII)V", (void *) android_glFramebufferTexture2D__IIIII },
+{"glFrontFace", "(I)V", (void *) android_glFrontFace__I },
+{"glGenBuffers", "(I[II)V", (void *) android_glGenBuffers__I_3II },
+{"glGenBuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenBuffers__ILjava_nio_IntBuffer_2 },
+{"glGenerateMipmap", "(I)V", (void *) android_glGenerateMipmap__I },
+{"glGenFramebuffers", "(I[II)V", (void *) android_glGenFramebuffers__I_3II },
+{"glGenFramebuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenFramebuffers__ILjava_nio_IntBuffer_2 },
+{"glGenRenderbuffers", "(I[II)V", (void *) android_glGenRenderbuffers__I_3II },
+{"glGenRenderbuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenRenderbuffers__ILjava_nio_IntBuffer_2 },
+{"glGenTextures", "(I[II)V", (void *) android_glGenTextures__I_3II },
+{"glGenTextures", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenTextures__ILjava_nio_IntBuffer_2 },
+{"glGetActiveAttrib", "(III[II[II[II[BI)V", (void *) android_glGetActiveAttrib__III_3II_3II_3II_3BI },
+{"glGetActiveAttrib", "(IIILjava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;B)V", (void *) android_glGetActiveAttrib__IIILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2B },
+{"glGetActiveUniform", "(III[II[II[II[BI)V", (void *) android_glGetActiveUniform__III_3II_3II_3II_3BI },
+{"glGetActiveUniform", "(IIILjava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;B)V", (void *) android_glGetActiveUniform__IIILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2B },
+{"glGetAttachedShaders", "(II[II[II)V", (void *) android_glGetAttachedShaders__II_3II_3II },
+{"glGetAttachedShaders", "(IILjava/nio/IntBuffer;Ljava/nio/IntBuffer;)V", (void *) android_glGetAttachedShaders__IILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 },
+{"glGetAttribLocation", "(ILjava/lang/String;)I", (void *) android_glGetAttribLocation__ILjava_lang_String_2 },
+{"glGetBooleanv", "(I[ZI)V", (void *) android_glGetBooleanv__I_3ZI },
+{"glGetBooleanv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetBooleanv__ILjava_nio_IntBuffer_2 },
+{"glGetBufferParameteriv", "(II[II)V", (void *) android_glGetBufferParameteriv__II_3II },
+{"glGetBufferParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetBufferParameteriv__IILjava_nio_IntBuffer_2 },
+{"glGetError", "()I", (void *) android_glGetError__ },
+{"glGetFloatv", "(I[FI)V", (void *) android_glGetFloatv__I_3FI },
+{"glGetFloatv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glGetFloatv__ILjava_nio_FloatBuffer_2 },
+{"glGetFramebufferAttachmentParameteriv", "(III[II)V", (void *) android_glGetFramebufferAttachmentParameteriv__III_3II },
+{"glGetFramebufferAttachmentParameteriv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetFramebufferAttachmentParameteriv__IIILjava_nio_IntBuffer_2 },
+{"glGetIntegerv", "(I[II)V", (void *) android_glGetIntegerv__I_3II },
+{"glGetIntegerv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetIntegerv__ILjava_nio_IntBuffer_2 },
+{"glGetProgramiv", "(II[II)V", (void *) android_glGetProgramiv__II_3II },
+{"glGetProgramiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetProgramiv__IILjava_nio_IntBuffer_2 },
+{"glGetProgramInfoLog", "(I)Ljava/lang/String;", (void *) android_glGetProgramInfoLog },
+{"glGetRenderbufferParameteriv", "(II[II)V", (void *) android_glGetRenderbufferParameteriv__II_3II },
+{"glGetRenderbufferParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetRenderbufferParameteriv__IILjava_nio_IntBuffer_2 },
+{"glGetShaderiv", "(II[II)V", (void *) android_glGetShaderiv__II_3II },
+{"glGetShaderiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetShaderiv__IILjava_nio_IntBuffer_2 },
+{"glGetShaderInfoLog", "(I)Ljava/lang/String;", (void *) android_glGetShaderInfoLog },
+{"glGetShaderPrecisionFormat", "(II[II[II)V", (void *) android_glGetShaderPrecisionFormat__II_3II_3II },
+{"glGetShaderPrecisionFormat", "(IILjava/nio/IntBuffer;Ljava/nio/IntBuffer;)V", (void *) android_glGetShaderPrecisionFormat__IILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 },
+{"glGetShaderSource", "(II[II[BI)V", (void *) android_glGetShaderSource__II_3II_3BI },
+{"glGetShaderSource", "(IILjava/nio/IntBuffer;B)V", (void *) android_glGetShaderSource__IILjava_nio_IntBuffer_2B },
+{"glGetString", "(I)Ljava/lang/String;", (void *) android_glGetString },
+{"glGetTexParameterfv", "(II[FI)V", (void *) android_glGetTexParameterfv__II_3FI },
+{"glGetTexParameterfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetTexParameterfv__IILjava_nio_FloatBuffer_2 },
+{"glGetTexParameteriv", "(II[II)V", (void *) android_glGetTexParameteriv__II_3II },
+{"glGetTexParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameteriv__IILjava_nio_IntBuffer_2 },
+{"glGetUniformfv", "(II[FI)V", (void *) android_glGetUniformfv__II_3FI },
+{"glGetUniformfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetUniformfv__IILjava_nio_FloatBuffer_2 },
+{"glGetUniformiv", "(II[II)V", (void *) android_glGetUniformiv__II_3II },
+{"glGetUniformiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetUniformiv__IILjava_nio_IntBuffer_2 },
+{"glGetUniformLocation", "(ILjava/lang/String;)I", (void *) android_glGetUniformLocation__ILjava_lang_String_2 },
+{"glGetVertexAttribfv", "(II[FI)V", (void *) android_glGetVertexAttribfv__II_3FI },
+{"glGetVertexAttribfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetVertexAttribfv__IILjava_nio_FloatBuffer_2 },
+{"glGetVertexAttribiv", "(II[II)V", (void *) android_glGetVertexAttribiv__II_3II },
+{"glGetVertexAttribiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetVertexAttribiv__IILjava_nio_IntBuffer_2 },
+{"glHint", "(II)V", (void *) android_glHint__II },
+{"glIsBuffer", "(I)Z", (void *) android_glIsBuffer__I },
+{"glIsEnabled", "(I)Z", (void *) android_glIsEnabled__I },
+{"glIsFramebuffer", "(I)Z", (void *) android_glIsFramebuffer__I },
+{"glIsProgram", "(I)Z", (void *) android_glIsProgram__I },
+{"glIsRenderbuffer", "(I)Z", (void *) android_glIsRenderbuffer__I },
+{"glIsShader", "(I)Z", (void *) android_glIsShader__I },
+{"glIsTexture", "(I)Z", (void *) android_glIsTexture__I },
+{"glLineWidth", "(F)V", (void *) android_glLineWidth__F },
+{"glLinkProgram", "(I)V", (void *) android_glLinkProgram__I },
+{"glPixelStorei", "(II)V", (void *) android_glPixelStorei__II },
+{"glPolygonOffset", "(FF)V", (void *) android_glPolygonOffset__FF },
+{"glReadPixels", "(IIIIIILjava/nio/Buffer;)V", (void *) android_glReadPixels__IIIIIILjava_nio_Buffer_2 },
+{"glReleaseShaderCompiler", "()V", (void *) android_glReleaseShaderCompiler__ },
+{"glRenderbufferStorage", "(IIII)V", (void *) android_glRenderbufferStorage__IIII },
+{"glSampleCoverage", "(FZ)V", (void *) android_glSampleCoverage__FZ },
+{"glScissor", "(IIII)V", (void *) android_glScissor__IIII },
+{"glShaderBinary", "(I[IIILjava/nio/Buffer;I)V", (void *) android_glShaderBinary__I_3IIILjava_nio_Buffer_2I },
+{"glShaderBinary", "(ILjava/nio/IntBuffer;ILjava/nio/Buffer;I)V", (void *) android_glShaderBinary__ILjava_nio_IntBuffer_2ILjava_nio_Buffer_2I },
+{"glShaderSource", "(ILjava/lang/String;)V", (void *) android_glShaderSource },
+{"glStencilFunc", "(III)V", (void *) android_glStencilFunc__III },
+{"glStencilFuncSeparate", "(IIII)V", (void *) android_glStencilFuncSeparate__IIII },
+{"glStencilMask", "(I)V", (void *) android_glStencilMask__I },
+{"glStencilMaskSeparate", "(II)V", (void *) android_glStencilMaskSeparate__II },
+{"glStencilOp", "(III)V", (void *) android_glStencilOp__III },
+{"glStencilOpSeparate", "(IIII)V", (void *) android_glStencilOpSeparate__IIII },
+{"glTexImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2 },
+{"glTexParameterf", "(IIF)V", (void *) android_glTexParameterf__IIF },
+{"glTexParameterfv", "(II[FI)V", (void *) android_glTexParameterfv__II_3FI },
+{"glTexParameterfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexParameterfv__IILjava_nio_FloatBuffer_2 },
+{"glTexParameteri", "(III)V", (void *) android_glTexParameteri__III },
+{"glTexParameteriv", "(II[II)V", (void *) android_glTexParameteriv__II_3II },
+{"glTexParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameteriv__IILjava_nio_IntBuffer_2 },
+{"glTexSubImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 },
+{"glUniform1f", "(IF)V", (void *) android_glUniform1f__IF },
+{"glUniform1fv", "(II[FI)V", (void *) android_glUniform1fv__II_3FI },
+{"glUniform1fv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glUniform1fv__IILjava_nio_FloatBuffer_2 },
+{"glUniform1i", "(II)V", (void *) android_glUniform1i__II },
+{"glUniform1iv", "(II[II)V", (void *) android_glUniform1iv__II_3II },
+{"glUniform1iv", "(IILjava/nio/IntBuffer;)V", (void *) android_glUniform1iv__IILjava_nio_IntBuffer_2 },
+{"glUniform2f", "(IFF)V", (void *) android_glUniform2f__IFF },
+{"glUniform2fv", "(II[FI)V", (void *) android_glUniform2fv__II_3FI },
+{"glUniform2fv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glUniform2fv__IILjava_nio_FloatBuffer_2 },
+{"glUniform2i", "(III)V", (void *) android_glUniform2i__III },
+{"glUniform2iv", "(II[II)V", (void *) android_glUniform2iv__II_3II },
+{"glUniform2iv", "(IILjava/nio/IntBuffer;)V", (void *) android_glUniform2iv__IILjava_nio_IntBuffer_2 },
+{"glUniform3f", "(IFFF)V", (void *) android_glUniform3f__IFFF },
+{"glUniform3fv", "(II[FI)V", (void *) android_glUniform3fv__II_3FI },
+{"glUniform3fv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glUniform3fv__IILjava_nio_FloatBuffer_2 },
+{"glUniform3i", "(IIII)V", (void *) android_glUniform3i__IIII },
+{"glUniform3iv", "(II[II)V", (void *) android_glUniform3iv__II_3II },
+{"glUniform3iv", "(IILjava/nio/IntBuffer;)V", (void *) android_glUniform3iv__IILjava_nio_IntBuffer_2 },
+{"glUniform4f", "(IFFFF)V", (void *) android_glUniform4f__IFFFF },
+{"glUniform4fv", "(II[FI)V", (void *) android_glUniform4fv__II_3FI },
+{"glUniform4fv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glUniform4fv__IILjava_nio_FloatBuffer_2 },
+{"glUniform4i", "(IIIII)V", (void *) android_glUniform4i__IIIII },
+{"glUniform4iv", "(II[II)V", (void *) android_glUniform4iv__II_3II },
+{"glUniform4iv", "(IILjava/nio/IntBuffer;)V", (void *) android_glUniform4iv__IILjava_nio_IntBuffer_2 },
+{"glUniformMatrix2fv", "(IIZ[FI)V", (void *) android_glUniformMatrix2fv__IIZ_3FI },
+{"glUniformMatrix2fv", "(IIZLjava/nio/FloatBuffer;)V", (void *) android_glUniformMatrix2fv__IIZLjava_nio_FloatBuffer_2 },
+{"glUniformMatrix3fv", "(IIZ[FI)V", (void *) android_glUniformMatrix3fv__IIZ_3FI },
+{"glUniformMatrix3fv", "(IIZLjava/nio/FloatBuffer;)V", (void *) android_glUniformMatrix3fv__IIZLjava_nio_FloatBuffer_2 },
+{"glUniformMatrix4fv", "(IIZ[FI)V", (void *) android_glUniformMatrix4fv__IIZ_3FI },
+{"glUniformMatrix4fv", "(IIZLjava/nio/FloatBuffer;)V", (void *) android_glUniformMatrix4fv__IIZLjava_nio_FloatBuffer_2 },
+{"glUseProgram", "(I)V", (void *) android_glUseProgram__I },
+{"glValidateProgram", "(I)V", (void *) android_glValidateProgram__I },
+{"glVertexAttrib1f", "(IF)V", (void *) android_glVertexAttrib1f__IF },
+{"glVertexAttrib1fv", "(I[FI)V", (void *) android_glVertexAttrib1fv__I_3FI },
+{"glVertexAttrib1fv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glVertexAttrib1fv__ILjava_nio_FloatBuffer_2 },
+{"glVertexAttrib2f", "(IFF)V", (void *) android_glVertexAttrib2f__IFF },
+{"glVertexAttrib2fv", "(I[FI)V", (void *) android_glVertexAttrib2fv__I_3FI },
+{"glVertexAttrib2fv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glVertexAttrib2fv__ILjava_nio_FloatBuffer_2 },
+{"glVertexAttrib3f", "(IFFF)V", (void *) android_glVertexAttrib3f__IFFF },
+{"glVertexAttrib3fv", "(I[FI)V", (void *) android_glVertexAttrib3fv__I_3FI },
+{"glVertexAttrib3fv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glVertexAttrib3fv__ILjava_nio_FloatBuffer_2 },
+{"glVertexAttrib4f", "(IFFFF)V", (void *) android_glVertexAttrib4f__IFFFF },
+{"glVertexAttrib4fv", "(I[FI)V", (void *) android_glVertexAttrib4fv__I_3FI },
+{"glVertexAttrib4fv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glVertexAttrib4fv__ILjava_nio_FloatBuffer_2 },
+{"glVertexAttribPointerBounds", "(IIIZILjava/nio/Buffer;I)V", (void *) android_glVertexAttribPointerBounds__IIIZILjava_nio_Buffer_2I },
+{"glViewport", "(IIII)V", (void *) android_glViewport__IIII },
+};
+
+int register_android_opengl_jni_GLES20(JNIEnv *_env)
+{
+ int err;
+ err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));
+ return err;
+}
diff --git a/opengl/java/android/opengl/GLES20.java b/opengl/java/android/opengl/GLES20.java
new file mode 100644
index 0000000..7ce318f
--- /dev/null
+++ b/opengl/java/android/opengl/GLES20.java
@@ -0,0 +1,1858 @@
+/*
+**
+** Copyright 2009, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+// This source file is automatically generated
+
+package android.opengl;
+
+/** OpenGL ES 2.0
+ * @hide
+ */
+public class GLES20 {
+ public static final int GL_ACTIVE_TEXTURE = 0x84E0;
+ public static final int GL_DEPTH_BUFFER_BIT = 0x00000100;
+ public static final int GL_STENCIL_BUFFER_BIT = 0x00000400;
+ public static final int GL_COLOR_BUFFER_BIT = 0x00004000;
+ public static final int GL_FALSE = 0;
+ public static final int GL_TRUE = 1;
+ public static final int GL_POINTS = 0x0000;
+ public static final int GL_LINES = 0x0001;
+ public static final int GL_LINE_LOOP = 0x0002;
+ public static final int GL_LINE_STRIP = 0x0003;
+ public static final int GL_TRIANGLES = 0x0004;
+ public static final int GL_TRIANGLE_STRIP = 0x0005;
+ public static final int GL_TRIANGLE_FAN = 0x0006;
+ public static final int GL_ZERO = 0;
+ public static final int GL_ONE = 1;
+ public static final int GL_SRC_COLOR = 0x0300;
+ public static final int GL_ONE_MINUS_SRC_COLOR = 0x0301;
+ public static final int GL_SRC_ALPHA = 0x0302;
+ public static final int GL_ONE_MINUS_SRC_ALPHA = 0x0303;
+ public static final int GL_DST_ALPHA = 0x0304;
+ public static final int GL_ONE_MINUS_DST_ALPHA = 0x0305;
+ public static final int GL_DST_COLOR = 0x0306;
+ public static final int GL_ONE_MINUS_DST_COLOR = 0x0307;
+ public static final int GL_SRC_ALPHA_SATURATE = 0x0308;
+ public static final int GL_FUNC_ADD = 0x8006;
+ public static final int GL_BLEND_EQUATION = 0x8009;
+ public static final int GL_BLEND_EQUATION_RGB = 0x8009; /* same as BLEND_EQUATION */
+ public static final int GL_BLEND_EQUATION_ALPHA = 0x883D;
+ public static final int GL_FUNC_SUBTRACT = 0x800A;
+ public static final int GL_FUNC_REVERSE_SUBTRACT = 0x800B;
+ public static final int GL_BLEND_DST_RGB = 0x80C8;
+ public static final int GL_BLEND_SRC_RGB = 0x80C9;
+ public static final int GL_BLEND_DST_ALPHA = 0x80CA;
+ public static final int GL_BLEND_SRC_ALPHA = 0x80CB;
+ public static final int GL_CONSTANT_COLOR = 0x8001;
+ public static final int GL_ONE_MINUS_CONSTANT_COLOR = 0x8002;
+ public static final int GL_CONSTANT_ALPHA = 0x8003;
+ public static final int GL_ONE_MINUS_CONSTANT_ALPHA = 0x8004;
+ public static final int GL_BLEND_COLOR = 0x8005;
+ public static final int GL_ARRAY_BUFFER = 0x8892;
+ public static final int GL_ELEMENT_ARRAY_BUFFER = 0x8893;
+ public static final int GL_ARRAY_BUFFER_BINDING = 0x8894;
+ public static final int GL_ELEMENT_ARRAY_BUFFER_BINDING = 0x8895;
+ public static final int GL_STREAM_DRAW = 0x88E0;
+ public static final int GL_STATIC_DRAW = 0x88E4;
+ public static final int GL_DYNAMIC_DRAW = 0x88E8;
+ public static final int GL_BUFFER_SIZE = 0x8764;
+ public static final int GL_BUFFER_USAGE = 0x8765;
+ public static final int GL_CURRENT_VERTEX_ATTRIB = 0x8626;
+ public static final int GL_FRONT = 0x0404;
+ public static final int GL_BACK = 0x0405;
+ public static final int GL_FRONT_AND_BACK = 0x0408;
+ public static final int GL_TEXTURE_2D = 0x0DE1;
+ public static final int GL_CULL_FACE = 0x0B44;
+ public static final int GL_BLEND = 0x0BE2;
+ public static final int GL_DITHER = 0x0BD0;
+ public static final int GL_STENCIL_TEST = 0x0B90;
+ public static final int GL_DEPTH_TEST = 0x0B71;
+ public static final int GL_SCISSOR_TEST = 0x0C11;
+ public static final int GL_POLYGON_OFFSET_FILL = 0x8037;
+ public static final int GL_SAMPLE_ALPHA_TO_COVERAGE = 0x809E;
+ public static final int GL_SAMPLE_COVERAGE = 0x80A0;
+ public static final int GL_NO_ERROR = 0;
+ public static final int GL_INVALID_ENUM = 0x0500;
+ public static final int GL_INVALID_VALUE = 0x0501;
+ public static final int GL_INVALID_OPERATION = 0x0502;
+ public static final int GL_OUT_OF_MEMORY = 0x0505;
+ public static final int GL_CW = 0x0900;
+ public static final int GL_CCW = 0x0901;
+ public static final int GL_LINE_WIDTH = 0x0B21;
+ public static final int GL_ALIASED_POINT_SIZE_RANGE = 0x846D;
+ public static final int GL_ALIASED_LINE_WIDTH_RANGE = 0x846E;
+ public static final int GL_CULL_FACE_MODE = 0x0B45;
+ public static final int GL_FRONT_FACE = 0x0B46;
+ public static final int GL_DEPTH_RANGE = 0x0B70;
+ public static final int GL_DEPTH_WRITEMASK = 0x0B72;
+ public static final int GL_DEPTH_CLEAR_VALUE = 0x0B73;
+ public static final int GL_DEPTH_FUNC = 0x0B74;
+ public static final int GL_STENCIL_CLEAR_VALUE = 0x0B91;
+ public static final int GL_STENCIL_FUNC = 0x0B92;
+ public static final int GL_STENCIL_FAIL = 0x0B94;
+ public static final int GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95;
+ public static final int GL_STENCIL_PASS_DEPTH_PASS = 0x0B96;
+ public static final int GL_STENCIL_REF = 0x0B97;
+ public static final int GL_STENCIL_VALUE_MASK = 0x0B93;
+ public static final int GL_STENCIL_WRITEMASK = 0x0B98;
+ public static final int GL_STENCIL_BACK_FUNC = 0x8800;
+ public static final int GL_STENCIL_BACK_FAIL = 0x8801;
+ public static final int GL_STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802;
+ public static final int GL_STENCIL_BACK_PASS_DEPTH_PASS = 0x8803;
+ public static final int GL_STENCIL_BACK_REF = 0x8CA3;
+ public static final int GL_STENCIL_BACK_VALUE_MASK = 0x8CA4;
+ public static final int GL_STENCIL_BACK_WRITEMASK = 0x8CA5;
+ public static final int GL_VIEWPORT = 0x0BA2;
+ public static final int GL_SCISSOR_BOX = 0x0C10;
+ public static final int GL_COLOR_CLEAR_VALUE = 0x0C22;
+ public static final int GL_COLOR_WRITEMASK = 0x0C23;
+ public static final int GL_UNPACK_ALIGNMENT = 0x0CF5;
+ public static final int GL_PACK_ALIGNMENT = 0x0D05;
+ public static final int GL_MAX_TEXTURE_SIZE = 0x0D33;
+ public static final int GL_MAX_VIEWPORT_DIMS = 0x0D3A;
+ public static final int GL_SUBPIXEL_BITS = 0x0D50;
+ public static final int GL_RED_BITS = 0x0D52;
+ public static final int GL_GREEN_BITS = 0x0D53;
+ public static final int GL_BLUE_BITS = 0x0D54;
+ public static final int GL_ALPHA_BITS = 0x0D55;
+ public static final int GL_DEPTH_BITS = 0x0D56;
+ public static final int GL_STENCIL_BITS = 0x0D57;
+ public static final int GL_POLYGON_OFFSET_UNITS = 0x2A00;
+ public static final int GL_POLYGON_OFFSET_FACTOR = 0x8038;
+ public static final int GL_TEXTURE_BINDING_2D = 0x8069;
+ public static final int GL_SAMPLE_BUFFERS = 0x80A8;
+ public static final int GL_SAMPLES = 0x80A9;
+ public static final int GL_SAMPLE_COVERAGE_VALUE = 0x80AA;
+ public static final int GL_SAMPLE_COVERAGE_INVERT = 0x80AB;
+ public static final int GL_NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2;
+ public static final int GL_COMPRESSED_TEXTURE_FORMATS = 0x86A3;
+ public static final int GL_DONT_CARE = 0x1100;
+ public static final int GL_FASTEST = 0x1101;
+ public static final int GL_NICEST = 0x1102;
+ public static final int GL_GENERATE_MIPMAP_HINT = 0x8192;
+ public static final int GL_BYTE = 0x1400;
+ public static final int GL_UNSIGNED_BYTE = 0x1401;
+ public static final int GL_SHORT = 0x1402;
+ public static final int GL_UNSIGNED_SHORT = 0x1403;
+ public static final int GL_INT = 0x1404;
+ public static final int GL_UNSIGNED_INT = 0x1405;
+ public static final int GL_FLOAT = 0x1406;
+ public static final int GL_FIXED = 0x140C;
+ public static final int GL_DEPTH_COMPONENT = 0x1902;
+ public static final int GL_ALPHA = 0x1906;
+ public static final int GL_RGB = 0x1907;
+ public static final int GL_RGBA = 0x1908;
+ public static final int GL_LUMINANCE = 0x1909;
+ public static final int GL_LUMINANCE_ALPHA = 0x190A;
+ public static final int GL_UNSIGNED_SHORT_4_4_4_4 = 0x8033;
+ public static final int GL_UNSIGNED_SHORT_5_5_5_1 = 0x8034;
+ public static final int GL_UNSIGNED_SHORT_5_6_5 = 0x8363;
+ public static final int GL_FRAGMENT_SHADER = 0x8B30;
+ public static final int GL_VERTEX_SHADER = 0x8B31;
+ public static final int GL_MAX_VERTEX_ATTRIBS = 0x8869;
+ public static final int GL_MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB;
+ public static final int GL_MAX_VARYING_VECTORS = 0x8DFC;
+ public static final int GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D;
+ public static final int GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C;
+ public static final int GL_MAX_TEXTURE_IMAGE_UNITS = 0x8872;
+ public static final int GL_MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD;
+ public static final int GL_SHADER_TYPE = 0x8B4F;
+ public static final int GL_DELETE_STATUS = 0x8B80;
+ public static final int GL_LINK_STATUS = 0x8B82;
+ public static final int GL_VALIDATE_STATUS = 0x8B83;
+ public static final int GL_ATTACHED_SHADERS = 0x8B85;
+ public static final int GL_ACTIVE_UNIFORMS = 0x8B86;
+ public static final int GL_ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87;
+ public static final int GL_ACTIVE_ATTRIBUTES = 0x8B89;
+ public static final int GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A;
+ public static final int GL_SHADING_LANGUAGE_VERSION = 0x8B8C;
+ public static final int GL_CURRENT_PROGRAM = 0x8B8D;
+ public static final int GL_NEVER = 0x0200;
+ public static final int GL_LESS = 0x0201;
+ public static final int GL_EQUAL = 0x0202;
+ public static final int GL_LEQUAL = 0x0203;
+ public static final int GL_GREATER = 0x0204;
+ public static final int GL_NOTEQUAL = 0x0205;
+ public static final int GL_GEQUAL = 0x0206;
+ public static final int GL_ALWAYS = 0x0207;
+ public static final int GL_KEEP = 0x1E00;
+ public static final int GL_REPLACE = 0x1E01;
+ public static final int GL_INCR = 0x1E02;
+ public static final int GL_DECR = 0x1E03;
+ public static final int GL_INVERT = 0x150A;
+ public static final int GL_INCR_WRAP = 0x8507;
+ public static final int GL_DECR_WRAP = 0x8508;
+ public static final int GL_VENDOR = 0x1F00;
+ public static final int GL_RENDERER = 0x1F01;
+ public static final int GL_VERSION = 0x1F02;
+ public static final int GL_EXTENSIONS = 0x1F03;
+ public static final int GL_NEAREST = 0x2600;
+ public static final int GL_LINEAR = 0x2601;
+ public static final int GL_NEAREST_MIPMAP_NEAREST = 0x2700;
+ public static final int GL_LINEAR_MIPMAP_NEAREST = 0x2701;
+ public static final int GL_NEAREST_MIPMAP_LINEAR = 0x2702;
+ public static final int GL_LINEAR_MIPMAP_LINEAR = 0x2703;
+ public static final int GL_TEXTURE_MAG_FILTER = 0x2800;
+ public static final int GL_TEXTURE_MIN_FILTER = 0x2801;
+ public static final int GL_TEXTURE_WRAP_S = 0x2802;
+ public static final int GL_TEXTURE_WRAP_T = 0x2803;
+ public static final int GL_TEXTURE = 0x1702;
+ public static final int GL_TEXTURE_CUBE_MAP = 0x8513;
+ public static final int GL_TEXTURE_BINDING_CUBE_MAP = 0x8514;
+ public static final int GL_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515;
+ public static final int GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516;
+ public static final int GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517;
+ public static final int GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518;
+ public static final int GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519;
+ public static final int GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A;
+ public static final int GL_MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C;
+ public static final int GL_TEXTURE0 = 0x84C0;
+ public static final int GL_TEXTURE1 = 0x84C1;
+ public static final int GL_TEXTURE2 = 0x84C2;
+ public static final int GL_TEXTURE3 = 0x84C3;
+ public static final int GL_TEXTURE4 = 0x84C4;
+ public static final int GL_TEXTURE5 = 0x84C5;
+ public static final int GL_TEXTURE6 = 0x84C6;
+ public static final int GL_TEXTURE7 = 0x84C7;
+ public static final int GL_TEXTURE8 = 0x84C8;
+ public static final int GL_TEXTURE9 = 0x84C9;
+ public static final int GL_TEXTURE10 = 0x84CA;
+ public static final int GL_TEXTURE11 = 0x84CB;
+ public static final int GL_TEXTURE12 = 0x84CC;
+ public static final int GL_TEXTURE13 = 0x84CD;
+ public static final int GL_TEXTURE14 = 0x84CE;
+ public static final int GL_TEXTURE15 = 0x84CF;
+ public static final int GL_TEXTURE16 = 0x84D0;
+ public static final int GL_TEXTURE17 = 0x84D1;
+ public static final int GL_TEXTURE18 = 0x84D2;
+ public static final int GL_TEXTURE19 = 0x84D3;
+ public static final int GL_TEXTURE20 = 0x84D4;
+ public static final int GL_TEXTURE21 = 0x84D5;
+ public static final int GL_TEXTURE22 = 0x84D6;
+ public static final int GL_TEXTURE23 = 0x84D7;
+ public static final int GL_TEXTURE24 = 0x84D8;
+ public static final int GL_TEXTURE25 = 0x84D9;
+ public static final int GL_TEXTURE26 = 0x84DA;
+ public static final int GL_TEXTURE27 = 0x84DB;
+ public static final int GL_TEXTURE28 = 0x84DC;
+ public static final int GL_TEXTURE29 = 0x84DD;
+ public static final int GL_TEXTURE30 = 0x84DE;
+ public static final int GL_TEXTURE31 = 0x84DF;
+ public static final int GL_REPEAT = 0x2901;
+ public static final int GL_CLAMP_TO_EDGE = 0x812F;
+ public static final int GL_MIRRORED_REPEAT = 0x8370;
+ public static final int GL_FLOAT_VEC2 = 0x8B50;
+ public static final int GL_FLOAT_VEC3 = 0x8B51;
+ public static final int GL_FLOAT_VEC4 = 0x8B52;
+ public static final int GL_INT_VEC2 = 0x8B53;
+ public static final int GL_INT_VEC3 = 0x8B54;
+ public static final int GL_INT_VEC4 = 0x8B55;
+ public static final int GL_BOOL = 0x8B56;
+ public static final int GL_BOOL_VEC2 = 0x8B57;
+ public static final int GL_BOOL_VEC3 = 0x8B58;
+ public static final int GL_BOOL_VEC4 = 0x8B59;
+ public static final int GL_FLOAT_MAT2 = 0x8B5A;
+ public static final int GL_FLOAT_MAT3 = 0x8B5B;
+ public static final int GL_FLOAT_MAT4 = 0x8B5C;
+ public static final int GL_SAMPLER_2D = 0x8B5E;
+ public static final int GL_SAMPLER_CUBE = 0x8B60;
+ public static final int GL_VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622;
+ public static final int GL_VERTEX_ATTRIB_ARRAY_SIZE = 0x8623;
+ public static final int GL_VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624;
+ public static final int GL_VERTEX_ATTRIB_ARRAY_TYPE = 0x8625;
+ public static final int GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A;
+ public static final int GL_VERTEX_ATTRIB_ARRAY_POINTER = 0x8645;
+ public static final int GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F;
+ public static final int GL_IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A;
+ public static final int GL_IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B;
+ public static final int GL_COMPILE_STATUS = 0x8B81;
+ public static final int GL_INFO_LOG_LENGTH = 0x8B84;
+ public static final int GL_SHADER_SOURCE_LENGTH = 0x8B88;
+ public static final int GL_SHADER_COMPILER = 0x8DFA;
+ public static final int GL_SHADER_BINARY_FORMATS = 0x8DF8;
+ public static final int GL_NUM_SHADER_BINARY_FORMATS = 0x8DF9;
+ public static final int GL_LOW_FLOAT = 0x8DF0;
+ public static final int GL_MEDIUM_FLOAT = 0x8DF1;
+ public static final int GL_HIGH_FLOAT = 0x8DF2;
+ public static final int GL_LOW_INT = 0x8DF3;
+ public static final int GL_MEDIUM_INT = 0x8DF4;
+ public static final int GL_HIGH_INT = 0x8DF5;
+ public static final int GL_FRAMEBUFFER = 0x8D40;
+ public static final int GL_RENDERBUFFER = 0x8D41;
+ public static final int GL_RGBA4 = 0x8056;
+ public static final int GL_RGB5_A1 = 0x8057;
+ public static final int GL_RGB565 = 0x8D62;
+ public static final int GL_DEPTH_COMPONENT16 = 0x81A5;
+ public static final int GL_STENCIL_INDEX = 0x1901;
+ public static final int GL_STENCIL_INDEX8 = 0x8D48;
+ public static final int GL_RENDERBUFFER_WIDTH = 0x8D42;
+ public static final int GL_RENDERBUFFER_HEIGHT = 0x8D43;
+ public static final int GL_RENDERBUFFER_INTERNAL_FORMAT = 0x8D44;
+ public static final int GL_RENDERBUFFER_RED_SIZE = 0x8D50;
+ public static final int GL_RENDERBUFFER_GREEN_SIZE = 0x8D51;
+ public static final int GL_RENDERBUFFER_BLUE_SIZE = 0x8D52;
+ public static final int GL_RENDERBUFFER_ALPHA_SIZE = 0x8D53;
+ public static final int GL_RENDERBUFFER_DEPTH_SIZE = 0x8D54;
+ public static final int GL_RENDERBUFFER_STENCIL_SIZE = 0x8D55;
+ public static final int GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0;
+ public static final int GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1;
+ public static final int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2;
+ public static final int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3;
+ public static final int GL_COLOR_ATTACHMENT0 = 0x8CE0;
+ public static final int GL_DEPTH_ATTACHMENT = 0x8D00;
+ public static final int GL_STENCIL_ATTACHMENT = 0x8D20;
+ public static final int GL_NONE = 0;
+ public static final int GL_FRAMEBUFFER_COMPLETE = 0x8CD5;
+ public static final int GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6;
+ public static final int GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7;
+ public static final int GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 0x8CD9;
+ public static final int GL_FRAMEBUFFER_UNSUPPORTED = 0x8CDD;
+ public static final int GL_FRAMEBUFFER_BINDING = 0x8CA6;
+ public static final int GL_RENDERBUFFER_BINDING = 0x8CA7;
+ public static final int GL_MAX_RENDERBUFFER_SIZE = 0x84E8;
+ public static final int GL_INVALID_FRAMEBUFFER_OPERATION = 0x0506;
+
+ native private static void _nativeClassInit();
+ static {
+ _nativeClassInit();
+ }
+ // C function void glActiveTexture ( GLenum texture )
+
+ public static native void glActiveTexture(
+ int texture
+ );
+
+ // C function void glAttachShader ( GLuint program, GLuint shader )
+
+ public static native void glAttachShader(
+ int program,
+ int shader
+ );
+
+ // C function void glBindAttribLocation ( GLuint program, GLuint index, const char *name )
+
+ public static native void glBindAttribLocation(
+ int program,
+ int index,
+ String name
+ );
+
+ // C function void glBindBuffer ( GLenum target, GLuint buffer )
+
+ public static native void glBindBuffer(
+ int target,
+ int buffer
+ );
+
+ // C function void glBindFramebuffer ( GLenum target, GLuint framebuffer )
+
+ public static native void glBindFramebuffer(
+ int target,
+ int framebuffer
+ );
+
+ // C function void glBindRenderbuffer ( GLenum target, GLuint renderbuffer )
+
+ public static native void glBindRenderbuffer(
+ int target,
+ int renderbuffer
+ );
+
+ // C function void glBindTexture ( GLenum target, GLuint texture )
+
+ public static native void glBindTexture(
+ int target,
+ int texture
+ );
+
+ // C function void glBlendColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
+
+ public static native void glBlendColor(
+ float red,
+ float green,
+ float blue,
+ float alpha
+ );
+
+ // C function void glBlendEquation ( GLenum mode )
+
+ public static native void glBlendEquation(
+ int mode
+ );
+
+ // C function void glBlendEquationSeparate ( GLenum modeRGB, GLenum modeAlpha )
+
+ public static native void glBlendEquationSeparate(
+ int modeRGB,
+ int modeAlpha
+ );
+
+ // C function void glBlendFunc ( GLenum sfactor, GLenum dfactor )
+
+ public static native void glBlendFunc(
+ int sfactor,
+ int dfactor
+ );
+
+ // C function void glBlendFuncSeparate ( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha )
+
+ public static native void glBlendFuncSeparate(
+ int srcRGB,
+ int dstRGB,
+ int srcAlpha,
+ int dstAlpha
+ );
+
+ // C function void glBufferData ( GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage )
+
+ public static native void glBufferData(
+ int target,
+ int size,
+ java.nio.Buffer data,
+ int usage
+ );
+
+ // C function void glBufferSubData ( GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data )
+
+ public static native void glBufferSubData(
+ int target,
+ int offset,
+ int size,
+ java.nio.Buffer data
+ );
+
+ // C function GLenum glCheckFramebufferStatus ( GLenum target )
+
+ public static native int glCheckFramebufferStatus(
+ int target
+ );
+
+ // C function void glClear ( GLbitfield mask )
+
+ public static native void glClear(
+ int mask
+ );
+
+ // C function void glClearColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
+
+ public static native void glClearColor(
+ float red,
+ float green,
+ float blue,
+ float alpha
+ );
+
+ // C function void glClearDepthf ( GLclampf depth )
+
+ public static native void glClearDepthf(
+ float depth
+ );
+
+ // C function void glClearStencil ( GLint s )
+
+ public static native void glClearStencil(
+ int s
+ );
+
+ // C function void glColorMask ( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
+
+ public static native void glColorMask(
+ boolean red,
+ boolean green,
+ boolean blue,
+ boolean alpha
+ );
+
+ // C function void glCompileShader ( GLuint shader )
+
+ public static native void glCompileShader(
+ int shader
+ );
+
+ // C function void glCompressedTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data )
+
+ public static native void glCompressedTexImage2D(
+ int target,
+ int level,
+ int internalformat,
+ int width,
+ int height,
+ int border,
+ int imageSize,
+ java.nio.Buffer data
+ );
+
+ // C function void glCompressedTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data )
+
+ public static native void glCompressedTexSubImage2D(
+ int target,
+ int level,
+ int xoffset,
+ int yoffset,
+ int width,
+ int height,
+ int format,
+ int imageSize,
+ java.nio.Buffer data
+ );
+
+ // C function void glCopyTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
+
+ public static native void glCopyTexImage2D(
+ int target,
+ int level,
+ int internalformat,
+ int x,
+ int y,
+ int width,
+ int height,
+ int border
+ );
+
+ // C function void glCopyTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
+
+ public static native void glCopyTexSubImage2D(
+ int target,
+ int level,
+ int xoffset,
+ int yoffset,
+ int x,
+ int y,
+ int width,
+ int height
+ );
+
+ // C function GLuint glCreateProgram ( void )
+
+ public static native int glCreateProgram(
+ );
+
+ // C function GLuint glCreateShader ( GLenum type )
+
+ public static native int glCreateShader(
+ int type
+ );
+
+ // C function void glCullFace ( GLenum mode )
+
+ public static native void glCullFace(
+ int mode
+ );
+
+ // C function void glDeleteBuffers ( GLsizei n, const GLuint *buffers )
+
+ public static native void glDeleteBuffers(
+ int n,
+ int[] buffers,
+ int offset
+ );
+
+ // C function void glDeleteBuffers ( GLsizei n, const GLuint *buffers )
+
+ public static native void glDeleteBuffers(
+ int n,
+ java.nio.IntBuffer buffers
+ );
+
+ // C function void glDeleteFramebuffers ( GLsizei n, const GLuint *framebuffers )
+
+ public static native void glDeleteFramebuffers(
+ int n,
+ int[] framebuffers,
+ int offset
+ );
+
+ // C function void glDeleteFramebuffers ( GLsizei n, const GLuint *framebuffers )
+
+ public static native void glDeleteFramebuffers(
+ int n,
+ java.nio.IntBuffer framebuffers
+ );
+
+ // C function void glDeleteProgram ( GLuint program )
+
+ public static native void glDeleteProgram(
+ int program
+ );
+
+ // C function void glDeleteRenderbuffers ( GLsizei n, const GLuint *renderbuffers )
+
+ public static native void glDeleteRenderbuffers(
+ int n,
+ int[] renderbuffers,
+ int offset
+ );
+
+ // C function void glDeleteRenderbuffers ( GLsizei n, const GLuint *renderbuffers )
+
+ public static native void glDeleteRenderbuffers(
+ int n,
+ java.nio.IntBuffer renderbuffers
+ );
+
+ // C function void glDeleteShader ( GLuint shader )
+
+ public static native void glDeleteShader(
+ int shader
+ );
+
+ // C function void glDeleteTextures ( GLsizei n, const GLuint *textures )
+
+ public static native void glDeleteTextures(
+ int n,
+ int[] textures,
+ int offset
+ );
+
+ // C function void glDeleteTextures ( GLsizei n, const GLuint *textures )
+
+ public static native void glDeleteTextures(
+ int n,
+ java.nio.IntBuffer textures
+ );
+
+ // C function void glDepthFunc ( GLenum func )
+
+ public static native void glDepthFunc(
+ int func
+ );
+
+ // C function void glDepthMask ( GLboolean flag )
+
+ public static native void glDepthMask(
+ boolean flag
+ );
+
+ // C function void glDepthRangef ( GLclampf zNear, GLclampf zFar )
+
+ public static native void glDepthRangef(
+ float zNear,
+ float zFar
+ );
+
+ // C function void glDetachShader ( GLuint program, GLuint shader )
+
+ public static native void glDetachShader(
+ int program,
+ int shader
+ );
+
+ // C function void glDisable ( GLenum cap )
+
+ public static native void glDisable(
+ int cap
+ );
+
+ // C function void glDisableVertexAttribArray ( GLuint index )
+
+ public static native void glDisableVertexAttribArray(
+ int index
+ );
+
+ // C function void glDrawArrays ( GLenum mode, GLint first, GLsizei count )
+
+ public static native void glDrawArrays(
+ int mode,
+ int first,
+ int count
+ );
+
+ // C function void glDrawElements ( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices )
+
+ public static native void glDrawElements(
+ int mode,
+ int count,
+ int type,
+ java.nio.Buffer indices
+ );
+
+ // C function void glEnable ( GLenum cap )
+
+ public static native void glEnable(
+ int cap
+ );
+
+ // C function void glEnableVertexAttribArray ( GLuint index )
+
+ public static native void glEnableVertexAttribArray(
+ int index
+ );
+
+ // C function void glFinish ( void )
+
+ public static native void glFinish(
+ );
+
+ // C function void glFlush ( void )
+
+ public static native void glFlush(
+ );
+
+ // C function void glFramebufferRenderbuffer ( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer )
+
+ public static native void glFramebufferRenderbuffer(
+ int target,
+ int attachment,
+ int renderbuffertarget,
+ int renderbuffer
+ );
+
+ // C function void glFramebufferTexture2D ( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
+
+ public static native void glFramebufferTexture2D(
+ int target,
+ int attachment,
+ int textarget,
+ int texture,
+ int level
+ );
+
+ // C function void glFrontFace ( GLenum mode )
+
+ public static native void glFrontFace(
+ int mode
+ );
+
+ // C function void glGenBuffers ( GLsizei n, GLuint *buffers )
+
+ public static native void glGenBuffers(
+ int n,
+ int[] buffers,
+ int offset
+ );
+
+ // C function void glGenBuffers ( GLsizei n, GLuint *buffers )
+
+ public static native void glGenBuffers(
+ int n,
+ java.nio.IntBuffer buffers
+ );
+
+ // C function void glGenerateMipmap ( GLenum target )
+
+ public static native void glGenerateMipmap(
+ int target
+ );
+
+ // C function void glGenFramebuffers ( GLsizei n, GLuint *framebuffers )
+
+ public static native void glGenFramebuffers(
+ int n,
+ int[] framebuffers,
+ int offset
+ );
+
+ // C function void glGenFramebuffers ( GLsizei n, GLuint *framebuffers )
+
+ public static native void glGenFramebuffers(
+ int n,
+ java.nio.IntBuffer framebuffers
+ );
+
+ // C function void glGenRenderbuffers ( GLsizei n, GLuint *renderbuffers )
+
+ public static native void glGenRenderbuffers(
+ int n,
+ int[] renderbuffers,
+ int offset
+ );
+
+ // C function void glGenRenderbuffers ( GLsizei n, GLuint *renderbuffers )
+
+ public static native void glGenRenderbuffers(
+ int n,
+ java.nio.IntBuffer renderbuffers
+ );
+
+ // C function void glGenTextures ( GLsizei n, GLuint *textures )
+
+ public static native void glGenTextures(
+ int n,
+ int[] textures,
+ int offset
+ );
+
+ // C function void glGenTextures ( GLsizei n, GLuint *textures )
+
+ public static native void glGenTextures(
+ int n,
+ java.nio.IntBuffer textures
+ );
+
+ // C function void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name )
+
+ public static native void glGetActiveAttrib(
+ int program,
+ int index,
+ int bufsize,
+ int[] length,
+ int lengthOffset,
+ int[] size,
+ int sizeOffset,
+ int[] type,
+ int typeOffset,
+ byte[] name,
+ int nameOffset
+ );
+
+ // C function void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name )
+
+ public static native void glGetActiveAttrib(
+ int program,
+ int index,
+ int bufsize,
+ java.nio.IntBuffer length,
+ java.nio.IntBuffer size,
+ java.nio.IntBuffer type,
+ byte name
+ );
+
+ // C function void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name )
+
+ public static native void glGetActiveUniform(
+ int program,
+ int index,
+ int bufsize,
+ int[] length,
+ int lengthOffset,
+ int[] size,
+ int sizeOffset,
+ int[] type,
+ int typeOffset,
+ byte[] name,
+ int nameOffset
+ );
+
+ // C function void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name )
+
+ public static native void glGetActiveUniform(
+ int program,
+ int index,
+ int bufsize,
+ java.nio.IntBuffer length,
+ java.nio.IntBuffer size,
+ java.nio.IntBuffer type,
+ byte name
+ );
+
+ // C function void glGetAttachedShaders ( GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders )
+
+ public static native void glGetAttachedShaders(
+ int program,
+ int maxcount,
+ int[] count,
+ int countOffset,
+ int[] shaders,
+ int shadersOffset
+ );
+
+ // C function void glGetAttachedShaders ( GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders )
+
+ public static native void glGetAttachedShaders(
+ int program,
+ int maxcount,
+ java.nio.IntBuffer count,
+ java.nio.IntBuffer shaders
+ );
+
+ // C function int glGetAttribLocation ( GLuint program, const char *name )
+
+ public static native int glGetAttribLocation(
+ int program,
+ String name
+ );
+
+ // C function void glGetBooleanv ( GLenum pname, GLboolean *params )
+
+ public static native void glGetBooleanv(
+ int pname,
+ boolean[] params,
+ int offset
+ );
+
+ // C function void glGetBooleanv ( GLenum pname, GLboolean *params )
+
+ public static native void glGetBooleanv(
+ int pname,
+ java.nio.IntBuffer params
+ );
+
+ // C function void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params )
+
+ public static native void glGetBufferParameteriv(
+ int target,
+ int pname,
+ int[] params,
+ int offset
+ );
+
+ // C function void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params )
+
+ public static native void glGetBufferParameteriv(
+ int target,
+ int pname,
+ java.nio.IntBuffer params
+ );
+
+ // C function GLenum glGetError ( void )
+
+ public static native int glGetError(
+ );
+
+ // C function void glGetFloatv ( GLenum pname, GLfloat *params )
+
+ public static native void glGetFloatv(
+ int pname,
+ float[] params,
+ int offset
+ );
+
+ // C function void glGetFloatv ( GLenum pname, GLfloat *params )
+
+ public static native void glGetFloatv(
+ int pname,
+ java.nio.FloatBuffer params
+ );
+
+ // C function void glGetFramebufferAttachmentParameteriv ( GLenum target, GLenum attachment, GLenum pname, GLint *params )
+
+ public static native void glGetFramebufferAttachmentParameteriv(
+ int target,
+ int attachment,
+ int pname,
+ int[] params,
+ int offset
+ );
+
+ // C function void glGetFramebufferAttachmentParameteriv ( GLenum target, GLenum attachment, GLenum pname, GLint *params )
+
+ public static native void glGetFramebufferAttachmentParameteriv(
+ int target,
+ int attachment,
+ int pname,
+ java.nio.IntBuffer params
+ );
+
+ // C function void glGetIntegerv ( GLenum pname, GLint *params )
+
+ public static native void glGetIntegerv(
+ int pname,
+ int[] params,
+ int offset
+ );
+
+ // C function void glGetIntegerv ( GLenum pname, GLint *params )
+
+ public static native void glGetIntegerv(
+ int pname,
+ java.nio.IntBuffer params
+ );
+
+ // C function void glGetProgramiv ( GLuint program, GLenum pname, GLint *params )
+
+ public static native void glGetProgramiv(
+ int program,
+ int pname,
+ int[] params,
+ int offset
+ );
+
+ // C function void glGetProgramiv ( GLuint program, GLenum pname, GLint *params )
+
+ public static native void glGetProgramiv(
+ int program,
+ int pname,
+ java.nio.IntBuffer params
+ );
+
+ // C function void glGetProgramInfoLog( GLuint program, GLsizei maxLength, GLsizei * length,
+ // GLchar * infoLog);
+
+ public static native String glGetProgramInfoLog(
+ int program
+ );
+ // C function void glGetRenderbufferParameteriv ( GLenum target, GLenum pname, GLint *params )
+
+ public static native void glGetRenderbufferParameteriv(
+ int target,
+ int pname,
+ int[] params,
+ int offset
+ );
+
+ // C function void glGetRenderbufferParameteriv ( GLenum target, GLenum pname, GLint *params )
+
+ public static native void glGetRenderbufferParameteriv(
+ int target,
+ int pname,
+ java.nio.IntBuffer params
+ );
+
+ // C function void glGetShaderiv ( GLuint shader, GLenum pname, GLint *params )
+
+ public static native void glGetShaderiv(
+ int shader,
+ int pname,
+ int[] params,
+ int offset
+ );
+
+ // C function void glGetShaderiv ( GLuint shader, GLenum pname, GLint *params )
+
+ public static native void glGetShaderiv(
+ int shader,
+ int pname,
+ java.nio.IntBuffer params
+ );
+
+ // C function void glGetShaderInfoLog( GLuint shader, GLsizei maxLength, GLsizei * length,
+ // GLchar * infoLog);
+
+ public static native String glGetShaderInfoLog(
+ int shader
+ );
+ // C function void glGetShaderPrecisionFormat ( GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision )
+
+ public static native void glGetShaderPrecisionFormat(
+ int shadertype,
+ int precisiontype,
+ int[] range,
+ int rangeOffset,
+ int[] precision,
+ int precisionOffset
+ );
+
+ // C function void glGetShaderPrecisionFormat ( GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision )
+
+ public static native void glGetShaderPrecisionFormat(
+ int shadertype,
+ int precisiontype,
+ java.nio.IntBuffer range,
+ java.nio.IntBuffer precision
+ );
+
+ // C function void glGetShaderSource ( GLuint shader, GLsizei bufsize, GLsizei *length, char *source )
+
+ public static native void glGetShaderSource(
+ int shader,
+ int bufsize,
+ int[] length,
+ int lengthOffset,
+ byte[] source,
+ int sourceOffset
+ );
+
+ // C function void glGetShaderSource ( GLuint shader, GLsizei bufsize, GLsizei *length, char *source )
+
+ public static native void glGetShaderSource(
+ int shader,
+ int bufsize,
+ java.nio.IntBuffer length,
+ byte source
+ );
+
+ // C function const GLubyte * glGetString ( GLenum name )
+
+ public static native String glGetString(
+ int name
+ );
+ // C function void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params )
+
+ public static native void glGetTexParameterfv(
+ int target,
+ int pname,
+ float[] params,
+ int offset
+ );
+
+ // C function void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params )
+
+ public static native void glGetTexParameterfv(
+ int target,
+ int pname,
+ java.nio.FloatBuffer params
+ );
+
+ // C function void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params )
+
+ public static native void glGetTexParameteriv(
+ int target,
+ int pname,
+ int[] params,
+ int offset
+ );
+
+ // C function void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params )
+
+ public static native void glGetTexParameteriv(
+ int target,
+ int pname,
+ java.nio.IntBuffer params
+ );
+
+ // C function void glGetUniformfv ( GLuint program, GLint location, GLfloat *params )
+
+ public static native void glGetUniformfv(
+ int program,
+ int location,
+ float[] params,
+ int offset
+ );
+
+ // C function void glGetUniformfv ( GLuint program, GLint location, GLfloat *params )
+
+ public static native void glGetUniformfv(
+ int program,
+ int location,
+ java.nio.FloatBuffer params
+ );
+
+ // C function void glGetUniformiv ( GLuint program, GLint location, GLint *params )
+
+ public static native void glGetUniformiv(
+ int program,
+ int location,
+ int[] params,
+ int offset
+ );
+
+ // C function void glGetUniformiv ( GLuint program, GLint location, GLint *params )
+
+ public static native void glGetUniformiv(
+ int program,
+ int location,
+ java.nio.IntBuffer params
+ );
+
+ // C function int glGetUniformLocation ( GLuint program, const char *name )
+
+ public static native int glGetUniformLocation(
+ int program,
+ String name
+ );
+
+ // C function void glGetVertexAttribfv ( GLuint index, GLenum pname, GLfloat *params )
+
+ public static native void glGetVertexAttribfv(
+ int index,
+ int pname,
+ float[] params,
+ int offset
+ );
+
+ // C function void glGetVertexAttribfv ( GLuint index, GLenum pname, GLfloat *params )
+
+ public static native void glGetVertexAttribfv(
+ int index,
+ int pname,
+ java.nio.FloatBuffer params
+ );
+
+ // C function void glGetVertexAttribiv ( GLuint index, GLenum pname, GLint *params )
+
+ public static native void glGetVertexAttribiv(
+ int index,
+ int pname,
+ int[] params,
+ int offset
+ );
+
+ // C function void glGetVertexAttribiv ( GLuint index, GLenum pname, GLint *params )
+
+ public static native void glGetVertexAttribiv(
+ int index,
+ int pname,
+ java.nio.IntBuffer params
+ );
+
+ // C function void glHint ( GLenum target, GLenum mode )
+
+ public static native void glHint(
+ int target,
+ int mode
+ );
+
+ // C function GLboolean glIsBuffer ( GLuint buffer )
+
+ public static native boolean glIsBuffer(
+ int buffer
+ );
+
+ // C function GLboolean glIsEnabled ( GLenum cap )
+
+ public static native boolean glIsEnabled(
+ int cap
+ );
+
+ // C function GLboolean glIsFramebuffer ( GLuint framebuffer )
+
+ public static native boolean glIsFramebuffer(
+ int framebuffer
+ );
+
+ // C function GLboolean glIsProgram ( GLuint program )
+
+ public static native boolean glIsProgram(
+ int program
+ );
+
+ // C function GLboolean glIsRenderbuffer ( GLuint renderbuffer )
+
+ public static native boolean glIsRenderbuffer(
+ int renderbuffer
+ );
+
+ // C function GLboolean glIsShader ( GLuint shader )
+
+ public static native boolean glIsShader(
+ int shader
+ );
+
+ // C function GLboolean glIsTexture ( GLuint texture )
+
+ public static native boolean glIsTexture(
+ int texture
+ );
+
+ // C function void glLineWidth ( GLfloat width )
+
+ public static native void glLineWidth(
+ float width
+ );
+
+ // C function void glLinkProgram ( GLuint program )
+
+ public static native void glLinkProgram(
+ int program
+ );
+
+ // C function void glPixelStorei ( GLenum pname, GLint param )
+
+ public static native void glPixelStorei(
+ int pname,
+ int param
+ );
+
+ // C function void glPolygonOffset ( GLfloat factor, GLfloat units )
+
+ public static native void glPolygonOffset(
+ float factor,
+ float units
+ );
+
+ // C function void glReadPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels )
+
+ public static native void glReadPixels(
+ int x,
+ int y,
+ int width,
+ int height,
+ int format,
+ int type,
+ java.nio.Buffer pixels
+ );
+
+ // C function void glReleaseShaderCompiler ( void )
+
+ public static native void glReleaseShaderCompiler(
+ );
+
+ // C function void glRenderbufferStorage ( GLenum target, GLenum internalformat, GLsizei width, GLsizei height )
+
+ public static native void glRenderbufferStorage(
+ int target,
+ int internalformat,
+ int width,
+ int height
+ );
+
+ // C function void glSampleCoverage ( GLclampf value, GLboolean invert )
+
+ public static native void glSampleCoverage(
+ float value,
+ boolean invert
+ );
+
+ // C function void glScissor ( GLint x, GLint y, GLsizei width, GLsizei height )
+
+ public static native void glScissor(
+ int x,
+ int y,
+ int width,
+ int height
+ );
+
+ // C function void glShaderBinary ( GLsizei n, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length )
+
+ public static native void glShaderBinary(
+ int n,
+ int[] shaders,
+ int offset,
+ int binaryformat,
+ java.nio.Buffer binary,
+ int length
+ );
+
+ // C function void glShaderBinary ( GLsizei n, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length )
+
+ public static native void glShaderBinary(
+ int n,
+ java.nio.IntBuffer shaders,
+ int binaryformat,
+ java.nio.Buffer binary,
+ int length
+ );
+
+ // C function void glShaderSource ( GLuint shader, GLsizei count, const GLchar ** string, const GLint* length )
+
+ public static native void glShaderSource(
+ int shader,
+ String string
+ );
+ // C function void glStencilFunc ( GLenum func, GLint ref, GLuint mask )
+
+ public static native void glStencilFunc(
+ int func,
+ int ref,
+ int mask
+ );
+
+ // C function void glStencilFuncSeparate ( GLenum face, GLenum func, GLint ref, GLuint mask )
+
+ public static native void glStencilFuncSeparate(
+ int face,
+ int func,
+ int ref,
+ int mask
+ );
+
+ // C function void glStencilMask ( GLuint mask )
+
+ public static native void glStencilMask(
+ int mask
+ );
+
+ // C function void glStencilMaskSeparate ( GLenum face, GLuint mask )
+
+ public static native void glStencilMaskSeparate(
+ int face,
+ int mask
+ );
+
+ // C function void glStencilOp ( GLenum fail, GLenum zfail, GLenum zpass )
+
+ public static native void glStencilOp(
+ int fail,
+ int zfail,
+ int zpass
+ );
+
+ // C function void glStencilOpSeparate ( GLenum face, GLenum fail, GLenum zfail, GLenum zpass )
+
+ public static native void glStencilOpSeparate(
+ int face,
+ int fail,
+ int zfail,
+ int zpass
+ );
+
+ // C function void glTexImage2D ( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
+
+ public static native void glTexImage2D(
+ int target,
+ int level,
+ int internalformat,
+ int width,
+ int height,
+ int border,
+ int format,
+ int type,
+ java.nio.Buffer pixels
+ );
+
+ // C function void glTexParameterf ( GLenum target, GLenum pname, GLfloat param )
+
+ public static native void glTexParameterf(
+ int target,
+ int pname,
+ float param
+ );
+
+ // C function void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params )
+
+ public static native void glTexParameterfv(
+ int target,
+ int pname,
+ float[] params,
+ int offset
+ );
+
+ // C function void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params )
+
+ public static native void glTexParameterfv(
+ int target,
+ int pname,
+ java.nio.FloatBuffer params
+ );
+
+ // C function void glTexParameteri ( GLenum target, GLenum pname, GLint param )
+
+ public static native void glTexParameteri(
+ int target,
+ int pname,
+ int param
+ );
+
+ // C function void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params )
+
+ public static native void glTexParameteriv(
+ int target,
+ int pname,
+ int[] params,
+ int offset
+ );
+
+ // C function void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params )
+
+ public static native void glTexParameteriv(
+ int target,
+ int pname,
+ java.nio.IntBuffer params
+ );
+
+ // C function void glTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels )
+
+ public static native void glTexSubImage2D(
+ int target,
+ int level,
+ int xoffset,
+ int yoffset,
+ int width,
+ int height,
+ int format,
+ int type,
+ java.nio.Buffer pixels
+ );
+
+ // C function void glUniform1f ( GLint location, GLfloat x )
+
+ public static native void glUniform1f(
+ int location,
+ float x
+ );
+
+ // C function void glUniform1fv ( GLint location, GLsizei count, const GLfloat *v )
+
+ public static native void glUniform1fv(
+ int location,
+ int count,
+ float[] v,
+ int offset
+ );
+
+ // C function void glUniform1fv ( GLint location, GLsizei count, const GLfloat *v )
+
+ public static native void glUniform1fv(
+ int location,
+ int count,
+ java.nio.FloatBuffer v
+ );
+
+ // C function void glUniform1i ( GLint location, GLint x )
+
+ public static native void glUniform1i(
+ int location,
+ int x
+ );
+
+ // C function void glUniform1iv ( GLint location, GLsizei count, const GLint *v )
+
+ public static native void glUniform1iv(
+ int location,
+ int count,
+ int[] v,
+ int offset
+ );
+
+ // C function void glUniform1iv ( GLint location, GLsizei count, const GLint *v )
+
+ public static native void glUniform1iv(
+ int location,
+ int count,
+ java.nio.IntBuffer v
+ );
+
+ // C function void glUniform2f ( GLint location, GLfloat x, GLfloat y )
+
+ public static native void glUniform2f(
+ int location,
+ float x,
+ float y
+ );
+
+ // C function void glUniform2fv ( GLint location, GLsizei count, const GLfloat *v )
+
+ public static native void glUniform2fv(
+ int location,
+ int count,
+ float[] v,
+ int offset
+ );
+
+ // C function void glUniform2fv ( GLint location, GLsizei count, const GLfloat *v )
+
+ public static native void glUniform2fv(
+ int location,
+ int count,
+ java.nio.FloatBuffer v
+ );
+
+ // C function void glUniform2i ( GLint location, GLint x, GLint y )
+
+ public static native void glUniform2i(
+ int location,
+ int x,
+ int y
+ );
+
+ // C function void glUniform2iv ( GLint location, GLsizei count, const GLint *v )
+
+ public static native void glUniform2iv(
+ int location,
+ int count,
+ int[] v,
+ int offset
+ );
+
+ // C function void glUniform2iv ( GLint location, GLsizei count, const GLint *v )
+
+ public static native void glUniform2iv(
+ int location,
+ int count,
+ java.nio.IntBuffer v
+ );
+
+ // C function void glUniform3f ( GLint location, GLfloat x, GLfloat y, GLfloat z )
+
+ public static native void glUniform3f(
+ int location,
+ float x,
+ float y,
+ float z
+ );
+
+ // C function void glUniform3fv ( GLint location, GLsizei count, const GLfloat *v )
+
+ public static native void glUniform3fv(
+ int location,
+ int count,
+ float[] v,
+ int offset
+ );
+
+ // C function void glUniform3fv ( GLint location, GLsizei count, const GLfloat *v )
+
+ public static native void glUniform3fv(
+ int location,
+ int count,
+ java.nio.FloatBuffer v
+ );
+
+ // C function void glUniform3i ( GLint location, GLint x, GLint y, GLint z )
+
+ public static native void glUniform3i(
+ int location,
+ int x,
+ int y,
+ int z
+ );
+
+ // C function void glUniform3iv ( GLint location, GLsizei count, const GLint *v )
+
+ public static native void glUniform3iv(
+ int location,
+ int count,
+ int[] v,
+ int offset
+ );
+
+ // C function void glUniform3iv ( GLint location, GLsizei count, const GLint *v )
+
+ public static native void glUniform3iv(
+ int location,
+ int count,
+ java.nio.IntBuffer v
+ );
+
+ // C function void glUniform4f ( GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+
+ public static native void glUniform4f(
+ int location,
+ float x,
+ float y,
+ float z,
+ float w
+ );
+
+ // C function void glUniform4fv ( GLint location, GLsizei count, const GLfloat *v )
+
+ public static native void glUniform4fv(
+ int location,
+ int count,
+ float[] v,
+ int offset
+ );
+
+ // C function void glUniform4fv ( GLint location, GLsizei count, const GLfloat *v )
+
+ public static native void glUniform4fv(
+ int location,
+ int count,
+ java.nio.FloatBuffer v
+ );
+
+ // C function void glUniform4i ( GLint location, GLint x, GLint y, GLint z, GLint w )
+
+ public static native void glUniform4i(
+ int location,
+ int x,
+ int y,
+ int z,
+ int w
+ );
+
+ // C function void glUniform4iv ( GLint location, GLsizei count, const GLint *v )
+
+ public static native void glUniform4iv(
+ int location,
+ int count,
+ int[] v,
+ int offset
+ );
+
+ // C function void glUniform4iv ( GLint location, GLsizei count, const GLint *v )
+
+ public static native void glUniform4iv(
+ int location,
+ int count,
+ java.nio.IntBuffer v
+ );
+
+ // C function void glUniformMatrix2fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+
+ public static native void glUniformMatrix2fv(
+ int location,
+ int count,
+ boolean transpose,
+ float[] value,
+ int offset
+ );
+
+ // C function void glUniformMatrix2fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+
+ public static native void glUniformMatrix2fv(
+ int location,
+ int count,
+ boolean transpose,
+ java.nio.FloatBuffer value
+ );
+
+ // C function void glUniformMatrix3fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+
+ public static native void glUniformMatrix3fv(
+ int location,
+ int count,
+ boolean transpose,
+ float[] value,
+ int offset
+ );
+
+ // C function void glUniformMatrix3fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+
+ public static native void glUniformMatrix3fv(
+ int location,
+ int count,
+ boolean transpose,
+ java.nio.FloatBuffer value
+ );
+
+ // C function void glUniformMatrix4fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+
+ public static native void glUniformMatrix4fv(
+ int location,
+ int count,
+ boolean transpose,
+ float[] value,
+ int offset
+ );
+
+ // C function void glUniformMatrix4fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+
+ public static native void glUniformMatrix4fv(
+ int location,
+ int count,
+ boolean transpose,
+ java.nio.FloatBuffer value
+ );
+
+ // C function void glUseProgram ( GLuint program )
+
+ public static native void glUseProgram(
+ int program
+ );
+
+ // C function void glValidateProgram ( GLuint program )
+
+ public static native void glValidateProgram(
+ int program
+ );
+
+ // C function void glVertexAttrib1f ( GLuint indx, GLfloat x )
+
+ public static native void glVertexAttrib1f(
+ int indx,
+ float x
+ );
+
+ // C function void glVertexAttrib1fv ( GLuint indx, const GLfloat *values )
+
+ public static native void glVertexAttrib1fv(
+ int indx,
+ float[] values,
+ int offset
+ );
+
+ // C function void glVertexAttrib1fv ( GLuint indx, const GLfloat *values )
+
+ public static native void glVertexAttrib1fv(
+ int indx,
+ java.nio.FloatBuffer values
+ );
+
+ // C function void glVertexAttrib2f ( GLuint indx, GLfloat x, GLfloat y )
+
+ public static native void glVertexAttrib2f(
+ int indx,
+ float x,
+ float y
+ );
+
+ // C function void glVertexAttrib2fv ( GLuint indx, const GLfloat *values )
+
+ public static native void glVertexAttrib2fv(
+ int indx,
+ float[] values,
+ int offset
+ );
+
+ // C function void glVertexAttrib2fv ( GLuint indx, const GLfloat *values )
+
+ public static native void glVertexAttrib2fv(
+ int indx,
+ java.nio.FloatBuffer values
+ );
+
+ // C function void glVertexAttrib3f ( GLuint indx, GLfloat x, GLfloat y, GLfloat z )
+
+ public static native void glVertexAttrib3f(
+ int indx,
+ float x,
+ float y,
+ float z
+ );
+
+ // C function void glVertexAttrib3fv ( GLuint indx, const GLfloat *values )
+
+ public static native void glVertexAttrib3fv(
+ int indx,
+ float[] values,
+ int offset
+ );
+
+ // C function void glVertexAttrib3fv ( GLuint indx, const GLfloat *values )
+
+ public static native void glVertexAttrib3fv(
+ int indx,
+ java.nio.FloatBuffer values
+ );
+
+ // C function void glVertexAttrib4f ( GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+
+ public static native void glVertexAttrib4f(
+ int indx,
+ float x,
+ float y,
+ float z,
+ float w
+ );
+
+ // C function void glVertexAttrib4fv ( GLuint indx, const GLfloat *values )
+
+ public static native void glVertexAttrib4fv(
+ int indx,
+ float[] values,
+ int offset
+ );
+
+ // C function void glVertexAttrib4fv ( GLuint indx, const GLfloat *values )
+
+ public static native void glVertexAttrib4fv(
+ int indx,
+ java.nio.FloatBuffer values
+ );
+
+ // C function void glVertexAttribPointer ( GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *ptr )
+
+ private static native void glVertexAttribPointerBounds(
+ int indx,
+ int size,
+ int type,
+ boolean normalized,
+ int stride,
+ java.nio.Buffer ptr,
+ int remaining
+ );
+
+ public static void glVertexAttribPointer(
+ int indx,
+ int size,
+ int type,
+ boolean normalized,
+ int stride,
+ java.nio.Buffer ptr
+ ) {
+ glVertexAttribPointerBounds(
+ indx,
+ size,
+ type,
+ normalized,
+ stride,
+ ptr,
+ ptr.remaining()
+ );
+ }
+
+ // C function void glViewport ( GLint x, GLint y, GLsizei width, GLsizei height )
+
+ public static native void glViewport(
+ int x,
+ int y,
+ int width,
+ int height
+ );
+
+}
diff --git a/opengl/tests/gl2_java/Android.mk b/opengl/tests/gl2_java/Android.mk
new file mode 100644
index 0000000..34f4aee
--- /dev/null
+++ b/opengl/tests/gl2_java/Android.mk
@@ -0,0 +1,18 @@
+#########################################################################
+# OpenGL ES 2.0 Java sample
+#########################################################################
+
+TOP_LOCAL_PATH:= $(call my-dir)
+
+# Build activity
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := $(call all-subdir-java-files)
+
+LOCAL_PACKAGE_NAME := GL2Java
+
+include $(BUILD_PACKAGE)
diff --git a/opengl/tests/gl2_java/AndroidManifest.xml b/opengl/tests/gl2_java/AndroidManifest.xml
new file mode 100644
index 0000000..d666e6c
--- /dev/null
+++ b/opengl/tests/gl2_java/AndroidManifest.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+**
+** Copyright 2009, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+-->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.android.gl2java">
+ <application
+ android:label="@string/gl2java_activity">
+ <activity android:name="GL2JavaActivity"
+ android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
+ android:launchMode="singleTask"
+ android:configChanges="orientation|keyboardHidden">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+ </application>
+</manifest>
diff --git a/opengl/tests/gl2_java/res/values/strings.xml b/opengl/tests/gl2_java/res/values/strings.xml
new file mode 100644
index 0000000..d718b1d
--- /dev/null
+++ b/opengl/tests/gl2_java/res/values/strings.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+-->
+
+<!-- This file contains resource definitions for displayed strings, allowing
+ them to be changed based on the locale and options. -->
+
+<resources>
+ <!-- Simple strings. -->
+ <string name="gl2java_activity">GL2Java</string>
+
+</resources>
+
diff --git a/opengl/tests/gl2_java/src/com/android/gl2java/GL2JavaActivity.java b/opengl/tests/gl2_java/src/com/android/gl2java/GL2JavaActivity.java
new file mode 100644
index 0000000..37654fb
--- /dev/null
+++ b/opengl/tests/gl2_java/src/com/android/gl2java/GL2JavaActivity.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.gl2java;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.WindowManager;
+
+import java.io.File;
+
+
+public class GL2JavaActivity extends Activity {
+
+ GL2JavaView mView;
+
+ @Override protected void onCreate(Bundle icicle) {
+ super.onCreate(icicle);
+ mView = new GL2JavaView(getApplication());
+ setContentView(mView);
+ }
+
+ @Override protected void onPause() {
+ super.onPause();
+ mView.onPause();
+ }
+
+ @Override protected void onResume() {
+ super.onResume();
+ mView.onResume();
+ }
+}
diff --git a/opengl/tests/gl2_java/src/com/android/gl2java/GL2JavaView.java b/opengl/tests/gl2_java/src/com/android/gl2java/GL2JavaView.java
new file mode 100644
index 0000000..0fb7a81
--- /dev/null
+++ b/opengl/tests/gl2_java/src/com/android/gl2java/GL2JavaView.java
@@ -0,0 +1,386 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.gl2java;
+
+import android.content.Context;
+import android.opengl.GLSurfaceView;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+
+import javax.microedition.khronos.egl.EGL10;
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.egl.EGLContext;
+import javax.microedition.khronos.egl.EGLDisplay;
+import javax.microedition.khronos.opengles.GL10;
+
+import android.opengl.GLES20;
+
+/**
+ * An implementation of SurfaceView that uses the dedicated surface for
+ * displaying an OpenGL animation. This allows the animation to run in a
+ * separate thread, without requiring that it be driven by the update mechanism
+ * of the view hierarchy.
+ *
+ * The application-specific rendering code is delegated to a GLView.Renderer
+ * instance.
+ */
+class GL2JavaView extends GLSurfaceView {
+ private static String TAG = "GL2JavaView";
+
+ public GL2JavaView(Context context) {
+ super(context);
+ init(false, 0, 0);
+ }
+
+ public GL2JavaView(Context context, boolean translucent, int depth, int stencil) {
+ super(context);
+ init(translucent, depth, stencil);
+ }
+
+ private void init(boolean translucent, int depth, int stencil) {
+ setEGLContextFactory(new ContextFactory());
+ setEGLConfigChooser( translucent ?
+ new ConfigChooser(8,8,8,8, depth, stencil) :
+ new ConfigChooser(5,6,5,0, depth, stencil));
+ setRenderer(new Renderer());
+ }
+
+ private static class ContextFactory implements GLSurfaceView.EGLContextFactory {
+ private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
+ public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig) {
+ Log.w(TAG, "creating OpenGL ES 2.0 context");
+ checkEglError("Before eglCreateContext", egl);
+ int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };
+ EGLContext context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
+ checkEglError("After eglCreateContext", egl);
+ return context;
+ }
+
+ public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context) {
+ egl.eglDestroyContext(display, context);
+ }
+ }
+
+ private static void checkEglError(String prompt, EGL10 egl) {
+ int error;
+ while ((error = egl.eglGetError()) != EGL10.EGL_SUCCESS) {
+ Log.e(TAG, String.format("%s: EGL error: 0x%x", prompt, error));
+ }
+ }
+
+ private static class ConfigChooser implements GLSurfaceView.EGLConfigChooser {
+ private static int EGL_OPENGL_ES2_BIT = 4;
+ private static int[] s_configAttribs2 =
+ {
+ EGL10.EGL_RED_SIZE, 4,
+ EGL10.EGL_GREEN_SIZE, 4,
+ EGL10.EGL_BLUE_SIZE, 4,
+ EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+ EGL10.EGL_NONE
+ };
+
+ public ConfigChooser(int r, int g, int b, int a, int depth, int stencil) {
+ mRedSize = r;
+ mGreenSize = g;
+ mBlueSize = b;
+ mAlphaSize = a;
+ mDepthSize = depth;
+ mStencilSize = stencil;
+ }
+
+ public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
+
+ int[] num_config = new int[1];
+ egl.eglChooseConfig(display, s_configAttribs2, null, 0, num_config);
+
+ int numConfigs = num_config[0];
+
+ if (numConfigs <= 0) {
+ throw new IllegalArgumentException("No configs match configSpec");
+ }
+ EGLConfig[] configs = new EGLConfig[numConfigs];
+ egl.eglChooseConfig(display, s_configAttribs2, configs, numConfigs, num_config);
+ // printConfigs(egl, display, configs);
+ return chooseConfig(egl, display, configs);
+ }
+
+ public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
+ EGLConfig[] configs) {
+ EGLConfig closestConfig = null;
+ int closestDistance = 1000;
+ for(EGLConfig config : configs) {
+ int d = findConfigAttrib(egl, display, config,
+ EGL10.EGL_DEPTH_SIZE, 0);
+ int s = findConfigAttrib(egl, display, config,
+ EGL10.EGL_STENCIL_SIZE, 0);
+ if (d >= mDepthSize && s>= mStencilSize) {
+ int r = findConfigAttrib(egl, display, config,
+ EGL10.EGL_RED_SIZE, 0);
+ int g = findConfigAttrib(egl, display, config,
+ EGL10.EGL_GREEN_SIZE, 0);
+ int b = findConfigAttrib(egl, display, config,
+ EGL10.EGL_BLUE_SIZE, 0);
+ int a = findConfigAttrib(egl, display, config,
+ EGL10.EGL_ALPHA_SIZE, 0);
+ int distance = Math.abs(r - mRedSize)
+ + Math.abs(g - mGreenSize)
+ + Math.abs(b - mBlueSize)
+ + Math.abs(a - mAlphaSize);
+ if (distance < closestDistance) {
+ closestDistance = distance;
+ closestConfig = config;
+ }
+ }
+ }
+ return closestConfig;
+ }
+
+ private int findConfigAttrib(EGL10 egl, EGLDisplay display,
+ EGLConfig config, int attribute, int defaultValue) {
+
+ if (egl.eglGetConfigAttrib(display, config, attribute, mValue)) {
+ return mValue[0];
+ }
+ return defaultValue;
+ }
+
+ private void printConfigs(EGL10 egl, EGLDisplay display,
+ EGLConfig[] configs) {
+ int numConfigs = configs.length;
+ Log.w(TAG, String.format("%d configurations", numConfigs));
+ for (int i = 0; i < numConfigs; i++) {
+ Log.w(TAG, String.format("Configuration %d:\n", i));
+ printConfig(egl, display, configs[i]);
+ }
+ }
+
+ private void printConfig(EGL10 egl, EGLDisplay display,
+ EGLConfig config) {
+ int[] attributes = {
+ EGL10.EGL_BUFFER_SIZE,
+ EGL10.EGL_ALPHA_SIZE,
+ EGL10.EGL_BLUE_SIZE,
+ EGL10.EGL_GREEN_SIZE,
+ EGL10.EGL_RED_SIZE,
+ EGL10.EGL_DEPTH_SIZE,
+ EGL10.EGL_STENCIL_SIZE,
+ EGL10.EGL_CONFIG_CAVEAT,
+ EGL10.EGL_CONFIG_ID,
+ EGL10.EGL_LEVEL,
+ EGL10.EGL_MAX_PBUFFER_HEIGHT,
+ EGL10.EGL_MAX_PBUFFER_PIXELS,
+ EGL10.EGL_MAX_PBUFFER_WIDTH,
+ EGL10.EGL_NATIVE_RENDERABLE,
+ EGL10.EGL_NATIVE_VISUAL_ID,
+ EGL10.EGL_NATIVE_VISUAL_TYPE,
+ 0x3030, // EGL10.EGL_PRESERVED_RESOURCES,
+ EGL10.EGL_SAMPLES,
+ EGL10.EGL_SAMPLE_BUFFERS,
+ EGL10.EGL_SURFACE_TYPE,
+ EGL10.EGL_TRANSPARENT_TYPE,
+ EGL10.EGL_TRANSPARENT_RED_VALUE,
+ EGL10.EGL_TRANSPARENT_GREEN_VALUE,
+ EGL10.EGL_TRANSPARENT_BLUE_VALUE,
+ 0x3039, // EGL10.EGL_BIND_TO_TEXTURE_RGB,
+ 0x303A, // EGL10.EGL_BIND_TO_TEXTURE_RGBA,
+ 0x303B, // EGL10.EGL_MIN_SWAP_INTERVAL,
+ 0x303C, // EGL10.EGL_MAX_SWAP_INTERVAL,
+ EGL10.EGL_LUMINANCE_SIZE,
+ EGL10.EGL_ALPHA_MASK_SIZE,
+ EGL10.EGL_COLOR_BUFFER_TYPE,
+ EGL10.EGL_RENDERABLE_TYPE,
+ 0x3042 // EGL10.EGL_CONFORMANT
+ };
+ String[] names = {
+ "EGL_BUFFER_SIZE",
+ "EGL_ALPHA_SIZE",
+ "EGL_BLUE_SIZE",
+ "EGL_GREEN_SIZE",
+ "EGL_RED_SIZE",
+ "EGL_DEPTH_SIZE",
+ "EGL_STENCIL_SIZE",
+ "EGL_CONFIG_CAVEAT",
+ "EGL_CONFIG_ID",
+ "EGL_LEVEL",
+ "EGL_MAX_PBUFFER_HEIGHT",
+ "EGL_MAX_PBUFFER_PIXELS",
+ "EGL_MAX_PBUFFER_WIDTH",
+ "EGL_NATIVE_RENDERABLE",
+ "EGL_NATIVE_VISUAL_ID",
+ "EGL_NATIVE_VISUAL_TYPE",
+ "EGL_PRESERVED_RESOURCES",
+ "EGL_SAMPLES",
+ "EGL_SAMPLE_BUFFERS",
+ "EGL_SURFACE_TYPE",
+ "EGL_TRANSPARENT_TYPE",
+ "EGL_TRANSPARENT_RED_VALUE",
+ "EGL_TRANSPARENT_GREEN_VALUE",
+ "EGL_TRANSPARENT_BLUE_VALUE",
+ "EGL_BIND_TO_TEXTURE_RGB",
+ "EGL_BIND_TO_TEXTURE_RGBA",
+ "EGL_MIN_SWAP_INTERVAL",
+ "EGL_MAX_SWAP_INTERVAL",
+ "EGL_LUMINANCE_SIZE",
+ "EGL_ALPHA_MASK_SIZE",
+ "EGL_COLOR_BUFFER_TYPE",
+ "EGL_RENDERABLE_TYPE",
+ "EGL_CONFORMANT"
+ };
+ int[] value = new int[1];
+ for (int i = 0; i < attributes.length; i++) {
+ int attribute = attributes[i];
+ String name = names[i];
+ if ( egl.eglGetConfigAttrib(display, config, attribute, value)) {
+ Log.w(TAG, String.format(" %s: %d\n", name, value[0]));
+ } else {
+ // Log.w(TAG, String.format(" %s: failed\n", name));
+ while (egl.eglGetError() != EGL10.EGL_SUCCESS);
+ }
+ }
+ }
+
+ // Subclasses can adjust these values:
+ protected int mRedSize;
+ protected int mGreenSize;
+ protected int mBlueSize;
+ protected int mAlphaSize;
+ protected int mDepthSize;
+ protected int mStencilSize;
+ private int[] mValue = new int[1];
+ }
+
+ private static class Renderer implements GLSurfaceView.Renderer {
+
+ public Renderer() {
+ mTriangleVertices = ByteBuffer.allocateDirect(mTriangleVerticesData.length * 4)
+ .order(ByteOrder.nativeOrder()).asFloatBuffer();
+ mTriangleVertices.put(mTriangleVerticesData).position(0);
+ }
+
+ public void onDrawFrame(GL10 gl) {
+ GLES20.glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
+ GLES20.glClear( GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
+ GLES20.glUseProgram(mProgram);
+ checkGlError("glUseProgram");
+
+ GLES20.glVertexAttribPointer(mvPositionHandle, 2, GLES20.GL_FLOAT, false, 0, mTriangleVertices);
+ checkGlError("glVertexAttribPointer");
+ GLES20.glEnableVertexAttribArray(mvPositionHandle);
+ checkGlError("glEnableVertexAttribArray");
+ GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 3);
+ checkGlError("glDrawArrays");
+
+ }
+
+ public void onSurfaceChanged(GL10 gl, int width, int height) {
+ GLES20.glViewport(0, 0, width, height);
+ }
+
+ public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+ mProgram = createProgram(mVertexShader, mFragmentShader);
+ if (mProgram == 0) {
+ return;
+ }
+ mvPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");
+ checkGlError("glGetAttribLocation");
+ if (mvPositionHandle == -1) {
+ throw new RuntimeException("Could not get attrib location for vPosition");
+ }
+ }
+
+ private int loadShader(int shaderType, String source) {
+ int shader = GLES20.glCreateShader(shaderType);
+ if (shader != 0) {
+ GLES20.glShaderSource(shader, source);
+ GLES20.glCompileShader(shader);
+ int[] compiled = new int[1];
+ GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0);
+ if (compiled[0] == 0) {
+ Log.e(TAG, "Could not compile shader " + shaderType + ":");
+ Log.e(TAG, GLES20.glGetShaderInfoLog(shader));
+ GLES20.glDeleteShader(shader);
+ shader = 0;
+ }
+ }
+ return shader;
+ }
+
+ private int createProgram(String vertexSource, String fragmentSource) {
+ int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource);
+ if (vertexShader == 0) {
+ return 0;
+ }
+
+ int pixelShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);
+ if (pixelShader == 0) {
+ return 0;
+ }
+
+ int program = GLES20.glCreateProgram();
+ if (program != 0) {
+ GLES20.glAttachShader(program, vertexShader);
+ checkGlError("glAttachShader");
+ GLES20.glAttachShader(program, pixelShader);
+ checkGlError("glAttachShader");
+ GLES20.glLinkProgram(program);
+ int[] linkStatus = new int[1];
+ GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0);
+ if (linkStatus[0] != GLES20.GL_TRUE) {
+ Log.e(TAG, "Could not link program: ");
+ Log.e(TAG, GLES20.glGetProgramInfoLog(program));
+ GLES20.glDeleteProgram(program);
+ program = 0;
+ }
+ }
+ return program;
+ }
+
+ private void checkGlError(String op) {
+ int error;
+ while ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR) {
+ Log.e(TAG, op + ": glError " + error);
+ throw new RuntimeException(op + ": glError " + error);
+ }
+ }
+
+ private final float[] mTriangleVerticesData = { 0.0f, 0.5f, -0.5f, -0.5f,
+ 0.5f, -0.5f };
+
+ private FloatBuffer mTriangleVertices;
+
+ private final String mVertexShader = "attribute vec4 vPosition;\n"
+ + "void main() {\n"
+ + " gl_Position = vPosition;\n"
+ + "}\n";
+
+ private final String mFragmentShader = "precision mediump float;\n"
+ + "void main() {\n"
+ + " gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);\n"
+ + "}\n";
+
+ private int mProgram;
+ private int mvPositionHandle;
+
+ }
+}
+
diff --git a/opengl/tools/glgen/gen b/opengl/tools/glgen/gen
index 9bff0b28..6c1a231 100755
--- a/opengl/tools/glgen/gen
+++ b/opengl/tools/glgen/gen
@@ -63,7 +63,7 @@
pushd out > /dev/null
mkdir classes
-javac -d classes com/google/android/gles_jni/GLImpl.java javax/microedition/khronos/opengles/GL10.java javax/microedition/khronos/opengles/GL10Ext.java javax/microedition/khronos/opengles/GL11.java javax/microedition/khronos/opengles/GL11Ext.java javax/microedition/khronos/opengles/GL11ExtensionPack.java android/opengl/GLES10.java android/opengl/GLES10Ext.java android/opengl/GLES11.java android/opengl/GLES11Ext.java
+javac -d classes com/google/android/gles_jni/GLImpl.java javax/microedition/khronos/opengles/GL10.java javax/microedition/khronos/opengles/GL10Ext.java javax/microedition/khronos/opengles/GL11.java javax/microedition/khronos/opengles/GL11Ext.java javax/microedition/khronos/opengles/GL11ExtensionPack.java android/opengl/GLES10.java android/opengl/GLES10Ext.java android/opengl/GLES11.java android/opengl/GLES11Ext.java android/opengl/GLES20.java
popd > /dev/null
JAVA_RESULT=$?
if [ $JAVA_RESULT -ne 0 ]; then
@@ -109,7 +109,7 @@
compareGenerated ../../java/javax/microedition/khronos/opengles generated/javax/microedition/khronos/opengles $x
done
-for x in GLES10 GLES10Ext GLES11 GLES11Ext
+for x in GLES10 GLES10Ext GLES11 GLES11Ext GLES20
do
compareGenerated ../../java/android/opengl generated/android/opengl ${x}.java
compareGenerated ../../../core/jni generated/C android_opengl_${x}.cpp
diff --git a/opengl/tools/glgen/specs/gles11/GLES20.spec b/opengl/tools/glgen/specs/gles11/GLES20.spec
new file mode 100644
index 0000000..61094d1
--- /dev/null
+++ b/opengl/tools/glgen/specs/gles11/GLES20.spec
@@ -0,0 +1,142 @@
+void glActiveTexture ( GLenum texture )
+void glAttachShader ( GLuint program, GLuint shader )
+void glBindAttribLocation ( GLuint program, GLuint index, const char *name )
+void glBindBuffer ( GLenum target, GLuint buffer )
+void glBindFramebuffer ( GLenum target, GLuint framebuffer )
+void glBindRenderbuffer ( GLenum target, GLuint renderbuffer )
+void glBindTexture ( GLenum target, GLuint texture )
+void glBlendColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
+void glBlendEquation ( GLenum mode )
+void glBlendEquationSeparate ( GLenum modeRGB, GLenum modeAlpha )
+void glBlendFunc ( GLenum sfactor, GLenum dfactor )
+void glBlendFuncSeparate ( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha )
+void glBufferData ( GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage )
+void glBufferSubData ( GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data )
+GLenum glCheckFramebufferStatus ( GLenum target )
+void glClear ( GLbitfield mask )
+void glClearColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
+void glClearDepthf ( GLclampf depth )
+void glClearStencil ( GLint s )
+void glColorMask ( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
+void glCompileShader ( GLuint shader )
+void glCompressedTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data )
+void glCompressedTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data )
+void glCopyTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
+void glCopyTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
+GLuint glCreateProgram ( void )
+GLuint glCreateShader ( GLenum type )
+void glCullFace ( GLenum mode )
+void glDeleteBuffers ( GLsizei n, const GLuint *buffers )
+void glDeleteFramebuffers ( GLsizei n, const GLuint *framebuffers )
+void glDeleteProgram ( GLuint program )
+void glDeleteRenderbuffers ( GLsizei n, const GLuint *renderbuffers )
+void glDeleteShader ( GLuint shader )
+void glDeleteTextures ( GLsizei n, const GLuint *textures )
+void glDepthFunc ( GLenum func )
+void glDepthMask ( GLboolean flag )
+void glDepthRangef ( GLclampf zNear, GLclampf zFar )
+void glDetachShader ( GLuint program, GLuint shader )
+void glDisable ( GLenum cap )
+void glDisableVertexAttribArray ( GLuint index )
+void glDrawArrays ( GLenum mode, GLint first, GLsizei count )
+void glDrawElements ( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices )
+void glEnable ( GLenum cap )
+void glEnableVertexAttribArray ( GLuint index )
+void glFinish ( void )
+void glFlush ( void )
+void glFramebufferRenderbuffer ( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer )
+void glFramebufferTexture2D ( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
+void glFrontFace ( GLenum mode )
+void glGenBuffers ( GLsizei n, GLuint *buffers )
+void glGenerateMipmap ( GLenum target )
+void glGenFramebuffers ( GLsizei n, GLuint *framebuffers )
+void glGenRenderbuffers ( GLsizei n, GLuint *renderbuffers )
+void glGenTextures ( GLsizei n, GLuint *textures )
+void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name )
+void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name )
+void glGetAttachedShaders ( GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders )
+int glGetAttribLocation ( GLuint program, const char *name )
+void glGetBooleanv ( GLenum pname, GLboolean *params )
+void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params )
+GLenum glGetError ( void )
+void glGetFloatv ( GLenum pname, GLfloat *params )
+void glGetFramebufferAttachmentParameteriv ( GLenum target, GLenum attachment, GLenum pname, GLint *params )
+void glGetIntegerv ( GLenum pname, GLint *params )
+void glGetProgramiv ( GLuint program, GLenum pname, GLint *params )
+void glGetProgramInfoLog ( GLuint program, GLsizei bufsize, GLsizei *length, char *infolog )
+void glGetRenderbufferParameteriv ( GLenum target, GLenum pname, GLint *params )
+void glGetShaderiv ( GLuint shader, GLenum pname, GLint *params )
+void glGetShaderInfoLog ( GLuint shader, GLsizei bufsize, GLsizei *length, char *infolog )
+void glGetShaderPrecisionFormat ( GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision )
+void glGetShaderSource ( GLuint shader, GLsizei bufsize, GLsizei *length, char *source )
+const GLubyte * glGetString ( GLenum name )
+void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params )
+void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params )
+void glGetUniformfv ( GLuint program, GLint location, GLfloat *params )
+void glGetUniformiv ( GLuint program, GLint location, GLint *params )
+int glGetUniformLocation ( GLuint program, const char *name )
+void glGetVertexAttribfv ( GLuint index, GLenum pname, GLfloat *params )
+void glGetVertexAttribiv ( GLuint index, GLenum pname, GLint *params )
+// void glGetVertexAttribPointerv ( GLuint index, GLenum pname, void **pointer )
+void glHint ( GLenum target, GLenum mode )
+GLboolean glIsBuffer ( GLuint buffer )
+GLboolean glIsEnabled ( GLenum cap )
+GLboolean glIsFramebuffer ( GLuint framebuffer )
+GLboolean glIsProgram ( GLuint program )
+GLboolean glIsRenderbuffer ( GLuint renderbuffer )
+GLboolean glIsShader ( GLuint shader )
+GLboolean glIsTexture ( GLuint texture )
+void glLineWidth ( GLfloat width )
+void glLinkProgram ( GLuint program )
+void glPixelStorei ( GLenum pname, GLint param )
+void glPolygonOffset ( GLfloat factor, GLfloat units )
+void glReadPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels )
+void glReleaseShaderCompiler ( void )
+void glRenderbufferStorage ( GLenum target, GLenum internalformat, GLsizei width, GLsizei height )
+void glSampleCoverage ( GLclampf value, GLboolean invert )
+void glScissor ( GLint x, GLint y, GLsizei width, GLsizei height )
+void glShaderBinary ( GLsizei n, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length )
+void glShaderSource ( GLuint shader )
+void glStencilFunc ( GLenum func, GLint ref, GLuint mask )
+void glStencilFuncSeparate ( GLenum face, GLenum func, GLint ref, GLuint mask )
+void glStencilMask ( GLuint mask )
+void glStencilMaskSeparate ( GLenum face, GLuint mask )
+void glStencilOp ( GLenum fail, GLenum zfail, GLenum zpass )
+void glStencilOpSeparate ( GLenum face, GLenum fail, GLenum zfail, GLenum zpass )
+void glTexImage2D ( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
+void glTexParameterf ( GLenum target, GLenum pname, GLfloat param )
+void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params )
+void glTexParameteri ( GLenum target, GLenum pname, GLint param )
+void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params )
+void glTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels )
+void glUniform1f ( GLint location, GLfloat x )
+void glUniform1fv ( GLint location, GLsizei count, const GLfloat *v )
+void glUniform1i ( GLint location, GLint x )
+void glUniform1iv ( GLint location, GLsizei count, const GLint *v )
+void glUniform2f ( GLint location, GLfloat x, GLfloat y )
+void glUniform2fv ( GLint location, GLsizei count, const GLfloat *v )
+void glUniform2i ( GLint location, GLint x, GLint y )
+void glUniform2iv ( GLint location, GLsizei count, const GLint *v )
+void glUniform3f ( GLint location, GLfloat x, GLfloat y, GLfloat z )
+void glUniform3fv ( GLint location, GLsizei count, const GLfloat *v )
+void glUniform3i ( GLint location, GLint x, GLint y, GLint z )
+void glUniform3iv ( GLint location, GLsizei count, const GLint *v )
+void glUniform4f ( GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+void glUniform4fv ( GLint location, GLsizei count, const GLfloat *v )
+void glUniform4i ( GLint location, GLint x, GLint y, GLint z, GLint w )
+void glUniform4iv ( GLint location, GLsizei count, const GLint *v )
+void glUniformMatrix2fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+void glUniformMatrix3fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+void glUniformMatrix4fv ( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+void glUseProgram ( GLuint program )
+void glValidateProgram ( GLuint program )
+void glVertexAttrib1f ( GLuint indx, GLfloat x )
+void glVertexAttrib1fv ( GLuint indx, const GLfloat *values )
+void glVertexAttrib2f ( GLuint indx, GLfloat x, GLfloat y )
+void glVertexAttrib2fv ( GLuint indx, const GLfloat *values )
+void glVertexAttrib3f ( GLuint indx, GLfloat x, GLfloat y, GLfloat z )
+void glVertexAttrib3fv ( GLuint indx, const GLfloat *values )
+void glVertexAttrib4f ( GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+void glVertexAttrib4fv ( GLuint indx, const GLfloat *values )
+void glVertexAttribPointer ( GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *ptr )
+void glViewport ( GLint x, GLint y, GLsizei width, GLsizei height )
\ No newline at end of file
diff --git a/opengl/tools/glgen/src/CType.java b/opengl/tools/glgen/src/CType.java
index 826c90d..d49e9ef 100644
--- a/opengl/tools/glgen/src/CType.java
+++ b/opengl/tools/glgen/src/CType.java
@@ -44,8 +44,12 @@
baseType.equals("void");
}
+ public boolean isConstCharPointer() {
+ return isConst && isPointer && baseType.equals("char");
+ }
+
public boolean isTypedPointer() {
- return isPointer() && !isVoid();
+ return isPointer() && !isVoid() && !isConstCharPointer();
}
public void setBaseType(String baseType) {
diff --git a/opengl/tools/glgen/src/GenerateGLES.java b/opengl/tools/glgen/src/GenerateGLES.java
index 60775b7..08063f3 100644
--- a/opengl/tools/glgen/src/GenerateGLES.java
+++ b/opengl/tools/glgen/src/GenerateGLES.java
@@ -70,7 +70,7 @@
// Generate files
for(String suffix: new String[] {"GLES10", "GLES10Ext",
- "GLES11", "GLES11Ext"})
+ "GLES11", "GLES11Ext", "GLES20"})
{
BufferedReader spec11Reader =
new BufferedReader(new FileReader("specs/gles11/"
diff --git a/opengl/tools/glgen/src/JType.java b/opengl/tools/glgen/src/JType.java
index df1177b..32d9fe7 100644
--- a/opengl/tools/glgen/src/JType.java
+++ b/opengl/tools/glgen/src/JType.java
@@ -6,6 +6,7 @@
String baseType;
boolean isArray;
boolean isClass;
+ boolean isString;
static HashMap<CType,JType> typeMapping = new HashMap<CType,JType>();
static HashMap<CType,JType> arrayTypeMapping = new HashMap<CType,JType>();
@@ -27,7 +28,10 @@
typeMapping.put(new CType("GLubyte"), new JType("byte"));
typeMapping.put(new CType("GLuint"), new JType("int"));
typeMapping.put(new CType("void"), new JType("void"));
- typeMapping.put(new CType("GLubyte", true, true), new JType("String"));
+ typeMapping.put(new CType("GLubyte", true, true), new JType("String", false, false));
+ typeMapping.put(new CType("char", false, true), new JType("byte"));
+ typeMapping.put(new CType("char", true, true), new JType("String", false, false));
+ typeMapping.put(new CType("int"), new JType("int"));
// Untyped pointers map to untyped Buffers
typeMapping.put(new CType("GLvoid", true, true),
@@ -42,6 +46,8 @@
// Typed pointers map to typed Buffers
typeMapping.put(new CType("GLboolean", false, true),
new JType("java.nio.IntBuffer", true, false));
+ typeMapping.put(new CType("GLenum", false, true),
+ new JType("java.nio.IntBuffer", true, false));
typeMapping.put(new CType("GLfixed", false, true),
new JType("java.nio.IntBuffer", true, false));
typeMapping.put(new CType("GLfixed", true, true),
@@ -54,6 +60,8 @@
new JType("java.nio.IntBuffer", true, false));
typeMapping.put(new CType("GLint", true, true),
new JType("java.nio.IntBuffer", true, false));
+ typeMapping.put(new CType("GLsizei", false, true),
+ new JType("java.nio.IntBuffer", true, false));
typeMapping.put(new CType("GLuint", false, true),
new JType("java.nio.IntBuffer", true, false));
typeMapping.put(new CType("GLuint", true, true),
@@ -62,8 +70,11 @@
new JType("java.nio.ShortBuffer", true, false));
// Typed pointers map to arrays + offsets
+ arrayTypeMapping.put(new CType("char", false, true),
+ new JType("byte", false, true));
arrayTypeMapping.put(new CType("GLboolean", false, true),
new JType("boolean", false, true));
+ arrayTypeMapping.put(new CType("GLenum", false, true), new JType("int", false, true));
arrayTypeMapping.put(new CType("GLfixed", true, true), new JType("int", false, true));
arrayTypeMapping.put(new CType("GLfixed", false, true), new JType("int", false, true));
arrayTypeMapping.put(new CType("GLfloat", false, true), new JType("float", false, true));
@@ -71,6 +82,8 @@
arrayTypeMapping.put(new CType("GLint", false, true), new JType("int", false, true));
arrayTypeMapping.put(new CType("GLint", true, true), new JType("int", false, true));
arrayTypeMapping.put(new CType("GLshort", true, true), new JType("short", false, true));
+ arrayTypeMapping.put(new CType("GLsizei", false, true), new JType("int", false, true));
+ arrayTypeMapping.put(new CType("GLsizei", true, true), new JType("int", false, true));
arrayTypeMapping.put(new CType("GLuint", false, true), new JType("int", false, true));
arrayTypeMapping.put(new CType("GLuint", true, true), new JType("int", false, true));
arrayTypeMapping.put(new CType("GLintptr"), new JType("int", false, true));
@@ -109,6 +122,10 @@
return isClass;
}
+ public boolean isString() {
+ return baseType.equals("String");
+ }
+
public boolean isPrimitive() {
return !isClass() && !isArray();
}
diff --git a/opengl/tools/glgen/src/JniCodeEmitter.java b/opengl/tools/glgen/src/JniCodeEmitter.java
index 2cdb244..4c1814a 100644
--- a/opengl/tools/glgen/src/JniCodeEmitter.java
+++ b/opengl/tools/glgen/src/JniCodeEmitter.java
@@ -37,6 +37,12 @@
jniName += "L";
} else if (baseType.equals("byte")) {
jniName += "B";
+ } else if (baseType.equals("String")) {
+ jniName += "Ljava/lang/String;";
+ } else if (baseType.equals("void")) {
+ // nothing.
+ } else {
+ throw new RuntimeException("Uknown primitive basetype " + baseType);
}
return jniName;
}
@@ -629,7 +635,7 @@
}
// Append signature to function name
- String sig = getJniMangledName(signature).replace('.', '_');
+ String sig = getJniMangledName(signature).replace('.', '_').replace('/', '_');
out.print("__" + sig);
outName += "__" + sig;
@@ -652,6 +658,7 @@
nativeRegistrations.add(s);
List<Integer> nonPrimitiveArgs = new ArrayList<Integer>();
+ List<Integer> stringArgs = new ArrayList<Integer>();
int numBufferArgs = 0;
List<String> bufferArgNames = new ArrayList<String>();
@@ -682,6 +689,9 @@
} else {
suffix = "";
}
+ if (argType.isString()) {
+ stringArgs.add(new Integer(i));
+ }
out.print(getJniType(argType) + " " + jfunc.getArgName(i) + suffix);
}
@@ -692,14 +702,19 @@
int numArrays = 0;
int numBuffers = 0;
+ int numStrings = 0;
for (int i = 0; i < nonPrimitiveArgs.size(); i++) {
int idx = nonPrimitiveArgs.get(i).intValue();
- if (jfunc.getArgType(idx).isArray()) {
+ JType argType = jfunc.getArgType(idx);
+ if (argType.isArray()) {
++numArrays;
}
- if (jfunc.getArgType(idx).isBuffer()) {
+ if (argType.isBuffer()) {
++numBuffers;
}
+ if (argType.isString()) {
+ ++numStrings;
+ }
}
// Emit method body
@@ -736,7 +751,9 @@
"android::gl::ogles_context_t *ctx = getContext(_env, _this);");
}
- boolean emitExceptionCheck = (numArrays > 0 || numBuffers > 0) &&
+ boolean initializeReturnValue = stringArgs.size() > 0;
+
+ boolean emitExceptionCheck = (numArrays > 0 || numBuffers > 0 || numStrings > 0) &&
hasNonConstArg(jfunc, cfunc, nonPrimitiveArgs);
// mChecker.getChecks(cfunc.getName()) != null
@@ -759,6 +776,9 @@
if (retval != null) {
out.println(indent + returnType.getDeclaration() +
" _returnValue = " + retval + ";");
+ } else if (initializeReturnValue) {
+ out.println(indent + returnType.getDeclaration() +
+ " _returnValue = 0;");
} else {
out.println(indent + returnType.getDeclaration() +
" _returnValue;");
@@ -789,7 +809,7 @@
jfunc.getArgName(idx) +
"_base = (" + decl + ") 0;");
}
- remaining = (numArrays <= 1 && numBuffers <= 1) ? "_remaining" :
+ remaining = ((numArrays + numBuffers) <= 1) ? "_remaining" :
"_" + cname + "Remaining";
out.println(indent +
"jint " + remaining + ";");
@@ -803,6 +823,40 @@
out.println();
}
+ // Emit local variable declaration for strings
+ if (stringArgs.size() > 0) {
+ for (int i = 0; i < stringArgs.size(); i++) {
+ int idx = stringArgs.get(i).intValue();
+ int cIndex = jfunc.getArgCIndex(idx);
+ String cname = cfunc.getArgName(cIndex);
+
+ out.println(indent + "const char* _native" + cname + " = 0;");
+ }
+
+ out.println();
+ }
+
+ // Null pointer checks and GetStringUTFChars
+ if (stringArgs.size() > 0) {
+ for (int i = 0; i < stringArgs.size(); i++) {
+ int idx = stringArgs.get(i).intValue();
+ int cIndex = jfunc.getArgCIndex(idx);
+ String cname = cfunc.getArgName(cIndex);
+
+ CType type = cfunc.getArgType(jfunc.getArgCIndex(idx));
+ String decl = type.getDeclaration();
+ out.println(indent + "if (!" + cname + ") {");
+ out.println(indent + " _env->ThrowNew(IAEClass, \"" + cname + " == null\");");
+ out.println(indent + " goto exit;");
+ needsExit = true;
+ out.println(indent + "}");
+
+ out.println(indent + "_native" + cname + " = _env->GetStringUTFChars(" + cname + ", 0);");
+ }
+
+ out.println();
+ }
+
// Emit 'GetPrimitiveArrayCritical' for arrays
// Emit 'GetPointer' calls for Buffer pointers
int bufArgIdx = 0;
@@ -814,7 +868,7 @@
String cname = cfunc.getArgName(cIndex);
offset = numArrays <= 1 ? "offset" :
cname + "Offset";
- remaining = (numArrays <= 1 && numBuffers <= 1) ? "_remaining" :
+ remaining = ((numArrays + numBuffers) <= 1) ? "_remaining" :
"_" + cname + "Remaining";
if (jfunc.getArgType(idx).isArray()) {
@@ -957,8 +1011,11 @@
out.print(indent + indent +
"(" +
typecast +
- ")" +
- cfunc.getArgName(i));
+ ")");
+ if (cfunc.getArgType(i).isConstCharPointer()) {
+ out.print("_native");
+ }
+ out.print(cfunc.getArgName(i));
if (i == numArgs - 1) {
if (isPointerFunc) {
@@ -1025,6 +1082,22 @@
}
}
+ // Emit local variable declaration for strings
+ if (stringArgs.size() > 0) {
+ for (int i = 0; i < stringArgs.size(); i++) {
+ int idx = stringArgs.get(i).intValue();
+ int cIndex = jfunc.getArgCIndex(idx);
+ String cname = cfunc.getArgName(cIndex);
+
+ out.println(indent + "if (_native" + cname + ") {");
+ out.println(indent + " _env->ReleaseStringUTFChars(" + cname + ", _native" + cname + ");");
+ out.println(indent + "}");
+ }
+
+ out.println();
+ }
+
+
if (!isVoid) {
out.println(indent + "return _returnValue;");
}
diff --git a/opengl/tools/glgen/stubs/gles11/GLES20Header.java-if b/opengl/tools/glgen/stubs/gles11/GLES20Header.java-if
new file mode 100644
index 0000000..7504509
--- /dev/null
+++ b/opengl/tools/glgen/stubs/gles11/GLES20Header.java-if
@@ -0,0 +1,331 @@
+**
+** Copyright 2009, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+// This source file is automatically generated
+
+package android.opengl;
+
+/** OpenGL ES 2.0
+ * @hide
+ */
+public class GLES20 {
+ public static final int GL_ACTIVE_TEXTURE = 0x84E0;
+ public static final int GL_DEPTH_BUFFER_BIT = 0x00000100;
+ public static final int GL_STENCIL_BUFFER_BIT = 0x00000400;
+ public static final int GL_COLOR_BUFFER_BIT = 0x00004000;
+ public static final int GL_FALSE = 0;
+ public static final int GL_TRUE = 1;
+ public static final int GL_POINTS = 0x0000;
+ public static final int GL_LINES = 0x0001;
+ public static final int GL_LINE_LOOP = 0x0002;
+ public static final int GL_LINE_STRIP = 0x0003;
+ public static final int GL_TRIANGLES = 0x0004;
+ public static final int GL_TRIANGLE_STRIP = 0x0005;
+ public static final int GL_TRIANGLE_FAN = 0x0006;
+ public static final int GL_ZERO = 0;
+ public static final int GL_ONE = 1;
+ public static final int GL_SRC_COLOR = 0x0300;
+ public static final int GL_ONE_MINUS_SRC_COLOR = 0x0301;
+ public static final int GL_SRC_ALPHA = 0x0302;
+ public static final int GL_ONE_MINUS_SRC_ALPHA = 0x0303;
+ public static final int GL_DST_ALPHA = 0x0304;
+ public static final int GL_ONE_MINUS_DST_ALPHA = 0x0305;
+ public static final int GL_DST_COLOR = 0x0306;
+ public static final int GL_ONE_MINUS_DST_COLOR = 0x0307;
+ public static final int GL_SRC_ALPHA_SATURATE = 0x0308;
+ public static final int GL_FUNC_ADD = 0x8006;
+ public static final int GL_BLEND_EQUATION = 0x8009;
+ public static final int GL_BLEND_EQUATION_RGB = 0x8009; /* same as BLEND_EQUATION */
+ public static final int GL_BLEND_EQUATION_ALPHA = 0x883D;
+ public static final int GL_FUNC_SUBTRACT = 0x800A;
+ public static final int GL_FUNC_REVERSE_SUBTRACT = 0x800B;
+ public static final int GL_BLEND_DST_RGB = 0x80C8;
+ public static final int GL_BLEND_SRC_RGB = 0x80C9;
+ public static final int GL_BLEND_DST_ALPHA = 0x80CA;
+ public static final int GL_BLEND_SRC_ALPHA = 0x80CB;
+ public static final int GL_CONSTANT_COLOR = 0x8001;
+ public static final int GL_ONE_MINUS_CONSTANT_COLOR = 0x8002;
+ public static final int GL_CONSTANT_ALPHA = 0x8003;
+ public static final int GL_ONE_MINUS_CONSTANT_ALPHA = 0x8004;
+ public static final int GL_BLEND_COLOR = 0x8005;
+ public static final int GL_ARRAY_BUFFER = 0x8892;
+ public static final int GL_ELEMENT_ARRAY_BUFFER = 0x8893;
+ public static final int GL_ARRAY_BUFFER_BINDING = 0x8894;
+ public static final int GL_ELEMENT_ARRAY_BUFFER_BINDING = 0x8895;
+ public static final int GL_STREAM_DRAW = 0x88E0;
+ public static final int GL_STATIC_DRAW = 0x88E4;
+ public static final int GL_DYNAMIC_DRAW = 0x88E8;
+ public static final int GL_BUFFER_SIZE = 0x8764;
+ public static final int GL_BUFFER_USAGE = 0x8765;
+ public static final int GL_CURRENT_VERTEX_ATTRIB = 0x8626;
+ public static final int GL_FRONT = 0x0404;
+ public static final int GL_BACK = 0x0405;
+ public static final int GL_FRONT_AND_BACK = 0x0408;
+ public static final int GL_TEXTURE_2D = 0x0DE1;
+ public static final int GL_CULL_FACE = 0x0B44;
+ public static final int GL_BLEND = 0x0BE2;
+ public static final int GL_DITHER = 0x0BD0;
+ public static final int GL_STENCIL_TEST = 0x0B90;
+ public static final int GL_DEPTH_TEST = 0x0B71;
+ public static final int GL_SCISSOR_TEST = 0x0C11;
+ public static final int GL_POLYGON_OFFSET_FILL = 0x8037;
+ public static final int GL_SAMPLE_ALPHA_TO_COVERAGE = 0x809E;
+ public static final int GL_SAMPLE_COVERAGE = 0x80A0;
+ public static final int GL_NO_ERROR = 0;
+ public static final int GL_INVALID_ENUM = 0x0500;
+ public static final int GL_INVALID_VALUE = 0x0501;
+ public static final int GL_INVALID_OPERATION = 0x0502;
+ public static final int GL_OUT_OF_MEMORY = 0x0505;
+ public static final int GL_CW = 0x0900;
+ public static final int GL_CCW = 0x0901;
+ public static final int GL_LINE_WIDTH = 0x0B21;
+ public static final int GL_ALIASED_POINT_SIZE_RANGE = 0x846D;
+ public static final int GL_ALIASED_LINE_WIDTH_RANGE = 0x846E;
+ public static final int GL_CULL_FACE_MODE = 0x0B45;
+ public static final int GL_FRONT_FACE = 0x0B46;
+ public static final int GL_DEPTH_RANGE = 0x0B70;
+ public static final int GL_DEPTH_WRITEMASK = 0x0B72;
+ public static final int GL_DEPTH_CLEAR_VALUE = 0x0B73;
+ public static final int GL_DEPTH_FUNC = 0x0B74;
+ public static final int GL_STENCIL_CLEAR_VALUE = 0x0B91;
+ public static final int GL_STENCIL_FUNC = 0x0B92;
+ public static final int GL_STENCIL_FAIL = 0x0B94;
+ public static final int GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95;
+ public static final int GL_STENCIL_PASS_DEPTH_PASS = 0x0B96;
+ public static final int GL_STENCIL_REF = 0x0B97;
+ public static final int GL_STENCIL_VALUE_MASK = 0x0B93;
+ public static final int GL_STENCIL_WRITEMASK = 0x0B98;
+ public static final int GL_STENCIL_BACK_FUNC = 0x8800;
+ public static final int GL_STENCIL_BACK_FAIL = 0x8801;
+ public static final int GL_STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802;
+ public static final int GL_STENCIL_BACK_PASS_DEPTH_PASS = 0x8803;
+ public static final int GL_STENCIL_BACK_REF = 0x8CA3;
+ public static final int GL_STENCIL_BACK_VALUE_MASK = 0x8CA4;
+ public static final int GL_STENCIL_BACK_WRITEMASK = 0x8CA5;
+ public static final int GL_VIEWPORT = 0x0BA2;
+ public static final int GL_SCISSOR_BOX = 0x0C10;
+ public static final int GL_COLOR_CLEAR_VALUE = 0x0C22;
+ public static final int GL_COLOR_WRITEMASK = 0x0C23;
+ public static final int GL_UNPACK_ALIGNMENT = 0x0CF5;
+ public static final int GL_PACK_ALIGNMENT = 0x0D05;
+ public static final int GL_MAX_TEXTURE_SIZE = 0x0D33;
+ public static final int GL_MAX_VIEWPORT_DIMS = 0x0D3A;
+ public static final int GL_SUBPIXEL_BITS = 0x0D50;
+ public static final int GL_RED_BITS = 0x0D52;
+ public static final int GL_GREEN_BITS = 0x0D53;
+ public static final int GL_BLUE_BITS = 0x0D54;
+ public static final int GL_ALPHA_BITS = 0x0D55;
+ public static final int GL_DEPTH_BITS = 0x0D56;
+ public static final int GL_STENCIL_BITS = 0x0D57;
+ public static final int GL_POLYGON_OFFSET_UNITS = 0x2A00;
+ public static final int GL_POLYGON_OFFSET_FACTOR = 0x8038;
+ public static final int GL_TEXTURE_BINDING_2D = 0x8069;
+ public static final int GL_SAMPLE_BUFFERS = 0x80A8;
+ public static final int GL_SAMPLES = 0x80A9;
+ public static final int GL_SAMPLE_COVERAGE_VALUE = 0x80AA;
+ public static final int GL_SAMPLE_COVERAGE_INVERT = 0x80AB;
+ public static final int GL_NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2;
+ public static final int GL_COMPRESSED_TEXTURE_FORMATS = 0x86A3;
+ public static final int GL_DONT_CARE = 0x1100;
+ public static final int GL_FASTEST = 0x1101;
+ public static final int GL_NICEST = 0x1102;
+ public static final int GL_GENERATE_MIPMAP_HINT = 0x8192;
+ public static final int GL_BYTE = 0x1400;
+ public static final int GL_UNSIGNED_BYTE = 0x1401;
+ public static final int GL_SHORT = 0x1402;
+ public static final int GL_UNSIGNED_SHORT = 0x1403;
+ public static final int GL_INT = 0x1404;
+ public static final int GL_UNSIGNED_INT = 0x1405;
+ public static final int GL_FLOAT = 0x1406;
+ public static final int GL_FIXED = 0x140C;
+ public static final int GL_DEPTH_COMPONENT = 0x1902;
+ public static final int GL_ALPHA = 0x1906;
+ public static final int GL_RGB = 0x1907;
+ public static final int GL_RGBA = 0x1908;
+ public static final int GL_LUMINANCE = 0x1909;
+ public static final int GL_LUMINANCE_ALPHA = 0x190A;
+ public static final int GL_UNSIGNED_SHORT_4_4_4_4 = 0x8033;
+ public static final int GL_UNSIGNED_SHORT_5_5_5_1 = 0x8034;
+ public static final int GL_UNSIGNED_SHORT_5_6_5 = 0x8363;
+ public static final int GL_FRAGMENT_SHADER = 0x8B30;
+ public static final int GL_VERTEX_SHADER = 0x8B31;
+ public static final int GL_MAX_VERTEX_ATTRIBS = 0x8869;
+ public static final int GL_MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB;
+ public static final int GL_MAX_VARYING_VECTORS = 0x8DFC;
+ public static final int GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D;
+ public static final int GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C;
+ public static final int GL_MAX_TEXTURE_IMAGE_UNITS = 0x8872;
+ public static final int GL_MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD;
+ public static final int GL_SHADER_TYPE = 0x8B4F;
+ public static final int GL_DELETE_STATUS = 0x8B80;
+ public static final int GL_LINK_STATUS = 0x8B82;
+ public static final int GL_VALIDATE_STATUS = 0x8B83;
+ public static final int GL_ATTACHED_SHADERS = 0x8B85;
+ public static final int GL_ACTIVE_UNIFORMS = 0x8B86;
+ public static final int GL_ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87;
+ public static final int GL_ACTIVE_ATTRIBUTES = 0x8B89;
+ public static final int GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A;
+ public static final int GL_SHADING_LANGUAGE_VERSION = 0x8B8C;
+ public static final int GL_CURRENT_PROGRAM = 0x8B8D;
+ public static final int GL_NEVER = 0x0200;
+ public static final int GL_LESS = 0x0201;
+ public static final int GL_EQUAL = 0x0202;
+ public static final int GL_LEQUAL = 0x0203;
+ public static final int GL_GREATER = 0x0204;
+ public static final int GL_NOTEQUAL = 0x0205;
+ public static final int GL_GEQUAL = 0x0206;
+ public static final int GL_ALWAYS = 0x0207;
+ public static final int GL_KEEP = 0x1E00;
+ public static final int GL_REPLACE = 0x1E01;
+ public static final int GL_INCR = 0x1E02;
+ public static final int GL_DECR = 0x1E03;
+ public static final int GL_INVERT = 0x150A;
+ public static final int GL_INCR_WRAP = 0x8507;
+ public static final int GL_DECR_WRAP = 0x8508;
+ public static final int GL_VENDOR = 0x1F00;
+ public static final int GL_RENDERER = 0x1F01;
+ public static final int GL_VERSION = 0x1F02;
+ public static final int GL_EXTENSIONS = 0x1F03;
+ public static final int GL_NEAREST = 0x2600;
+ public static final int GL_LINEAR = 0x2601;
+ public static final int GL_NEAREST_MIPMAP_NEAREST = 0x2700;
+ public static final int GL_LINEAR_MIPMAP_NEAREST = 0x2701;
+ public static final int GL_NEAREST_MIPMAP_LINEAR = 0x2702;
+ public static final int GL_LINEAR_MIPMAP_LINEAR = 0x2703;
+ public static final int GL_TEXTURE_MAG_FILTER = 0x2800;
+ public static final int GL_TEXTURE_MIN_FILTER = 0x2801;
+ public static final int GL_TEXTURE_WRAP_S = 0x2802;
+ public static final int GL_TEXTURE_WRAP_T = 0x2803;
+ public static final int GL_TEXTURE = 0x1702;
+ public static final int GL_TEXTURE_CUBE_MAP = 0x8513;
+ public static final int GL_TEXTURE_BINDING_CUBE_MAP = 0x8514;
+ public static final int GL_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515;
+ public static final int GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516;
+ public static final int GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517;
+ public static final int GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518;
+ public static final int GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519;
+ public static final int GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A;
+ public static final int GL_MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C;
+ public static final int GL_TEXTURE0 = 0x84C0;
+ public static final int GL_TEXTURE1 = 0x84C1;
+ public static final int GL_TEXTURE2 = 0x84C2;
+ public static final int GL_TEXTURE3 = 0x84C3;
+ public static final int GL_TEXTURE4 = 0x84C4;
+ public static final int GL_TEXTURE5 = 0x84C5;
+ public static final int GL_TEXTURE6 = 0x84C6;
+ public static final int GL_TEXTURE7 = 0x84C7;
+ public static final int GL_TEXTURE8 = 0x84C8;
+ public static final int GL_TEXTURE9 = 0x84C9;
+ public static final int GL_TEXTURE10 = 0x84CA;
+ public static final int GL_TEXTURE11 = 0x84CB;
+ public static final int GL_TEXTURE12 = 0x84CC;
+ public static final int GL_TEXTURE13 = 0x84CD;
+ public static final int GL_TEXTURE14 = 0x84CE;
+ public static final int GL_TEXTURE15 = 0x84CF;
+ public static final int GL_TEXTURE16 = 0x84D0;
+ public static final int GL_TEXTURE17 = 0x84D1;
+ public static final int GL_TEXTURE18 = 0x84D2;
+ public static final int GL_TEXTURE19 = 0x84D3;
+ public static final int GL_TEXTURE20 = 0x84D4;
+ public static final int GL_TEXTURE21 = 0x84D5;
+ public static final int GL_TEXTURE22 = 0x84D6;
+ public static final int GL_TEXTURE23 = 0x84D7;
+ public static final int GL_TEXTURE24 = 0x84D8;
+ public static final int GL_TEXTURE25 = 0x84D9;
+ public static final int GL_TEXTURE26 = 0x84DA;
+ public static final int GL_TEXTURE27 = 0x84DB;
+ public static final int GL_TEXTURE28 = 0x84DC;
+ public static final int GL_TEXTURE29 = 0x84DD;
+ public static final int GL_TEXTURE30 = 0x84DE;
+ public static final int GL_TEXTURE31 = 0x84DF;
+ public static final int GL_REPEAT = 0x2901;
+ public static final int GL_CLAMP_TO_EDGE = 0x812F;
+ public static final int GL_MIRRORED_REPEAT = 0x8370;
+ public static final int GL_FLOAT_VEC2 = 0x8B50;
+ public static final int GL_FLOAT_VEC3 = 0x8B51;
+ public static final int GL_FLOAT_VEC4 = 0x8B52;
+ public static final int GL_INT_VEC2 = 0x8B53;
+ public static final int GL_INT_VEC3 = 0x8B54;
+ public static final int GL_INT_VEC4 = 0x8B55;
+ public static final int GL_BOOL = 0x8B56;
+ public static final int GL_BOOL_VEC2 = 0x8B57;
+ public static final int GL_BOOL_VEC3 = 0x8B58;
+ public static final int GL_BOOL_VEC4 = 0x8B59;
+ public static final int GL_FLOAT_MAT2 = 0x8B5A;
+ public static final int GL_FLOAT_MAT3 = 0x8B5B;
+ public static final int GL_FLOAT_MAT4 = 0x8B5C;
+ public static final int GL_SAMPLER_2D = 0x8B5E;
+ public static final int GL_SAMPLER_CUBE = 0x8B60;
+ public static final int GL_VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622;
+ public static final int GL_VERTEX_ATTRIB_ARRAY_SIZE = 0x8623;
+ public static final int GL_VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624;
+ public static final int GL_VERTEX_ATTRIB_ARRAY_TYPE = 0x8625;
+ public static final int GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A;
+ public static final int GL_VERTEX_ATTRIB_ARRAY_POINTER = 0x8645;
+ public static final int GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F;
+ public static final int GL_IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A;
+ public static final int GL_IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B;
+ public static final int GL_COMPILE_STATUS = 0x8B81;
+ public static final int GL_INFO_LOG_LENGTH = 0x8B84;
+ public static final int GL_SHADER_SOURCE_LENGTH = 0x8B88;
+ public static final int GL_SHADER_COMPILER = 0x8DFA;
+ public static final int GL_SHADER_BINARY_FORMATS = 0x8DF8;
+ public static final int GL_NUM_SHADER_BINARY_FORMATS = 0x8DF9;
+ public static final int GL_LOW_FLOAT = 0x8DF0;
+ public static final int GL_MEDIUM_FLOAT = 0x8DF1;
+ public static final int GL_HIGH_FLOAT = 0x8DF2;
+ public static final int GL_LOW_INT = 0x8DF3;
+ public static final int GL_MEDIUM_INT = 0x8DF4;
+ public static final int GL_HIGH_INT = 0x8DF5;
+ public static final int GL_FRAMEBUFFER = 0x8D40;
+ public static final int GL_RENDERBUFFER = 0x8D41;
+ public static final int GL_RGBA4 = 0x8056;
+ public static final int GL_RGB5_A1 = 0x8057;
+ public static final int GL_RGB565 = 0x8D62;
+ public static final int GL_DEPTH_COMPONENT16 = 0x81A5;
+ public static final int GL_STENCIL_INDEX = 0x1901;
+ public static final int GL_STENCIL_INDEX8 = 0x8D48;
+ public static final int GL_RENDERBUFFER_WIDTH = 0x8D42;
+ public static final int GL_RENDERBUFFER_HEIGHT = 0x8D43;
+ public static final int GL_RENDERBUFFER_INTERNAL_FORMAT = 0x8D44;
+ public static final int GL_RENDERBUFFER_RED_SIZE = 0x8D50;
+ public static final int GL_RENDERBUFFER_GREEN_SIZE = 0x8D51;
+ public static final int GL_RENDERBUFFER_BLUE_SIZE = 0x8D52;
+ public static final int GL_RENDERBUFFER_ALPHA_SIZE = 0x8D53;
+ public static final int GL_RENDERBUFFER_DEPTH_SIZE = 0x8D54;
+ public static final int GL_RENDERBUFFER_STENCIL_SIZE = 0x8D55;
+ public static final int GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0;
+ public static final int GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1;
+ public static final int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2;
+ public static final int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3;
+ public static final int GL_COLOR_ATTACHMENT0 = 0x8CE0;
+ public static final int GL_DEPTH_ATTACHMENT = 0x8D00;
+ public static final int GL_STENCIL_ATTACHMENT = 0x8D20;
+ public static final int GL_NONE = 0;
+ public static final int GL_FRAMEBUFFER_COMPLETE = 0x8CD5;
+ public static final int GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6;
+ public static final int GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7;
+ public static final int GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 0x8CD9;
+ public static final int GL_FRAMEBUFFER_UNSUPPORTED = 0x8CDD;
+ public static final int GL_FRAMEBUFFER_BINDING = 0x8CA6;
+ public static final int GL_RENDERBUFFER_BINDING = 0x8CA7;
+ public static final int GL_MAX_RENDERBUFFER_SIZE = 0x84E8;
+ public static final int GL_INVALID_FRAMEBUFFER_OPERATION = 0x0506;
+
+ native private static void _nativeClassInit();
+ static {
+ _nativeClassInit();
+ }
diff --git a/opengl/tools/glgen/stubs/gles11/GLES20cHeader.cpp b/opengl/tools/glgen/stubs/gles11/GLES20cHeader.cpp
new file mode 100644
index 0000000..e451e9a
--- /dev/null
+++ b/opengl/tools/glgen/stubs/gles11/GLES20cHeader.cpp
@@ -0,0 +1,150 @@
+**
+** Copyright 2009, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+// This source file is automatically generated
+
+#include <android_runtime/AndroidRuntime.h>
+#include <utils/misc.h>
+
+#include <assert.h>
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+static int initialized = 0;
+
+static jclass nioAccessClass;
+static jclass bufferClass;
+static jclass OOMEClass;
+static jclass UOEClass;
+static jclass IAEClass;
+static jclass AIOOBEClass;
+static jmethodID getBasePointerID;
+static jmethodID getBaseArrayID;
+static jmethodID getBaseArrayOffsetID;
+static jfieldID positionID;
+static jfieldID limitID;
+static jfieldID elementSizeShiftID;
+
+/* Cache method IDs each time the class is loaded. */
+
+static void
+nativeClassInitBuffer(JNIEnv *_env)
+{
+ jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess");
+ nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal);
+
+ jclass bufferClassLocal = _env->FindClass("java/nio/Buffer");
+ bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal);
+
+ getBasePointerID = _env->GetStaticMethodID(nioAccessClass,
+ "getBasePointer", "(Ljava/nio/Buffer;)J");
+ getBaseArrayID = _env->GetStaticMethodID(nioAccessClass,
+ "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;");
+ getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass,
+ "getBaseArrayOffset", "(Ljava/nio/Buffer;)I");
+
+ positionID = _env->GetFieldID(bufferClass, "position", "I");
+ limitID = _env->GetFieldID(bufferClass, "limit", "I");
+ elementSizeShiftID =
+ _env->GetFieldID(bufferClass, "_elementSizeShift", "I");
+}
+
+
+static void
+nativeClassInit(JNIEnv *_env, jclass glImplClass)
+{
+ nativeClassInitBuffer(_env);
+
+ jclass IAEClassLocal =
+ _env->FindClass("java/lang/IllegalArgumentException");
+ jclass OOMEClassLocal =
+ _env->FindClass("java/lang/OutOfMemoryError");
+ jclass UOEClassLocal =
+ _env->FindClass("java/lang/UnsupportedOperationException");
+ jclass AIOOBEClassLocal =
+ _env->FindClass("java/lang/ArrayIndexOutOfBoundsException");
+
+ IAEClass = (jclass) _env->NewGlobalRef(IAEClassLocal);
+ OOMEClass = (jclass) _env->NewGlobalRef(OOMEClassLocal);
+ UOEClass = (jclass) _env->NewGlobalRef(UOEClassLocal);
+ AIOOBEClass = (jclass) _env->NewGlobalRef(AIOOBEClassLocal);
+}
+
+static void *
+getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining)
+{
+ jint position;
+ jint limit;
+ jint elementSizeShift;
+ jlong pointer;
+ jint offset;
+ void *data;
+
+ position = _env->GetIntField(buffer, positionID);
+ limit = _env->GetIntField(buffer, limitID);
+ elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
+ *remaining = (limit - position) << elementSizeShift;
+ pointer = _env->CallStaticLongMethod(nioAccessClass,
+ getBasePointerID, buffer);
+ if (pointer != 0L) {
+ *array = NULL;
+ return (void *) (jint) pointer;
+ }
+
+ *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass,
+ getBaseArrayID, buffer);
+ offset = _env->CallStaticIntMethod(nioAccessClass,
+ getBaseArrayOffsetID, buffer);
+ data = _env->GetPrimitiveArrayCritical(*array, (jboolean *) 0);
+
+ return (void *) ((char *) data + offset);
+}
+
+
+static void
+releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit)
+{
+ _env->ReleasePrimitiveArrayCritical(array, data,
+ commit ? 0 : JNI_ABORT);
+}
+
+static void *
+getDirectBufferPointer(JNIEnv *_env, jobject buffer) {
+ char* buf = (char*) _env->GetDirectBufferAddress(buffer);
+ if (buf) {
+ jint position = _env->GetIntField(buffer, positionID);
+ jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
+ buf += position << elementSizeShift;
+ } else {
+ _env->ThrowNew(IAEClass, "Must use a native order direct Buffer");
+ }
+ return (void*) buf;
+}
+
+static int
+getNumCompressedTextureFormats() {
+ int numCompressedTextureFormats = 0;
+ glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numCompressedTextureFormats);
+ return numCompressedTextureFormats;
+}
+
+static void glVertexAttribPointerBounds(GLuint indx, GLint size, GLenum type,
+ GLboolean normalized, GLsizei stride, const GLvoid *pointer, GLsizei count) {
+ glVertexAttribPointer(indx, size, type, normalized, stride, pointer);
+}
+
+// --------------------------------------------------------------------------
+
diff --git a/opengl/tools/glgen/stubs/gles11/glGetProgramInfoLog.cpp b/opengl/tools/glgen/stubs/gles11/glGetProgramInfoLog.cpp
new file mode 100644
index 0000000..d92f5159
--- /dev/null
+++ b/opengl/tools/glgen/stubs/gles11/glGetProgramInfoLog.cpp
@@ -0,0 +1,27 @@
+#include <string.h>
+
+/* void glGetProgramInfoLog ( GLuint shader, GLsizei maxLength, GLsizei* length, GLchar* infoLog ) */
+static
+jstring
+android_glGetProgramInfoLog (JNIEnv *_env, jobject _this, jint shader) {
+ GLint infoLen = 0;
+ jstring _result = 0;
+ char* buf = 0;
+ glGetProgramiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
+ if (infoLen) {
+ char* buf = (char*) malloc(infoLen);
+ if (buf == 0) {
+ _env->ThrowNew(IAEClass, "out of memory");
+ goto exit;
+ }
+ glGetProgramInfoLog(shader, infoLen, NULL, buf);
+ _result = _env->NewStringUTF(buf);
+ } else {
+ _result = _env->NewStringUTF("");
+ }
+exit:
+ if (buf) {
+ free(buf);
+ }
+ return _result;
+}
\ No newline at end of file
diff --git a/opengl/tools/glgen/stubs/gles11/glGetProgramInfoLog.java b/opengl/tools/glgen/stubs/gles11/glGetProgramInfoLog.java
new file mode 100644
index 0000000..19504f2
--- /dev/null
+++ b/opengl/tools/glgen/stubs/gles11/glGetProgramInfoLog.java
@@ -0,0 +1,6 @@
+ // C function void glGetProgramInfoLog( GLuint program, GLsizei maxLength, GLsizei * length,
+ // GLchar * infoLog);
+
+ public static native String glGetProgramInfoLog(
+ int program
+ );
diff --git a/opengl/tools/glgen/stubs/gles11/glGetProgramInfoLog.nativeReg b/opengl/tools/glgen/stubs/gles11/glGetProgramInfoLog.nativeReg
new file mode 100644
index 0000000..8553f2d
--- /dev/null
+++ b/opengl/tools/glgen/stubs/gles11/glGetProgramInfoLog.nativeReg
@@ -0,0 +1 @@
+{"glGetProgramInfoLog", "(I)Ljava/lang/String;", (void *) android_glGetProgramInfoLog },
diff --git a/opengl/tools/glgen/stubs/gles11/glGetShaderInfoLog.cpp b/opengl/tools/glgen/stubs/gles11/glGetShaderInfoLog.cpp
new file mode 100644
index 0000000..5441d66
--- /dev/null
+++ b/opengl/tools/glgen/stubs/gles11/glGetShaderInfoLog.cpp
@@ -0,0 +1,27 @@
+#include <string.h>
+
+/* void glGetShaderInfoLog ( GLuint shader, GLsizei maxLength, GLsizei* length, GLchar* infoLog ) */
+static
+jstring
+android_glGetShaderInfoLog (JNIEnv *_env, jobject _this, jint shader) {
+ GLint infoLen = 0;
+ jstring _result = 0;
+ char* buf = 0;
+ glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
+ if (infoLen) {
+ char* buf = (char*) malloc(infoLen);
+ if (buf == 0) {
+ _env->ThrowNew(IAEClass, "out of memory");
+ goto exit;
+ }
+ glGetShaderInfoLog(shader, infoLen, NULL, buf);
+ _result = _env->NewStringUTF(buf);
+ } else {
+ _result = _env->NewStringUTF("");
+ }
+exit:
+ if (buf) {
+ free(buf);
+ }
+ return _result;
+}
\ No newline at end of file
diff --git a/opengl/tools/glgen/stubs/gles11/glGetShaderInfoLog.java b/opengl/tools/glgen/stubs/gles11/glGetShaderInfoLog.java
new file mode 100644
index 0000000..1fac6be
--- /dev/null
+++ b/opengl/tools/glgen/stubs/gles11/glGetShaderInfoLog.java
@@ -0,0 +1,6 @@
+ // C function void glGetShaderInfoLog( GLuint shader, GLsizei maxLength, GLsizei * length,
+ // GLchar * infoLog);
+
+ public static native String glGetShaderInfoLog(
+ int shader
+ );
diff --git a/opengl/tools/glgen/stubs/gles11/glGetShaderInfoLog.nativeReg b/opengl/tools/glgen/stubs/gles11/glGetShaderInfoLog.nativeReg
new file mode 100644
index 0000000..71163c3
--- /dev/null
+++ b/opengl/tools/glgen/stubs/gles11/glGetShaderInfoLog.nativeReg
@@ -0,0 +1 @@
+{"glGetShaderInfoLog", "(I)Ljava/lang/String;", (void *) android_glGetShaderInfoLog },
diff --git a/opengl/tools/glgen/stubs/gles11/glShaderSource.cpp b/opengl/tools/glgen/stubs/gles11/glShaderSource.cpp
new file mode 100644
index 0000000..c274108
--- /dev/null
+++ b/opengl/tools/glgen/stubs/gles11/glShaderSource.cpp
@@ -0,0 +1,17 @@
+
+/* void glShaderSource ( GLuint shader, GLsizei count, const GLchar ** string, const GLint * length ) */
+static
+void
+android_glShaderSource
+ (JNIEnv *_env, jobject _this, jint shader, jstring string) {
+
+ if (!string) {
+ _env->ThrowNew(IAEClass, "string == null");
+ return;
+ }
+
+ const char* nativeString = _env->GetStringUTFChars(string, 0);
+ const char* strings[] = {nativeString};
+ glShaderSource(shader, 1, strings, 0);
+ _env->ReleaseStringUTFChars(string, nativeString);
+}
diff --git a/opengl/tools/glgen/stubs/gles11/glShaderSource.java b/opengl/tools/glgen/stubs/gles11/glShaderSource.java
new file mode 100644
index 0000000..a9c338a
--- /dev/null
+++ b/opengl/tools/glgen/stubs/gles11/glShaderSource.java
@@ -0,0 +1,6 @@
+ // C function void glShaderSource ( GLuint shader, GLsizei count, const GLchar ** string, const GLint* length )
+
+ public static native void glShaderSource(
+ int shader,
+ String string
+ );
diff --git a/opengl/tools/glgen/stubs/gles11/glShaderSource.nativeReg b/opengl/tools/glgen/stubs/gles11/glShaderSource.nativeReg
new file mode 100644
index 0000000..b17783a
--- /dev/null
+++ b/opengl/tools/glgen/stubs/gles11/glShaderSource.nativeReg
@@ -0,0 +1 @@
+{"glShaderSource", "(ILjava/lang/String;)V", (void *) android_glShaderSource },