66089a33ea
Adds support for formerly-unimplemented methods: glCurrentPaletteMatrixOES glLoadPaletteFromModelViewMatrixOES glMatrixIndexPointerOES glWeightPointerOES The bulk of the changes are related to implementing the two PointerOES methods, which are implemented pretty much the same way as the existing Pointer methods were implemented. This change also changes the way glPointSizePointerOES is implemented, making it act like all the other Pointer methods. (Previously it was not handling non-direct-buffer arguments correctly.) Fixes bug 2308625 "Support matrix palette skinning in JSR239 and related APIs" Also updated GLLogWraper to fix two bugs in GLLogWrapper that were discovered while testing matrix palette skinning support: a) Handle trying to print the contents of null-but-enabled buffers. (It's not legal to draw with null-but-enabled buffers, and in fact some OpenGL drivers will crash if you try to render in this state, but there's no reason the GLLogWrapper should crash while trying to debug this situation. b) Don't read off the end of a vertex buffer with non-zero position when printing the entire contents of the vertex buffer. Now we only print from the current position to the end of the buffer.
147 lines
4.8 KiB
C++
147 lines
4.8 KiB
C++
**
|
|
** Copyright 2009, The Android Open Source Project
|
|
**
|
|
** Licensed under the Apache License, Version 2.0 (the "License");
|
|
** you may not use this file except in compliance with the License.
|
|
** You may obtain a copy of the License at
|
|
**
|
|
** http://www.apache.org/licenses/LICENSE-2.0
|
|
**
|
|
** Unless required by applicable law or agreed to in writing, software
|
|
** distributed under the License is distributed on an "AS IS" BASIS,
|
|
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
** See the License for the specific language governing permissions and
|
|
** limitations under the License.
|
|
*/
|
|
|
|
// This source file is automatically generated
|
|
|
|
#include <android_runtime/AndroidRuntime.h>
|
|
#include <utils/misc.h>
|
|
|
|
#include <assert.h>
|
|
#include <GLES/gl.h>
|
|
#include <GLES/glext.h>
|
|
|
|
/* special calls implemented in Android's GLES wrapper used to more
|
|
* efficiently bound-check passed arrays */
|
|
extern "C" {
|
|
GL_API void GL_APIENTRY glMatrixIndexPointerOESBounds(GLint size, GLenum type, GLsizei stride,
|
|
const GLvoid *ptr, GLsizei count);
|
|
GL_API void GL_APIENTRY glWeightPointerOESBounds(GLint size, GLenum type, GLsizei stride,
|
|
const GLvoid *ptr, GLsizei count);
|
|
}
|
|
|
|
static int initialized = 0;
|
|
|
|
static jclass nioAccessClass;
|
|
static jclass bufferClass;
|
|
static jclass OOMEClass;
|
|
static jclass UOEClass;
|
|
static jclass IAEClass;
|
|
static jclass AIOOBEClass;
|
|
static jmethodID getBasePointerID;
|
|
static jmethodID getBaseArrayID;
|
|
static jmethodID getBaseArrayOffsetID;
|
|
static jfieldID positionID;
|
|
static jfieldID limitID;
|
|
static jfieldID elementSizeShiftID;
|
|
|
|
/* Cache method IDs each time the class is loaded. */
|
|
|
|
static void
|
|
nativeClassInitBuffer(JNIEnv *_env)
|
|
{
|
|
jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess");
|
|
nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal);
|
|
|
|
jclass bufferClassLocal = _env->FindClass("java/nio/Buffer");
|
|
bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal);
|
|
|
|
getBasePointerID = _env->GetStaticMethodID(nioAccessClass,
|
|
"getBasePointer", "(Ljava/nio/Buffer;)J");
|
|
getBaseArrayID = _env->GetStaticMethodID(nioAccessClass,
|
|
"getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;");
|
|
getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass,
|
|
"getBaseArrayOffset", "(Ljava/nio/Buffer;)I");
|
|
|
|
positionID = _env->GetFieldID(bufferClass, "position", "I");
|
|
limitID = _env->GetFieldID(bufferClass, "limit", "I");
|
|
elementSizeShiftID =
|
|
_env->GetFieldID(bufferClass, "_elementSizeShift", "I");
|
|
}
|
|
|
|
|
|
static void
|
|
nativeClassInit(JNIEnv *_env, jclass glImplClass)
|
|
{
|
|
nativeClassInitBuffer(_env);
|
|
|
|
jclass IAEClassLocal =
|
|
_env->FindClass("java/lang/IllegalArgumentException");
|
|
jclass OOMEClassLocal =
|
|
_env->FindClass("java/lang/OutOfMemoryError");
|
|
jclass UOEClassLocal =
|
|
_env->FindClass("java/lang/UnsupportedOperationException");
|
|
jclass AIOOBEClassLocal =
|
|
_env->FindClass("java/lang/ArrayIndexOutOfBoundsException");
|
|
|
|
IAEClass = (jclass) _env->NewGlobalRef(IAEClassLocal);
|
|
OOMEClass = (jclass) _env->NewGlobalRef(OOMEClassLocal);
|
|
UOEClass = (jclass) _env->NewGlobalRef(UOEClassLocal);
|
|
AIOOBEClass = (jclass) _env->NewGlobalRef(AIOOBEClassLocal);
|
|
}
|
|
|
|
static void *
|
|
getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining)
|
|
{
|
|
jint position;
|
|
jint limit;
|
|
jint elementSizeShift;
|
|
jlong pointer;
|
|
jint offset;
|
|
void *data;
|
|
|
|
position = _env->GetIntField(buffer, positionID);
|
|
limit = _env->GetIntField(buffer, limitID);
|
|
elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
|
|
*remaining = (limit - position) << elementSizeShift;
|
|
pointer = _env->CallStaticLongMethod(nioAccessClass,
|
|
getBasePointerID, buffer);
|
|
if (pointer != 0L) {
|
|
*array = NULL;
|
|
return (void *) (jint) pointer;
|
|
}
|
|
|
|
*array = (jarray) _env->CallStaticObjectMethod(nioAccessClass,
|
|
getBaseArrayID, buffer);
|
|
offset = _env->CallStaticIntMethod(nioAccessClass,
|
|
getBaseArrayOffsetID, buffer);
|
|
data = _env->GetPrimitiveArrayCritical(*array, (jboolean *) 0);
|
|
|
|
return (void *) ((char *) data + offset);
|
|
}
|
|
|
|
|
|
static void
|
|
releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit)
|
|
{
|
|
_env->ReleasePrimitiveArrayCritical(array, data,
|
|
commit ? 0 : JNI_ABORT);
|
|
}
|
|
|
|
static void *
|
|
getDirectBufferPointer(JNIEnv *_env, jobject buffer) {
|
|
char* buf = (char*) _env->GetDirectBufferAddress(buffer);
|
|
if (buf) {
|
|
jint position = _env->GetIntField(buffer, positionID);
|
|
jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
|
|
buf += position << elementSizeShift;
|
|
} else {
|
|
_env->ThrowNew(IAEClass, "Must use a native order direct Buffer");
|
|
}
|
|
return (void*) buf;
|
|
}
|
|
// --------------------------------------------------------------------------
|
|
|