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 <GLES/gl.h>
21 #include <GLES/glext.h>
22
23 #include "jni.h"
24 #include "JNIHelp.h"
25 #include <android_runtime/AndroidRuntime.h>
26 #include <utils/misc.h>
27 #include <assert.h>
28
29 static int initialized = 0;
30
31 static jclass nioAccessClass;
32 static jclass bufferClass;
33 static jmethodID getBasePointerID;
34 static jmethodID getBaseArrayID;
35 static jmethodID getBaseArrayOffsetID;
36 static jfieldID positionID;
37 static jfieldID limitID;
38 static jfieldID elementSizeShiftID;
39
40
41 /* special calls implemented in Android's GLES wrapper used to more
42 * efficiently bound-check passed arrays */
43 extern "C" {
44 #ifdef GL_VERSION_ES_CM_1_1
45 GL_API void GL_APIENTRY glColorPointerBounds(GLint size, GLenum type, GLsizei stride,
46 const GLvoid *ptr, GLsizei count);
47 GL_API void GL_APIENTRY glNormalPointerBounds(GLenum type, GLsizei stride,
48 const GLvoid *pointer, GLsizei count);
49 GL_API void GL_APIENTRY glTexCoordPointerBounds(GLint size, GLenum type,
50 GLsizei stride, const GLvoid *pointer, GLsizei count);
51 GL_API void GL_APIENTRY glVertexPointerBounds(GLint size, GLenum type,
52 GLsizei stride, const GLvoid *pointer, GLsizei count);
53 GL_API void GL_APIENTRY glPointSizePointerOESBounds(GLenum type,
54 GLsizei stride, const GLvoid *pointer, GLsizei count);
55 GL_API void GL_APIENTRY glMatrixIndexPointerOESBounds(GLint size, GLenum type,
56 GLsizei stride, const GLvoid *pointer, GLsizei count);
57 GL_API void GL_APIENTRY glWeightPointerOESBounds(GLint size, GLenum type,
58 GLsizei stride, const GLvoid *pointer, GLsizei count);
59 #endif
60 #ifdef GL_ES_VERSION_2_0
glVertexAttribPointerBounds(GLuint indx,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const GLvoid * pointer,GLsizei count)61 static void glVertexAttribPointerBounds(GLuint indx, GLint size, GLenum type,
62 GLboolean normalized, GLsizei stride, const GLvoid *pointer, GLsizei count) {
63 glVertexAttribPointer(indx, size, type, normalized, stride, pointer);
64 }
65 #endif
66 #ifdef GL_ES_VERSION_3_0
glVertexAttribIPointerBounds(GLuint indx,GLint size,GLenum type,GLsizei stride,const GLvoid * pointer,GLsizei count)67 static void glVertexAttribIPointerBounds(GLuint indx, GLint size, GLenum type,
68 GLsizei stride, const GLvoid *pointer, GLsizei count) {
69 glVertexAttribIPointer(indx, size, type, stride, pointer);
70 }
71 #endif
72 }
73
74 /* Cache method IDs each time the class is loaded. */
75
76 static void
nativeClassInit(JNIEnv * _env,jclass glImplClass)77 nativeClassInit(JNIEnv *_env, jclass glImplClass)
78 {
79 jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess");
80 nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal);
81
82 jclass bufferClassLocal = _env->FindClass("java/nio/Buffer");
83 bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal);
84
85 getBasePointerID = _env->GetStaticMethodID(nioAccessClass,
86 "getBasePointer", "(Ljava/nio/Buffer;)J");
87 getBaseArrayID = _env->GetStaticMethodID(nioAccessClass,
88 "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;");
89 getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass,
90 "getBaseArrayOffset", "(Ljava/nio/Buffer;)I");
91
92 positionID = _env->GetFieldID(bufferClass, "position", "I");
93 limitID = _env->GetFieldID(bufferClass, "limit", "I");
94 elementSizeShiftID =
95 _env->GetFieldID(bufferClass, "_elementSizeShift", "I");
96 }
97
98 static void *
getPointer(JNIEnv * _env,jobject buffer,jarray * array,jint * remaining,jint * offset)99 getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining, jint *offset)
100 {
101 jint position;
102 jint limit;
103 jint elementSizeShift;
104 jlong pointer;
105
106 position = _env->GetIntField(buffer, positionID);
107 limit = _env->GetIntField(buffer, limitID);
108 elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
109 *remaining = (limit - position) << elementSizeShift;
110 pointer = _env->CallStaticLongMethod(nioAccessClass,
111 getBasePointerID, buffer);
112 if (pointer != 0L) {
113 *array = NULL;
114 return (void *) (jint) pointer;
115 }
116
117 *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass,
118 getBaseArrayID, buffer);
119 *offset = _env->CallStaticIntMethod(nioAccessClass,
120 getBaseArrayOffsetID, buffer);
121
122 return NULL;
123 }
124
125 static void
releasePointer(JNIEnv * _env,jarray array,void * data,jboolean commit)126 releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit)
127 {
128 _env->ReleasePrimitiveArrayCritical(array, data,
129 commit ? 0 : JNI_ABORT);
130 }
131
132 static void *
getDirectBufferPointer(JNIEnv * _env,jobject buffer)133 getDirectBufferPointer(JNIEnv *_env, jobject buffer) {
134 char* buf = (char*) _env->GetDirectBufferAddress(buffer);
135 if (buf) {
136 jint position = _env->GetIntField(buffer, positionID);
137 jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
138 buf += position << elementSizeShift;
139 } else {
140 jniThrowException(_env, "java/lang/IllegalArgumentException",
141 "Must use a native order direct Buffer");
142 }
143 return (void*) buf;
144 }
145
146 // --------------------------------------------------------------------------
147
148 /*
149 * returns the number of values glGet returns for a given pname.
150 *
151 * The code below is written such that pnames requiring only one values
152 * are the default (and are not explicitely tested for). This makes the
153 * checking code much shorter/readable/efficient.
154 *
155 * This means that unknown pnames (e.g.: extensions) will default to 1. If
156 * that unknown pname needs more than 1 value, then the validation check
157 * is incomplete and the app may crash if it passed the wrong number params.
158 */
getNeededCount(GLint pname)159 static int getNeededCount(GLint pname) {
160 int needed = 1;
161 #ifdef GL_ES_VERSION_2_0
162 // GLES 2.x pnames
163 switch (pname) {
164 case GL_ALIASED_LINE_WIDTH_RANGE:
165 case GL_ALIASED_POINT_SIZE_RANGE:
166 needed = 2;
167 break;
168
169 case GL_BLEND_COLOR:
170 case GL_COLOR_CLEAR_VALUE:
171 case GL_COLOR_WRITEMASK:
172 case GL_SCISSOR_BOX:
173 case GL_VIEWPORT:
174 needed = 4;
175 break;
176
177 case GL_COMPRESSED_TEXTURE_FORMATS:
178 glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed);
179 break;
180
181 case GL_SHADER_BINARY_FORMATS:
182 glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &needed);
183 break;
184 }
185 #endif
186
187 #ifdef GL_VERSION_ES_CM_1_1
188 // GLES 1.x pnames
189 switch (pname) {
190 case GL_ALIASED_LINE_WIDTH_RANGE:
191 case GL_ALIASED_POINT_SIZE_RANGE:
192 case GL_DEPTH_RANGE:
193 case GL_SMOOTH_LINE_WIDTH_RANGE:
194 case GL_SMOOTH_POINT_SIZE_RANGE:
195 needed = 2;
196 break;
197
198 case GL_CURRENT_NORMAL:
199 case GL_POINT_DISTANCE_ATTENUATION:
200 needed = 3;
201 break;
202
203 case GL_COLOR_CLEAR_VALUE:
204 case GL_COLOR_WRITEMASK:
205 case GL_CURRENT_COLOR:
206 case GL_CURRENT_TEXTURE_COORDS:
207 case GL_FOG_COLOR:
208 case GL_LIGHT_MODEL_AMBIENT:
209 case GL_SCISSOR_BOX:
210 case GL_VIEWPORT:
211 needed = 4;
212 break;
213
214 case GL_MODELVIEW_MATRIX:
215 case GL_PROJECTION_MATRIX:
216 case GL_TEXTURE_MATRIX:
217 needed = 16;
218 break;
219
220 case GL_COMPRESSED_TEXTURE_FORMATS:
221 glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed);
222 break;
223 }
224 #endif
225 return needed;
226 }
227
228 template <typename JTYPEARRAY, typename CTYPE, void GET(GLenum, CTYPE*)>
229 static void
get(JNIEnv * _env,jobject _this,jint pname,JTYPEARRAY params_ref,jint offset)230 get
231 (JNIEnv *_env, jobject _this, jint pname, JTYPEARRAY params_ref, jint offset) {
232 jint _exception = 0;
233 const char * _exceptionType;
234 const char * _exceptionMessage;
235 CTYPE *params_base = (CTYPE *) 0;
236 jint _remaining;
237 CTYPE *params = (CTYPE *) 0;
238 int _needed = 0;
239
240 if (!params_ref) {
241 _exception = 1;
242 _exceptionType = "java/lang/IllegalArgumentException";
243 _exceptionMessage = "params == null";
244 goto exit;
245 }
246 if (offset < 0) {
247 _exception = 1;
248 _exceptionType = "java/lang/IllegalArgumentException";
249 _exceptionMessage = "offset < 0";
250 goto exit;
251 }
252 _remaining = _env->GetArrayLength(params_ref) - offset;
253 _needed = getNeededCount(pname);
254 // if we didn't find this pname, we just assume the user passed
255 // an array of the right size -- this might happen with extensions
256 // or if we forget an enum here.
257 if (_remaining < _needed) {
258 _exception = 1;
259 _exceptionType = "java/lang/IllegalArgumentException";
260 _exceptionMessage = "length - offset < needed";
261 goto exit;
262 }
263 params_base = (CTYPE *)
264 _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0);
265 params = params_base + offset;
266
267 GET(
268 (GLenum)pname,
269 (CTYPE *)params
270 );
271
272 exit:
273 if (params_base) {
274 _env->ReleasePrimitiveArrayCritical(params_ref, params_base,
275 _exception ? JNI_ABORT: 0);
276 }
277 if (_exception) {
278 jniThrowException(_env, _exceptionType, _exceptionMessage);
279 }
280 }
281
282
283 template <typename CTYPE, void GET(GLenum, CTYPE*)>
284 static void
getarray(JNIEnv * _env,jobject _this,jint pname,jobject params_buf)285 getarray
286 (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
287 jint _exception = 0;
288 const char * _exceptionType;
289 const char * _exceptionMessage;
290 jarray _array = (jarray) 0;
291 jint _bufferOffset = (jint) 0;
292 jint _remaining;
293 CTYPE *params = (CTYPE *) 0;
294 int _needed = 0;
295
296 params = (CTYPE *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
297 _remaining /= sizeof(CTYPE); // convert from bytes to item count
298 _needed = getNeededCount(pname);
299 // if we didn't find this pname, we just assume the user passed
300 // an array of the right size -- this might happen with extensions
301 // or if we forget an enum here.
302 if (_needed>0 && _remaining < _needed) {
303 _exception = 1;
304 _exceptionType = "java/lang/IllegalArgumentException";
305 _exceptionMessage = "remaining() < needed";
306 goto exit;
307 }
308 if (params == NULL) {
309 char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
310 params = (CTYPE *) (_paramsBase + _bufferOffset);
311 }
312 GET(
313 (GLenum)pname,
314 (CTYPE *)params
315 );
316
317 exit:
318 if (_array) {
319 releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
320 }
321 if (_exception) {
322 jniThrowException(_env, _exceptionType, _exceptionMessage);
323 }
324 }
325
326 // --------------------------------------------------------------------------
327 /* GLbitfield glQueryMatrixxOES ( GLfixed *mantissa, GLint *exponent ) */
328 static jint
android_glQueryMatrixxOES___3II_3II(JNIEnv * _env,jobject _this,jintArray mantissa_ref,jint mantissaOffset,jintArray exponent_ref,jint exponentOffset)329 android_glQueryMatrixxOES___3II_3II
330 (JNIEnv *_env, jobject _this, jintArray mantissa_ref, jint mantissaOffset, jintArray exponent_ref, jint exponentOffset) {
331 jint _exception = 0;
332 const char * _exceptionType = NULL;
333 const char * _exceptionMessage = NULL;
334 GLbitfield _returnValue = -1;
335 GLfixed *mantissa_base = (GLfixed *) 0;
336 jint _mantissaRemaining;
337 GLfixed *mantissa = (GLfixed *) 0;
338 GLint *exponent_base = (GLint *) 0;
339 jint _exponentRemaining;
340 GLint *exponent = (GLint *) 0;
341
342 if (!mantissa_ref) {
343 _exception = 1;
344 _exceptionType = "java/lang/IllegalArgumentException";
345 _exceptionMessage = "mantissa == null";
346 goto exit;
347 }
348 if (mantissaOffset < 0) {
349 _exception = 1;
350 _exceptionType = "java/lang/IllegalArgumentException";
351 _exceptionMessage = "mantissaOffset < 0";
352 goto exit;
353 }
354 _mantissaRemaining = _env->GetArrayLength(mantissa_ref) - mantissaOffset;
355 if (_mantissaRemaining < 16) {
356 _exception = 1;
357 _exceptionType = "java/lang/IllegalArgumentException";
358 _exceptionMessage = "length - mantissaOffset < 16 < needed";
359 goto exit;
360 }
361 mantissa_base = (GLfixed *)
362 _env->GetPrimitiveArrayCritical(mantissa_ref, (jboolean *)0);
363 mantissa = mantissa_base + mantissaOffset;
364
365 if (!exponent_ref) {
366 _exception = 1;
367 _exceptionType = "java/lang/IllegalArgumentException";
368 _exceptionMessage = "exponent == null";
369 goto exit;
370 }
371 if (exponentOffset < 0) {
372 _exception = 1;
373 _exceptionType = "java/lang/IllegalArgumentException";
374 _exceptionMessage = "exponentOffset < 0";
375 goto exit;
376 }
377 _exponentRemaining = _env->GetArrayLength(exponent_ref) - exponentOffset;
378 if (_exponentRemaining < 16) {
379 _exception = 1;
380 _exceptionType = "java/lang/IllegalArgumentException";
381 _exceptionMessage = "length - exponentOffset < 16 < needed";
382 goto exit;
383 }
384 exponent_base = (GLint *)
385 _env->GetPrimitiveArrayCritical(exponent_ref, (jboolean *)0);
386 exponent = exponent_base + exponentOffset;
387
388 _returnValue = glQueryMatrixxOES(
389 (GLfixed *)mantissa,
390 (GLint *)exponent
391 );
392
393 exit:
394 if (exponent_base) {
395 _env->ReleasePrimitiveArrayCritical(exponent_ref, exponent_base,
396 _exception ? JNI_ABORT: 0);
397 }
398 if (mantissa_base) {
399 _env->ReleasePrimitiveArrayCritical(mantissa_ref, mantissa_base,
400 _exception ? JNI_ABORT: 0);
401 }
402 if (_exception) {
403 jniThrowException(_env, _exceptionType, _exceptionMessage);
404 }
405 return (jint)_returnValue;
406 }
407
408 /* GLbitfield glQueryMatrixxOES ( GLfixed *mantissa, GLint *exponent ) */
409 static jint
android_glQueryMatrixxOES__Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2(JNIEnv * _env,jobject _this,jobject mantissa_buf,jobject exponent_buf)410 android_glQueryMatrixxOES__Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2
411 (JNIEnv *_env, jobject _this, jobject mantissa_buf, jobject exponent_buf) {
412 jint _exception = 0;
413 const char * _exceptionType = NULL;
414 const char * _exceptionMessage = NULL;
415 jarray _mantissaArray = (jarray) 0;
416 jint _mantissaBufferOffset = (jint) 0;
417 jarray _exponentArray = (jarray) 0;
418 jint _exponentBufferOffset = (jint) 0;
419 GLbitfield _returnValue = -1;
420 jint _mantissaRemaining;
421 GLfixed *mantissa = (GLfixed *) 0;
422 jint _exponentRemaining;
423 GLint *exponent = (GLint *) 0;
424
425 mantissa = (GLfixed *)getPointer(_env, mantissa_buf, &_mantissaArray, &_mantissaRemaining, &_mantissaBufferOffset);
426 if (_mantissaRemaining < 16) {
427 _exception = 1;
428 _exceptionType = "java/lang/IllegalArgumentException";
429 _exceptionMessage = "remaining() < 16 < needed";
430 goto exit;
431 }
432 exponent = (GLint *)getPointer(_env, exponent_buf, &_exponentArray, &_exponentRemaining, &_exponentBufferOffset);
433 if (_exponentRemaining < 16) {
434 _exception = 1;
435 _exceptionType = "java/lang/IllegalArgumentException";
436 _exceptionMessage = "remaining() < 16 < needed";
437 goto exit;
438 }
439 if (mantissa == NULL) {
440 char * _mantissaBase = (char *)_env->GetPrimitiveArrayCritical(_mantissaArray, (jboolean *) 0);
441 mantissa = (GLfixed *) (_mantissaBase + _mantissaBufferOffset);
442 }
443 if (exponent == NULL) {
444 char * _exponentBase = (char *)_env->GetPrimitiveArrayCritical(_exponentArray, (jboolean *) 0);
445 exponent = (GLint *) (_exponentBase + _exponentBufferOffset);
446 }
447 _returnValue = glQueryMatrixxOES(
448 (GLfixed *)mantissa,
449 (GLint *)exponent
450 );
451
452 exit:
453 if (_exponentArray) {
454 releasePointer(_env, _exponentArray, exponent, _exception ? JNI_FALSE : JNI_TRUE);
455 }
456 if (_mantissaArray) {
457 releasePointer(_env, _mantissaArray, mantissa, _exception ? JNI_FALSE : JNI_TRUE);
458 }
459 if (_exception) {
460 jniThrowException(_env, _exceptionType, _exceptionMessage);
461 }
462 return (jint)_returnValue;
463 }
464
465 static const char *classPathName = "android/opengl/GLES10Ext";
466
467 static JNINativeMethod methods[] = {
468 {"_nativeClassInit", "()V", (void*)nativeClassInit },
469 {"glQueryMatrixxOES", "([II[II)I", (void *) android_glQueryMatrixxOES___3II_3II },
470 {"glQueryMatrixxOES", "(Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;)I", (void *) android_glQueryMatrixxOES__Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 },
471 };
472
register_android_opengl_jni_GLES10Ext(JNIEnv * _env)473 int register_android_opengl_jni_GLES10Ext(JNIEnv *_env)
474 {
475 int err;
476 err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));
477 return err;
478 }
479