core/jni/android_opengl_GLES10Ext.cpp - platform/frameworks/base - Git at Google

 /*
 **
 ** Copyright 2009, The Android Open Source Project
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */

 // This source file is automatically generated

 #pragma GCC diagnostic ignored "-Wunused-variable"
 #pragma GCC diagnostic ignored "-Wunused-function"

 #include <GLES/gl.h>
 #include <GLES/glext.h>

 #include <jni.h>
 #include <nativehelper/JNIHelp.h>
 #include <android_runtime/AndroidRuntime.h>
 #include <utils/misc.h>
 #include <assert.h>


 /* 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
 }

 static void
 nativeClassInit(JNIEnv *_env, jclass glImplClass)
 {
 }

 static void *
 getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining, jint *offset)
 {
     jint position;
     jint limit;
     jint elementSizeShift;
     jlong pointer;

     pointer = jniGetNioBufferFields(_env, buffer, &position, &limit, &elementSizeShift);
     *remaining = (limit - position) << elementSizeShift;
     if (pointer != 0L) {
         *array = nullptr;
         pointer += position << elementSizeShift;
         return reinterpret_cast<void*>(pointer);
     }

     *array = jniGetNioBufferBaseArray(_env, buffer);
     *offset = jniGetNioBufferBaseArrayOffset(_env, buffer);
     return nullptr;
 }

 class ByteArrayGetter {
 public:
     static void* Get(JNIEnv* _env, jbyteArray array, jboolean* is_copy) {
         return _env->GetByteArrayElements(array, is_copy);
     }
 };
 class BooleanArrayGetter {
 public:
     static void* Get(JNIEnv* _env, jbooleanArray array, jboolean* is_copy) {
         return _env->GetBooleanArrayElements(array, is_copy);
     }
 };
 class CharArrayGetter {
 public:
     static void* Get(JNIEnv* _env, jcharArray array, jboolean* is_copy) {
         return _env->GetCharArrayElements(array, is_copy);
     }
 };
 class ShortArrayGetter {
 public:
     static void* Get(JNIEnv* _env, jshortArray array, jboolean* is_copy) {
         return _env->GetShortArrayElements(array, is_copy);
     }
 };
 class IntArrayGetter {
 public:
     static void* Get(JNIEnv* _env, jintArray array, jboolean* is_copy) {
         return _env->GetIntArrayElements(array, is_copy);
     }
 };
 class LongArrayGetter {
 public:
     static void* Get(JNIEnv* _env, jlongArray array, jboolean* is_copy) {
         return _env->GetLongArrayElements(array, is_copy);
     }
 };
 class FloatArrayGetter {
 public:
     static void* Get(JNIEnv* _env, jfloatArray array, jboolean* is_copy) {
         return _env->GetFloatArrayElements(array, is_copy);
     }
 };
 class DoubleArrayGetter {
 public:
     static void* Get(JNIEnv* _env, jdoubleArray array, jboolean* is_copy) {
         return _env->GetDoubleArrayElements(array, is_copy);
     }
 };

 template<typename JTYPEARRAY, typename ARRAYGETTER>
 static void*
 getArrayPointer(JNIEnv *_env, JTYPEARRAY array, jboolean* is_copy) {
     return ARRAYGETTER::Get(_env, array, is_copy);
 }

 class ByteArrayReleaser {
 public:
     static void Release(JNIEnv* _env, jbyteArray array, jbyte* data, jboolean commit) {
         _env->ReleaseByteArrayElements(array, data, commit ? 0 : JNI_ABORT);
     }
 };
 class BooleanArrayReleaser {
 public:
     static void Release(JNIEnv* _env, jbooleanArray array, jboolean* data, jboolean commit) {
         _env->ReleaseBooleanArrayElements(array, data, commit ? 0 : JNI_ABORT);
     }
 };
 class CharArrayReleaser {
 public:
     static void Release(JNIEnv* _env, jcharArray array, jchar* data, jboolean commit) {
         _env->ReleaseCharArrayElements(array, data, commit ? 0 : JNI_ABORT);
     }
 };
 class ShortArrayReleaser {
 public:
     static void Release(JNIEnv* _env, jshortArray array, jshort* data, jboolean commit) {
         _env->ReleaseShortArrayElements(array, data, commit ? 0 : JNI_ABORT);
     }
 };
 class IntArrayReleaser {
 public:
     static void Release(JNIEnv* _env, jintArray array, jint* data, jboolean commit) {
         _env->ReleaseIntArrayElements(array, data, commit ? 0 : JNI_ABORT);
     }
 };
 class LongArrayReleaser {
 public:
     static void Release(JNIEnv* _env, jlongArray array, jlong* data, jboolean commit) {
         _env->ReleaseLongArrayElements(array, data, commit ? 0 : JNI_ABORT);
     }
 };
 class FloatArrayReleaser {
 public:
     static void Release(JNIEnv* _env, jfloatArray array, jfloat* data, jboolean commit) {
         _env->ReleaseFloatArrayElements(array, data, commit ? 0 : JNI_ABORT);
     }
 };
 class DoubleArrayReleaser {
 public:
     static void Release(JNIEnv* _env, jdoubleArray array, jdouble* data, jboolean commit) {
         _env->ReleaseDoubleArrayElements(array, data, commit ? 0 : JNI_ABORT);
     }
 };

 template<typename JTYPEARRAY, typename NTYPEARRAY, typename ARRAYRELEASER>
 static void
 releaseArrayPointer(JNIEnv *_env, JTYPEARRAY array, NTYPEARRAY data, jboolean commit) {
     ARRAYRELEASER::Release(_env, array, data, commit);
 }

 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) {
     jint position;
     jint limit;
     jint elementSizeShift;
     jlong pointer;
     pointer = jniGetNioBufferFields(_env, buffer, &position, &limit, &elementSizeShift);
     if (pointer == 0) {
         jniThrowException(_env, "java/lang/IllegalArgumentException",
                           "Must use a native order direct Buffer");
         return nullptr;
     }
     pointer += position << elementSizeShift;
     return reinterpret_cast<void*>(pointer);
 }

 // --------------------------------------------------------------------------

 /*
  * 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_3_0
     // GLES 3.x pnames
     switch (pname) {
         case GL_MAX_VIEWPORT_DIMS:
             needed = 2;
             break;

         case GL_PROGRAM_BINARY_FORMATS:
             glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &needed);
             break;
     }
 #endif

 #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 <typename JTYPEARRAY, typename ARRAYGETTER, typename NTYPEARRAY,
           typename ARRAYRELEASER, typename CTYPE, void GET(GLenum, CTYPE*)>
 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 *) getArrayPointer<JTYPEARRAY, ARRAYGETTER>(
         _env, params_ref, (jboolean *)0);
     params = params_base + offset;

     GET(
         (GLenum)pname,
         (CTYPE *)params
     );

 exit:
     if (params_base) {
         releaseArrayPointer<JTYPEARRAY, NTYPEARRAY, ARRAYRELEASER>(
             _env, params_ref, params_base, !_exception);
     }
     if (_exception) {
         jniThrowException(_env, _exceptionType, _exceptionMessage);
     }
 }


 template <typename CTYPE, typename JTYPEARRAY, typename ARRAYGETTER, typename NTYPEARRAY,
           typename ARRAYRELEASER, void GET(GLenum, CTYPE*)>
 static void
 getarray
   (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
     jint _exception = 0;
     const char * _exceptionType;
     const char * _exceptionMessage;
     JTYPEARRAY _array = (JTYPEARRAY) 0;
     jint _bufferOffset = (jint) 0;
     jint _remaining;
     CTYPE *params = (CTYPE *) 0;
     int _needed = 0;

     params = (CTYPE *)getPointer(_env, params_buf, (jarray*)&_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 *) getArrayPointer<JTYPEARRAY, ARRAYGETTER>(
             _env, _array, (jboolean *) 0);
         params = (CTYPE *) (_paramsBase + _bufferOffset);
     }
     GET(
         (GLenum)pname,
         (CTYPE *)params
     );

 exit:
     if (_array) {
         releaseArrayPointer<JTYPEARRAY, NTYPEARRAY, ARRAYRELEASER>(
             _env, _array, (NTYPEARRAY)params, _exception ? JNI_FALSE : JNI_TRUE);
     }
     if (_exception) {
         jniThrowException(_env, _exceptionType, _exceptionMessage);
     }
 }

 // --------------------------------------------------------------------------
 /* GLbitfield glQueryMatrixxOES ( GLfixed *mantissa, GLint *exponent ) */
 static jint
 android_glQueryMatrixxOES___3II_3II
   (JNIEnv *_env, jobject _this, jintArray mantissa_ref, jint mantissaOffset, jintArray exponent_ref, jint exponentOffset) {
     jint _exception = 0;
     const char * _exceptionType = NULL;
     const char * _exceptionMessage = NULL;
     GLbitfield _returnValue = -1;
     GLfixed *mantissa_base = (GLfixed *) 0;
     jint _mantissaRemaining;
     GLfixed *mantissa = (GLfixed *) 0;
     GLint *exponent_base = (GLint *) 0;
     jint _exponentRemaining;
     GLint *exponent = (GLint *) 0;

     if (!mantissa_ref) {
         _exception = 1;
         _exceptionType = "java/lang/IllegalArgumentException";
         _exceptionMessage = "mantissa == null";
         goto exit;
     }
     if (mantissaOffset < 0) {
         _exception = 1;
         _exceptionType = "java/lang/IllegalArgumentException";
         _exceptionMessage = "mantissaOffset < 0";
         goto exit;
     }
     _mantissaRemaining = _env->GetArrayLength(mantissa_ref) - mantissaOffset;
     if (_mantissaRemaining < 16) {
         _exception = 1;
         _exceptionType = "java/lang/IllegalArgumentException";
         _exceptionMessage = "length - mantissaOffset < 16 < needed";
         goto exit;
     }
     mantissa_base = (GLfixed *)
         _env->GetIntArrayElements(mantissa_ref, (jboolean *)0);
     mantissa = mantissa_base + mantissaOffset;

     if (!exponent_ref) {
         _exception = 1;
         _exceptionType = "java/lang/IllegalArgumentException";
         _exceptionMessage = "exponent == null";
         goto exit;
     }
     if (exponentOffset < 0) {
         _exception = 1;
         _exceptionType = "java/lang/IllegalArgumentException";
         _exceptionMessage = "exponentOffset < 0";
         goto exit;
     }
     _exponentRemaining = _env->GetArrayLength(exponent_ref) - exponentOffset;
     if (_exponentRemaining < 16) {
         _exception = 1;
         _exceptionType = "java/lang/IllegalArgumentException";
         _exceptionMessage = "length - exponentOffset < 16 < needed";
         goto exit;
     }
     exponent_base = (GLint *)
         _env->GetIntArrayElements(exponent_ref, (jboolean *)0);
     exponent = exponent_base + exponentOffset;

     _returnValue = glQueryMatrixxOES(
         (GLfixed *)mantissa,
         (GLint *)exponent
     );

 exit:
     if (exponent_base) {
         _env->ReleaseIntArrayElements(exponent_ref, (jint*)exponent_base,
             _exception ? JNI_ABORT: 0);
     }
     if (mantissa_base) {
         _env->ReleaseIntArrayElements(mantissa_ref, (jint*)mantissa_base,
             _exception ? JNI_ABORT: 0);
     }
     if (_exception) {
         jniThrowException(_env, _exceptionType, _exceptionMessage);
         return (jint)0;
     }
     return (jint)_returnValue;
 }

 /* GLbitfield glQueryMatrixxOES ( GLfixed *mantissa, GLint *exponent ) */
 static jint
 android_glQueryMatrixxOES__Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2
   (JNIEnv *_env, jobject _this, jobject mantissa_buf, jobject exponent_buf) {
     jint _exception = 0;
     const char * _exceptionType = NULL;
     const char * _exceptionMessage = NULL;
     jintArray _mantissaArray = (jintArray) 0;
     jint _mantissaBufferOffset = (jint) 0;
     jintArray _exponentArray = (jintArray) 0;
     jint _exponentBufferOffset = (jint) 0;
     GLbitfield _returnValue = -1;
     jint _mantissaRemaining;
     GLfixed *mantissa = (GLfixed *) 0;
     jint _exponentRemaining;
     GLint *exponent = (GLint *) 0;

     if (!mantissa_buf) {
         _exception = 1;
         _exceptionType = "java/lang/IllegalArgumentException";
         _exceptionMessage = "mantissa == null";
         goto exit;
     }
     mantissa = (GLfixed *)getPointer(_env, mantissa_buf, (jarray*)&_mantissaArray, &_mantissaRemaining, &_mantissaBufferOffset);
     if (_mantissaRemaining < 16) {
         _exception = 1;
         _exceptionType = "java/lang/IllegalArgumentException";
         _exceptionMessage = "remaining() < 16 < needed";
         goto exit;
     }
     if (!exponent_buf) {
         _exception = 1;
         _exceptionType = "java/lang/IllegalArgumentException";
         _exceptionMessage = "exponent == null";
         goto exit;
     }
     exponent = (GLint *)getPointer(_env, exponent_buf, (jarray*)&_exponentArray, &_exponentRemaining, &_exponentBufferOffset);
     if (_exponentRemaining < 16) {
         _exception = 1;
         _exceptionType = "java/lang/IllegalArgumentException";
         _exceptionMessage = "remaining() < 16 < needed";
         goto exit;
     }
     if (mantissa == NULL) {
         char * _mantissaBase = (char *)_env->GetIntArrayElements(_mantissaArray, (jboolean *) 0);
         mantissa = (GLfixed *) (_mantissaBase + _mantissaBufferOffset);
     }
     if (exponent == NULL) {
         char * _exponentBase = (char *)_env->GetIntArrayElements(_exponentArray, (jboolean *) 0);
         exponent = (GLint *) (_exponentBase + _exponentBufferOffset);
     }
     _returnValue = glQueryMatrixxOES(
         (GLfixed *)mantissa,
         (GLint *)exponent
     );

 exit:
     if (_exponentArray) {
         _env->ReleaseIntArrayElements(_exponentArray, (jint*)exponent, _exception ? JNI_ABORT : 0);
     }
     if (_mantissaArray) {
         _env->ReleaseIntArrayElements(_mantissaArray, (jint*)mantissa, _exception ? JNI_ABORT : 0);
     }
     if (_exception) {
         jniThrowException(_env, _exceptionType, _exceptionMessage);
         return (jint)0;
     }
     return (jint)_returnValue;
 }

 static const char *classPathName = "android/opengl/GLES10Ext";

 static const JNINativeMethod methods[] = {
 {"_nativeClassInit", "()V", (void*)nativeClassInit },
 {"glQueryMatrixxOES", "([II[II)I", (void *) android_glQueryMatrixxOES___3II_3II },
 {"glQueryMatrixxOES", "(Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;)I", (void *) android_glQueryMatrixxOES__Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 },
 };

 int register_android_opengl_jni_GLES10Ext(JNIEnv *_env)
 {
     int err;
     err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));
     return err;
 }
	/*
	**
	** Copyright 2009, The Android Open Source Project
	**
	** Licensed under the Apache License, Version 2.0 (the "License");
	** you may not use this file except in compliance with the License.
	** You may obtain a copy of the License at
	**
	** http://www.apache.org/licenses/LICENSE-2.0
	**
	** Unless required by applicable law or agreed to in writing, software
	** distributed under the License is distributed on an "AS IS" BASIS,
	** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	** See the License for the specific language governing permissions and
	** limitations under the License.
	*/

	// This source file is automatically generated

	#pragma GCC diagnostic ignored "-Wunused-variable"
	#pragma GCC diagnostic ignored "-Wunused-function"

	#include <GLES/gl.h>
	#include <GLES/glext.h>

	#include <jni.h>
	#include <nativehelper/JNIHelp.h>
	#include <android_runtime/AndroidRuntime.h>
	#include <utils/misc.h>
	#include <assert.h>


	/* 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
	}

	static void
	nativeClassInit(JNIEnv *_env, jclass glImplClass)
	{
	}

	static void *
	getPointer(JNIEnv _env, jobject buffer, jarray array, jint remaining, jint offset)
	{
	jint position;
	jint limit;
	jint elementSizeShift;
	jlong pointer;

	pointer = jniGetNioBufferFields(_env, buffer, &position, &limit, &elementSizeShift);
	*remaining = (limit - position) << elementSizeShift;
	if (pointer != 0L) {
	*array = nullptr;
	pointer += position << elementSizeShift;
	return reinterpret_cast<void*>(pointer);
	}

	*array = jniGetNioBufferBaseArray(_env, buffer);
	*offset = jniGetNioBufferBaseArrayOffset(_env, buffer);
	return nullptr;
	}

	class ByteArrayGetter {
	public:
	static void* Get(JNIEnv* _env, jbyteArray array, jboolean* is_copy) {
	return _env->GetByteArrayElements(array, is_copy);
	}
	};
	class BooleanArrayGetter {
	public:
	static void* Get(JNIEnv* _env, jbooleanArray array, jboolean* is_copy) {
	return _env->GetBooleanArrayElements(array, is_copy);
	}
	};
	class CharArrayGetter {
	public:
	static void* Get(JNIEnv* _env, jcharArray array, jboolean* is_copy) {
	return _env->GetCharArrayElements(array, is_copy);
	}
	};
	class ShortArrayGetter {
	public:
	static void* Get(JNIEnv* _env, jshortArray array, jboolean* is_copy) {
	return _env->GetShortArrayElements(array, is_copy);
	}
	};
	class IntArrayGetter {
	public:
	static void* Get(JNIEnv* _env, jintArray array, jboolean* is_copy) {
	return _env->GetIntArrayElements(array, is_copy);
	}
	};
	class LongArrayGetter {
	public:
	static void* Get(JNIEnv* _env, jlongArray array, jboolean* is_copy) {
	return _env->GetLongArrayElements(array, is_copy);
	}
	};
	class FloatArrayGetter {
	public:
	static void* Get(JNIEnv* _env, jfloatArray array, jboolean* is_copy) {
	return _env->GetFloatArrayElements(array, is_copy);
	}
	};
	class DoubleArrayGetter {
	public:
	static void* Get(JNIEnv* _env, jdoubleArray array, jboolean* is_copy) {
	return _env->GetDoubleArrayElements(array, is_copy);
	}
	};

	template<typename JTYPEARRAY, typename ARRAYGETTER>
	static void*
	getArrayPointer(JNIEnv _env, JTYPEARRAY array, jboolean is_copy) {
	return ARRAYGETTER::Get(_env, array, is_copy);
	}

	class ByteArrayReleaser {
	public:
	static void Release(JNIEnv* _env, jbyteArray array, jbyte* data, jboolean commit) {
	_env->ReleaseByteArrayElements(array, data, commit ? 0 : JNI_ABORT);
	}
	};
	class BooleanArrayReleaser {
	public:
	static void Release(JNIEnv* _env, jbooleanArray array, jboolean* data, jboolean commit) {
	_env->ReleaseBooleanArrayElements(array, data, commit ? 0 : JNI_ABORT);
	}
	};
	class CharArrayReleaser {
	public:
	static void Release(JNIEnv* _env, jcharArray array, jchar* data, jboolean commit) {
	_env->ReleaseCharArrayElements(array, data, commit ? 0 : JNI_ABORT);
	}
	};
	class ShortArrayReleaser {
	public:
	static void Release(JNIEnv* _env, jshortArray array, jshort* data, jboolean commit) {
	_env->ReleaseShortArrayElements(array, data, commit ? 0 : JNI_ABORT);
	}
	};
	class IntArrayReleaser {
	public:
	static void Release(JNIEnv* _env, jintArray array, jint* data, jboolean commit) {
	_env->ReleaseIntArrayElements(array, data, commit ? 0 : JNI_ABORT);
	}
	};
	class LongArrayReleaser {
	public:
	static void Release(JNIEnv* _env, jlongArray array, jlong* data, jboolean commit) {
	_env->ReleaseLongArrayElements(array, data, commit ? 0 : JNI_ABORT);
	}
	};
	class FloatArrayReleaser {
	public:
	static void Release(JNIEnv* _env, jfloatArray array, jfloat* data, jboolean commit) {
	_env->ReleaseFloatArrayElements(array, data, commit ? 0 : JNI_ABORT);
	}
	};
	class DoubleArrayReleaser {
	public:
	static void Release(JNIEnv* _env, jdoubleArray array, jdouble* data, jboolean commit) {
	_env->ReleaseDoubleArrayElements(array, data, commit ? 0 : JNI_ABORT);
	}
	};

	template<typename JTYPEARRAY, typename NTYPEARRAY, typename ARRAYRELEASER>
	static void
	releaseArrayPointer(JNIEnv *_env, JTYPEARRAY array, NTYPEARRAY data, jboolean commit) {
	ARRAYRELEASER::Release(_env, array, data, commit);
	}

	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) {
	jint position;
	jint limit;
	jint elementSizeShift;
	jlong pointer;
	pointer = jniGetNioBufferFields(_env, buffer, &position, &limit, &elementSizeShift);
	if (pointer == 0) {
	jniThrowException(_env, "java/lang/IllegalArgumentException",
	"Must use a native order direct Buffer");
	return nullptr;
	}
	pointer += position << elementSizeShift;
	return reinterpret_cast<void*>(pointer);
	}

	// --------------------------------------------------------------------------

	/*
	* 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_3_0
	// GLES 3.x pnames
	switch (pname) {
	case GL_MAX_VIEWPORT_DIMS:
	needed = 2;
	break;

	case GL_PROGRAM_BINARY_FORMATS:
	glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &needed);
	break;
	}
	#endif

	#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 <typename JTYPEARRAY, typename ARRAYGETTER, typename NTYPEARRAY,
	typename ARRAYRELEASER, typename CTYPE, void GET(GLenum, CTYPE*)>
	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 *) getArrayPointer<JTYPEARRAY, ARRAYGETTER>(
	_env, params_ref, (jboolean *)0);
	params = params_base + offset;

	GET(
	(GLenum)pname,
	(CTYPE *)params
	);

	exit:
	if (params_base) {
	releaseArrayPointer<JTYPEARRAY, NTYPEARRAY, ARRAYRELEASER>(
	_env, params_ref, params_base, !_exception);
	}
	if (_exception) {
	jniThrowException(_env, _exceptionType, _exceptionMessage);
	}
	}


	template <typename CTYPE, typename JTYPEARRAY, typename ARRAYGETTER, typename NTYPEARRAY,
	typename ARRAYRELEASER, void GET(GLenum, CTYPE*)>
	static void
	getarray
	(JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
	jint _exception = 0;
	const char * _exceptionType;
	const char * _exceptionMessage;
	JTYPEARRAY _array = (JTYPEARRAY) 0;
	jint _bufferOffset = (jint) 0;
	jint _remaining;
	CTYPE params = (CTYPE ) 0;
	int _needed = 0;

	params = (CTYPE )getPointer(_env, params_buf, (jarray)&_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 *) getArrayPointer<JTYPEARRAY, ARRAYGETTER>(
	_env, _array, (jboolean *) 0);
	params = (CTYPE *) (_paramsBase + _bufferOffset);
	}
	GET(
	(GLenum)pname,
	(CTYPE *)params
	);

	exit:
	if (_array) {
	releaseArrayPointer<JTYPEARRAY, NTYPEARRAY, ARRAYRELEASER>(
	_env, _array, (NTYPEARRAY)params, _exception ? JNI_FALSE : JNI_TRUE);
	}
	if (_exception) {
	jniThrowException(_env, _exceptionType, _exceptionMessage);
	}
	}

	// --------------------------------------------------------------------------
	/* GLbitfield glQueryMatrixxOES ( GLfixed mantissa, GLint exponent ) */
	static jint
	android_glQueryMatrixxOES___3II_3II
	(JNIEnv *_env, jobject _this, jintArray mantissa_ref, jint mantissaOffset, jintArray exponent_ref, jint exponentOffset) {
	jint _exception = 0;
	const char * _exceptionType = NULL;
	const char * _exceptionMessage = NULL;
	GLbitfield _returnValue = -1;
	GLfixed mantissa_base = (GLfixed ) 0;
	jint _mantissaRemaining;
	GLfixed mantissa = (GLfixed ) 0;
	GLint exponent_base = (GLint ) 0;
	jint _exponentRemaining;
	GLint exponent = (GLint ) 0;

	if (!mantissa_ref) {
	_exception = 1;
	_exceptionType = "java/lang/IllegalArgumentException";
	_exceptionMessage = "mantissa == null";
	goto exit;
	}
	if (mantissaOffset < 0) {
	_exception = 1;
	_exceptionType = "java/lang/IllegalArgumentException";
	_exceptionMessage = "mantissaOffset < 0";
	goto exit;
	}
	_mantissaRemaining = _env->GetArrayLength(mantissa_ref) - mantissaOffset;
	if (_mantissaRemaining < 16) {
	_exception = 1;
	_exceptionType = "java/lang/IllegalArgumentException";
	_exceptionMessage = "length - mantissaOffset < 16 < needed";
	goto exit;
	}
	mantissa_base = (GLfixed *)
	_env->GetIntArrayElements(mantissa_ref, (jboolean *)0);
	mantissa = mantissa_base + mantissaOffset;

	if (!exponent_ref) {
	_exception = 1;
	_exceptionType = "java/lang/IllegalArgumentException";
	_exceptionMessage = "exponent == null";
	goto exit;
	}
	if (exponentOffset < 0) {
	_exception = 1;
	_exceptionType = "java/lang/IllegalArgumentException";
	_exceptionMessage = "exponentOffset < 0";
	goto exit;
	}
	_exponentRemaining = _env->GetArrayLength(exponent_ref) - exponentOffset;
	if (_exponentRemaining < 16) {
	_exception = 1;
	_exceptionType = "java/lang/IllegalArgumentException";
	_exceptionMessage = "length - exponentOffset < 16 < needed";
	goto exit;
	}
	exponent_base = (GLint *)
	_env->GetIntArrayElements(exponent_ref, (jboolean *)0);
	exponent = exponent_base + exponentOffset;

	_returnValue = glQueryMatrixxOES(
	(GLfixed *)mantissa,
	(GLint *)exponent
	);

	exit:
	if (exponent_base) {
	_env->ReleaseIntArrayElements(exponent_ref, (jint*)exponent_base,
	_exception ? JNI_ABORT: 0);
	}
	if (mantissa_base) {
	_env->ReleaseIntArrayElements(mantissa_ref, (jint*)mantissa_base,
	_exception ? JNI_ABORT: 0);
	}
	if (_exception) {
	jniThrowException(_env, _exceptionType, _exceptionMessage);
	return (jint)0;
	}
	return (jint)_returnValue;
	}

	/* GLbitfield glQueryMatrixxOES ( GLfixed mantissa, GLint exponent ) */
	static jint
	android_glQueryMatrixxOES__Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2
	(JNIEnv *_env, jobject _this, jobject mantissa_buf, jobject exponent_buf) {
	jint _exception = 0;
	const char * _exceptionType = NULL;
	const char * _exceptionMessage = NULL;
	jintArray _mantissaArray = (jintArray) 0;
	jint _mantissaBufferOffset = (jint) 0;
	jintArray _exponentArray = (jintArray) 0;
	jint _exponentBufferOffset = (jint) 0;
	GLbitfield _returnValue = -1;
	jint _mantissaRemaining;
	GLfixed mantissa = (GLfixed ) 0;
	jint _exponentRemaining;
	GLint exponent = (GLint ) 0;

	if (!mantissa_buf) {
	_exception = 1;
	_exceptionType = "java/lang/IllegalArgumentException";
	_exceptionMessage = "mantissa == null";
	goto exit;
	}
	mantissa = (GLfixed )getPointer(_env, mantissa_buf, (jarray)&_mantissaArray, &_mantissaRemaining, &_mantissaBufferOffset);
	if (_mantissaRemaining < 16) {
	_exception = 1;
	_exceptionType = "java/lang/IllegalArgumentException";
	_exceptionMessage = "remaining() < 16 < needed";
	goto exit;
	}
	if (!exponent_buf) {
	_exception = 1;
	_exceptionType = "java/lang/IllegalArgumentException";
	_exceptionMessage = "exponent == null";
	goto exit;
	}
	exponent = (GLint )getPointer(_env, exponent_buf, (jarray)&_exponentArray, &_exponentRemaining, &_exponentBufferOffset);
	if (_exponentRemaining < 16) {
	_exception = 1;
	_exceptionType = "java/lang/IllegalArgumentException";
	_exceptionMessage = "remaining() < 16 < needed";
	goto exit;
	}
	if (mantissa == NULL) {
	char * _mantissaBase = (char )_env->GetIntArrayElements(_mantissaArray, (jboolean ) 0);
	mantissa = (GLfixed *) (_mantissaBase + _mantissaBufferOffset);
	}
	if (exponent == NULL) {
	char * _exponentBase = (char )_env->GetIntArrayElements(_exponentArray, (jboolean ) 0);
	exponent = (GLint *) (_exponentBase + _exponentBufferOffset);
	}
	_returnValue = glQueryMatrixxOES(
	(GLfixed *)mantissa,
	(GLint *)exponent
	);

	exit:
	if (_exponentArray) {
	_env->ReleaseIntArrayElements(_exponentArray, (jint*)exponent, _exception ? JNI_ABORT : 0);
	}
	if (_mantissaArray) {
	_env->ReleaseIntArrayElements(_mantissaArray, (jint*)mantissa, _exception ? JNI_ABORT : 0);
	}
	if (_exception) {
	jniThrowException(_env, _exceptionType, _exceptionMessage);
	return (jint)0;
	}
	return (jint)_returnValue;
	}

	static const char *classPathName = "android/opengl/GLES10Ext";

	static const JNINativeMethod methods[] = {
	{"_nativeClassInit", "()V", (void*)nativeClassInit },
	{"glQueryMatrixxOES", "([II[II)I", (void *) android_glQueryMatrixxOES___3II_3II },
	{"glQueryMatrixxOES", "(Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;)I", (void *) android_glQueryMatrixxOES__Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 },
	};

	int register_android_opengl_jni_GLES10Ext(JNIEnv *_env)
	{
	int err;
	err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));
	return err;
	}