Blame - core/jni/android_opengl_GLES20.cpp - platform/frameworks/base

blob: ef25319b760087b6f79d9340ffa0c136c9c489ea [file] [log] [blame]

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