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#pragma GCC diagnostic ignored "-Wunused-variable"
21#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
22#pragma GCC diagnostic ignored "-Wunused-function"
23
24#include <GLES/gl.h>
25#include <GLES/glext.h>
26
27#include <jni.h>
28#include <JNIHelp.h>
29#include <android_runtime/AndroidRuntime.h>
30#include <utils/misc.h>
31#include <assert.h>
32
33static int initialized = 0;
34
35static jclass nioAccessClass;
36static jclass bufferClass;
37static jmethodID getBasePointerID;
38static jmethodID getBaseArrayID;
39static jmethodID getBaseArrayOffsetID;
40static jfieldID positionID;
41static jfieldID limitID;
42static jfieldID elementSizeShiftID;
43
44
45/* special calls implemented in Android's GLES wrapper used to more
46 * efficiently bound-check passed arrays */
47extern "C" {
48#ifdef GL_VERSION_ES_CM_1_1
49GL_API void GL_APIENTRY glColorPointerBounds(GLint size, GLenum type, GLsizei stride,
50        const GLvoid *ptr, GLsizei count);
51GL_API void GL_APIENTRY glNormalPointerBounds(GLenum type, GLsizei stride,
52        const GLvoid *pointer, GLsizei count);
53GL_API void GL_APIENTRY glTexCoordPointerBounds(GLint size, GLenum type,
54        GLsizei stride, const GLvoid *pointer, GLsizei count);
55GL_API void GL_APIENTRY glVertexPointerBounds(GLint size, GLenum type,
56        GLsizei stride, const GLvoid *pointer, GLsizei count);
57GL_API void GL_APIENTRY glPointSizePointerOESBounds(GLenum type,
58        GLsizei stride, const GLvoid *pointer, GLsizei count);
59GL_API void GL_APIENTRY glMatrixIndexPointerOESBounds(GLint size, GLenum type,
60        GLsizei stride, const GLvoid *pointer, GLsizei count);
61GL_API void GL_APIENTRY glWeightPointerOESBounds(GLint size, GLenum type,
62        GLsizei stride, const GLvoid *pointer, GLsizei count);
63#endif
64#ifdef GL_ES_VERSION_2_0
65static void glVertexAttribPointerBounds(GLuint indx, GLint size, GLenum type,
66        GLboolean normalized, GLsizei stride, const GLvoid *pointer, GLsizei count) {
67    glVertexAttribPointer(indx, size, type, normalized, stride, pointer);
68}
69#endif
70#ifdef GL_ES_VERSION_3_0
71static void glVertexAttribIPointerBounds(GLuint indx, GLint size, GLenum type,
72        GLsizei stride, const GLvoid *pointer, GLsizei count) {
73    glVertexAttribIPointer(indx, size, type, stride, pointer);
74}
75#endif
76}
77
78/* Cache method IDs each time the class is loaded. */
79
80static void
81nativeClassInit(JNIEnv *_env, jclass glImplClass)
82{
83    jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess");
84    nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal);
85
86    jclass bufferClassLocal = _env->FindClass("java/nio/Buffer");
87    bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal);
88
89    getBasePointerID = _env->GetStaticMethodID(nioAccessClass,
90            "getBasePointer", "(Ljava/nio/Buffer;)J");
91    getBaseArrayID = _env->GetStaticMethodID(nioAccessClass,
92            "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;");
93    getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass,
94            "getBaseArrayOffset", "(Ljava/nio/Buffer;)I");
95
96    positionID = _env->GetFieldID(bufferClass, "position", "I");
97    limitID = _env->GetFieldID(bufferClass, "limit", "I");
98    elementSizeShiftID =
99        _env->GetFieldID(bufferClass, "_elementSizeShift", "I");
100}
101
102static void *
103getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining, jint *offset)
104{
105    jint position;
106    jint limit;
107    jint elementSizeShift;
108    jlong pointer;
109
110    position = _env->GetIntField(buffer, positionID);
111    limit = _env->GetIntField(buffer, limitID);
112    elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
113    *remaining = (limit - position) << elementSizeShift;
114    pointer = _env->CallStaticLongMethod(nioAccessClass,
115            getBasePointerID, buffer);
116    if (pointer != 0L) {
117        *array = NULL;
118        return reinterpret_cast<void*>(pointer);
119    }
120
121    *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass,
122            getBaseArrayID, buffer);
123    *offset = _env->CallStaticIntMethod(nioAccessClass,
124            getBaseArrayOffsetID, buffer);
125
126    return NULL;
127}
128
129class ByteArrayGetter {
130public:
131    static void* Get(JNIEnv* _env, jbyteArray array, jboolean* is_copy) {
132        return _env->GetByteArrayElements(array, is_copy);
133    }
134};
135class BooleanArrayGetter {
136public:
137    static void* Get(JNIEnv* _env, jbooleanArray array, jboolean* is_copy) {
138        return _env->GetBooleanArrayElements(array, is_copy);
139    }
140};
141class CharArrayGetter {
142public:
143    static void* Get(JNIEnv* _env, jcharArray array, jboolean* is_copy) {
144        return _env->GetCharArrayElements(array, is_copy);
145    }
146};
147class ShortArrayGetter {
148public:
149    static void* Get(JNIEnv* _env, jshortArray array, jboolean* is_copy) {
150        return _env->GetShortArrayElements(array, is_copy);
151    }
152};
153class IntArrayGetter {
154public:
155    static void* Get(JNIEnv* _env, jintArray array, jboolean* is_copy) {
156        return _env->GetIntArrayElements(array, is_copy);
157    }
158};
159class LongArrayGetter {
160public:
161    static void* Get(JNIEnv* _env, jlongArray array, jboolean* is_copy) {
162        return _env->GetLongArrayElements(array, is_copy);
163    }
164};
165class FloatArrayGetter {
166public:
167    static void* Get(JNIEnv* _env, jfloatArray array, jboolean* is_copy) {
168        return _env->GetFloatArrayElements(array, is_copy);
169    }
170};
171class DoubleArrayGetter {
172public:
173    static void* Get(JNIEnv* _env, jdoubleArray array, jboolean* is_copy) {
174        return _env->GetDoubleArrayElements(array, is_copy);
175    }
176};
177
178template<typename JTYPEARRAY, typename ARRAYGETTER>
179static void*
180getArrayPointer(JNIEnv *_env, JTYPEARRAY array, jboolean* is_copy) {
181    return ARRAYGETTER::Get(_env, array, is_copy);
182}
183
184class ByteArrayReleaser {
185public:
186    static void Release(JNIEnv* _env, jbyteArray array, jbyte* data, jboolean commit) {
187        _env->ReleaseByteArrayElements(array, data, commit ? 0 : JNI_ABORT);
188    }
189};
190class BooleanArrayReleaser {
191public:
192    static void Release(JNIEnv* _env, jbooleanArray array, jboolean* data, jboolean commit) {
193        _env->ReleaseBooleanArrayElements(array, data, commit ? 0 : JNI_ABORT);
194    }
195};
196class CharArrayReleaser {
197public:
198    static void Release(JNIEnv* _env, jcharArray array, jchar* data, jboolean commit) {
199        _env->ReleaseCharArrayElements(array, data, commit ? 0 : JNI_ABORT);
200    }
201};
202class ShortArrayReleaser {
203public:
204    static void Release(JNIEnv* _env, jshortArray array, jshort* data, jboolean commit) {
205        _env->ReleaseShortArrayElements(array, data, commit ? 0 : JNI_ABORT);
206    }
207};
208class IntArrayReleaser {
209public:
210    static void Release(JNIEnv* _env, jintArray array, jint* data, jboolean commit) {
211        _env->ReleaseIntArrayElements(array, data, commit ? 0 : JNI_ABORT);
212    }
213};
214class LongArrayReleaser {
215public:
216    static void Release(JNIEnv* _env, jlongArray array, jlong* data, jboolean commit) {
217        _env->ReleaseLongArrayElements(array, data, commit ? 0 : JNI_ABORT);
218    }
219};
220class FloatArrayReleaser {
221public:
222    static void Release(JNIEnv* _env, jfloatArray array, jfloat* data, jboolean commit) {
223        _env->ReleaseFloatArrayElements(array, data, commit ? 0 : JNI_ABORT);
224    }
225};
226class DoubleArrayReleaser {
227public:
228    static void Release(JNIEnv* _env, jdoubleArray array, jdouble* data, jboolean commit) {
229        _env->ReleaseDoubleArrayElements(array, data, commit ? 0 : JNI_ABORT);
230    }
231};
232
233template<typename JTYPEARRAY, typename NTYPEARRAY, typename ARRAYRELEASER>
234static void
235releaseArrayPointer(JNIEnv *_env, JTYPEARRAY array, NTYPEARRAY data, jboolean commit) {
236    ARRAYRELEASER::Release(_env, array, data, commit);
237}
238
239static void
240releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit)
241{
242    _env->ReleasePrimitiveArrayCritical(array, data,
243                       commit ? 0 : JNI_ABORT);
244}
245
246static void *
247getDirectBufferPointer(JNIEnv *_env, jobject buffer) {
248    char* buf = (char*) _env->GetDirectBufferAddress(buffer);
249    if (buf) {
250        jint position = _env->GetIntField(buffer, positionID);
251        jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
252        buf += position << elementSizeShift;
253    } else {
254        jniThrowException(_env, "java/lang/IllegalArgumentException",
255                          "Must use a native order direct Buffer");
256    }
257    return (void*) buf;
258}
259
260// --------------------------------------------------------------------------
261
262/*
263 * returns the number of values glGet returns for a given pname.
264 *
265 * The code below is written such that pnames requiring only one values
266 * are the default (and are not explicitely tested for). This makes the
267 * checking code much shorter/readable/efficient.
268 *
269 * This means that unknown pnames (e.g.: extensions) will default to 1. If
270 * that unknown pname needs more than 1 value, then the validation check
271 * is incomplete and the app may crash if it passed the wrong number params.
272 */
273static int getNeededCount(GLint pname) {
274    int needed = 1;
275#ifdef GL_ES_VERSION_3_0
276    // GLES 3.x pnames
277    switch (pname) {
278        case GL_MAX_VIEWPORT_DIMS:
279            needed = 2;
280            break;
281
282        case GL_PROGRAM_BINARY_FORMATS:
283            glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &needed);
284            break;
285    }
286#endif
287
288#ifdef GL_ES_VERSION_2_0
289    // GLES 2.x pnames
290    switch (pname) {
291        case GL_ALIASED_LINE_WIDTH_RANGE:
292        case GL_ALIASED_POINT_SIZE_RANGE:
293            needed = 2;
294            break;
295
296        case GL_BLEND_COLOR:
297        case GL_COLOR_CLEAR_VALUE:
298        case GL_COLOR_WRITEMASK:
299        case GL_SCISSOR_BOX:
300        case GL_VIEWPORT:
301            needed = 4;
302            break;
303
304        case GL_COMPRESSED_TEXTURE_FORMATS:
305            glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed);
306            break;
307
308        case GL_SHADER_BINARY_FORMATS:
309            glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &needed);
310            break;
311    }
312#endif
313
314#ifdef GL_VERSION_ES_CM_1_1
315    // GLES 1.x pnames
316    switch (pname) {
317        case GL_ALIASED_LINE_WIDTH_RANGE:
318        case GL_ALIASED_POINT_SIZE_RANGE:
319        case GL_DEPTH_RANGE:
320        case GL_SMOOTH_LINE_WIDTH_RANGE:
321        case GL_SMOOTH_POINT_SIZE_RANGE:
322            needed = 2;
323            break;
324
325        case GL_CURRENT_NORMAL:
326        case GL_POINT_DISTANCE_ATTENUATION:
327            needed = 3;
328            break;
329
330        case GL_COLOR_CLEAR_VALUE:
331        case GL_COLOR_WRITEMASK:
332        case GL_CURRENT_COLOR:
333        case GL_CURRENT_TEXTURE_COORDS:
334        case GL_FOG_COLOR:
335        case GL_LIGHT_MODEL_AMBIENT:
336        case GL_SCISSOR_BOX:
337        case GL_VIEWPORT:
338            needed = 4;
339            break;
340
341        case GL_MODELVIEW_MATRIX:
342        case GL_PROJECTION_MATRIX:
343        case GL_TEXTURE_MATRIX:
344            needed = 16;
345            break;
346
347        case GL_COMPRESSED_TEXTURE_FORMATS:
348            glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &needed);
349            break;
350    }
351#endif
352    return needed;
353}
354
355template <typename JTYPEARRAY, typename ARRAYGETTER, typename NTYPEARRAY,
356          typename ARRAYRELEASER, typename CTYPE, void GET(GLenum, CTYPE*)>
357static void
358get
359  (JNIEnv *_env, jobject _this, jint pname, JTYPEARRAY params_ref, jint offset) {
360    jint _exception = 0;
361    const char * _exceptionType;
362    const char * _exceptionMessage;
363    CTYPE *params_base = (CTYPE *) 0;
364    jint _remaining;
365    CTYPE *params = (CTYPE *) 0;
366    int _needed = 0;
367
368    if (!params_ref) {
369        _exception = 1;
370        _exceptionType = "java/lang/IllegalArgumentException";
371        _exceptionMessage = "params == null";
372        goto exit;
373    }
374    if (offset < 0) {
375        _exception = 1;
376        _exceptionType = "java/lang/IllegalArgumentException";
377        _exceptionMessage = "offset < 0";
378        goto exit;
379    }
380    _remaining = _env->GetArrayLength(params_ref) - offset;
381    _needed = getNeededCount(pname);
382    // if we didn't find this pname, we just assume the user passed
383    // an array of the right size -- this might happen with extensions
384    // or if we forget an enum here.
385    if (_remaining < _needed) {
386        _exception = 1;
387        _exceptionType = "java/lang/IllegalArgumentException";
388        _exceptionMessage = "length - offset < needed";
389        goto exit;
390    }
391    params_base = (CTYPE *) getArrayPointer<JTYPEARRAY, ARRAYGETTER>(
392        _env, params_ref, (jboolean *)0);
393    params = params_base + offset;
394
395    GET(
396        (GLenum)pname,
397        (CTYPE *)params
398    );
399
400exit:
401    if (params_base) {
402        releaseArrayPointer<JTYPEARRAY, NTYPEARRAY, ARRAYRELEASER>(
403            _env, params_ref, params_base, !_exception);
404    }
405    if (_exception) {
406        jniThrowException(_env, _exceptionType, _exceptionMessage);
407    }
408}
409
410
411template <typename CTYPE, typename JTYPEARRAY, typename ARRAYGETTER, typename NTYPEARRAY,
412          typename ARRAYRELEASER, void GET(GLenum, CTYPE*)>
413static void
414getarray
415  (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
416    jint _exception = 0;
417    const char * _exceptionType;
418    const char * _exceptionMessage;
419    JTYPEARRAY _array = (JTYPEARRAY) 0;
420    jint _bufferOffset = (jint) 0;
421    jint _remaining;
422    CTYPE *params = (CTYPE *) 0;
423    int _needed = 0;
424
425    params = (CTYPE *)getPointer(_env, params_buf, (jarray*)&_array, &_remaining, &_bufferOffset);
426    _remaining /= sizeof(CTYPE);    // convert from bytes to item count
427    _needed = getNeededCount(pname);
428    // if we didn't find this pname, we just assume the user passed
429    // an array of the right size -- this might happen with extensions
430    // or if we forget an enum here.
431    if (_needed>0 && _remaining < _needed) {
432        _exception = 1;
433        _exceptionType = "java/lang/IllegalArgumentException";
434        _exceptionMessage = "remaining() < needed";
435        goto exit;
436    }
437    if (params == NULL) {
438        char * _paramsBase = (char *) getArrayPointer<JTYPEARRAY, ARRAYGETTER>(
439            _env, _array, (jboolean *) 0);
440        params = (CTYPE *) (_paramsBase + _bufferOffset);
441    }
442    GET(
443        (GLenum)pname,
444        (CTYPE *)params
445    );
446
447exit:
448    if (_array) {
449        releaseArrayPointer<JTYPEARRAY, NTYPEARRAY, ARRAYRELEASER>(
450            _env, _array, (NTYPEARRAY)params, _exception ? JNI_FALSE : JNI_TRUE);
451    }
452    if (_exception) {
453        jniThrowException(_env, _exceptionType, _exceptionMessage);
454    }
455}
456
457// --------------------------------------------------------------------------
458/* GLbitfield glQueryMatrixxOES ( GLfixed *mantissa, GLint *exponent ) */
459static jint
460android_glQueryMatrixxOES___3II_3II
461  (JNIEnv *_env, jobject _this, jintArray mantissa_ref, jint mantissaOffset, jintArray exponent_ref, jint exponentOffset) {
462    jint _exception = 0;
463    const char * _exceptionType = NULL;
464    const char * _exceptionMessage = NULL;
465    GLbitfield _returnValue = -1;
466    GLfixed *mantissa_base = (GLfixed *) 0;
467    jint _mantissaRemaining;
468    GLfixed *mantissa = (GLfixed *) 0;
469    GLint *exponent_base = (GLint *) 0;
470    jint _exponentRemaining;
471    GLint *exponent = (GLint *) 0;
472
473    if (!mantissa_ref) {
474        _exception = 1;
475        _exceptionType = "java/lang/IllegalArgumentException";
476        _exceptionMessage = "mantissa == null";
477        goto exit;
478    }
479    if (mantissaOffset < 0) {
480        _exception = 1;
481        _exceptionType = "java/lang/IllegalArgumentException";
482        _exceptionMessage = "mantissaOffset < 0";
483        goto exit;
484    }
485    _mantissaRemaining = _env->GetArrayLength(mantissa_ref) - mantissaOffset;
486    if (_mantissaRemaining < 16) {
487        _exception = 1;
488        _exceptionType = "java/lang/IllegalArgumentException";
489        _exceptionMessage = "length - mantissaOffset < 16 < needed";
490        goto exit;
491    }
492    mantissa_base = (GLfixed *)
493        _env->GetIntArrayElements(mantissa_ref, (jboolean *)0);
494    mantissa = mantissa_base + mantissaOffset;
495
496    if (!exponent_ref) {
497        _exception = 1;
498        _exceptionType = "java/lang/IllegalArgumentException";
499        _exceptionMessage = "exponent == null";
500        goto exit;
501    }
502    if (exponentOffset < 0) {
503        _exception = 1;
504        _exceptionType = "java/lang/IllegalArgumentException";
505        _exceptionMessage = "exponentOffset < 0";
506        goto exit;
507    }
508    _exponentRemaining = _env->GetArrayLength(exponent_ref) - exponentOffset;
509    if (_exponentRemaining < 16) {
510        _exception = 1;
511        _exceptionType = "java/lang/IllegalArgumentException";
512        _exceptionMessage = "length - exponentOffset < 16 < needed";
513        goto exit;
514    }
515    exponent_base = (GLint *)
516        _env->GetIntArrayElements(exponent_ref, (jboolean *)0);
517    exponent = exponent_base + exponentOffset;
518
519    _returnValue = glQueryMatrixxOES(
520        (GLfixed *)mantissa,
521        (GLint *)exponent
522    );
523
524exit:
525    if (exponent_base) {
526        _env->ReleaseIntArrayElements(exponent_ref, (jint*)exponent_base,
527            _exception ? JNI_ABORT: 0);
528    }
529    if (mantissa_base) {
530        _env->ReleaseIntArrayElements(mantissa_ref, (jint*)mantissa_base,
531            _exception ? JNI_ABORT: 0);
532    }
533    if (_exception) {
534        jniThrowException(_env, _exceptionType, _exceptionMessage);
535    }
536    return (jint)_returnValue;
537}
538
539/* GLbitfield glQueryMatrixxOES ( GLfixed *mantissa, GLint *exponent ) */
540static jint
541android_glQueryMatrixxOES__Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2
542  (JNIEnv *_env, jobject _this, jobject mantissa_buf, jobject exponent_buf) {
543    jint _exception = 0;
544    const char * _exceptionType = NULL;
545    const char * _exceptionMessage = NULL;
546    jintArray _mantissaArray = (jintArray) 0;
547    jint _mantissaBufferOffset = (jint) 0;
548    jintArray _exponentArray = (jintArray) 0;
549    jint _exponentBufferOffset = (jint) 0;
550    GLbitfield _returnValue = -1;
551    jint _mantissaRemaining;
552    GLfixed *mantissa = (GLfixed *) 0;
553    jint _exponentRemaining;
554    GLint *exponent = (GLint *) 0;
555
556    if (!mantissa_buf) {
557        _exception = 1;
558        _exceptionType = "java/lang/IllegalArgumentException";
559        _exceptionMessage = "mantissa == null";
560        goto exit;
561    }
562    mantissa = (GLfixed *)getPointer(_env, mantissa_buf, (jarray*)&_mantissaArray, &_mantissaRemaining, &_mantissaBufferOffset);
563    if (_mantissaRemaining < 16) {
564        _exception = 1;
565        _exceptionType = "java/lang/IllegalArgumentException";
566        _exceptionMessage = "remaining() < 16 < needed";
567        goto exit;
568    }
569    if (!exponent_buf) {
570        _exception = 1;
571        _exceptionType = "java/lang/IllegalArgumentException";
572        _exceptionMessage = "exponent == null";
573        goto exit;
574    }
575    exponent = (GLint *)getPointer(_env, exponent_buf, (jarray*)&_exponentArray, &_exponentRemaining, &_exponentBufferOffset);
576    if (_exponentRemaining < 16) {
577        _exception = 1;
578        _exceptionType = "java/lang/IllegalArgumentException";
579        _exceptionMessage = "remaining() < 16 < needed";
580        goto exit;
581    }
582    if (mantissa == NULL) {
583        char * _mantissaBase = (char *)_env->GetIntArrayElements(_mantissaArray, (jboolean *) 0);
584        mantissa = (GLfixed *) (_mantissaBase + _mantissaBufferOffset);
585    }
586    if (exponent == NULL) {
587        char * _exponentBase = (char *)_env->GetIntArrayElements(_exponentArray, (jboolean *) 0);
588        exponent = (GLint *) (_exponentBase + _exponentBufferOffset);
589    }
590    _returnValue = glQueryMatrixxOES(
591        (GLfixed *)mantissa,
592        (GLint *)exponent
593    );
594
595exit:
596    if (_exponentArray) {
597        _env->ReleaseIntArrayElements(_exponentArray, (jint*)exponent, _exception ? JNI_ABORT : 0);
598    }
599    if (_mantissaArray) {
600        _env->ReleaseIntArrayElements(_mantissaArray, (jint*)mantissa, _exception ? JNI_ABORT : 0);
601    }
602    if (_exception) {
603        jniThrowException(_env, _exceptionType, _exceptionMessage);
604    }
605    return (jint)_returnValue;
606}
607
608static const char *classPathName = "android/opengl/GLES10Ext";
609
610static const JNINativeMethod methods[] = {
611{"_nativeClassInit", "()V", (void*)nativeClassInit },
612{"glQueryMatrixxOES", "([II[II)I", (void *) android_glQueryMatrixxOES___3II_3II },
613{"glQueryMatrixxOES", "(Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;)I", (void *) android_glQueryMatrixxOES__Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 },
614};
615
616int register_android_opengl_jni_GLES10Ext(JNIEnv *_env)
617{
618    int err;
619    err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));
620    return err;
621}
622