From 7ab63acdd0a257272512d0bcf5e06036fa0b9fdf Mon Sep 17 00:00:00 2001 From: Jesse Hall Date: Mon, 19 May 2014 15:13:41 -0700 Subject: opengl: Add GLES31 and GLES31Ext classes Bug: 15028495 Change-Id: Ie967c1938060edb42864dd48efa668ae7bf5cd76 --- core/jni/Android.mk | 2 + core/jni/AndroidRuntime.cpp | 4 + core/jni/android_opengl_GLES31.cpp | 3168 +++++++++++++++++++++++++++++ core/jni/android_opengl_GLES31Ext.cpp | 1385 +++++++++++++ opengl/java/android/opengl/GLES31.java | 1100 ++++++++++ opengl/java/android/opengl/GLES31Ext.java | 679 +++++++ 6 files changed, 6338 insertions(+) create mode 100644 core/jni/android_opengl_GLES31.cpp create mode 100644 core/jni/android_opengl_GLES31Ext.cpp create mode 100644 opengl/java/android/opengl/GLES31.java create mode 100644 opengl/java/android/opengl/GLES31Ext.java diff --git a/core/jni/Android.mk b/core/jni/Android.mk index 355204e..83c26f6 100644 --- a/core/jni/Android.mk +++ b/core/jni/Android.mk @@ -36,6 +36,8 @@ LOCAL_SRC_FILES:= \ android_opengl_GLES11Ext.cpp \ android_opengl_GLES20.cpp \ android_opengl_GLES30.cpp \ + android_opengl_GLES31.cpp \ + android_opengl_GLES31Ext.cpp \ android_database_CursorWindow.cpp \ android_database_SQLiteCommon.cpp \ android_database_SQLiteConnection.cpp \ diff --git a/core/jni/AndroidRuntime.cpp b/core/jni/AndroidRuntime.cpp index a4dc824..948b51e 100644 --- a/core/jni/AndroidRuntime.cpp +++ b/core/jni/AndroidRuntime.cpp @@ -74,6 +74,8 @@ 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_opengl_jni_GLES30(JNIEnv* env); +extern int register_android_opengl_jni_GLES31(JNIEnv* env); +extern int register_android_opengl_jni_GLES31Ext(JNIEnv* env); extern int register_android_hardware_Camera(JNIEnv *env); extern int register_android_hardware_camera2_CameraMetadata(JNIEnv *env); @@ -1228,6 +1230,8 @@ static const RegJNIRec gRegJNI[] = { REG_JNI(register_android_opengl_jni_GLES11Ext), REG_JNI(register_android_opengl_jni_GLES20), REG_JNI(register_android_opengl_jni_GLES30), + REG_JNI(register_android_opengl_jni_GLES31), + REG_JNI(register_android_opengl_jni_GLES31Ext), REG_JNI(register_android_graphics_Bitmap), REG_JNI(register_android_graphics_BitmapFactory), diff --git a/core/jni/android_opengl_GLES31.cpp b/core/jni/android_opengl_GLES31.cpp new file mode 100644 index 0000000..c634b91 --- /dev/null +++ b/core/jni/android_opengl_GLES31.cpp @@ -0,0 +1,3168 @@ +/* + * Copyright 2014 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 +#include +#include "jni.h" +#include "JNIHelp.h" +#include +#include +#include + +static int initialized = 0; + +static jclass nioAccessClass; +static jclass bufferClass; +static jmethodID getBasePointerID; +static jmethodID getBaseArrayID; +static jmethodID getBaseArrayOffsetID; +static jfieldID positionID; +static jfieldID limitID; +static jfieldID elementSizeShiftID; + + +/* special calls implemented in Android's GLES wrapper used to more + * efficiently bound-check passed arrays */ +extern "C" { +#ifdef GL_VERSION_ES_CM_1_1 +GL_API void GL_APIENTRY glColorPointerBounds(GLint size, GLenum type, GLsizei stride, + const GLvoid *ptr, GLsizei count); +GL_API void GL_APIENTRY glNormalPointerBounds(GLenum type, GLsizei stride, + const GLvoid *pointer, GLsizei count); +GL_API void GL_APIENTRY glTexCoordPointerBounds(GLint size, GLenum type, + GLsizei stride, const GLvoid *pointer, GLsizei count); +GL_API void GL_APIENTRY glVertexPointerBounds(GLint size, GLenum type, + GLsizei stride, const GLvoid *pointer, GLsizei count); +GL_API void GL_APIENTRY glPointSizePointerOESBounds(GLenum type, + GLsizei stride, const GLvoid *pointer, GLsizei count); +GL_API void GL_APIENTRY glMatrixIndexPointerOESBounds(GLint size, GLenum type, + GLsizei stride, const GLvoid *pointer, GLsizei count); +GL_API void GL_APIENTRY glWeightPointerOESBounds(GLint size, GLenum type, + GLsizei stride, const GLvoid *pointer, GLsizei count); +#endif +#ifdef GL_ES_VERSION_2_0 +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); +} +#endif +#ifdef GL_ES_VERSION_3_0 +static void glVertexAttribIPointerBounds(GLuint indx, GLint size, GLenum type, + GLsizei stride, const GLvoid *pointer, GLsizei count) { + glVertexAttribIPointer(indx, size, type, stride, pointer); +} +#endif +} + +/* Cache method IDs each time the class is loaded. */ + +static void +nativeClassInit(JNIEnv *_env, jclass glImplClass) +{ + 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 * +getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining, jint *offset) +{ + jint position; + jint limit; + jint elementSizeShift; + jlong pointer; + + 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 reinterpret_cast(pointer); + } + + *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass, + getBaseArrayID, buffer); + *offset = _env->CallStaticIntMethod(nioAccessClass, + getBaseArrayOffsetID, buffer); + + return NULL; +} + +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 { + jniThrowException(_env, "java/lang/IllegalArgumentException", + "Must use a native order direct Buffer"); + } + return (void*) buf; +} + +// -------------------------------------------------------------------------- + +/* + * returns the number of values glGet returns for a given pname. + * + * The code below is written such that pnames requiring only one values + * are the default (and are not explicitely tested for). This makes the + * checking code much shorter/readable/efficient. + * + * This means that unknown pnames (e.g.: extensions) will default to 1. If + * that unknown pname needs more than 1 value, then the validation check + * is incomplete and the app may crash if it passed the wrong number params. + */ +static int getNeededCount(GLint pname) { + int needed = 1; +#ifdef GL_ES_VERSION_2_0 + // GLES 2.x pnames + switch (pname) { + case GL_ALIASED_LINE_WIDTH_RANGE: + case GL_ALIASED_POINT_SIZE_RANGE: + needed = 2; + break; + + case GL_BLEND_COLOR: + case GL_COLOR_CLEAR_VALUE: + case GL_COLOR_WRITEMASK: + case GL_SCISSOR_BOX: + case GL_VIEWPORT: + needed = 4; + break; + + case GL_COMPRESSED_TEXTURE_FORMATS: + glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed); + break; + + case GL_SHADER_BINARY_FORMATS: + glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &needed); + break; + } +#endif + +#ifdef GL_VERSION_ES_CM_1_1 + // GLES 1.x pnames + switch (pname) { + case GL_ALIASED_LINE_WIDTH_RANGE: + case GL_ALIASED_POINT_SIZE_RANGE: + case GL_DEPTH_RANGE: + case GL_SMOOTH_LINE_WIDTH_RANGE: + case GL_SMOOTH_POINT_SIZE_RANGE: + needed = 2; + break; + + case GL_CURRENT_NORMAL: + case GL_POINT_DISTANCE_ATTENUATION: + needed = 3; + break; + + case GL_COLOR_CLEAR_VALUE: + case GL_COLOR_WRITEMASK: + case GL_CURRENT_COLOR: + case GL_CURRENT_TEXTURE_COORDS: + case GL_FOG_COLOR: + case GL_LIGHT_MODEL_AMBIENT: + case GL_SCISSOR_BOX: + case GL_VIEWPORT: + needed = 4; + break; + + case GL_MODELVIEW_MATRIX: + case GL_PROJECTION_MATRIX: + case GL_TEXTURE_MATRIX: + needed = 16; + break; + + case GL_COMPRESSED_TEXTURE_FORMATS: + glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed); + break; + } +#endif + return needed; +} + +template +static void +get + (JNIEnv *_env, jobject _this, jint pname, JTYPEARRAY params_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType; + const char * _exceptionMessage; + CTYPE *params_base = (CTYPE *) 0; + jint _remaining; + CTYPE *params = (CTYPE *) 0; + int _needed = 0; + + if (!params_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "params == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + _needed = getNeededCount(pname); + // if we didn't find this pname, we just assume the user passed + // an array of the right size -- this might happen with extensions + // or if we forget an enum here. + if (_remaining < _needed) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "length - offset < needed"; + goto exit; + } + params_base = (CTYPE *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + GET( + (GLenum)pname, + (CTYPE *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + + +template +static void +getarray + (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { + jint _exception = 0; + const char * _exceptionType; + const char * _exceptionMessage; + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + CTYPE *params = (CTYPE *) 0; + int _needed = 0; + + params = (CTYPE *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset); + _remaining /= sizeof(CTYPE); // convert from bytes to item count + _needed = getNeededCount(pname); + // if we didn't find this pname, we just assume the user passed + // an array of the right size -- this might happen with extensions + // or if we forget an enum here. + if (_needed>0 && _remaining < _needed) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "remaining() < needed"; + goto exit; + } + if (params == NULL) { + char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + params = (CTYPE *) (_paramsBase + _bufferOffset); + } + GET( + (GLenum)pname, + (CTYPE *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +// -------------------------------------------------------------------------- +/* void glDispatchCompute ( GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z ) */ +static void +android_glDispatchCompute__III + (JNIEnv *_env, jobject _this, jint num_groups_x, jint num_groups_y, jint num_groups_z) { + glDispatchCompute( + (GLuint)num_groups_x, + (GLuint)num_groups_y, + (GLuint)num_groups_z + ); +} + +/* void glDispatchComputeIndirect ( GLintptr indirect ) */ +static void android_glDispatchComputeIndirect(JNIEnv *_env, jobject, jlong indirect) { + // 'indirect' is a byte offset, not a pointer. GL checks for negative and too-large values. + // Here we only need to check for successful 64-bit to 32-bit conversion. + // - jlong is a int64_t (jni.h) + // - GLintptr is a long (khrplatform.h) + if (sizeof(GLintptr) != sizeof(jlong) && (indirect < LONG_MIN || indirect > LONG_MAX)) { + jniThrowException(_env, "java/lang/IllegalArgumentException", "indirect offset too large"); + return; + } + glDispatchComputeIndirect((GLintptr)indirect); +} + +/* void glDrawArraysIndirect ( GLenum mode, const void *indirect ) */ +static void android_glDrawArraysIndirect(JNIEnv *_env, jobject, int mode, jlong indirect) { + // In OpenGL ES, 'indirect' is a byte offset into a buffer, not a raw pointer. + // GL checks for too-large values. Here we only need to check for successful signed 64-bit + // to unsigned 32-bit conversion. + if (sizeof(void*) != sizeof(jlong) && indirect > UINTPTR_MAX) { + jniThrowException(_env, "java/lang/IllegalArgumentException", "indirect offset too large"); + return; + } + glDrawArraysIndirect(mode, (const void*)indirect); +} + +/* void glDrawElementsIndirect ( GLenum mode, GLenum type, const void *indirect ) */ +static void android_glDrawElementsIndirect(JNIEnv *_env, jobject, jint mode, jint type, jlong indirect) { + // In OpenGL ES, 'indirect' is a byte offset into a buffer, not a raw pointer. + // GL checks for too-large values. Here we only need to check for successful signed 64-bit + // to unsigned 32-bit conversion. + if (sizeof(void*) != sizeof(jlong) && indirect > UINTPTR_MAX) { + jniThrowException(_env, "java/lang/IllegalArgumentException", "indirect offset too large"); + return; + } + glDrawElementsIndirect(mode, type, (const void*)indirect); +} + +/* void glFramebufferParameteri ( GLenum target, GLenum pname, GLint param ) */ +static void +android_glFramebufferParameteri__III + (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) { + glFramebufferParameteri( + (GLenum)target, + (GLenum)pname, + (GLint)param + ); +} + +/* void glGetFramebufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */ +static void +android_glGetFramebufferParameteriv__II_3II + (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLint *params_base = (GLint *) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + if (!params_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "params == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + params_base = (GLint *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetFramebufferParameteriv( + (GLenum)target, + (GLenum)pname, + (GLint *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glGetFramebufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */ +static void +android_glGetFramebufferParameteriv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset); + if (params == NULL) { + char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + params = (GLint *) (_paramsBase + _bufferOffset); + } + glGetFramebufferParameteriv( + (GLenum)target, + (GLenum)pname, + (GLint *)params + ); + if (_array) { + releasePointer(_env, _array, params, JNI_TRUE); + } +} + +/* void glGetProgramInterfaceiv ( GLuint program, GLenum programInterface, GLenum pname, GLint *params ) */ +static void +android_glGetProgramInterfaceiv__III_3II + (JNIEnv *_env, jobject _this, jint program, jint programInterface, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLint *params_base = (GLint *) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + if (!params_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "params == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + params_base = (GLint *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetProgramInterfaceiv( + (GLuint)program, + (GLenum)programInterface, + (GLenum)pname, + (GLint *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glGetProgramInterfaceiv ( GLuint program, GLenum programInterface, GLenum pname, GLint *params ) */ +static void +android_glGetProgramInterfaceiv__IIILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint programInterface, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset); + if (params == NULL) { + char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + params = (GLint *) (_paramsBase + _bufferOffset); + } + glGetProgramInterfaceiv( + (GLuint)program, + (GLenum)programInterface, + (GLenum)pname, + (GLint *)params + ); + if (_array) { + releasePointer(_env, _array, params, JNI_TRUE); + } +} + +/* GLuint glGetProgramResourceIndex ( GLuint program, GLenum programInterface, const GLchar *name ) */ +static jint +android_glGetProgramResourceIndex__IILjava_lang_String_2 + (JNIEnv *_env, jobject _this, jint program, jint programInterface, jstring name) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLuint _returnValue = 0; + const char* _nativename = 0; + + if (!name) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "name == null"; + goto exit; + } + _nativename = _env->GetStringUTFChars(name, 0); + + _returnValue = glGetProgramResourceIndex( + (GLuint)program, + (GLenum)programInterface, + (GLchar *)_nativename + ); + +exit: + if (_nativename) { + _env->ReleaseStringUTFChars(name, _nativename); + } + + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } + return (jint)_returnValue; +} + +/* void glGetProgramResourceName ( GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name ) */ +static jstring +android_glGetProgramResourceName + (JNIEnv *_env, jobject _this, jint program, jint programInterface, jint index) { + jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented"); + return NULL; +} + +/* void glGetProgramResourceiv ( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params ) */ +static void +android_glGetProgramResourceiv__IIII_3III_3II_3II + (JNIEnv *_env, jobject _this, jint program, jint programInterface, jint index, jint propCount, jintArray props_ref, jint propsOffset, jint bufSize, jintArray length_ref, jint lengthOffset, jintArray params_ref, jint paramsOffset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLenum *props_base = (GLenum *) 0; + jint _propsRemaining; + GLenum *props = (GLenum *) 0; + GLsizei *length_base = (GLsizei *) 0; + jint _lengthRemaining; + GLsizei *length = (GLsizei *) 0; + GLint *params_base = (GLint *) 0; + jint _paramsRemaining; + GLint *params = (GLint *) 0; + + if (!props_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "props == null"; + goto exit; + } + if (propsOffset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "propsOffset < 0"; + goto exit; + } + _propsRemaining = _env->GetArrayLength(props_ref) - propsOffset; + props_base = (GLenum *) + _env->GetPrimitiveArrayCritical(props_ref, (jboolean *)0); + props = props_base + propsOffset; + + if (!length_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "length == null"; + goto exit; + } + if (lengthOffset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "lengthOffset < 0"; + goto exit; + } + _lengthRemaining = _env->GetArrayLength(length_ref) - lengthOffset; + length_base = (GLsizei *) + _env->GetPrimitiveArrayCritical(length_ref, (jboolean *)0); + length = length_base + lengthOffset; + + if (!params_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "params == null"; + goto exit; + } + if (paramsOffset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "paramsOffset < 0"; + goto exit; + } + _paramsRemaining = _env->GetArrayLength(params_ref) - paramsOffset; + params_base = (GLint *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + paramsOffset; + + glGetProgramResourceiv( + (GLuint)program, + (GLenum)programInterface, + (GLuint)index, + (GLsizei)propCount, + (GLenum *)props, + (GLsizei)bufSize, + (GLsizei *)length, + (GLint *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } + if (length_base) { + _env->ReleasePrimitiveArrayCritical(length_ref, length_base, + _exception ? JNI_ABORT: 0); + } + if (props_base) { + _env->ReleasePrimitiveArrayCritical(props_ref, props_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glGetProgramResourceiv ( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params ) */ +static void +android_glGetProgramResourceiv__IIIILjava_nio_IntBuffer_2ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint programInterface, jint index, jint propCount, jobject props_buf, jint bufSize, jobject length_buf, jobject params_buf) { + jarray _propsArray = (jarray) 0; + jint _propsBufferOffset = (jint) 0; + jarray _lengthArray = (jarray) 0; + jint _lengthBufferOffset = (jint) 0; + jarray _paramsArray = (jarray) 0; + jint _paramsBufferOffset = (jint) 0; + jint _propsRemaining; + GLenum *props = (GLenum *) 0; + jint _lengthRemaining; + GLsizei *length = (GLsizei *) 0; + jint _paramsRemaining; + GLint *params = (GLint *) 0; + + props = (GLenum *)getPointer(_env, props_buf, &_propsArray, &_propsRemaining, &_propsBufferOffset); + length = (GLsizei *)getPointer(_env, length_buf, &_lengthArray, &_lengthRemaining, &_lengthBufferOffset); + params = (GLint *)getPointer(_env, params_buf, &_paramsArray, &_paramsRemaining, &_paramsBufferOffset); + if (props == NULL) { + char * _propsBase = (char *)_env->GetPrimitiveArrayCritical(_propsArray, (jboolean *) 0); + props = (GLenum *) (_propsBase + _propsBufferOffset); + } + if (length == NULL) { + char * _lengthBase = (char *)_env->GetPrimitiveArrayCritical(_lengthArray, (jboolean *) 0); + length = (GLsizei *) (_lengthBase + _lengthBufferOffset); + } + if (params == NULL) { + char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_paramsArray, (jboolean *) 0); + params = (GLint *) (_paramsBase + _paramsBufferOffset); + } + glGetProgramResourceiv( + (GLuint)program, + (GLenum)programInterface, + (GLuint)index, + (GLsizei)propCount, + (GLenum *)props, + (GLsizei)bufSize, + (GLsizei *)length, + (GLint *)params + ); + if (_paramsArray) { + releasePointer(_env, _paramsArray, params, JNI_TRUE); + } + if (_lengthArray) { + releasePointer(_env, _lengthArray, length, JNI_TRUE); + } + if (_propsArray) { + releasePointer(_env, _propsArray, props, JNI_FALSE); + } +} + +/* GLint glGetProgramResourceLocation ( GLuint program, GLenum programInterface, const GLchar *name ) */ +static jint +android_glGetProgramResourceLocation__IILjava_lang_String_2 + (JNIEnv *_env, jobject _this, jint program, jint programInterface, jstring name) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLint _returnValue = 0; + const char* _nativename = 0; + + if (!name) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "name == null"; + goto exit; + } + _nativename = _env->GetStringUTFChars(name, 0); + + _returnValue = glGetProgramResourceLocation( + (GLuint)program, + (GLenum)programInterface, + (GLchar *)_nativename + ); + +exit: + if (_nativename) { + _env->ReleaseStringUTFChars(name, _nativename); + } + + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } + return (jint)_returnValue; +} + +/* void glUseProgramStages ( GLuint pipeline, GLbitfield stages, GLuint program ) */ +static void +android_glUseProgramStages__III + (JNIEnv *_env, jobject _this, jint pipeline, jint stages, jint program) { + glUseProgramStages( + (GLuint)pipeline, + (GLbitfield)stages, + (GLuint)program + ); +} + +/* void glActiveShaderProgram ( GLuint pipeline, GLuint program ) */ +static void +android_glActiveShaderProgram__II + (JNIEnv *_env, jobject _this, jint pipeline, jint program) { + glActiveShaderProgram( + (GLuint)pipeline, + (GLuint)program + ); +} + +/* GLuint glCreateShaderProgramv ( GLenum type, GLsizei count, const GLchar *const *strings ) */ +static jint +android_glCreateShaderProgramv + (JNIEnv *_env, jobject _this, jint type, jobjectArray strings) { + + jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented"); + return 0; +} +/* void glBindProgramPipeline ( GLuint pipeline ) */ +static void +android_glBindProgramPipeline__I + (JNIEnv *_env, jobject _this, jint pipeline) { + glBindProgramPipeline( + (GLuint)pipeline + ); +} + +/* void glDeleteProgramPipelines ( GLsizei n, const GLuint *pipelines ) */ +static void +android_glDeleteProgramPipelines__I_3II + (JNIEnv *_env, jobject _this, jint n, jintArray pipelines_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLuint *pipelines_base = (GLuint *) 0; + jint _remaining; + GLuint *pipelines = (GLuint *) 0; + + if (!pipelines_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "pipelines == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(pipelines_ref) - offset; + pipelines_base = (GLuint *) + _env->GetPrimitiveArrayCritical(pipelines_ref, (jboolean *)0); + pipelines = pipelines_base + offset; + + glDeleteProgramPipelines( + (GLsizei)n, + (GLuint *)pipelines + ); + +exit: + if (pipelines_base) { + _env->ReleasePrimitiveArrayCritical(pipelines_ref, pipelines_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glDeleteProgramPipelines ( GLsizei n, const GLuint *pipelines ) */ +static void +android_glDeleteProgramPipelines__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint n, jobject pipelines_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLuint *pipelines = (GLuint *) 0; + + pipelines = (GLuint *)getPointer(_env, pipelines_buf, &_array, &_remaining, &_bufferOffset); + if (pipelines == NULL) { + char * _pipelinesBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + pipelines = (GLuint *) (_pipelinesBase + _bufferOffset); + } + glDeleteProgramPipelines( + (GLsizei)n, + (GLuint *)pipelines + ); + if (_array) { + releasePointer(_env, _array, pipelines, JNI_FALSE); + } +} + +/* void glGenProgramPipelines ( GLsizei n, GLuint *pipelines ) */ +static void +android_glGenProgramPipelines__I_3II + (JNIEnv *_env, jobject _this, jint n, jintArray pipelines_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLuint *pipelines_base = (GLuint *) 0; + jint _remaining; + GLuint *pipelines = (GLuint *) 0; + + if (!pipelines_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "pipelines == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(pipelines_ref) - offset; + pipelines_base = (GLuint *) + _env->GetPrimitiveArrayCritical(pipelines_ref, (jboolean *)0); + pipelines = pipelines_base + offset; + + glGenProgramPipelines( + (GLsizei)n, + (GLuint *)pipelines + ); + +exit: + if (pipelines_base) { + _env->ReleasePrimitiveArrayCritical(pipelines_ref, pipelines_base, + _exception ? JNI_ABORT: 0); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glGenProgramPipelines ( GLsizei n, GLuint *pipelines ) */ +static void +android_glGenProgramPipelines__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint n, jobject pipelines_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLuint *pipelines = (GLuint *) 0; + + pipelines = (GLuint *)getPointer(_env, pipelines_buf, &_array, &_remaining, &_bufferOffset); + if (pipelines == NULL) { + char * _pipelinesBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + pipelines = (GLuint *) (_pipelinesBase + _bufferOffset); + } + glGenProgramPipelines( + (GLsizei)n, + (GLuint *)pipelines + ); + if (_array) { + releasePointer(_env, _array, pipelines, JNI_TRUE); + } +} + +/* GLboolean glIsProgramPipeline ( GLuint pipeline ) */ +static jboolean +android_glIsProgramPipeline__I + (JNIEnv *_env, jobject _this, jint pipeline) { + GLboolean _returnValue; + _returnValue = glIsProgramPipeline( + (GLuint)pipeline + ); + return (jboolean)_returnValue; +} + +/* void glGetProgramPipelineiv ( GLuint pipeline, GLenum pname, GLint *params ) */ +static void +android_glGetProgramPipelineiv__II_3II + (JNIEnv *_env, jobject _this, jint pipeline, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLint *params_base = (GLint *) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + if (!params_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "params == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + params_base = (GLint *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetProgramPipelineiv( + (GLuint)pipeline, + (GLenum)pname, + (GLint *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glGetProgramPipelineiv ( GLuint pipeline, GLenum pname, GLint *params ) */ +static void +android_glGetProgramPipelineiv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint pipeline, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset); + if (params == NULL) { + char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + params = (GLint *) (_paramsBase + _bufferOffset); + } + glGetProgramPipelineiv( + (GLuint)pipeline, + (GLenum)pname, + (GLint *)params + ); + if (_array) { + releasePointer(_env, _array, params, JNI_TRUE); + } +} + +/* void glProgramUniform1i ( GLuint program, GLint location, GLint v0 ) */ +static void +android_glProgramUniform1i__III + (JNIEnv *_env, jobject _this, jint program, jint location, jint v0) { + glProgramUniform1i( + (GLuint)program, + (GLint)location, + (GLint)v0 + ); +} + +/* void glProgramUniform2i ( GLuint program, GLint location, GLint v0, GLint v1 ) */ +static void +android_glProgramUniform2i__IIII + (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1) { + glProgramUniform2i( + (GLuint)program, + (GLint)location, + (GLint)v0, + (GLint)v1 + ); +} + +/* void glProgramUniform3i ( GLuint program, GLint location, GLint v0, GLint v1, GLint v2 ) */ +static void +android_glProgramUniform3i__IIIII + (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1, jint v2) { + glProgramUniform3i( + (GLuint)program, + (GLint)location, + (GLint)v0, + (GLint)v1, + (GLint)v2 + ); +} + +/* void glProgramUniform4i ( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 ) */ +static void +android_glProgramUniform4i__IIIIII + (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1, jint v2, jint v3) { + glProgramUniform4i( + (GLuint)program, + (GLint)location, + (GLint)v0, + (GLint)v1, + (GLint)v2, + (GLint)v3 + ); +} + +/* void glProgramUniform1ui ( GLuint program, GLint location, GLuint v0 ) */ +static void +android_glProgramUniform1ui__III + (JNIEnv *_env, jobject _this, jint program, jint location, jint v0) { + glProgramUniform1ui( + (GLuint)program, + (GLint)location, + (GLuint)v0 + ); +} + +/* void glProgramUniform2ui ( GLuint program, GLint location, GLuint v0, GLuint v1 ) */ +static void +android_glProgramUniform2ui__IIII + (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1) { + glProgramUniform2ui( + (GLuint)program, + (GLint)location, + (GLuint)v0, + (GLuint)v1 + ); +} + +/* void glProgramUniform3ui ( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 ) */ +static void +android_glProgramUniform3ui__IIIII + (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1, jint v2) { + glProgramUniform3ui( + (GLuint)program, + (GLint)location, + (GLuint)v0, + (GLuint)v1, + (GLuint)v2 + ); +} + +/* void glProgramUniform4ui ( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) */ +static void +android_glProgramUniform4ui__IIIIII + (JNIEnv *_env, jobject _this, jint program, jint location, jint v0, jint v1, jint v2, jint v3) { + glProgramUniform4ui( + (GLuint)program, + (GLint)location, + (GLuint)v0, + (GLuint)v1, + (GLuint)v2, + (GLuint)v3 + ); +} + +/* void glProgramUniform1f ( GLuint program, GLint location, GLfloat v0 ) */ +static void +android_glProgramUniform1f__IIF + (JNIEnv *_env, jobject _this, jint program, jint location, jfloat v0) { + glProgramUniform1f( + (GLuint)program, + (GLint)location, + (GLfloat)v0 + ); +} + +/* void glProgramUniform2f ( GLuint program, GLint location, GLfloat v0, GLfloat v1 ) */ +static void +android_glProgramUniform2f__IIFF + (JNIEnv *_env, jobject _this, jint program, jint location, jfloat v0, jfloat v1) { + glProgramUniform2f( + (GLuint)program, + (GLint)location, + (GLfloat)v0, + (GLfloat)v1 + ); +} + +/* void glProgramUniform3f ( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 ) */ +static void +android_glProgramUniform3f__IIFFF + (JNIEnv *_env, jobject _this, jint program, jint location, jfloat v0, jfloat v1, jfloat v2) { + glProgramUniform3f( + (GLuint)program, + (GLint)location, + (GLfloat)v0, + (GLfloat)v1, + (GLfloat)v2 + ); +} + +/* void glProgramUniform4f ( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) */ +static void +android_glProgramUniform4f__IIFFFF + (JNIEnv *_env, jobject _this, jint program, jint location, jfloat v0, jfloat v1, jfloat v2, jfloat v3) { + glProgramUniform4f( + (GLuint)program, + (GLint)location, + (GLfloat)v0, + (GLfloat)v1, + (GLfloat)v2, + (GLfloat)v3 + ); +} + +/* void glProgramUniform1iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */ +static void +android_glProgramUniform1iv__III_3II + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLint *value_base = (GLint *) 0; + jint _remaining; + GLint *value = (GLint *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLint *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniform1iv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLint *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniform1iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */ +static void +android_glProgramUniform1iv__IIILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLint *value = (GLint *) 0; + + value = (GLint *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLint *) (_valueBase + _bufferOffset); + } + glProgramUniform1iv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLint *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniform2iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */ +static void +android_glProgramUniform2iv__III_3II + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLint *value_base = (GLint *) 0; + jint _remaining; + GLint *value = (GLint *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLint *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniform2iv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLint *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniform2iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */ +static void +android_glProgramUniform2iv__IIILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLint *value = (GLint *) 0; + + value = (GLint *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLint *) (_valueBase + _bufferOffset); + } + glProgramUniform2iv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLint *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniform3iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */ +static void +android_glProgramUniform3iv__III_3II + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLint *value_base = (GLint *) 0; + jint _remaining; + GLint *value = (GLint *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLint *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniform3iv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLint *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniform3iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */ +static void +android_glProgramUniform3iv__IIILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLint *value = (GLint *) 0; + + value = (GLint *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLint *) (_valueBase + _bufferOffset); + } + glProgramUniform3iv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLint *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniform4iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */ +static void +android_glProgramUniform4iv__III_3II + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLint *value_base = (GLint *) 0; + jint _remaining; + GLint *value = (GLint *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLint *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniform4iv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLint *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniform4iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) */ +static void +android_glProgramUniform4iv__IIILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLint *value = (GLint *) 0; + + value = (GLint *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLint *) (_valueBase + _bufferOffset); + } + glProgramUniform4iv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLint *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniform1uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */ +static void +android_glProgramUniform1uiv__III_3II + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLuint *value_base = (GLuint *) 0; + jint _remaining; + GLuint *value = (GLuint *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLuint *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniform1uiv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLuint *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniform1uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */ +static void +android_glProgramUniform1uiv__IIILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLuint *value = (GLuint *) 0; + + value = (GLuint *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLuint *) (_valueBase + _bufferOffset); + } + glProgramUniform1uiv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLuint *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniform2uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */ +static void +android_glProgramUniform2uiv__III_3II + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLuint *value_base = (GLuint *) 0; + jint _remaining; + GLuint *value = (GLuint *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLuint *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniform2uiv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLuint *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniform2uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */ +static void +android_glProgramUniform2uiv__IIILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLuint *value = (GLuint *) 0; + + value = (GLuint *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLuint *) (_valueBase + _bufferOffset); + } + glProgramUniform2uiv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLuint *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniform3uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */ +static void +android_glProgramUniform3uiv__III_3II + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLuint *value_base = (GLuint *) 0; + jint _remaining; + GLuint *value = (GLuint *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLuint *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniform3uiv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLuint *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniform3uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */ +static void +android_glProgramUniform3uiv__IIILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLuint *value = (GLuint *) 0; + + value = (GLuint *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLuint *) (_valueBase + _bufferOffset); + } + glProgramUniform3uiv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLuint *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniform4uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */ +static void +android_glProgramUniform4uiv__III_3II + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jintArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLuint *value_base = (GLuint *) 0; + jint _remaining; + GLuint *value = (GLuint *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLuint *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniform4uiv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLuint *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniform4uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) */ +static void +android_glProgramUniform4uiv__IIILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLuint *value = (GLuint *) 0; + + value = (GLuint *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLuint *) (_valueBase + _bufferOffset); + } + glProgramUniform4uiv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLuint *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniform1fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */ +static void +android_glProgramUniform1fv__III_3FI + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jfloatArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLfloat *value_base = (GLfloat *) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniform1fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLfloat *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniform1fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */ +static void +android_glProgramUniform1fv__IIILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLfloat *) (_valueBase + _bufferOffset); + } + glProgramUniform1fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLfloat *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniform2fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */ +static void +android_glProgramUniform2fv__III_3FI + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jfloatArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLfloat *value_base = (GLfloat *) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniform2fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLfloat *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniform2fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */ +static void +android_glProgramUniform2fv__IIILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLfloat *) (_valueBase + _bufferOffset); + } + glProgramUniform2fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLfloat *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniform3fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */ +static void +android_glProgramUniform3fv__III_3FI + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jfloatArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLfloat *value_base = (GLfloat *) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniform3fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLfloat *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniform3fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */ +static void +android_glProgramUniform3fv__IIILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLfloat *) (_valueBase + _bufferOffset); + } + glProgramUniform3fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLfloat *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniform4fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */ +static void +android_glProgramUniform4fv__III_3FI + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jfloatArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLfloat *value_base = (GLfloat *) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniform4fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLfloat *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniform4fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) */ +static void +android_glProgramUniform4fv__IIILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLfloat *) (_valueBase + _bufferOffset); + } + glProgramUniform4fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLfloat *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniformMatrix2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix2fv__IIIZ_3FI + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLfloat *value_base = (GLfloat *) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniformMatrix2fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniformMatrix2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix2fv__IIIZLjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLfloat *) (_valueBase + _bufferOffset); + } + glProgramUniformMatrix2fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniformMatrix3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix3fv__IIIZ_3FI + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLfloat *value_base = (GLfloat *) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniformMatrix3fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniformMatrix3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix3fv__IIIZLjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLfloat *) (_valueBase + _bufferOffset); + } + glProgramUniformMatrix3fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniformMatrix4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix4fv__IIIZ_3FI + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLfloat *value_base = (GLfloat *) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniformMatrix4fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniformMatrix4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix4fv__IIIZLjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLfloat *) (_valueBase + _bufferOffset); + } + glProgramUniformMatrix4fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniformMatrix2x3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix2x3fv__IIIZ_3FI + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLfloat *value_base = (GLfloat *) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniformMatrix2x3fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniformMatrix2x3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix2x3fv__IIIZLjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLfloat *) (_valueBase + _bufferOffset); + } + glProgramUniformMatrix2x3fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniformMatrix3x2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix3x2fv__IIIZ_3FI + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLfloat *value_base = (GLfloat *) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniformMatrix3x2fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniformMatrix3x2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix3x2fv__IIIZLjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLfloat *) (_valueBase + _bufferOffset); + } + glProgramUniformMatrix3x2fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniformMatrix2x4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix2x4fv__IIIZ_3FI + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLfloat *value_base = (GLfloat *) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniformMatrix2x4fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniformMatrix2x4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix2x4fv__IIIZLjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLfloat *) (_valueBase + _bufferOffset); + } + glProgramUniformMatrix2x4fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniformMatrix4x2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix4x2fv__IIIZ_3FI + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLfloat *value_base = (GLfloat *) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniformMatrix4x2fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniformMatrix4x2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix4x2fv__IIIZLjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLfloat *) (_valueBase + _bufferOffset); + } + glProgramUniformMatrix4x2fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniformMatrix3x4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix3x4fv__IIIZ_3FI + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLfloat *value_base = (GLfloat *) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniformMatrix3x4fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniformMatrix3x4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix3x4fv__IIIZLjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLfloat *) (_valueBase + _bufferOffset); + } + glProgramUniformMatrix3x4fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glProgramUniformMatrix4x3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix4x3fv__IIIZ_3FI + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLfloat *value_base = (GLfloat *) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(value_ref, (jboolean *)0); + value = value_base + offset; + + glProgramUniformMatrix4x3fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + +exit: + if (value_base) { + _env->ReleasePrimitiveArrayCritical(value_ref, value_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glProgramUniformMatrix4x3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) */ +static void +android_glProgramUniformMatrix4x3fv__IIIZLjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint program, jint location, jint count, jboolean transpose, jobject value_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLfloat *value = (GLfloat *) 0; + + value = (GLfloat *)getPointer(_env, value_buf, &_array, &_remaining, &_bufferOffset); + if (value == NULL) { + char * _valueBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + value = (GLfloat *) (_valueBase + _bufferOffset); + } + glProgramUniformMatrix4x3fv( + (GLuint)program, + (GLint)location, + (GLsizei)count, + (GLboolean)transpose, + (GLfloat *)value + ); + if (_array) { + releasePointer(_env, _array, value, JNI_FALSE); + } +} + +/* void glValidateProgramPipeline ( GLuint pipeline ) */ +static void +android_glValidateProgramPipeline__I + (JNIEnv *_env, jobject _this, jint pipeline) { + glValidateProgramPipeline( + (GLuint)pipeline + ); +} + +#include + +/* void glGetProgramPipelineInfoLog ( GLuint shader, GLsizei maxLength, GLsizei* length, GLchar* infoLog ) */ +static jstring android_glGetProgramPipelineInfoLog(JNIEnv *_env, jobject, jint shader) { + GLint infoLen = 0; + glGetProgramPipelineiv(shader, GL_INFO_LOG_LENGTH, &infoLen); + if (!infoLen) { + return _env->NewStringUTF(""); + } + char* buf = (char*) malloc(infoLen); + if (buf == NULL) { + jniThrowException(_env, "java/lang/OutOfMemoryError", "out of memory"); + return NULL; + } + glGetProgramPipelineInfoLog(shader, infoLen, NULL, buf); + jstring result = _env->NewStringUTF(buf); + free(buf); + return result; +} +/* void glBindImageTexture ( GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format ) */ +static void +android_glBindImageTexture__IIIZIII + (JNIEnv *_env, jobject _this, jint unit, jint texture, jint level, jboolean layered, jint layer, jint access, jint format) { + glBindImageTexture( + (GLuint)unit, + (GLuint)texture, + (GLint)level, + (GLboolean)layered, + (GLint)layer, + (GLenum)access, + (GLenum)format + ); +} + +/* void glGetBooleani_v ( GLenum target, GLuint index, GLboolean *data ) */ +static void +android_glGetBooleani_v__II_3ZI + (JNIEnv *_env, jobject _this, jint target, jint index, jbooleanArray data_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLboolean *data_base = (GLboolean *) 0; + jint _remaining; + GLboolean *data = (GLboolean *) 0; + + if (!data_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "data == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(data_ref) - offset; + data_base = (GLboolean *) + _env->GetPrimitiveArrayCritical(data_ref, (jboolean *)0); + data = data_base + offset; + + glGetBooleani_v( + (GLenum)target, + (GLuint)index, + (GLboolean *)data + ); + +exit: + if (data_base) { + _env->ReleasePrimitiveArrayCritical(data_ref, data_base, + _exception ? JNI_ABORT: 0); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glGetBooleani_v ( GLenum target, GLuint index, GLboolean *data ) */ +static void +android_glGetBooleani_v__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint index, jobject data_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLboolean *data = (GLboolean *) 0; + + data = (GLboolean *)getPointer(_env, data_buf, &_array, &_remaining, &_bufferOffset); + if (data == NULL) { + char * _dataBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + data = (GLboolean *) (_dataBase + _bufferOffset); + } + glGetBooleani_v( + (GLenum)target, + (GLuint)index, + (GLboolean *)data + ); + if (_array) { + releasePointer(_env, _array, data, JNI_TRUE); + } +} + +/* void glMemoryBarrier ( GLbitfield barriers ) */ +static void +android_glMemoryBarrier__I + (JNIEnv *_env, jobject _this, jint barriers) { + glMemoryBarrier( + (GLbitfield)barriers + ); +} + +/* void glMemoryBarrierByRegion ( GLbitfield barriers ) */ +static void +android_glMemoryBarrierByRegion__I + (JNIEnv *_env, jobject _this, jint barriers) { + glMemoryBarrierByRegion( + (GLbitfield)barriers + ); +} + +/* void glTexStorage2DMultisample ( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations ) */ +static void +android_glTexStorage2DMultisample__IIIIIZ + (JNIEnv *_env, jobject _this, jint target, jint samples, jint internalformat, jint width, jint height, jboolean fixedsamplelocations) { + glTexStorage2DMultisample( + (GLenum)target, + (GLsizei)samples, + (GLenum)internalformat, + (GLsizei)width, + (GLsizei)height, + (GLboolean)fixedsamplelocations + ); +} + +/* void glGetMultisamplefv ( GLenum pname, GLuint index, GLfloat *val ) */ +static void +android_glGetMultisamplefv__II_3FI + (JNIEnv *_env, jobject _this, jint pname, jint index, jfloatArray val_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLfloat *val_base = (GLfloat *) 0; + jint _remaining; + GLfloat *val = (GLfloat *) 0; + + if (!val_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "val == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(val_ref) - offset; + val_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(val_ref, (jboolean *)0); + val = val_base + offset; + + glGetMultisamplefv( + (GLenum)pname, + (GLuint)index, + (GLfloat *)val + ); + +exit: + if (val_base) { + _env->ReleasePrimitiveArrayCritical(val_ref, val_base, + _exception ? JNI_ABORT: 0); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glGetMultisamplefv ( GLenum pname, GLuint index, GLfloat *val ) */ +static void +android_glGetMultisamplefv__IILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint pname, jint index, jobject val_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLfloat *val = (GLfloat *) 0; + + val = (GLfloat *)getPointer(_env, val_buf, &_array, &_remaining, &_bufferOffset); + if (val == NULL) { + char * _valBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + val = (GLfloat *) (_valBase + _bufferOffset); + } + glGetMultisamplefv( + (GLenum)pname, + (GLuint)index, + (GLfloat *)val + ); + if (_array) { + releasePointer(_env, _array, val, JNI_TRUE); + } +} + +/* void glSampleMaski ( GLuint maskNumber, GLbitfield mask ) */ +static void +android_glSampleMaski__II + (JNIEnv *_env, jobject _this, jint maskNumber, jint mask) { + glSampleMaski( + (GLuint)maskNumber, + (GLbitfield)mask + ); +} + +/* void glGetTexLevelParameteriv ( GLenum target, GLint level, GLenum pname, GLint *params ) */ +static void +android_glGetTexLevelParameteriv__III_3II + (JNIEnv *_env, jobject _this, jint target, jint level, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLint *params_base = (GLint *) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + if (!params_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "params == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + params_base = (GLint *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetTexLevelParameteriv( + (GLenum)target, + (GLint)level, + (GLenum)pname, + (GLint *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glGetTexLevelParameteriv ( GLenum target, GLint level, GLenum pname, GLint *params ) */ +static void +android_glGetTexLevelParameteriv__IIILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint level, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset); + if (params == NULL) { + char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + params = (GLint *) (_paramsBase + _bufferOffset); + } + glGetTexLevelParameteriv( + (GLenum)target, + (GLint)level, + (GLenum)pname, + (GLint *)params + ); + if (_array) { + releasePointer(_env, _array, params, JNI_TRUE); + } +} + +/* void glGetTexLevelParameterfv ( GLenum target, GLint level, GLenum pname, GLfloat *params ) */ +static void +android_glGetTexLevelParameterfv__III_3FI + (JNIEnv *_env, jobject _this, jint target, jint level, jint pname, jfloatArray params_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLfloat *params_base = (GLfloat *) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + if (!params_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "params == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + params_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetTexLevelParameterfv( + (GLenum)target, + (GLint)level, + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glGetTexLevelParameterfv ( GLenum target, GLint level, GLenum pname, GLfloat *params ) */ +static void +android_glGetTexLevelParameterfv__IIILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint level, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset); + if (params == NULL) { + char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + params = (GLfloat *) (_paramsBase + _bufferOffset); + } + glGetTexLevelParameterfv( + (GLenum)target, + (GLint)level, + (GLenum)pname, + (GLfloat *)params + ); + if (_array) { + releasePointer(_env, _array, params, JNI_TRUE); + } +} + +/* void glBindVertexBuffer ( GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride ) */ +static void +android_glBindVertexBuffer__IIJI + (JNIEnv *_env, jobject _this, jint bindingindex, jint buffer, jlong offset, jint stride) { + if (sizeof(GLintptr) != sizeof(jlong) && (offset < LONG_MIN || offset > LONG_MAX)) { + jniThrowException(_env, "java/lang/IllegalArgumentException", "offset too large"); + return; + } + glBindVertexBuffer( + (GLuint)bindingindex, + (GLuint)buffer, + (GLintptr)offset, + (GLsizei)stride + ); +} +/* void glVertexAttribFormat ( GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset ) */ +static void +android_glVertexAttribFormat__IIIZI + (JNIEnv *_env, jobject _this, jint attribindex, jint size, jint type, jboolean normalized, jint relativeoffset) { + glVertexAttribFormat( + (GLuint)attribindex, + (GLint)size, + (GLenum)type, + (GLboolean)normalized, + (GLuint)relativeoffset + ); +} + +/* void glVertexAttribIFormat ( GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset ) */ +static void +android_glVertexAttribIFormat__IIII + (JNIEnv *_env, jobject _this, jint attribindex, jint size, jint type, jint relativeoffset) { + glVertexAttribIFormat( + (GLuint)attribindex, + (GLint)size, + (GLenum)type, + (GLuint)relativeoffset + ); +} + +/* void glVertexAttribBinding ( GLuint attribindex, GLuint bindingindex ) */ +static void +android_glVertexAttribBinding__II + (JNIEnv *_env, jobject _this, jint attribindex, jint bindingindex) { + glVertexAttribBinding( + (GLuint)attribindex, + (GLuint)bindingindex + ); +} + +/* void glVertexBindingDivisor ( GLuint bindingindex, GLuint divisor ) */ +static void +android_glVertexBindingDivisor__II + (JNIEnv *_env, jobject _this, jint bindingindex, jint divisor) { + glVertexBindingDivisor( + (GLuint)bindingindex, + (GLuint)divisor + ); +} + +static const char *classPathName = "android/opengl/GLES31"; + +static JNINativeMethod methods[] = { +{"_nativeClassInit", "()V", (void*)nativeClassInit }, +{"glDispatchCompute", "(III)V", (void *) android_glDispatchCompute__III }, +{"glDispatchComputeIndirect", "(J)V", (void *) android_glDispatchComputeIndirect }, +{"glDrawArraysIndirect", "(IJ)V", (void *) android_glDrawArraysIndirect }, +{"glDrawElementsIndirect", "(IIJ)V", (void *) android_glDrawElementsIndirect }, +{"glFramebufferParameteri", "(III)V", (void *) android_glFramebufferParameteri__III }, +{"glGetFramebufferParameteriv", "(II[II)V", (void *) android_glGetFramebufferParameteriv__II_3II }, +{"glGetFramebufferParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetFramebufferParameteriv__IILjava_nio_IntBuffer_2 }, +{"glGetProgramInterfaceiv", "(III[II)V", (void *) android_glGetProgramInterfaceiv__III_3II }, +{"glGetProgramInterfaceiv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetProgramInterfaceiv__IIILjava_nio_IntBuffer_2 }, +{"glGetProgramResourceIndex", "(IILjava/lang/String;)I", (void *) android_glGetProgramResourceIndex__IILjava_lang_String_2 }, +{"glGetProgramResourceName", "(III)Ljava/lang/String;", (void *) android_glGetProgramResourceName }, +{"glGetProgramResourceiv", "(IIII[III[II[II)V", (void *) android_glGetProgramResourceiv__IIII_3III_3II_3II }, +{"glGetProgramResourceiv", "(IIIILjava/nio/IntBuffer;ILjava/nio/IntBuffer;Ljava/nio/IntBuffer;)V", (void *) android_glGetProgramResourceiv__IIIILjava_nio_IntBuffer_2ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 }, +{"glGetProgramResourceLocation", "(IILjava/lang/String;)I", (void *) android_glGetProgramResourceLocation__IILjava_lang_String_2 }, +{"glUseProgramStages", "(III)V", (void *) android_glUseProgramStages__III }, +{"glActiveShaderProgram", "(II)V", (void *) android_glActiveShaderProgram__II }, +{"glCreateShaderProgramv", "(I[Ljava/lang/String;)I", (void *) android_glCreateShaderProgramv }, +{"glBindProgramPipeline", "(I)V", (void *) android_glBindProgramPipeline__I }, +{"glDeleteProgramPipelines", "(I[II)V", (void *) android_glDeleteProgramPipelines__I_3II }, +{"glDeleteProgramPipelines", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteProgramPipelines__ILjava_nio_IntBuffer_2 }, +{"glGenProgramPipelines", "(I[II)V", (void *) android_glGenProgramPipelines__I_3II }, +{"glGenProgramPipelines", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenProgramPipelines__ILjava_nio_IntBuffer_2 }, +{"glIsProgramPipeline", "(I)Z", (void *) android_glIsProgramPipeline__I }, +{"glGetProgramPipelineiv", "(II[II)V", (void *) android_glGetProgramPipelineiv__II_3II }, +{"glGetProgramPipelineiv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetProgramPipelineiv__IILjava_nio_IntBuffer_2 }, +{"glProgramUniform1i", "(III)V", (void *) android_glProgramUniform1i__III }, +{"glProgramUniform2i", "(IIII)V", (void *) android_glProgramUniform2i__IIII }, +{"glProgramUniform3i", "(IIIII)V", (void *) android_glProgramUniform3i__IIIII }, +{"glProgramUniform4i", "(IIIIII)V", (void *) android_glProgramUniform4i__IIIIII }, +{"glProgramUniform1ui", "(III)V", (void *) android_glProgramUniform1ui__III }, +{"glProgramUniform2ui", "(IIII)V", (void *) android_glProgramUniform2ui__IIII }, +{"glProgramUniform3ui", "(IIIII)V", (void *) android_glProgramUniform3ui__IIIII }, +{"glProgramUniform4ui", "(IIIIII)V", (void *) android_glProgramUniform4ui__IIIIII }, +{"glProgramUniform1f", "(IIF)V", (void *) android_glProgramUniform1f__IIF }, +{"glProgramUniform2f", "(IIFF)V", (void *) android_glProgramUniform2f__IIFF }, +{"glProgramUniform3f", "(IIFFF)V", (void *) android_glProgramUniform3f__IIFFF }, +{"glProgramUniform4f", "(IIFFFF)V", (void *) android_glProgramUniform4f__IIFFFF }, +{"glProgramUniform1iv", "(III[II)V", (void *) android_glProgramUniform1iv__III_3II }, +{"glProgramUniform1iv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform1iv__IIILjava_nio_IntBuffer_2 }, +{"glProgramUniform2iv", "(III[II)V", (void *) android_glProgramUniform2iv__III_3II }, +{"glProgramUniform2iv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform2iv__IIILjava_nio_IntBuffer_2 }, +{"glProgramUniform3iv", "(III[II)V", (void *) android_glProgramUniform3iv__III_3II }, +{"glProgramUniform3iv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform3iv__IIILjava_nio_IntBuffer_2 }, +{"glProgramUniform4iv", "(III[II)V", (void *) android_glProgramUniform4iv__III_3II }, +{"glProgramUniform4iv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform4iv__IIILjava_nio_IntBuffer_2 }, +{"glProgramUniform1uiv", "(III[II)V", (void *) android_glProgramUniform1uiv__III_3II }, +{"glProgramUniform1uiv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform1uiv__IIILjava_nio_IntBuffer_2 }, +{"glProgramUniform2uiv", "(III[II)V", (void *) android_glProgramUniform2uiv__III_3II }, +{"glProgramUniform2uiv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform2uiv__IIILjava_nio_IntBuffer_2 }, +{"glProgramUniform3uiv", "(III[II)V", (void *) android_glProgramUniform3uiv__III_3II }, +{"glProgramUniform3uiv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform3uiv__IIILjava_nio_IntBuffer_2 }, +{"glProgramUniform4uiv", "(III[II)V", (void *) android_glProgramUniform4uiv__III_3II }, +{"glProgramUniform4uiv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glProgramUniform4uiv__IIILjava_nio_IntBuffer_2 }, +{"glProgramUniform1fv", "(III[FI)V", (void *) android_glProgramUniform1fv__III_3FI }, +{"glProgramUniform1fv", "(IIILjava/nio/FloatBuffer;)V", (void *) android_glProgramUniform1fv__IIILjava_nio_FloatBuffer_2 }, +{"glProgramUniform2fv", "(III[FI)V", (void *) android_glProgramUniform2fv__III_3FI }, +{"glProgramUniform2fv", "(IIILjava/nio/FloatBuffer;)V", (void *) android_glProgramUniform2fv__IIILjava_nio_FloatBuffer_2 }, +{"glProgramUniform3fv", "(III[FI)V", (void *) android_glProgramUniform3fv__III_3FI }, +{"glProgramUniform3fv", "(IIILjava/nio/FloatBuffer;)V", (void *) android_glProgramUniform3fv__IIILjava_nio_FloatBuffer_2 }, +{"glProgramUniform4fv", "(III[FI)V", (void *) android_glProgramUniform4fv__III_3FI }, +{"glProgramUniform4fv", "(IIILjava/nio/FloatBuffer;)V", (void *) android_glProgramUniform4fv__IIILjava_nio_FloatBuffer_2 }, +{"glProgramUniformMatrix2fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix2fv__IIIZ_3FI }, +{"glProgramUniformMatrix2fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix2fv__IIIZLjava_nio_FloatBuffer_2 }, +{"glProgramUniformMatrix3fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix3fv__IIIZ_3FI }, +{"glProgramUniformMatrix3fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix3fv__IIIZLjava_nio_FloatBuffer_2 }, +{"glProgramUniformMatrix4fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix4fv__IIIZ_3FI }, +{"glProgramUniformMatrix4fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix4fv__IIIZLjava_nio_FloatBuffer_2 }, +{"glProgramUniformMatrix2x3fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix2x3fv__IIIZ_3FI }, +{"glProgramUniformMatrix2x3fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix2x3fv__IIIZLjava_nio_FloatBuffer_2 }, +{"glProgramUniformMatrix3x2fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix3x2fv__IIIZ_3FI }, +{"glProgramUniformMatrix3x2fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix3x2fv__IIIZLjava_nio_FloatBuffer_2 }, +{"glProgramUniformMatrix2x4fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix2x4fv__IIIZ_3FI }, +{"glProgramUniformMatrix2x4fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix2x4fv__IIIZLjava_nio_FloatBuffer_2 }, +{"glProgramUniformMatrix4x2fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix4x2fv__IIIZ_3FI }, +{"glProgramUniformMatrix4x2fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix4x2fv__IIIZLjava_nio_FloatBuffer_2 }, +{"glProgramUniformMatrix3x4fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix3x4fv__IIIZ_3FI }, +{"glProgramUniformMatrix3x4fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix3x4fv__IIIZLjava_nio_FloatBuffer_2 }, +{"glProgramUniformMatrix4x3fv", "(IIIZ[FI)V", (void *) android_glProgramUniformMatrix4x3fv__IIIZ_3FI }, +{"glProgramUniformMatrix4x3fv", "(IIIZLjava/nio/FloatBuffer;)V", (void *) android_glProgramUniformMatrix4x3fv__IIIZLjava_nio_FloatBuffer_2 }, +{"glValidateProgramPipeline", "(I)V", (void *) android_glValidateProgramPipeline__I }, +{"glGetProgramPipelineInfoLog", "(I)Ljava/lang/String;", (void *) android_glGetProgramPipelineInfoLog }, +{"glBindImageTexture", "(IIIZIII)V", (void *) android_glBindImageTexture__IIIZIII }, +{"glGetBooleani_v", "(II[ZI)V", (void *) android_glGetBooleani_v__II_3ZI }, +{"glGetBooleani_v", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetBooleani_v__IILjava_nio_IntBuffer_2 }, +{"glMemoryBarrier", "(I)V", (void *) android_glMemoryBarrier__I }, +{"glMemoryBarrierByRegion", "(I)V", (void *) android_glMemoryBarrierByRegion__I }, +{"glTexStorage2DMultisample", "(IIIIIZ)V", (void *) android_glTexStorage2DMultisample__IIIIIZ }, +{"glGetMultisamplefv", "(II[FI)V", (void *) android_glGetMultisamplefv__II_3FI }, +{"glGetMultisamplefv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetMultisamplefv__IILjava_nio_FloatBuffer_2 }, +{"glSampleMaski", "(II)V", (void *) android_glSampleMaski__II }, +{"glGetTexLevelParameteriv", "(III[II)V", (void *) android_glGetTexLevelParameteriv__III_3II }, +{"glGetTexLevelParameteriv", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetTexLevelParameteriv__IIILjava_nio_IntBuffer_2 }, +{"glGetTexLevelParameterfv", "(III[FI)V", (void *) android_glGetTexLevelParameterfv__III_3FI }, +{"glGetTexLevelParameterfv", "(IIILjava/nio/FloatBuffer;)V", (void *) android_glGetTexLevelParameterfv__IIILjava_nio_FloatBuffer_2 }, +{"glBindVertexBuffer", "(IIJI)V", (void *) android_glBindVertexBuffer__IIJI }, +{"glVertexAttribFormat", "(IIIZI)V", (void *) android_glVertexAttribFormat__IIIZI }, +{"glVertexAttribIFormat", "(IIII)V", (void *) android_glVertexAttribIFormat__IIII }, +{"glVertexAttribBinding", "(II)V", (void *) android_glVertexAttribBinding__II }, +{"glVertexBindingDivisor", "(II)V", (void *) android_glVertexBindingDivisor__II }, +}; + +int register_android_opengl_jni_GLES31(JNIEnv *_env) +{ + int err; + err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods)); + return err; +} diff --git a/core/jni/android_opengl_GLES31Ext.cpp b/core/jni/android_opengl_GLES31Ext.cpp new file mode 100644 index 0000000..270b50e --- /dev/null +++ b/core/jni/android_opengl_GLES31Ext.cpp @@ -0,0 +1,1385 @@ +/* + * Copyright 2014 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 +#include + +#include "jni.h" +#include "JNIHelp.h" +#include +#include +#include + +static int initialized = 0; + +static jclass nioAccessClass; +static jclass bufferClass; +static jmethodID getBasePointerID; +static jmethodID getBaseArrayID; +static jmethodID getBaseArrayOffsetID; +static jfieldID positionID; +static jfieldID limitID; +static jfieldID elementSizeShiftID; + + +/* special calls implemented in Android's GLES wrapper used to more + * efficiently bound-check passed arrays */ +extern "C" { +#ifdef GL_VERSION_ES_CM_1_1 +GL_API void GL_APIENTRY glColorPointerBounds(GLint size, GLenum type, GLsizei stride, + const GLvoid *ptr, GLsizei count); +GL_API void GL_APIENTRY glNormalPointerBounds(GLenum type, GLsizei stride, + const GLvoid *pointer, GLsizei count); +GL_API void GL_APIENTRY glTexCoordPointerBounds(GLint size, GLenum type, + GLsizei stride, const GLvoid *pointer, GLsizei count); +GL_API void GL_APIENTRY glVertexPointerBounds(GLint size, GLenum type, + GLsizei stride, const GLvoid *pointer, GLsizei count); +GL_API void GL_APIENTRY glPointSizePointerOESBounds(GLenum type, + GLsizei stride, const GLvoid *pointer, GLsizei count); +GL_API void GL_APIENTRY glMatrixIndexPointerOESBounds(GLint size, GLenum type, + GLsizei stride, const GLvoid *pointer, GLsizei count); +GL_API void GL_APIENTRY glWeightPointerOESBounds(GLint size, GLenum type, + GLsizei stride, const GLvoid *pointer, GLsizei count); +#endif +#ifdef GL_ES_VERSION_2_0 +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); +} +#endif +#ifdef GL_ES_VERSION_3_0 +static void glVertexAttribIPointerBounds(GLuint indx, GLint size, GLenum type, + GLsizei stride, const GLvoid *pointer, GLsizei count) { + glVertexAttribIPointer(indx, size, type, stride, pointer); +} +#endif +} + +/* Cache method IDs each time the class is loaded. */ + +static void +nativeClassInit(JNIEnv *_env, jclass glImplClass) +{ + 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 * +getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining, jint *offset) +{ + jint position; + jint limit; + jint elementSizeShift; + jlong pointer; + + 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 reinterpret_cast(pointer); + } + + *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass, + getBaseArrayID, buffer); + *offset = _env->CallStaticIntMethod(nioAccessClass, + getBaseArrayOffsetID, buffer); + + return NULL; +} + +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 { + jniThrowException(_env, "java/lang/IllegalArgumentException", + "Must use a native order direct Buffer"); + } + return (void*) buf; +} + +// -------------------------------------------------------------------------- + +/* + * returns the number of values glGet returns for a given pname. + * + * The code below is written such that pnames requiring only one values + * are the default (and are not explicitely tested for). This makes the + * checking code much shorter/readable/efficient. + * + * This means that unknown pnames (e.g.: extensions) will default to 1. If + * that unknown pname needs more than 1 value, then the validation check + * is incomplete and the app may crash if it passed the wrong number params. + */ +static int getNeededCount(GLint pname) { + int needed = 1; +#ifdef GL_ES_VERSION_2_0 + // GLES 2.x pnames + switch (pname) { + case GL_ALIASED_LINE_WIDTH_RANGE: + case GL_ALIASED_POINT_SIZE_RANGE: + needed = 2; + break; + + case GL_BLEND_COLOR: + case GL_COLOR_CLEAR_VALUE: + case GL_COLOR_WRITEMASK: + case GL_SCISSOR_BOX: + case GL_VIEWPORT: + needed = 4; + break; + + case GL_COMPRESSED_TEXTURE_FORMATS: + glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed); + break; + + case GL_SHADER_BINARY_FORMATS: + glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &needed); + break; + } +#endif + +#ifdef GL_VERSION_ES_CM_1_1 + // GLES 1.x pnames + switch (pname) { + case GL_ALIASED_LINE_WIDTH_RANGE: + case GL_ALIASED_POINT_SIZE_RANGE: + case GL_DEPTH_RANGE: + case GL_SMOOTH_LINE_WIDTH_RANGE: + case GL_SMOOTH_POINT_SIZE_RANGE: + needed = 2; + break; + + case GL_CURRENT_NORMAL: + case GL_POINT_DISTANCE_ATTENUATION: + needed = 3; + break; + + case GL_COLOR_CLEAR_VALUE: + case GL_COLOR_WRITEMASK: + case GL_CURRENT_COLOR: + case GL_CURRENT_TEXTURE_COORDS: + case GL_FOG_COLOR: + case GL_LIGHT_MODEL_AMBIENT: + case GL_SCISSOR_BOX: + case GL_VIEWPORT: + needed = 4; + break; + + case GL_MODELVIEW_MATRIX: + case GL_PROJECTION_MATRIX: + case GL_TEXTURE_MATRIX: + needed = 16; + break; + + case GL_COMPRESSED_TEXTURE_FORMATS: + glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed); + break; + } +#endif + return needed; +} + +template +static void +get + (JNIEnv *_env, jobject _this, jint pname, JTYPEARRAY params_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType; + const char * _exceptionMessage; + CTYPE *params_base = (CTYPE *) 0; + jint _remaining; + CTYPE *params = (CTYPE *) 0; + int _needed = 0; + + if (!params_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "params == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + _needed = getNeededCount(pname); + // if we didn't find this pname, we just assume the user passed + // an array of the right size -- this might happen with extensions + // or if we forget an enum here. + if (_remaining < _needed) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "length - offset < needed"; + goto exit; + } + params_base = (CTYPE *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + GET( + (GLenum)pname, + (CTYPE *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + + +template +static void +getarray + (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { + jint _exception = 0; + const char * _exceptionType; + const char * _exceptionMessage; + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + CTYPE *params = (CTYPE *) 0; + int _needed = 0; + + params = (CTYPE *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset); + _remaining /= sizeof(CTYPE); // convert from bytes to item count + _needed = getNeededCount(pname); + // if we didn't find this pname, we just assume the user passed + // an array of the right size -- this might happen with extensions + // or if we forget an enum here. + if (_needed>0 && _remaining < _needed) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "remaining() < needed"; + goto exit; + } + if (params == NULL) { + char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + params = (CTYPE *) (_paramsBase + _bufferOffset); + } + GET( + (GLenum)pname, + (CTYPE *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +// -------------------------------------------------------------------------- +/* void glBlendBarrierKHR ( void ) */ +static void +android_glBlendBarrierKHR__ + (JNIEnv *_env, jobject _this) { + glBlendBarrierKHR(); +} + +/* void glDebugMessageControlKHR ( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled ) */ +static void +android_glDebugMessageControlKHR__IIII_3IIZ + (JNIEnv *_env, jobject _this, jint source, jint type, jint severity, jint count, jintArray ids_ref, jint offset, jboolean enabled) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLuint *ids_base = (GLuint *) 0; + jint _remaining; + GLuint *ids = (GLuint *) 0; + + if (!ids_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "ids == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(ids_ref) - offset; + ids_base = (GLuint *) + _env->GetPrimitiveArrayCritical(ids_ref, (jboolean *)0); + ids = ids_base + offset; + + glDebugMessageControlKHR( + (GLenum)source, + (GLenum)type, + (GLenum)severity, + (GLsizei)count, + (GLuint *)ids, + (GLboolean)enabled + ); + +exit: + if (ids_base) { + _env->ReleasePrimitiveArrayCritical(ids_ref, ids_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glDebugMessageControlKHR ( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled ) */ +static void +android_glDebugMessageControlKHR__IIIILjava_nio_IntBuffer_2Z + (JNIEnv *_env, jobject _this, jint source, jint type, jint severity, jint count, jobject ids_buf, jboolean enabled) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLuint *ids = (GLuint *) 0; + + ids = (GLuint *)getPointer(_env, ids_buf, &_array, &_remaining, &_bufferOffset); + if (ids == NULL) { + char * _idsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + ids = (GLuint *) (_idsBase + _bufferOffset); + } + glDebugMessageControlKHR( + (GLenum)source, + (GLenum)type, + (GLenum)severity, + (GLsizei)count, + (GLuint *)ids, + (GLboolean)enabled + ); + if (_array) { + releasePointer(_env, _array, ids, JNI_FALSE); + } +} + +/* void glDebugMessageInsertKHR ( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf ) */ +static void +android_glDebugMessageInsertKHR__IIIILjava_lang_String_2 + (JNIEnv *_env, jobject _this, jint source, jint type, jint id, jint severity, jstring buf) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + const char* _nativebuf = 0; + jint _length = 0; + + if (!buf) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "buf == null"; + goto exit; + } + _nativebuf = _env->GetStringUTFChars(buf, 0); + _length = _env->GetStringUTFLength(buf); + + glDebugMessageInsertKHR( + (GLenum)source, + (GLenum)type, + (GLuint)id, + (GLenum)severity, + (GLsizei)_length, + (GLchar *)_nativebuf + ); + +exit: + if (_nativebuf) { + _env->ReleaseStringUTFChars(buf, _nativebuf); + } + + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glDebugMessageCallbackKHR ( GLDEBUGPROCKHR callback, const void *userParam ) */ +static void +android_glDebugMessageCallbackKHR(JNIEnv *_env, jobject _this, jobject callback) { + jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented"); +} +/* GLuint glGetDebugMessageLogKHR ( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) */ +static jint +android_glGetDebugMessageLogKHR__II_3II_3II_3II_3II_3II_3BI + (JNIEnv *_env, jobject _this, jint count, jint bufSize, jintArray sources_ref, jint sourcesOffset, jintArray types_ref, jint typesOffset, jintArray ids_ref, jint idsOffset, jintArray severities_ref, jint severitiesOffset, jintArray lengths_ref, jint lengthsOffset, jbyteArray messageLog_ref, jint messageLogOffset) { + jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented"); + return 0; +} + +/* GLuint glGetDebugMessageLogKHR ( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) */ +static uint +android_glGetDebugMessageLogKHR__ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_ByteBuffer_2 + (JNIEnv *_env, jobject _this, jint count, jobject sources_ref, jobject types_ref, jobject ids_ref, jobject severities_ref, jobject lengths_ref, jobject messageLog_ref) { + jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented"); + return 0; +} + +/* GLuint glGetDebugMessageLogKHR ( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) */ +static jobjectArray +android_glGetDebugMessageLogKHR__I_3II_3II_3II_3II + (JNIEnv *_env, jobject _this, jint count, jintArray sources_ref, jint sourcesOffset, jintArray types_ref, jint typesOffset, jintArray ids_ref, jint idsOffset, jintArray severities_ref, jint severitiesOffset) { + jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented"); + return 0; +} + +/* GLuint glGetDebugMessageLogKHR ( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) */ +static jobjectArray +android_glGetDebugMessageLogKHR__ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint count, jobject sources_ref, jobject types_ref, jobject ids_ref, jobject severities_ref) { + jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented"); + return 0; +} +/* void glPushDebugGroupKHR ( GLenum source, GLuint id, GLsizei length, const GLchar *message ) */ +static void +android_glPushDebugGroupKHR__IIILjava_lang_String_2 + (JNIEnv *_env, jobject _this, jint source, jint id, jint length, jstring message) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + const char* _nativemessage = 0; + + if (!message) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "message == null"; + goto exit; + } + _nativemessage = _env->GetStringUTFChars(message, 0); + + glPushDebugGroupKHR( + (GLenum)source, + (GLuint)id, + (GLsizei)length, + (GLchar *)_nativemessage + ); + +exit: + if (_nativemessage) { + _env->ReleaseStringUTFChars(message, _nativemessage); + } + + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glPopDebugGroupKHR ( void ) */ +static void +android_glPopDebugGroupKHR__ + (JNIEnv *_env, jobject _this) { + glPopDebugGroupKHR(); +} + +/* void glObjectLabelKHR ( GLenum identifier, GLuint name, GLsizei length, const GLchar *label ) */ +static void +android_glObjectLabelKHR__IIILjava_lang_String_2 + (JNIEnv *_env, jobject _this, jint identifier, jint name, jint length, jstring label) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + const char* _nativelabel = 0; + + if (!label) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "label == null"; + goto exit; + } + _nativelabel = _env->GetStringUTFChars(label, 0); + + glObjectLabelKHR( + (GLenum)identifier, + (GLuint)name, + (GLsizei)length, + (GLchar *)_nativelabel + ); + +exit: + if (_nativelabel) { + _env->ReleaseStringUTFChars(label, _nativelabel); + } + + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glGetObjectLabelKHR ( GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label ) */ +static jstring +android_glGetObjectLabelKHR(JNIEnv *_env, jobject _this, jint identifier, jint name) { + jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented"); + return NULL; +} + +/* void glObjectPtrLabelKHR ( const void *ptr, GLsizei length, const GLchar *label ) */ +static void +android_glObjectPtrLabelKHR(JNIEnv *_env, jobject _this, jlong ptr, jstring label) { + jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented"); +} + +/* void glGetObjectPtrLabelKHR ( const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label ) */ +static jstring +android_glGetObjectPtrLabelKHR(JNIEnv *_env, jobject _this, jlong ptr) { + jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented"); + return NULL; +} + +/* void glGetPointervKHR ( GLenum pname, void **params ) */ +static jobject +android_glGetDebugMessageCallbackKHR(JNIEnv *_env, jobject _this) { + jniThrowException(_env, "java/lang/UnsupportedOperationException", "not yet implemented"); + return NULL; +} + +/* void glMinSampleShadingOES ( GLfloat value ) */ +static void +android_glMinSampleShadingOES__F + (JNIEnv *_env, jobject _this, jfloat value) { + glMinSampleShadingOES( + (GLfloat)value + ); +} + +/* void glTexStorage3DMultisampleOES ( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations ) */ +static void +android_glTexStorage3DMultisampleOES__IIIIIIZ + (JNIEnv *_env, jobject _this, jint target, jint samples, jint internalformat, jint width, jint height, jint depth, jboolean fixedsamplelocations) { + glTexStorage3DMultisampleOES( + (GLenum)target, + (GLsizei)samples, + (GLenum)internalformat, + (GLsizei)width, + (GLsizei)height, + (GLsizei)depth, + (GLboolean)fixedsamplelocations + ); +} + +/* void glCopyImageSubDataEXT ( GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth ) */ +static void +android_glCopyImageSubDataEXT__IIIIIIIIIIIIIII + (JNIEnv *_env, jobject _this, jint srcName, jint srcTarget, jint srcLevel, jint srcX, jint srcY, jint srcZ, jint dstName, jint dstTarget, jint dstLevel, jint dstX, jint dstY, jint dstZ, jint srcWidth, jint srcHeight, jint srcDepth) { + glCopyImageSubDataEXT( + (GLuint)srcName, + (GLenum)srcTarget, + (GLint)srcLevel, + (GLint)srcX, + (GLint)srcY, + (GLint)srcZ, + (GLuint)dstName, + (GLenum)dstTarget, + (GLint)dstLevel, + (GLint)dstX, + (GLint)dstY, + (GLint)dstZ, + (GLsizei)srcWidth, + (GLsizei)srcHeight, + (GLsizei)srcDepth + ); +} + +/* void glEnableiEXT ( GLenum target, GLuint index ) */ +static void +android_glEnableiEXT__II + (JNIEnv *_env, jobject _this, jint target, jint index) { + glEnableiEXT( + (GLenum)target, + (GLuint)index + ); +} + +/* void glDisableiEXT ( GLenum target, GLuint index ) */ +static void +android_glDisableiEXT__II + (JNIEnv *_env, jobject _this, jint target, jint index) { + glDisableiEXT( + (GLenum)target, + (GLuint)index + ); +} + +/* void glBlendEquationiEXT ( GLuint buf, GLenum mode ) */ +static void +android_glBlendEquationiEXT__II + (JNIEnv *_env, jobject _this, jint buf, jint mode) { + glBlendEquationiEXT( + (GLuint)buf, + (GLenum)mode + ); +} + +/* void glBlendEquationSeparateiEXT ( GLuint buf, GLenum modeRGB, GLenum modeAlpha ) */ +static void +android_glBlendEquationSeparateiEXT__III + (JNIEnv *_env, jobject _this, jint buf, jint modeRGB, jint modeAlpha) { + glBlendEquationSeparateiEXT( + (GLuint)buf, + (GLenum)modeRGB, + (GLenum)modeAlpha + ); +} + +/* void glBlendFunciEXT ( GLuint buf, GLenum src, GLenum dst ) */ +static void +android_glBlendFunciEXT__III + (JNIEnv *_env, jobject _this, jint buf, jint src, jint dst) { + glBlendFunciEXT( + (GLuint)buf, + (GLenum)src, + (GLenum)dst + ); +} + +/* void glBlendFuncSeparateiEXT ( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) */ +static void +android_glBlendFuncSeparateiEXT__IIIII + (JNIEnv *_env, jobject _this, jint buf, jint srcRGB, jint dstRGB, jint srcAlpha, jint dstAlpha) { + glBlendFuncSeparateiEXT( + (GLuint)buf, + (GLenum)srcRGB, + (GLenum)dstRGB, + (GLenum)srcAlpha, + (GLenum)dstAlpha + ); +} + +/* void glColorMaskiEXT ( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a ) */ +static void +android_glColorMaskiEXT__IZZZZ + (JNIEnv *_env, jobject _this, jint index, jboolean r, jboolean g, jboolean b, jboolean a) { + glColorMaskiEXT( + (GLuint)index, + (GLboolean)r, + (GLboolean)g, + (GLboolean)b, + (GLboolean)a + ); +} + +/* GLboolean glIsEnablediEXT ( GLenum target, GLuint index ) */ +static jboolean +android_glIsEnablediEXT__II + (JNIEnv *_env, jobject _this, jint target, jint index) { + GLboolean _returnValue; + _returnValue = glIsEnablediEXT( + (GLenum)target, + (GLuint)index + ); + return (jboolean)_returnValue; +} + +/* void glFramebufferTextureEXT ( GLenum target, GLenum attachment, GLuint texture, GLint level ) */ +static void +android_glFramebufferTextureEXT__IIII + (JNIEnv *_env, jobject _this, jint target, jint attachment, jint texture, jint level) { + glFramebufferTextureEXT( + (GLenum)target, + (GLenum)attachment, + (GLuint)texture, + (GLint)level + ); +} + +/* void glPrimitiveBoundingBoxEXT ( GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW ) */ +static void +android_glPrimitiveBoundingBoxEXT__FFFFFFFF + (JNIEnv *_env, jobject _this, jfloat minX, jfloat minY, jfloat minZ, jfloat minW, jfloat maxX, jfloat maxY, jfloat maxZ, jfloat maxW) { + glPrimitiveBoundingBoxEXT( + (GLfloat)minX, + (GLfloat)minY, + (GLfloat)minZ, + (GLfloat)minW, + (GLfloat)maxX, + (GLfloat)maxY, + (GLfloat)maxZ, + (GLfloat)maxW + ); +} + +/* void glPatchParameteriEXT ( GLenum pname, GLint value ) */ +static void +android_glPatchParameteriEXT__II + (JNIEnv *_env, jobject _this, jint pname, jint value) { + glPatchParameteriEXT( + (GLenum)pname, + (GLint)value + ); +} + +/* void glTexParameterIivEXT ( GLenum target, GLenum pname, const GLint *params ) */ +static void +android_glTexParameterIivEXT__II_3II + (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLint *params_base = (GLint *) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + if (!params_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "params == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + params_base = (GLint *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glTexParameterIivEXT( + (GLenum)target, + (GLenum)pname, + (GLint *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glTexParameterIivEXT ( GLenum target, GLenum pname, const GLint *params ) */ +static void +android_glTexParameterIivEXT__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset); + if (params == NULL) { + char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + params = (GLint *) (_paramsBase + _bufferOffset); + } + glTexParameterIivEXT( + (GLenum)target, + (GLenum)pname, + (GLint *)params + ); + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glTexParameterIuivEXT ( GLenum target, GLenum pname, const GLuint *params ) */ +static void +android_glTexParameterIuivEXT__II_3II + (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLuint *params_base = (GLuint *) 0; + jint _remaining; + GLuint *params = (GLuint *) 0; + + if (!params_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "params == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + params_base = (GLuint *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glTexParameterIuivEXT( + (GLenum)target, + (GLenum)pname, + (GLuint *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glTexParameterIuivEXT ( GLenum target, GLenum pname, const GLuint *params ) */ +static void +android_glTexParameterIuivEXT__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLuint *params = (GLuint *) 0; + + params = (GLuint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset); + if (params == NULL) { + char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + params = (GLuint *) (_paramsBase + _bufferOffset); + } + glTexParameterIuivEXT( + (GLenum)target, + (GLenum)pname, + (GLuint *)params + ); + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glGetTexParameterIivEXT ( GLenum target, GLenum pname, GLint *params ) */ +static void +android_glGetTexParameterIivEXT__II_3II + (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLint *params_base = (GLint *) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + if (!params_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "params == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + params_base = (GLint *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetTexParameterIivEXT( + (GLenum)target, + (GLenum)pname, + (GLint *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glGetTexParameterIivEXT ( GLenum target, GLenum pname, GLint *params ) */ +static void +android_glGetTexParameterIivEXT__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset); + if (params == NULL) { + char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + params = (GLint *) (_paramsBase + _bufferOffset); + } + glGetTexParameterIivEXT( + (GLenum)target, + (GLenum)pname, + (GLint *)params + ); + if (_array) { + releasePointer(_env, _array, params, JNI_TRUE); + } +} + +/* void glGetTexParameterIuivEXT ( GLenum target, GLenum pname, GLuint *params ) */ +static void +android_glGetTexParameterIuivEXT__II_3II + (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLuint *params_base = (GLuint *) 0; + jint _remaining; + GLuint *params = (GLuint *) 0; + + if (!params_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "params == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + params_base = (GLuint *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetTexParameterIuivEXT( + (GLenum)target, + (GLenum)pname, + (GLuint *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glGetTexParameterIuivEXT ( GLenum target, GLenum pname, GLuint *params ) */ +static void +android_glGetTexParameterIuivEXT__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLuint *params = (GLuint *) 0; + + params = (GLuint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset); + if (params == NULL) { + char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + params = (GLuint *) (_paramsBase + _bufferOffset); + } + glGetTexParameterIuivEXT( + (GLenum)target, + (GLenum)pname, + (GLuint *)params + ); + if (_array) { + releasePointer(_env, _array, params, JNI_TRUE); + } +} + +/* void glSamplerParameterIivEXT ( GLuint sampler, GLenum pname, const GLint *param ) */ +static void +android_glSamplerParameterIivEXT__II_3II + (JNIEnv *_env, jobject _this, jint sampler, jint pname, jintArray param_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLint *param_base = (GLint *) 0; + jint _remaining; + GLint *param = (GLint *) 0; + + if (!param_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "param == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(param_ref) - offset; + param_base = (GLint *) + _env->GetPrimitiveArrayCritical(param_ref, (jboolean *)0); + param = param_base + offset; + + glSamplerParameterIivEXT( + (GLuint)sampler, + (GLenum)pname, + (GLint *)param + ); + +exit: + if (param_base) { + _env->ReleasePrimitiveArrayCritical(param_ref, param_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glSamplerParameterIivEXT ( GLuint sampler, GLenum pname, const GLint *param ) */ +static void +android_glSamplerParameterIivEXT__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint sampler, jint pname, jobject param_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLint *param = (GLint *) 0; + + param = (GLint *)getPointer(_env, param_buf, &_array, &_remaining, &_bufferOffset); + if (param == NULL) { + char * _paramBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + param = (GLint *) (_paramBase + _bufferOffset); + } + glSamplerParameterIivEXT( + (GLuint)sampler, + (GLenum)pname, + (GLint *)param + ); + if (_array) { + releasePointer(_env, _array, param, JNI_FALSE); + } +} + +/* void glSamplerParameterIuivEXT ( GLuint sampler, GLenum pname, const GLuint *param ) */ +static void +android_glSamplerParameterIuivEXT__II_3II + (JNIEnv *_env, jobject _this, jint sampler, jint pname, jintArray param_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLuint *param_base = (GLuint *) 0; + jint _remaining; + GLuint *param = (GLuint *) 0; + + if (!param_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "param == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(param_ref) - offset; + param_base = (GLuint *) + _env->GetPrimitiveArrayCritical(param_ref, (jboolean *)0); + param = param_base + offset; + + glSamplerParameterIuivEXT( + (GLuint)sampler, + (GLenum)pname, + (GLuint *)param + ); + +exit: + if (param_base) { + _env->ReleasePrimitiveArrayCritical(param_ref, param_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glSamplerParameterIuivEXT ( GLuint sampler, GLenum pname, const GLuint *param ) */ +static void +android_glSamplerParameterIuivEXT__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint sampler, jint pname, jobject param_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLuint *param = (GLuint *) 0; + + param = (GLuint *)getPointer(_env, param_buf, &_array, &_remaining, &_bufferOffset); + if (param == NULL) { + char * _paramBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + param = (GLuint *) (_paramBase + _bufferOffset); + } + glSamplerParameterIuivEXT( + (GLuint)sampler, + (GLenum)pname, + (GLuint *)param + ); + if (_array) { + releasePointer(_env, _array, param, JNI_FALSE); + } +} + +/* void glGetSamplerParameterIivEXT ( GLuint sampler, GLenum pname, GLint *params ) */ +static void +android_glGetSamplerParameterIivEXT__II_3II + (JNIEnv *_env, jobject _this, jint sampler, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLint *params_base = (GLint *) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + if (!params_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "params == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + params_base = (GLint *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetSamplerParameterIivEXT( + (GLuint)sampler, + (GLenum)pname, + (GLint *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glGetSamplerParameterIivEXT ( GLuint sampler, GLenum pname, GLint *params ) */ +static void +android_glGetSamplerParameterIivEXT__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint sampler, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset); + if (params == NULL) { + char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + params = (GLint *) (_paramsBase + _bufferOffset); + } + glGetSamplerParameterIivEXT( + (GLuint)sampler, + (GLenum)pname, + (GLint *)params + ); + if (_array) { + releasePointer(_env, _array, params, JNI_TRUE); + } +} + +/* void glGetSamplerParameterIuivEXT ( GLuint sampler, GLenum pname, GLuint *params ) */ +static void +android_glGetSamplerParameterIuivEXT__II_3II + (JNIEnv *_env, jobject _this, jint sampler, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + GLuint *params_base = (GLuint *) 0; + jint _remaining; + GLuint *params = (GLuint *) 0; + + if (!params_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "params == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + params_base = (GLuint *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetSamplerParameterIuivEXT( + (GLuint)sampler, + (GLenum)pname, + (GLuint *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } +} + +/* void glGetSamplerParameterIuivEXT ( GLuint sampler, GLenum pname, GLuint *params ) */ +static void +android_glGetSamplerParameterIuivEXT__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint sampler, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + jint _remaining; + GLuint *params = (GLuint *) 0; + + params = (GLuint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset); + if (params == NULL) { + char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + params = (GLuint *) (_paramsBase + _bufferOffset); + } + glGetSamplerParameterIuivEXT( + (GLuint)sampler, + (GLenum)pname, + (GLuint *)params + ); + if (_array) { + releasePointer(_env, _array, params, JNI_TRUE); + } +} + +/* void glTexBufferEXT ( GLenum target, GLenum internalformat, GLuint buffer ) */ +static void +android_glTexBufferEXT__III + (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint buffer) { + glTexBufferEXT( + (GLenum)target, + (GLenum)internalformat, + (GLuint)buffer + ); +} + +/* void glTexBufferRangeEXT ( GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size ) */ +static void +android_glTexBufferRangeEXT__IIIII + (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint buffer, jint offset, jint size) { + glTexBufferRangeEXT( + (GLenum)target, + (GLenum)internalformat, + (GLuint)buffer, + (GLintptr)offset, + (GLsizeiptr)size + ); +} + +static const char *classPathName = "android/opengl/GLES31Ext"; + +static JNINativeMethod methods[] = { +{"_nativeClassInit", "()V", (void*)nativeClassInit }, +{"glBlendBarrierKHR", "()V", (void *) android_glBlendBarrierKHR__ }, +{"glDebugMessageControlKHR", "(IIII[IIZ)V", (void *) android_glDebugMessageControlKHR__IIII_3IIZ }, +{"glDebugMessageControlKHR", "(IIIILjava/nio/IntBuffer;Z)V", (void *) android_glDebugMessageControlKHR__IIIILjava_nio_IntBuffer_2Z }, +{"glDebugMessageInsertKHR", "(IIIILjava/lang/String;)V", (void *) android_glDebugMessageInsertKHR__IIIILjava_lang_String_2 }, +{"glDebugMessageCallbackKHR", "(Landroid/opengl/GLES31Ext$DebugProcKHR;)V", (void *) android_glDebugMessageCallbackKHR }, +{"glGetDebugMessageLogKHR", "(II[II[II[II[II[II[BI)I", (void *) android_glGetDebugMessageLogKHR__II_3II_3II_3II_3II_3II_3BI }, +{"glGetDebugMessageLogKHR", "(ILjava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/ByteBuffer;)I", (void *) android_glGetDebugMessageLogKHR__ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_ByteBuffer_2 }, +{"glGetDebugMessageLogKHR", "(I[II[II[II[II)[Ljava/lang/String;", (void *) android_glGetDebugMessageLogKHR__I_3II_3II_3II_3II }, +{"glGetDebugMessageLogKHR", "(ILjava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;)[Ljava/lang/String;", (void *) android_glGetDebugMessageLogKHR__ILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 }, +{"glPushDebugGroupKHR", "(IIILjava/lang/String;)V", (void *) android_glPushDebugGroupKHR__IIILjava_lang_String_2 }, +{"glPopDebugGroupKHR", "()V", (void *) android_glPopDebugGroupKHR__ }, +{"glObjectLabelKHR", "(IIILjava/lang/String;)V", (void *) android_glObjectLabelKHR__IIILjava_lang_String_2 }, +{"glGetObjectLabelKHR", "(II)Ljava/lang/String;", (void *) android_glGetObjectLabelKHR }, +{"glObjectPtrLabelKHR", "(JLjava/lang/String;)V", (void *) android_glObjectPtrLabelKHR }, +{"glGetObjectPtrLabelKHR", "(J)Ljava/lang/String;", (void *) android_glGetObjectPtrLabelKHR }, +{"glGetDebugMessageCallbackKHR", "()Landroid/opengl/GLES31Ext$DebugProcKHR;", (void *) android_glGetDebugMessageCallbackKHR }, +{"glMinSampleShadingOES", "(F)V", (void *) android_glMinSampleShadingOES__F }, +{"glTexStorage3DMultisampleOES", "(IIIIIIZ)V", (void *) android_glTexStorage3DMultisampleOES__IIIIIIZ }, +{"glCopyImageSubDataEXT", "(IIIIIIIIIIIIIII)V", (void *) android_glCopyImageSubDataEXT__IIIIIIIIIIIIIII }, +{"glEnableiEXT", "(II)V", (void *) android_glEnableiEXT__II }, +{"glDisableiEXT", "(II)V", (void *) android_glDisableiEXT__II }, +{"glBlendEquationiEXT", "(II)V", (void *) android_glBlendEquationiEXT__II }, +{"glBlendEquationSeparateiEXT", "(III)V", (void *) android_glBlendEquationSeparateiEXT__III }, +{"glBlendFunciEXT", "(III)V", (void *) android_glBlendFunciEXT__III }, +{"glBlendFuncSeparateiEXT", "(IIIII)V", (void *) android_glBlendFuncSeparateiEXT__IIIII }, +{"glColorMaskiEXT", "(IZZZZ)V", (void *) android_glColorMaskiEXT__IZZZZ }, +{"glIsEnablediEXT", "(II)Z", (void *) android_glIsEnablediEXT__II }, +{"glFramebufferTextureEXT", "(IIII)V", (void *) android_glFramebufferTextureEXT__IIII }, +{"glPrimitiveBoundingBoxEXT", "(FFFFFFFF)V", (void *) android_glPrimitiveBoundingBoxEXT__FFFFFFFF }, +{"glPatchParameteriEXT", "(II)V", (void *) android_glPatchParameteriEXT__II }, +{"glTexParameterIivEXT", "(II[II)V", (void *) android_glTexParameterIivEXT__II_3II }, +{"glTexParameterIivEXT", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameterIivEXT__IILjava_nio_IntBuffer_2 }, +{"glTexParameterIuivEXT", "(II[II)V", (void *) android_glTexParameterIuivEXT__II_3II }, +{"glTexParameterIuivEXT", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameterIuivEXT__IILjava_nio_IntBuffer_2 }, +{"glGetTexParameterIivEXT", "(II[II)V", (void *) android_glGetTexParameterIivEXT__II_3II }, +{"glGetTexParameterIivEXT", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameterIivEXT__IILjava_nio_IntBuffer_2 }, +{"glGetTexParameterIuivEXT", "(II[II)V", (void *) android_glGetTexParameterIuivEXT__II_3II }, +{"glGetTexParameterIuivEXT", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameterIuivEXT__IILjava_nio_IntBuffer_2 }, +{"glSamplerParameterIivEXT", "(II[II)V", (void *) android_glSamplerParameterIivEXT__II_3II }, +{"glSamplerParameterIivEXT", "(IILjava/nio/IntBuffer;)V", (void *) android_glSamplerParameterIivEXT__IILjava_nio_IntBuffer_2 }, +{"glSamplerParameterIuivEXT", "(II[II)V", (void *) android_glSamplerParameterIuivEXT__II_3II }, +{"glSamplerParameterIuivEXT", "(IILjava/nio/IntBuffer;)V", (void *) android_glSamplerParameterIuivEXT__IILjava_nio_IntBuffer_2 }, +{"glGetSamplerParameterIivEXT", "(II[II)V", (void *) android_glGetSamplerParameterIivEXT__II_3II }, +{"glGetSamplerParameterIivEXT", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetSamplerParameterIivEXT__IILjava_nio_IntBuffer_2 }, +{"glGetSamplerParameterIuivEXT", "(II[II)V", (void *) android_glGetSamplerParameterIuivEXT__II_3II }, +{"glGetSamplerParameterIuivEXT", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetSamplerParameterIuivEXT__IILjava_nio_IntBuffer_2 }, +{"glTexBufferEXT", "(III)V", (void *) android_glTexBufferEXT__III }, +{"glTexBufferRangeEXT", "(IIIII)V", (void *) android_glTexBufferRangeEXT__IIIII }, +}; + +int register_android_opengl_jni_GLES31Ext(JNIEnv *_env) +{ + int err; + err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods)); + return err; +} diff --git a/opengl/java/android/opengl/GLES31.java b/opengl/java/android/opengl/GLES31.java new file mode 100644 index 0000000..9f8728f --- /dev/null +++ b/opengl/java/android/opengl/GLES31.java @@ -0,0 +1,1100 @@ +/* + * Copyright 2014 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 3.1 + * @hide + */ +public class GLES31 extends GLES30 { + + public static final int GL_VERTEX_SHADER_BIT = 0x00000001; + public static final int GL_FRAGMENT_SHADER_BIT = 0x00000002; + public static final int GL_UNIFORM_BARRIER_BIT = 0x00000004; + public static final int GL_TEXTURE_FETCH_BARRIER_BIT = 0x00000008; + public static final int GL_COMPUTE_SHADER_BIT = 0x00000020; + public static final int GL_COMMAND_BARRIER_BIT = 0x00000040; + public static final int GL_PIXEL_BUFFER_BARRIER_BIT = 0x00000080; + public static final int GL_TEXTURE_UPDATE_BARRIER_BIT = 0x00000100; + public static final int GL_BUFFER_UPDATE_BARRIER_BIT = 0x00000200; + public static final int GL_FRAMEBUFFER_BARRIER_BIT = 0x00000400; + public static final int GL_TRANSFORM_FEEDBACK_BARRIER_BIT = 0x00000800; + public static final int GL_ATOMIC_COUNTER_BARRIER_BIT = 0x00001000; + public static final int GL_SHADER_STORAGE_BARRIER_BIT = 0x00002000; + public static final int GL_ALL_SHADER_BITS = -1; // 0xFFFFFFFF + + public static final int GL_TEXTURE_WIDTH = 0x1000; + public static final int GL_TEXTURE_HEIGHT = 0x1001; + public static final int GL_TEXTURE_INTERNAL_FORMAT = 0x1003; + public static final int GL_STENCIL_INDEX = 0x1901; + public static final int GL_TEXTURE_RED_SIZE = 0x805C; + public static final int GL_TEXTURE_GREEN_SIZE = 0x805D; + public static final int GL_TEXTURE_BLUE_SIZE = 0x805E; + public static final int GL_TEXTURE_ALPHA_SIZE = 0x805F; + public static final int GL_TEXTURE_DEPTH = 0x8071; + public static final int GL_PROGRAM_SEPARABLE = 0x8258; + public static final int GL_ACTIVE_PROGRAM = 0x8259; + public static final int GL_PROGRAM_PIPELINE_BINDING = 0x825A; + public static final int GL_MAX_COMPUTE_SHARED_MEMORY_SIZE = 0x8262; + public static final int GL_MAX_COMPUTE_UNIFORM_COMPONENTS = 0x8263; + public static final int GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = 0x8264; + public static final int GL_MAX_COMPUTE_ATOMIC_COUNTERS = 0x8265; + public static final int GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = 0x8266; + public static final int GL_COMPUTE_WORK_GROUP_SIZE = 0x8267; + public static final int GL_MAX_UNIFORM_LOCATIONS = 0x826E; + public static final int GL_VERTEX_ATTRIB_BINDING = 0x82D4; + public static final int GL_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D5; + public static final int GL_VERTEX_BINDING_DIVISOR = 0x82D6; + public static final int GL_VERTEX_BINDING_OFFSET = 0x82D7; + public static final int GL_VERTEX_BINDING_STRIDE = 0x82D8; + public static final int GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D9; + public static final int GL_MAX_VERTEX_ATTRIB_BINDINGS = 0x82DA; + public static final int GL_MAX_VERTEX_ATTRIB_STRIDE = 0x82E5; + public static final int GL_TEXTURE_COMPRESSED = 0x86A1; + public static final int GL_TEXTURE_DEPTH_SIZE = 0x884A; + public static final int GL_READ_ONLY = 0x88B8; + public static final int GL_WRITE_ONLY = 0x88B9; + public static final int GL_READ_WRITE = 0x88BA; + public static final int GL_TEXTURE_STENCIL_SIZE = 0x88F1; + public static final int GL_TEXTURE_RED_TYPE = 0x8C10; + public static final int GL_TEXTURE_GREEN_TYPE = 0x8C11; + public static final int GL_TEXTURE_BLUE_TYPE = 0x8C12; + public static final int GL_TEXTURE_ALPHA_TYPE = 0x8C13; + public static final int GL_TEXTURE_DEPTH_TYPE = 0x8C16; + public static final int GL_TEXTURE_SHARED_SIZE = 0x8C3F; + public static final int GL_SAMPLE_POSITION = 0x8E50; + public static final int GL_SAMPLE_MASK = 0x8E51; + public static final int GL_SAMPLE_MASK_VALUE = 0x8E52; + public static final int GL_MAX_SAMPLE_MASK_WORDS = 0x8E59; + public static final int GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E; + public static final int GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F; + public static final int GL_MAX_IMAGE_UNITS = 0x8F38; + public static final int GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES = 0x8F39; + public static final int GL_IMAGE_BINDING_NAME = 0x8F3A; + public static final int GL_IMAGE_BINDING_LEVEL = 0x8F3B; + public static final int GL_IMAGE_BINDING_LAYERED = 0x8F3C; + public static final int GL_IMAGE_BINDING_LAYER = 0x8F3D; + public static final int GL_IMAGE_BINDING_ACCESS = 0x8F3E; + public static final int GL_DRAW_INDIRECT_BUFFER = 0x8F3F; + public static final int GL_DRAW_INDIRECT_BUFFER_BINDING = 0x8F43; + public static final int GL_VERTEX_BINDING_BUFFER = 0x8F4F; + public static final int GL_IMAGE_2D = 0x904D; + public static final int GL_IMAGE_3D = 0x904E; + public static final int GL_IMAGE_CUBE = 0x9050; + public static final int GL_IMAGE_2D_ARRAY = 0x9053; + public static final int GL_INT_IMAGE_2D = 0x9058; + public static final int GL_INT_IMAGE_3D = 0x9059; + public static final int GL_INT_IMAGE_CUBE = 0x905B; + public static final int GL_INT_IMAGE_2D_ARRAY = 0x905E; + public static final int GL_UNSIGNED_INT_IMAGE_2D = 0x9063; + public static final int GL_UNSIGNED_INT_IMAGE_3D = 0x9064; + public static final int GL_UNSIGNED_INT_IMAGE_CUBE = 0x9066; + public static final int GL_UNSIGNED_INT_IMAGE_2D_ARRAY = 0x9069; + public static final int GL_IMAGE_BINDING_FORMAT = 0x906E; + public static final int GL_IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7; + public static final int GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8; + public static final int GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9; + public static final int GL_MAX_VERTEX_IMAGE_UNIFORMS = 0x90CA; + public static final int GL_MAX_FRAGMENT_IMAGE_UNIFORMS = 0x90CE; + public static final int GL_MAX_COMBINED_IMAGE_UNIFORMS = 0x90CF; + public static final int GL_SHADER_STORAGE_BUFFER = 0x90D2; + public static final int GL_SHADER_STORAGE_BUFFER_BINDING = 0x90D3; + public static final int GL_SHADER_STORAGE_BUFFER_START = 0x90D4; + public static final int GL_SHADER_STORAGE_BUFFER_SIZE = 0x90D5; + public static final int GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS = 0x90D6; + public static final int GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = 0x90DA; + public static final int GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS = 0x90DB; + public static final int GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS = 0x90DC; + public static final int GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS = 0x90DD; + public static final int GL_MAX_SHADER_STORAGE_BLOCK_SIZE = 0x90DE; + public static final int GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = 0x90DF; + public static final int GL_DEPTH_STENCIL_TEXTURE_MODE = 0x90EA; + public static final int GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS = 0x90EB; + public static final int GL_DISPATCH_INDIRECT_BUFFER = 0x90EE; + public static final int GL_DISPATCH_INDIRECT_BUFFER_BINDING = 0x90EF; + public static final int GL_TEXTURE_2D_MULTISAMPLE = 0x9100; + public static final int GL_TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104; + public static final int GL_TEXTURE_SAMPLES = 0x9106; + public static final int GL_TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107; + public static final int GL_SAMPLER_2D_MULTISAMPLE = 0x9108; + public static final int GL_INT_SAMPLER_2D_MULTISAMPLE = 0x9109; + public static final int GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A; + public static final int GL_MAX_COLOR_TEXTURE_SAMPLES = 0x910E; + public static final int GL_MAX_DEPTH_TEXTURE_SAMPLES = 0x910F; + public static final int GL_MAX_INTEGER_SAMPLES = 0x9110; + public static final int GL_COMPUTE_SHADER = 0x91B9; + public static final int GL_MAX_COMPUTE_UNIFORM_BLOCKS = 0x91BB; + public static final int GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS = 0x91BC; + public static final int GL_MAX_COMPUTE_IMAGE_UNIFORMS = 0x91BD; + public static final int GL_MAX_COMPUTE_WORK_GROUP_COUNT = 0x91BE; + public static final int GL_MAX_COMPUTE_WORK_GROUP_SIZE = 0x91BF; + public static final int GL_ATOMIC_COUNTER_BUFFER = 0x92C0; + public static final int GL_ATOMIC_COUNTER_BUFFER_BINDING = 0x92C1; + public static final int GL_ATOMIC_COUNTER_BUFFER_START = 0x92C2; + public static final int GL_ATOMIC_COUNTER_BUFFER_SIZE = 0x92C3; + public static final int GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC; + public static final int GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0; + public static final int GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1; + public static final int GL_MAX_VERTEX_ATOMIC_COUNTERS = 0x92D2; + public static final int GL_MAX_FRAGMENT_ATOMIC_COUNTERS = 0x92D6; + public static final int GL_MAX_COMBINED_ATOMIC_COUNTERS = 0x92D7; + public static final int GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8; + public static final int GL_ACTIVE_ATOMIC_COUNTER_BUFFERS = 0x92D9; + public static final int GL_UNSIGNED_INT_ATOMIC_COUNTER = 0x92DB; + public static final int GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC; + public static final int GL_UNIFORM = 0x92E1; + public static final int GL_UNIFORM_BLOCK = 0x92E2; + public static final int GL_PROGRAM_INPUT = 0x92E3; + public static final int GL_PROGRAM_OUTPUT = 0x92E4; + public static final int GL_BUFFER_VARIABLE = 0x92E5; + public static final int GL_SHADER_STORAGE_BLOCK = 0x92E6; + public static final int GL_TRANSFORM_FEEDBACK_VARYING = 0x92F4; + public static final int GL_ACTIVE_RESOURCES = 0x92F5; + public static final int GL_MAX_NAME_LENGTH = 0x92F6; + public static final int GL_MAX_NUM_ACTIVE_VARIABLES = 0x92F7; + public static final int GL_NAME_LENGTH = 0x92F9; + public static final int GL_TYPE = 0x92FA; + public static final int GL_ARRAY_SIZE = 0x92FB; + public static final int GL_OFFSET = 0x92FC; + public static final int GL_BLOCK_INDEX = 0x92FD; + public static final int GL_ARRAY_STRIDE = 0x92FE; + public static final int GL_MATRIX_STRIDE = 0x92FF; + public static final int GL_IS_ROW_MAJOR = 0x9300; + public static final int GL_ATOMIC_COUNTER_BUFFER_INDEX = 0x9301; + public static final int GL_BUFFER_BINDING = 0x9302; + public static final int GL_BUFFER_DATA_SIZE = 0x9303; + public static final int GL_NUM_ACTIVE_VARIABLES = 0x9304; + public static final int GL_ACTIVE_VARIABLES = 0x9305; + public static final int GL_REFERENCED_BY_VERTEX_SHADER = 0x9306; + public static final int GL_REFERENCED_BY_FRAGMENT_SHADER = 0x930A; + public static final int GL_REFERENCED_BY_COMPUTE_SHADER = 0x930B; + public static final int GL_TOP_LEVEL_ARRAY_SIZE = 0x930C; + public static final int GL_TOP_LEVEL_ARRAY_STRIDE = 0x930D; + public static final int GL_LOCATION = 0x930E; + public static final int GL_FRAMEBUFFER_DEFAULT_WIDTH = 0x9310; + public static final int GL_FRAMEBUFFER_DEFAULT_HEIGHT = 0x9311; + public static final int GL_FRAMEBUFFER_DEFAULT_SAMPLES = 0x9313; + public static final int GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = 0x9314; + public static final int GL_MAX_FRAMEBUFFER_WIDTH = 0x9315; + public static final int GL_MAX_FRAMEBUFFER_HEIGHT = 0x9316; + public static final int GL_MAX_FRAMEBUFFER_SAMPLES = 0x9318; + + native private static void _nativeClassInit(); + static { + _nativeClassInit(); + } + + private GLES31() {} + // C function void glDispatchCompute ( GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z ) + + public static native void glDispatchCompute( + int num_groups_x, + int num_groups_y, + int num_groups_z + ); + + // C function void glDispatchComputeIndirect ( GLintptr indirect ); + + public static native void glDispatchComputeIndirect(long indirect); + + // C function void glDrawArraysIndirect ( GLenum mode, const void *indirect ); + + public static native void glDrawArraysIndirect(int mode, long indirect); + + // C function glDrawElementsIndirect ( GLenum mode, GLenum type, const void *indirect ); + + public static native void glDrawElementsIndirect(int mode, int type, long indirect); + + // C function void glFramebufferParameteri ( GLenum target, GLenum pname, GLint param ) + + public static native void glFramebufferParameteri( + int target, + int pname, + int param + ); + + // C function void glGetFramebufferParameteriv ( GLenum target, GLenum pname, GLint *params ) + + public static native void glGetFramebufferParameteriv( + int target, + int pname, + int[] params, + int offset + ); + + // C function void glGetFramebufferParameteriv ( GLenum target, GLenum pname, GLint *params ) + + public static native void glGetFramebufferParameteriv( + int target, + int pname, + java.nio.IntBuffer params + ); + + // C function void glGetProgramInterfaceiv ( GLuint program, GLenum programInterface, GLenum pname, GLint *params ) + + public static native void glGetProgramInterfaceiv( + int program, + int programInterface, + int pname, + int[] params, + int offset + ); + + // C function void glGetProgramInterfaceiv ( GLuint program, GLenum programInterface, GLenum pname, GLint *params ) + + public static native void glGetProgramInterfaceiv( + int program, + int programInterface, + int pname, + java.nio.IntBuffer params + ); + + // C function GLuint glGetProgramResourceIndex ( GLuint program, GLenum programInterface, const GLchar *name ) + + public static native int glGetProgramResourceIndex( + int program, + int programInterface, + String name + ); + + // C function void glGetProgramResourceName ( GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name ) + + public static native String glGetProgramResourceName( + int program, + int programInterface, + int index + ); + + // C function void glGetProgramResourceiv ( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params ) + + public static native void glGetProgramResourceiv( + int program, + int programInterface, + int index, + int propCount, + int[] props, + int propsOffset, + int bufSize, + int[] length, + int lengthOffset, + int[] params, + int paramsOffset + ); + + // C function void glGetProgramResourceiv ( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params ) + + public static native void glGetProgramResourceiv( + int program, + int programInterface, + int index, + int propCount, + java.nio.IntBuffer props, + int bufSize, + java.nio.IntBuffer length, + java.nio.IntBuffer params + ); + + // C function GLint glGetProgramResourceLocation ( GLuint program, GLenum programInterface, const GLchar *name ) + + public static native int glGetProgramResourceLocation( + int program, + int programInterface, + String name + ); + + // C function void glUseProgramStages ( GLuint pipeline, GLbitfield stages, GLuint program ) + + public static native void glUseProgramStages( + int pipeline, + int stages, + int program + ); + + // C function void glActiveShaderProgram ( GLuint pipeline, GLuint program ) + + public static native void glActiveShaderProgram( + int pipeline, + int program + ); + + // C function GLuint glCreateShaderProgramv ( GLenum type, GLsizei count, const GLchar *const *strings ) + + public static native int glCreateShaderProgramv( + int type, + String[] strings + ); + + // C function void glBindProgramPipeline ( GLuint pipeline ) + + public static native void glBindProgramPipeline( + int pipeline + ); + + // C function void glDeleteProgramPipelines ( GLsizei n, const GLuint *pipelines ) + + public static native void glDeleteProgramPipelines( + int n, + int[] pipelines, + int offset + ); + + // C function void glDeleteProgramPipelines ( GLsizei n, const GLuint *pipelines ) + + public static native void glDeleteProgramPipelines( + int n, + java.nio.IntBuffer pipelines + ); + + // C function void glGenProgramPipelines ( GLsizei n, GLuint *pipelines ) + + public static native void glGenProgramPipelines( + int n, + int[] pipelines, + int offset + ); + + // C function void glGenProgramPipelines ( GLsizei n, GLuint *pipelines ) + + public static native void glGenProgramPipelines( + int n, + java.nio.IntBuffer pipelines + ); + + // C function GLboolean glIsProgramPipeline ( GLuint pipeline ) + + public static native boolean glIsProgramPipeline( + int pipeline + ); + + // C function void glGetProgramPipelineiv ( GLuint pipeline, GLenum pname, GLint *params ) + + public static native void glGetProgramPipelineiv( + int pipeline, + int pname, + int[] params, + int offset + ); + + // C function void glGetProgramPipelineiv ( GLuint pipeline, GLenum pname, GLint *params ) + + public static native void glGetProgramPipelineiv( + int pipeline, + int pname, + java.nio.IntBuffer params + ); + + // C function void glProgramUniform1i ( GLuint program, GLint location, GLint v0 ) + + public static native void glProgramUniform1i( + int program, + int location, + int v0 + ); + + // C function void glProgramUniform2i ( GLuint program, GLint location, GLint v0, GLint v1 ) + + public static native void glProgramUniform2i( + int program, + int location, + int v0, + int v1 + ); + + // C function void glProgramUniform3i ( GLuint program, GLint location, GLint v0, GLint v1, GLint v2 ) + + public static native void glProgramUniform3i( + int program, + int location, + int v0, + int v1, + int v2 + ); + + // C function void glProgramUniform4i ( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 ) + + public static native void glProgramUniform4i( + int program, + int location, + int v0, + int v1, + int v2, + int v3 + ); + + // C function void glProgramUniform1ui ( GLuint program, GLint location, GLuint v0 ) + + public static native void glProgramUniform1ui( + int program, + int location, + int v0 + ); + + // C function void glProgramUniform2ui ( GLuint program, GLint location, GLuint v0, GLuint v1 ) + + public static native void glProgramUniform2ui( + int program, + int location, + int v0, + int v1 + ); + + // C function void glProgramUniform3ui ( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 ) + + public static native void glProgramUniform3ui( + int program, + int location, + int v0, + int v1, + int v2 + ); + + // C function void glProgramUniform4ui ( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) + + public static native void glProgramUniform4ui( + int program, + int location, + int v0, + int v1, + int v2, + int v3 + ); + + // C function void glProgramUniform1f ( GLuint program, GLint location, GLfloat v0 ) + + public static native void glProgramUniform1f( + int program, + int location, + float v0 + ); + + // C function void glProgramUniform2f ( GLuint program, GLint location, GLfloat v0, GLfloat v1 ) + + public static native void glProgramUniform2f( + int program, + int location, + float v0, + float v1 + ); + + // C function void glProgramUniform3f ( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 ) + + public static native void glProgramUniform3f( + int program, + int location, + float v0, + float v1, + float v2 + ); + + // C function void glProgramUniform4f ( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) + + public static native void glProgramUniform4f( + int program, + int location, + float v0, + float v1, + float v2, + float v3 + ); + + // C function void glProgramUniform1iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) + + public static native void glProgramUniform1iv( + int program, + int location, + int count, + int[] value, + int offset + ); + + // C function void glProgramUniform1iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) + + public static native void glProgramUniform1iv( + int program, + int location, + int count, + java.nio.IntBuffer value + ); + + // C function void glProgramUniform2iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) + + public static native void glProgramUniform2iv( + int program, + int location, + int count, + int[] value, + int offset + ); + + // C function void glProgramUniform2iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) + + public static native void glProgramUniform2iv( + int program, + int location, + int count, + java.nio.IntBuffer value + ); + + // C function void glProgramUniform3iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) + + public static native void glProgramUniform3iv( + int program, + int location, + int count, + int[] value, + int offset + ); + + // C function void glProgramUniform3iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) + + public static native void glProgramUniform3iv( + int program, + int location, + int count, + java.nio.IntBuffer value + ); + + // C function void glProgramUniform4iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) + + public static native void glProgramUniform4iv( + int program, + int location, + int count, + int[] value, + int offset + ); + + // C function void glProgramUniform4iv ( GLuint program, GLint location, GLsizei count, const GLint *value ) + + public static native void glProgramUniform4iv( + int program, + int location, + int count, + java.nio.IntBuffer value + ); + + // C function void glProgramUniform1uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) + + public static native void glProgramUniform1uiv( + int program, + int location, + int count, + int[] value, + int offset + ); + + // C function void glProgramUniform1uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) + + public static native void glProgramUniform1uiv( + int program, + int location, + int count, + java.nio.IntBuffer value + ); + + // C function void glProgramUniform2uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) + + public static native void glProgramUniform2uiv( + int program, + int location, + int count, + int[] value, + int offset + ); + + // C function void glProgramUniform2uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) + + public static native void glProgramUniform2uiv( + int program, + int location, + int count, + java.nio.IntBuffer value + ); + + // C function void glProgramUniform3uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) + + public static native void glProgramUniform3uiv( + int program, + int location, + int count, + int[] value, + int offset + ); + + // C function void glProgramUniform3uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) + + public static native void glProgramUniform3uiv( + int program, + int location, + int count, + java.nio.IntBuffer value + ); + + // C function void glProgramUniform4uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) + + public static native void glProgramUniform4uiv( + int program, + int location, + int count, + int[] value, + int offset + ); + + // C function void glProgramUniform4uiv ( GLuint program, GLint location, GLsizei count, const GLuint *value ) + + public static native void glProgramUniform4uiv( + int program, + int location, + int count, + java.nio.IntBuffer value + ); + + // C function void glProgramUniform1fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) + + public static native void glProgramUniform1fv( + int program, + int location, + int count, + float[] value, + int offset + ); + + // C function void glProgramUniform1fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) + + public static native void glProgramUniform1fv( + int program, + int location, + int count, + java.nio.FloatBuffer value + ); + + // C function void glProgramUniform2fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) + + public static native void glProgramUniform2fv( + int program, + int location, + int count, + float[] value, + int offset + ); + + // C function void glProgramUniform2fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) + + public static native void glProgramUniform2fv( + int program, + int location, + int count, + java.nio.FloatBuffer value + ); + + // C function void glProgramUniform3fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) + + public static native void glProgramUniform3fv( + int program, + int location, + int count, + float[] value, + int offset + ); + + // C function void glProgramUniform3fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) + + public static native void glProgramUniform3fv( + int program, + int location, + int count, + java.nio.FloatBuffer value + ); + + // C function void glProgramUniform4fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) + + public static native void glProgramUniform4fv( + int program, + int location, + int count, + float[] value, + int offset + ); + + // C function void glProgramUniform4fv ( GLuint program, GLint location, GLsizei count, const GLfloat *value ) + + public static native void glProgramUniform4fv( + int program, + int location, + int count, + java.nio.FloatBuffer value + ); + + // C function void glProgramUniformMatrix2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix2fv( + int program, + int location, + int count, + boolean transpose, + float[] value, + int offset + ); + + // C function void glProgramUniformMatrix2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix2fv( + int program, + int location, + int count, + boolean transpose, + java.nio.FloatBuffer value + ); + + // C function void glProgramUniformMatrix3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix3fv( + int program, + int location, + int count, + boolean transpose, + float[] value, + int offset + ); + + // C function void glProgramUniformMatrix3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix3fv( + int program, + int location, + int count, + boolean transpose, + java.nio.FloatBuffer value + ); + + // C function void glProgramUniformMatrix4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix4fv( + int program, + int location, + int count, + boolean transpose, + float[] value, + int offset + ); + + // C function void glProgramUniformMatrix4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix4fv( + int program, + int location, + int count, + boolean transpose, + java.nio.FloatBuffer value + ); + + // C function void glProgramUniformMatrix2x3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix2x3fv( + int program, + int location, + int count, + boolean transpose, + float[] value, + int offset + ); + + // C function void glProgramUniformMatrix2x3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix2x3fv( + int program, + int location, + int count, + boolean transpose, + java.nio.FloatBuffer value + ); + + // C function void glProgramUniformMatrix3x2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix3x2fv( + int program, + int location, + int count, + boolean transpose, + float[] value, + int offset + ); + + // C function void glProgramUniformMatrix3x2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix3x2fv( + int program, + int location, + int count, + boolean transpose, + java.nio.FloatBuffer value + ); + + // C function void glProgramUniformMatrix2x4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix2x4fv( + int program, + int location, + int count, + boolean transpose, + float[] value, + int offset + ); + + // C function void glProgramUniformMatrix2x4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix2x4fv( + int program, + int location, + int count, + boolean transpose, + java.nio.FloatBuffer value + ); + + // C function void glProgramUniformMatrix4x2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix4x2fv( + int program, + int location, + int count, + boolean transpose, + float[] value, + int offset + ); + + // C function void glProgramUniformMatrix4x2fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix4x2fv( + int program, + int location, + int count, + boolean transpose, + java.nio.FloatBuffer value + ); + + // C function void glProgramUniformMatrix3x4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix3x4fv( + int program, + int location, + int count, + boolean transpose, + float[] value, + int offset + ); + + // C function void glProgramUniformMatrix3x4fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix3x4fv( + int program, + int location, + int count, + boolean transpose, + java.nio.FloatBuffer value + ); + + // C function void glProgramUniformMatrix4x3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix4x3fv( + int program, + int location, + int count, + boolean transpose, + float[] value, + int offset + ); + + // C function void glProgramUniformMatrix4x3fv ( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) + + public static native void glProgramUniformMatrix4x3fv( + int program, + int location, + int count, + boolean transpose, + java.nio.FloatBuffer value + ); + + // C function void glValidateProgramPipeline ( GLuint pipeline ) + + public static native void glValidateProgramPipeline( + int pipeline + ); + + // C function void glGetProgramPipelineInfoLog( GLuint program, GLsizei maxLength, GLsizei * length, GLchar * infoLog); + + public static native String glGetProgramPipelineInfoLog( + int program + ); + + // C function void glBindImageTexture ( GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format ) + + public static native void glBindImageTexture( + int unit, + int texture, + int level, + boolean layered, + int layer, + int access, + int format + ); + + // C function void glGetBooleani_v ( GLenum target, GLuint index, GLboolean *data ) + + public static native void glGetBooleani_v( + int target, + int index, + boolean[] data, + int offset + ); + + // C function void glGetBooleani_v ( GLenum target, GLuint index, GLboolean *data ) + + public static native void glGetBooleani_v( + int target, + int index, + java.nio.IntBuffer data + ); + + // C function void glMemoryBarrier ( GLbitfield barriers ) + + public static native void glMemoryBarrier( + int barriers + ); + + // C function void glMemoryBarrierByRegion ( GLbitfield barriers ) + + public static native void glMemoryBarrierByRegion( + int barriers + ); + + // C function void glTexStorage2DMultisample ( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations ) + + public static native void glTexStorage2DMultisample( + int target, + int samples, + int internalformat, + int width, + int height, + boolean fixedsamplelocations + ); + + // C function void glGetMultisamplefv ( GLenum pname, GLuint index, GLfloat *val ) + + public static native void glGetMultisamplefv( + int pname, + int index, + float[] val, + int offset + ); + + // C function void glGetMultisamplefv ( GLenum pname, GLuint index, GLfloat *val ) + + public static native void glGetMultisamplefv( + int pname, + int index, + java.nio.FloatBuffer val + ); + + // C function void glSampleMaski ( GLuint maskNumber, GLbitfield mask ) + + public static native void glSampleMaski( + int maskNumber, + int mask + ); + + // C function void glGetTexLevelParameteriv ( GLenum target, GLint level, GLenum pname, GLint *params ) + + public static native void glGetTexLevelParameteriv( + int target, + int level, + int pname, + int[] params, + int offset + ); + + // C function void glGetTexLevelParameteriv ( GLenum target, GLint level, GLenum pname, GLint *params ) + + public static native void glGetTexLevelParameteriv( + int target, + int level, + int pname, + java.nio.IntBuffer params + ); + + // C function void glGetTexLevelParameterfv ( GLenum target, GLint level, GLenum pname, GLfloat *params ) + + public static native void glGetTexLevelParameterfv( + int target, + int level, + int pname, + float[] params, + int offset + ); + + // C function void glGetTexLevelParameterfv ( GLenum target, GLint level, GLenum pname, GLfloat *params ) + + public static native void glGetTexLevelParameterfv( + int target, + int level, + int pname, + java.nio.FloatBuffer params + ); + + // C function void glBindVertexBuffer ( GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride ) + + public static native void glBindVertexBuffer( + int bindingindex, + int buffer, + long offset, + int stride + ); + + // C function void glVertexAttribFormat ( GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset ) + + public static native void glVertexAttribFormat( + int attribindex, + int size, + int type, + boolean normalized, + int relativeoffset + ); + + // C function void glVertexAttribIFormat ( GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset ) + + public static native void glVertexAttribIFormat( + int attribindex, + int size, + int type, + int relativeoffset + ); + + // C function void glVertexAttribBinding ( GLuint attribindex, GLuint bindingindex ) + + public static native void glVertexAttribBinding( + int attribindex, + int bindingindex + ); + + // C function void glVertexBindingDivisor ( GLuint bindingindex, GLuint divisor ) + + public static native void glVertexBindingDivisor( + int bindingindex, + int divisor + ); + +} diff --git a/opengl/java/android/opengl/GLES31Ext.java b/opengl/java/android/opengl/GLES31Ext.java new file mode 100644 index 0000000..af34cf0 --- /dev/null +++ b/opengl/java/android/opengl/GLES31Ext.java @@ -0,0 +1,679 @@ +/* + * Copyright 2014 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; + +/** @hide */ +public class GLES31Ext { + + // GL_KHR_blend_equation_advanced + public static final int GL_BLEND_ADVANCED_COHERENT_KHR = 0x9285; + public static final int GL_MULTIPLY_KHR = 0x9294; + public static final int GL_SCREEN_KHR = 0x9295; + public static final int GL_OVERLAY_KHR = 0x9296; + public static final int GL_DARKEN_KHR = 0x9297; + public static final int GL_LIGHTEN_KHR = 0x9298; + public static final int GL_COLORDODGE_KHR = 0x9299; + public static final int GL_COLORBURN_KHR = 0x929A; + public static final int GL_HARDLIGHT_KHR = 0x929B; + public static final int GL_SOFTLIGHT_KHR = 0x929C; + public static final int GL_DIFFERENCE_KHR = 0x929E; + public static final int GL_EXCLUSION_KHR = 0x92A0; + public static final int GL_HSL_HUE_KHR = 0x92AD; + public static final int GL_HSL_SATURATION_KHR = 0x92AE; + public static final int GL_HSL_COLOR_KHR = 0x92AF; + public static final int GL_HSL_LUMINOSITY_KHR = 0x92B0; + + // GL_KHR_debug + public static final int GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR = 0x8242; + public static final int GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR = 0x8243; + public static final int GL_DEBUG_CALLBACK_FUNCTION_KHR = 0x8244; + public static final int GL_DEBUG_CALLBACK_USER_PARAM_KHR = 0x8245; + public static final int GL_DEBUG_SOURCE_API_KHR = 0x8246; + public static final int GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR = 0x8247; + public static final int GL_DEBUG_SOURCE_SHADER_COMPILER_KHR = 0x8248; + public static final int GL_DEBUG_SOURCE_THIRD_PARTY_KHR = 0x8249; + public static final int GL_DEBUG_SOURCE_APPLICATION_KHR = 0x824A; + public static final int GL_DEBUG_SOURCE_OTHER_KHR = 0x824B; + public static final int GL_DEBUG_TYPE_ERROR_KHR = 0x824C; + public static final int GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR = 0x824D; + public static final int GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR = 0x824E; + public static final int GL_DEBUG_TYPE_PORTABILITY_KHR = 0x824F; + public static final int GL_DEBUG_TYPE_PERFORMANCE_KHR = 0x8250; + public static final int GL_DEBUG_TYPE_OTHER_KHR = 0x8251; + public static final int GL_DEBUG_TYPE_MARKER_KHR = 0x8268; + public static final int GL_DEBUG_TYPE_PUSH_GROUP_KHR = 0x8269; + public static final int GL_DEBUG_TYPE_POP_GROUP_KHR = 0x826A; + public static final int GL_DEBUG_SEVERITY_NOTIFICATION_KHR = 0x826B; + public static final int GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR = 0x826C; + public static final int GL_DEBUG_GROUP_STACK_DEPTH_KHR = 0x826D; + public static final int GL_BUFFER_KHR = 0x82E0; + public static final int GL_SHADER_KHR = 0x82E1; + public static final int GL_PROGRAM_KHR = 0x82E2; + public static final int GL_VERTEX_ARRAY_KHR = 0x8074; + public static final int GL_QUERY_KHR = 0x82E3; + public static final int GL_SAMPLER_KHR = 0x82E6; + public static final int GL_MAX_LABEL_LENGTH_KHR = 0x82E8; + public static final int GL_MAX_DEBUG_MESSAGE_LENGTH_KHR = 0x9143; + public static final int GL_MAX_DEBUG_LOGGED_MESSAGES_KHR = 0x9144; + public static final int GL_DEBUG_LOGGED_MESSAGES_KHR = 0x9145; + public static final int GL_DEBUG_SEVERITY_HIGH_KHR = 0x9146; + public static final int GL_DEBUG_SEVERITY_MEDIUM_KHR = 0x9147; + public static final int GL_DEBUG_SEVERITY_LOW_KHR = 0x9148; + public static final int GL_DEBUG_OUTPUT_KHR = 0x92E0; + public static final int GL_CONTEXT_FLAG_DEBUG_BIT_KHR = 0x00000002; + public static final int GL_STACK_OVERFLOW_KHR = 0x0503; + public static final int GL_STACK_UNDERFLOW_KHR = 0x0504; + + // GL_KHR_texture_compression_astc_ldr + public static final int GL_COMPRESSED_RGBA_ASTC_4x4_KHR = 0x93B0; + public static final int GL_COMPRESSED_RGBA_ASTC_5x4_KHR = 0x93B1; + public static final int GL_COMPRESSED_RGBA_ASTC_5x5_KHR = 0x93B2; + public static final int GL_COMPRESSED_RGBA_ASTC_6x5_KHR = 0x93B3; + public static final int GL_COMPRESSED_RGBA_ASTC_6x6_KHR = 0x93B4; + public static final int GL_COMPRESSED_RGBA_ASTC_8x5_KHR = 0x93B5; + public static final int GL_COMPRESSED_RGBA_ASTC_8x6_KHR = 0x93B6; + public static final int GL_COMPRESSED_RGBA_ASTC_8x8_KHR = 0x93B7; + public static final int GL_COMPRESSED_RGBA_ASTC_10x5_KHR = 0x93B8; + public static final int GL_COMPRESSED_RGBA_ASTC_10x6_KHR = 0x93B9; + public static final int GL_COMPRESSED_RGBA_ASTC_10x8_KHR = 0x93BA; + public static final int GL_COMPRESSED_RGBA_ASTC_10x10_KHR = 0x93BB; + public static final int GL_COMPRESSED_RGBA_ASTC_12x10_KHR = 0x93BC; + public static final int GL_COMPRESSED_RGBA_ASTC_12x12_KHR = 0x93BD; + public static final int GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = 0x93D0; + public static final int GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = 0x93D1; + public static final int GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = 0x93D2; + public static final int GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = 0x93D3; + public static final int GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = 0x93D4; + public static final int GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = 0x93D5; + public static final int GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = 0x93D6; + public static final int GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = 0x93D7; + public static final int GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = 0x93D8; + public static final int GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = 0x93D9; + public static final int GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = 0x93DA; + public static final int GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = 0x93DB; + public static final int GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = 0x93DC; + public static final int GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = 0x93DD; + + // GL_OES_sample_shading + public static final int GL_SAMPLE_SHADING_OES = 0x8C36; + public static final int GL_MIN_SAMPLE_SHADING_VALUE_OES = 0x8C37; + + // GL_OES_shader_multisample_interpolation + public static final int GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES = 0x8E5B; + public static final int GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES = 0x8E5C; + public static final int GL_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES = 0x8E5D; + + // GL_OES_texture_stencil8 + public static final int GL_STENCIL_INDEX_OES = 0x1901; + public static final int GL_STENCIL_INDEX8_OES = 0x8D48; + + // GL_OES_texture_storage_multisample_2d_array + public static final int GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES = 0x9102; + public static final int GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES = 0x9105; + public static final int GL_SAMPLER_2D_MULTISAMPLE_ARRAY_OES = 0x910B; + public static final int GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES = 0x910C; + public static final int GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES = 0x910D; + + // GL_EXT_geometry_shader + public static final int GL_GEOMETRY_SHADER_EXT = 0x8DD9; + public static final int GL_GEOMETRY_SHADER_BIT_EXT = 0x00000004; + public static final int GL_GEOMETRY_LINKED_VERTICES_OUT_EXT = 0x8916; + public static final int GL_GEOMETRY_LINKED_INPUT_TYPE_EXT = 0x8917; + public static final int GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT = 0x8918; + public static final int GL_GEOMETRY_SHADER_INVOCATIONS_EXT = 0x887F; + public static final int GL_LAYER_PROVOKING_VERTEX_EXT = 0x825E; + public static final int GL_LINES_ADJACENCY_EXT = 0x000A; + public static final int GL_LINE_STRIP_ADJACENCY_EXT = 0x000B; + public static final int GL_TRIANGLES_ADJACENCY_EXT = 0x000C; + public static final int GL_TRIANGLE_STRIP_ADJACENCY_EXT = 0x000D; + public static final int GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = 0x8DDF; + public static final int GL_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT = 0x8A2C; + public static final int GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT = 0x8A32; + public static final int GL_MAX_GEOMETRY_INPUT_COMPONENTS_EXT = 0x9123; + public static final int GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT = 0x9124; + public static final int GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = 0x8DE0; + public static final int GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = 0x8DE1; + public static final int GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT = 0x8E5A; + public static final int GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = 0x8C29; + public static final int GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT = 0x92CF; + public static final int GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT = 0x92D5; + public static final int GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT = 0x90CD; + public static final int GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT = 0x90D7; + public static final int GL_FIRST_VERTEX_CONVENTION_EXT = 0x8E4D; + public static final int GL_LAST_VERTEX_CONVENTION_EXT = 0x8E4E; + public static final int GL_UNDEFINED_VERTEX_EXT = 0x8260; + public static final int GL_PRIMITIVES_GENERATED_EXT = 0x8C87; + public static final int GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT = 0x9312; + public static final int GL_MAX_FRAMEBUFFER_LAYERS_EXT = 0x9317; + public static final int GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = 0x8DA8; + public static final int GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = 0x8DA7; + public static final int GL_REFERENCED_BY_GEOMETRY_SHADER_EXT = 0x9309; + + // GL_EXT_primitive_bounding_box + public static final int GL_PRIMITIVE_BOUNDING_BOX_EXT = 0x92BE; + + // GL_EXT_tessellation_shader + public static final int GL_PATCHES_EXT = 0x000E; + public static final int GL_PATCH_VERTICES_EXT = 0x8E72; + public static final int GL_TESS_CONTROL_OUTPUT_VERTICES_EXT = 0x8E75; + public static final int GL_TESS_GEN_MODE_EXT = 0x8E76; + public static final int GL_TESS_GEN_SPACING_EXT = 0x8E77; + public static final int GL_TESS_GEN_VERTEX_ORDER_EXT = 0x8E78; + public static final int GL_TESS_GEN_POINT_MODE_EXT = 0x8E79; + public static final int GL_ISOLINES_EXT = 0x8E7A; + public static final int GL_QUADS_EXT = 0x0007; + public static final int GL_FRACTIONAL_ODD_EXT = 0x8E7B; + public static final int GL_FRACTIONAL_EVEN_EXT = 0x8E7C; + public static final int GL_MAX_PATCH_VERTICES_EXT = 0x8E7D; + public static final int GL_MAX_TESS_GEN_LEVEL_EXT = 0x8E7E; + public static final int GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT = 0x8E7F; + public static final int GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT = 0x8E80; + public static final int GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT = 0x8E81; + public static final int GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT = 0x8E82; + public static final int GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT = 0x8E83; + public static final int GL_MAX_TESS_PATCH_COMPONENTS_EXT = 0x8E84; + public static final int GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT = 0x8E85; + public static final int GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT = 0x8E86; + public static final int GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT = 0x8E89; + public static final int GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT = 0x8E8A; + public static final int GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT = 0x886C; + public static final int GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT = 0x886D; + public static final int GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT = 0x8E1E; + public static final int GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT = 0x8E1F; + public static final int GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT = 0x92CD; + public static final int GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT = 0x92CE; + public static final int GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT = 0x92D3; + public static final int GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT = 0x92D4; + public static final int GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT = 0x90CB; + public static final int GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT = 0x90CC; + public static final int GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT = 0x90D8; + public static final int GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT = 0x90D9; + public static final int GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED = 0x8221; + public static final int GL_IS_PER_PATCH_EXT = 0x92E7; + public static final int GL_REFERENCED_BY_TESS_CONTROL_SHADER_EXT = 0x9307; + public static final int GL_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT = 0x9308; + public static final int GL_TESS_CONTROL_SHADER_EXT = 0x8E88; + public static final int GL_TESS_EVALUATION_SHADER_EXT = 0x8E87; + public static final int GL_TESS_CONTROL_SHADER_BIT_EXT = 0x00000008; + public static final int GL_TESS_EVALUATION_SHADER_BIT_EXT = 0x00000010; + + // GL_EXT_texture_border_clamp + public static final int GL_TEXTURE_BORDER_COLOR_EXT = 0x1004; + public static final int GL_CLAMP_TO_BORDER_EXT = 0x812D; + + // GL_EXT_texture_buffer + public static final int GL_TEXTURE_BUFFER_EXT = 0x8C2A; + public static final int GL_TEXTURE_BUFFER_BINDING_EXT = 0x8C2A; + public static final int GL_MAX_TEXTURE_BUFFER_SIZE_EXT = 0x8C2B; + public static final int GL_TEXTURE_BINDING_BUFFER_EXT = 0x8C2C; + public static final int GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = 0x8C2D; + public static final int GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT = 0x919F; + public static final int GL_SAMPLER_BUFFER_EXT = 0x8DC2; + public static final int GL_INT_SAMPLER_BUFFER_EXT = 0x8DD0; + public static final int GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT = 0x8DD8; + public static final int GL_IMAGE_BUFFER_EXT = 0x9051; + public static final int GL_INT_IMAGE_BUFFER_EXT = 0x905C; + public static final int GL_UNSIGNED_INT_IMAGE_BUFFER_EXT = 0x9067; + public static final int GL_TEXTURE_BUFFER_OFFSET_EXT = 0x919D; + public static final int GL_TEXTURE_BUFFER_SIZE_EXT = 0x919E; + + // GL_EXT_texture_cube_map_array + public static final int GL_TEXTURE_CUBE_MAP_ARRAY_EXT = 0x9009; + public static final int GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT = 0x900A; + public static final int GL_SAMPLER_CUBE_MAP_ARRAY_EXT = 0x900C; + public static final int GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT = 0x900D; + public static final int GL_INT_SAMPLER_CUBE_MAP_ARRAY_EXT = 0x900E; + public static final int GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT = 0x900F; + public static final int GL_IMAGE_CUBE_MAP_ARRAY_EXT = 0x9054; + public static final int GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT = 0x905F; + public static final int GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT = 0x906A; + + // GL_EXT_texture_sRGB_decode + public static final int GL_TEXTURE_SRGB_DECODE_EXT = 0x8A48; + public static final int GL_DECODE_EXT = 0x8A49; + public static final int GL_SKIP_DECODE_EXT = 0x8A4A; + + native private static void _nativeClassInit(); + static { + _nativeClassInit(); + } + + private GLES31Ext() {} + // C function void glBlendBarrierKHR ( void ) + + public static native void glBlendBarrierKHR( + ); + + // C function void glDebugMessageControlKHR ( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled ) + + public static native void glDebugMessageControlKHR( + int source, + int type, + int severity, + int count, + int[] ids, + int offset, + boolean enabled + ); + + // C function void glDebugMessageControlKHR ( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled ) + + public static native void glDebugMessageControlKHR( + int source, + int type, + int severity, + int count, + java.nio.IntBuffer ids, + boolean enabled + ); + + // C function void glDebugMessageInsertKHR ( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf ) + + public static native void glDebugMessageInsertKHR( + int source, + int type, + int id, + int severity, + String buf + ); + + // C function void glDebugMessageCallbackKHR ( GLDEBUGPROCKHR callback, const void *userParam ) + + public interface DebugProcKHR { + void onMessage(int source, int type, int id, int severity, String message); + } + + public static native void glDebugMessageCallbackKHR(DebugProcKHR callback); + + // C function GLuint glGetDebugMessageLogKHR ( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) + + public static native int glGetDebugMessageLogKHR( + int count, + int bufSize, + int[] sources, + int sourcesOffset, + int[] types, + int typesOffset, + int[] ids, + int idsOffset, + int[] severities, + int severitiesOffset, + int[] lengths, + int lengthsOffset, + byte[] messageLog, + int messageLogOffset); + + // C function GLuint glGetDebugMessageLogKHR ( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) + + public static native int glGetDebugMessageLogKHR( + int count, + java.nio.IntBuffer sources, + java.nio.IntBuffer types, + java.nio.IntBuffer ids, + java.nio.IntBuffer severities, + java.nio.IntBuffer lengths, + java.nio.ByteBuffer messageLog); + + // C function GLuint glGetDebugMessageLogKHR ( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) + + public static native String[] glGetDebugMessageLogKHR( + int count, + int[] sources, + int sourcesOffset, + int[] types, + int typesOffset, + int[] ids, + int idsOffset, + int[] severities, + int severitiesOffset); + + // C function GLuint glGetDebugMessageLogKHR ( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) + + public static native String[] glGetDebugMessageLogKHR( + int count, + java.nio.IntBuffer sources, + java.nio.IntBuffer types, + java.nio.IntBuffer ids, + java.nio.IntBuffer severities); + + // C function void glPushDebugGroupKHR ( GLenum source, GLuint id, GLsizei length, const GLchar *message ) + + public static native void glPushDebugGroupKHR( + int source, + int id, + int length, + String message + ); + + // C function void glPopDebugGroupKHR ( void ) + + public static native void glPopDebugGroupKHR( + ); + + // C function void glObjectLabelKHR ( GLenum identifier, GLuint name, GLsizei length, const GLchar *label ) + + public static native void glObjectLabelKHR( + int identifier, + int name, + int length, + String label + ); + + // C function void glGetObjectLabelKHR ( GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label ) + + public static native String glGetObjectLabelKHR(int identifier, int name); + + // C function void glObjectPtrLabelKHR ( const void *ptr, GLsizei length, const GLchar *label ) + + public static native void glObjectPtrLabelKHR(long ptr, String label); + + // C function void glGetObjectPtrLabelKHR ( const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label ) + + public static native String glGetObjectPtrLabelKHR(long ptr); + + // C function void glGetPointervKHR ( GLenum pname, void **params ) + + public static native DebugProcKHR glGetDebugMessageCallbackKHR(); + + // C function void glMinSampleShadingOES ( GLfloat value ) + + public static native void glMinSampleShadingOES( + float value + ); + + // C function void glTexStorage3DMultisampleOES ( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations ) + + public static native void glTexStorage3DMultisampleOES( + int target, + int samples, + int internalformat, + int width, + int height, + int depth, + boolean fixedsamplelocations + ); + + // C function void glCopyImageSubDataEXT ( GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth ) + + public static native void glCopyImageSubDataEXT( + int srcName, + int srcTarget, + int srcLevel, + int srcX, + int srcY, + int srcZ, + int dstName, + int dstTarget, + int dstLevel, + int dstX, + int dstY, + int dstZ, + int srcWidth, + int srcHeight, + int srcDepth + ); + + // C function void glEnableiEXT ( GLenum target, GLuint index ) + + public static native void glEnableiEXT( + int target, + int index + ); + + // C function void glDisableiEXT ( GLenum target, GLuint index ) + + public static native void glDisableiEXT( + int target, + int index + ); + + // C function void glBlendEquationiEXT ( GLuint buf, GLenum mode ) + + public static native void glBlendEquationiEXT( + int buf, + int mode + ); + + // C function void glBlendEquationSeparateiEXT ( GLuint buf, GLenum modeRGB, GLenum modeAlpha ) + + public static native void glBlendEquationSeparateiEXT( + int buf, + int modeRGB, + int modeAlpha + ); + + // C function void glBlendFunciEXT ( GLuint buf, GLenum src, GLenum dst ) + + public static native void glBlendFunciEXT( + int buf, + int src, + int dst + ); + + // C function void glBlendFuncSeparateiEXT ( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) + + public static native void glBlendFuncSeparateiEXT( + int buf, + int srcRGB, + int dstRGB, + int srcAlpha, + int dstAlpha + ); + + // C function void glColorMaskiEXT ( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a ) + + public static native void glColorMaskiEXT( + int index, + boolean r, + boolean g, + boolean b, + boolean a + ); + + // C function GLboolean glIsEnablediEXT ( GLenum target, GLuint index ) + + public static native boolean glIsEnablediEXT( + int target, + int index + ); + + // C function void glFramebufferTextureEXT ( GLenum target, GLenum attachment, GLuint texture, GLint level ) + + public static native void glFramebufferTextureEXT( + int target, + int attachment, + int texture, + int level + ); + + // C function void glPrimitiveBoundingBoxEXT ( GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW ) + + public static native void glPrimitiveBoundingBoxEXT( + float minX, + float minY, + float minZ, + float minW, + float maxX, + float maxY, + float maxZ, + float maxW + ); + + // C function void glPatchParameteriEXT ( GLenum pname, GLint value ) + + public static native void glPatchParameteriEXT( + int pname, + int value + ); + + // C function void glTexParameterIivEXT ( GLenum target, GLenum pname, const GLint *params ) + + public static native void glTexParameterIivEXT( + int target, + int pname, + int[] params, + int offset + ); + + // C function void glTexParameterIivEXT ( GLenum target, GLenum pname, const GLint *params ) + + public static native void glTexParameterIivEXT( + int target, + int pname, + java.nio.IntBuffer params + ); + + // C function void glTexParameterIuivEXT ( GLenum target, GLenum pname, const GLuint *params ) + + public static native void glTexParameterIuivEXT( + int target, + int pname, + int[] params, + int offset + ); + + // C function void glTexParameterIuivEXT ( GLenum target, GLenum pname, const GLuint *params ) + + public static native void glTexParameterIuivEXT( + int target, + int pname, + java.nio.IntBuffer params + ); + + // C function void glGetTexParameterIivEXT ( GLenum target, GLenum pname, GLint *params ) + + public static native void glGetTexParameterIivEXT( + int target, + int pname, + int[] params, + int offset + ); + + // C function void glGetTexParameterIivEXT ( GLenum target, GLenum pname, GLint *params ) + + public static native void glGetTexParameterIivEXT( + int target, + int pname, + java.nio.IntBuffer params + ); + + // C function void glGetTexParameterIuivEXT ( GLenum target, GLenum pname, GLuint *params ) + + public static native void glGetTexParameterIuivEXT( + int target, + int pname, + int[] params, + int offset + ); + + // C function void glGetTexParameterIuivEXT ( GLenum target, GLenum pname, GLuint *params ) + + public static native void glGetTexParameterIuivEXT( + int target, + int pname, + java.nio.IntBuffer params + ); + + // C function void glSamplerParameterIivEXT ( GLuint sampler, GLenum pname, const GLint *param ) + + public static native void glSamplerParameterIivEXT( + int sampler, + int pname, + int[] param, + int offset + ); + + // C function void glSamplerParameterIivEXT ( GLuint sampler, GLenum pname, const GLint *param ) + + public static native void glSamplerParameterIivEXT( + int sampler, + int pname, + java.nio.IntBuffer param + ); + + // C function void glSamplerParameterIuivEXT ( GLuint sampler, GLenum pname, const GLuint *param ) + + public static native void glSamplerParameterIuivEXT( + int sampler, + int pname, + int[] param, + int offset + ); + + // C function void glSamplerParameterIuivEXT ( GLuint sampler, GLenum pname, const GLuint *param ) + + public static native void glSamplerParameterIuivEXT( + int sampler, + int pname, + java.nio.IntBuffer param + ); + + // C function void glGetSamplerParameterIivEXT ( GLuint sampler, GLenum pname, GLint *params ) + + public static native void glGetSamplerParameterIivEXT( + int sampler, + int pname, + int[] params, + int offset + ); + + // C function void glGetSamplerParameterIivEXT ( GLuint sampler, GLenum pname, GLint *params ) + + public static native void glGetSamplerParameterIivEXT( + int sampler, + int pname, + java.nio.IntBuffer params + ); + + // C function void glGetSamplerParameterIuivEXT ( GLuint sampler, GLenum pname, GLuint *params ) + + public static native void glGetSamplerParameterIuivEXT( + int sampler, + int pname, + int[] params, + int offset + ); + + // C function void glGetSamplerParameterIuivEXT ( GLuint sampler, GLenum pname, GLuint *params ) + + public static native void glGetSamplerParameterIuivEXT( + int sampler, + int pname, + java.nio.IntBuffer params + ); + + // C function void glTexBufferEXT ( GLenum target, GLenum internalformat, GLuint buffer ) + + public static native void glTexBufferEXT( + int target, + int internalformat, + int buffer + ); + + // C function void glTexBufferRangeEXT ( GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size ) + + public static native void glTexBufferRangeEXT( + int target, + int internalformat, + int buffer, + int offset, + int size + ); + +} -- cgit v1.1