diff options
Diffstat (limited to 'opengl/java/android/opengl/GLErrorWrapper.java')
| -rw-r--r-- | opengl/java/android/opengl/GLErrorWrapper.java | 961 |
1 files changed, 961 insertions, 0 deletions
diff --git a/opengl/java/android/opengl/GLErrorWrapper.java b/opengl/java/android/opengl/GLErrorWrapper.java new file mode 100644 index 00000000000..884a1a09539 --- /dev/null +++ b/opengl/java/android/opengl/GLErrorWrapper.java @@ -0,0 +1,961 @@ +/* + * Copyright (C) 2007 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. + */ + +package android.opengl; + +import java.nio.Buffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.nio.ShortBuffer; + +import javax.microedition.khronos.opengles.GL; + +/** + * Implement an error checking wrapper. The wrapper will automatically call + * glError after each GL operation, and throw a GLException if an error + * occurs. (By design, calling glError itself will not cause an exception + * to be thrown.) Enabling error checking is an alternative to manually + * calling glError after every GL operation. + */ +class GLErrorWrapper extends GLWrapperBase { + boolean mCheckError; + boolean mCheckThread; + Thread mOurThread; + + public GLErrorWrapper(GL gl, int configFlags) { + super(gl); + mCheckError = (configFlags & GLDebugHelper.CONFIG_CHECK_GL_ERROR) != 0; + mCheckThread = (configFlags & GLDebugHelper.CONFIG_CHECK_THREAD) != 0; + } + + private void checkThread() { + if (mCheckThread) { + Thread currentThread = Thread.currentThread(); + if (mOurThread == null) { + mOurThread = currentThread; + } else { + if (!mOurThread.equals(currentThread)) { + throw new GLException(GLDebugHelper.ERROR_WRONG_THREAD, + "OpenGL method called from wrong thread."); + } + } + } + } + + private void checkError() { + if (mCheckError) { + int glError; + if ((glError = mgl.glGetError()) != 0) { + throw new GLException(glError); + } + } + } + + // --------------------------------------------------------------------- + // GL10 methods: + + public void glActiveTexture(int texture) { + checkThread(); + mgl.glActiveTexture(texture); + checkError(); + } + + public void glAlphaFunc(int func, float ref) { + checkThread(); + mgl.glAlphaFunc(func, ref); + checkError(); + } + + public void glAlphaFuncx(int func, int ref) { + checkThread(); + mgl.glAlphaFuncx(func, ref); + checkError(); + } + + public void glBindTexture(int target, int texture) { + checkThread(); + mgl.glBindTexture(target, texture); + checkError(); + } + + public void glBlendFunc(int sfactor, int dfactor) { + checkThread(); + mgl.glBlendFunc(sfactor, dfactor); + checkError(); + } + + public void glClear(int mask) { + checkThread(); + mgl.glClear(mask); + checkError(); + } + + public void glClearColor(float red, float green, float blue, float alpha) { + checkThread(); + mgl.glClearColor(red, green, blue, alpha); + checkError(); + } + + public void glClearColorx(int red, int green, int blue, int alpha) { + checkThread(); + mgl.glClearColorx(red, green, blue, alpha); + checkError(); + } + + public void glClearDepthf(float depth) { + checkThread(); + mgl.glClearDepthf(depth); + checkError(); + } + + public void glClearDepthx(int depth) { + checkThread(); + mgl.glClearDepthx(depth); + checkError(); + } + + public void glClearStencil(int s) { + checkThread(); + mgl.glClearStencil(s); + checkError(); + } + + public void glClientActiveTexture(int texture) { + checkThread(); + mgl.glClientActiveTexture(texture); + checkError(); + } + + public void glColor4f(float red, float green, float blue, float alpha) { + checkThread(); + mgl.glColor4f(red, green, blue, alpha); + checkError(); + } + + public void glColor4x(int red, int green, int blue, int alpha) { + checkThread(); + mgl.glColor4x(red, green, blue, alpha); + checkError(); + } + + public void glColorMask(boolean red, boolean green, boolean blue, + boolean alpha) { + checkThread(); + mgl.glColorMask(red, green, blue, alpha); + checkError(); + } + + public void glColorPointer(int size, int type, int stride, Buffer pointer) { + checkThread(); + mgl.glColorPointer(size, type, stride, pointer); + checkError(); + } + + public void glCompressedTexImage2D(int target, int level, + int internalformat, int width, int height, int border, + int imageSize, Buffer data) { + checkThread(); + mgl.glCompressedTexImage2D(target, level, internalformat, width, + height, border, imageSize, data); + checkError(); + } + + public void glCompressedTexSubImage2D(int target, int level, int xoffset, + int yoffset, int width, int height, int format, int imageSize, + Buffer data) { + checkThread(); + mgl.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, + height, format, imageSize, data); + checkError(); + } + + public void glCopyTexImage2D(int target, int level, int internalformat, + int x, int y, int width, int height, int border) { + checkThread(); + mgl.glCopyTexImage2D(target, level, internalformat, x, y, width, + height, border); + checkError(); + } + + public void glCopyTexSubImage2D(int target, int level, int xoffset, + int yoffset, int x, int y, int width, int height) { + checkThread(); + mgl.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, + height); + checkError(); + } + + public void glCullFace(int mode) { + checkThread(); + mgl.glCullFace(mode); + checkError(); + } + + public void glDeleteTextures(int n, int[] textures, int offset) { + checkThread(); + mgl.glDeleteTextures(n, textures, offset); + checkError(); + } + + public void glDeleteTextures(int n, IntBuffer textures) { + checkThread(); + mgl.glDeleteTextures(n, textures); + checkError(); + } + + public void glDepthFunc(int func) { + checkThread(); + mgl.glDepthFunc(func); + checkError(); + } + + public void glDepthMask(boolean flag) { + checkThread(); + mgl.glDepthMask(flag); + checkError(); + } + + public void glDepthRangef(float near, float far) { + checkThread(); + mgl.glDepthRangef(near, far); + checkError(); + } + + public void glDepthRangex(int near, int far) { + checkThread(); + mgl.glDepthRangex(near, far); + checkError(); + } + + public void glDisable(int cap) { + checkThread(); + mgl.glDisable(cap); + checkError(); + } + + public void glDisableClientState(int array) { + checkThread(); + mgl.glDisableClientState(array); + checkError(); + } + + public void glDrawArrays(int mode, int first, int count) { + checkThread(); + mgl.glDrawArrays(mode, first, count); + checkError(); + } + + public void glDrawElements(int mode, int count, int type, Buffer indices) { + checkThread(); + mgl.glDrawElements(mode, count, type, indices); + checkError(); + } + + public void glEnable(int cap) { + checkThread(); + mgl.glEnable(cap); + checkError(); + } + + public void glEnableClientState(int array) { + checkThread(); + mgl.glEnableClientState(array); + checkError(); + } + + public void glFinish() { + checkThread(); + mgl.glFinish(); + checkError(); + } + + public void glFlush() { + checkThread(); + mgl.glFlush(); + checkError(); + } + + public void glFogf(int pname, float param) { + checkThread(); + mgl.glFogf(pname, param); + checkError(); + } + + public void glFogfv(int pname, float[] params, int offset) { + checkThread(); + mgl.glFogfv(pname, params, offset); + checkError(); + } + + public void glFogfv(int pname, FloatBuffer params) { + checkThread(); + mgl.glFogfv(pname, params); + checkError(); + } + + public void glFogx(int pname, int param) { + checkThread(); + mgl.glFogx(pname, param); + checkError(); + } + + public void glFogxv(int pname, int[] params, int offset) { + checkThread(); + mgl.glFogxv(pname, params, offset); + checkError(); + } + + public void glFogxv(int pname, IntBuffer params) { + checkThread(); + mgl.glFogxv(pname, params); + checkError(); + } + + public void glFrontFace(int mode) { + checkThread(); + mgl.glFrontFace(mode); + checkError(); + } + + public void glFrustumf(float left, float right, float bottom, float top, + float near, float far) { + checkThread(); + mgl.glFrustumf(left, right, bottom, top, near, far); + checkError(); + } + + public void glFrustumx(int left, int right, int bottom, int top, int near, + int far) { + checkThread(); + mgl.glFrustumx(left, right, bottom, top, near, far); + checkError(); + } + + public void glGenTextures(int n, int[] textures, int offset) { + checkThread(); + mgl.glGenTextures(n, textures, offset); + checkError(); + } + + public void glGenTextures(int n, IntBuffer textures) { + checkThread(); + mgl.glGenTextures(n, textures); + checkError(); + } + + public int glGetError() { + checkThread(); + int result = mgl.glGetError(); + return result; + } + + public void glGetIntegerv(int pname, int[] params, int offset) { + checkThread(); + mgl.glGetIntegerv(pname, params, offset); + checkError(); + } + + public void glGetIntegerv(int pname, IntBuffer params) { + checkThread(); + mgl.glGetIntegerv(pname, params); + checkError(); + } + + public String glGetString(int name) { + checkThread(); + String result = mgl.glGetString(name); + checkError(); + return result; + } + + public void glHint(int target, int mode) { + checkThread(); + mgl.glHint(target, mode); + checkError(); + } + + public void glLightModelf(int pname, float param) { + checkThread(); + mgl.glLightModelf(pname, param); + checkError(); + } + + public void glLightModelfv(int pname, float[] params, int offset) { + checkThread(); + mgl.glLightModelfv(pname, params, offset); + checkError(); + } + + public void glLightModelfv(int pname, FloatBuffer params) { + checkThread(); + mgl.glLightModelfv(pname, params); + checkError(); + } + + public void glLightModelx(int pname, int param) { + checkThread(); + mgl.glLightModelx(pname, param); + checkError(); + } + + public void glLightModelxv(int pname, int[] params, int offset) { + checkThread(); + mgl.glLightModelxv(pname, params, offset); + checkError(); + } + + public void glLightModelxv(int pname, IntBuffer params) { + checkThread(); + mgl.glLightModelxv(pname, params); + checkError(); + } + + public void glLightf(int light, int pname, float param) { + checkThread(); + mgl.glLightf(light, pname, param); + checkError(); + } + + public void glLightfv(int light, int pname, float[] params, int offset) { + checkThread(); + mgl.glLightfv(light, pname, params, offset); + checkError(); + } + + public void glLightfv(int light, int pname, FloatBuffer params) { + checkThread(); + mgl.glLightfv(light, pname, params); + checkError(); + } + + public void glLightx(int light, int pname, int param) { + checkThread(); + mgl.glLightx(light, pname, param); + checkError(); + } + + public void glLightxv(int light, int pname, int[] params, int offset) { + checkThread(); + mgl.glLightxv(light, pname, params, offset); + checkError(); + } + + public void glLightxv(int light, int pname, IntBuffer params) { + checkThread(); + mgl.glLightxv(light, pname, params); + checkError(); + } + + public void glLineWidth(float width) { + checkThread(); + mgl.glLineWidth(width); + checkError(); + } + + public void glLineWidthx(int width) { + checkThread(); + mgl.glLineWidthx(width); + checkError(); + } + + public void glLoadIdentity() { + checkThread(); + mgl.glLoadIdentity(); + checkError(); + } + + public void glLoadMatrixf(float[] m, int offset) { + checkThread(); + mgl.glLoadMatrixf(m, offset); + checkError(); + } + + public void glLoadMatrixf(FloatBuffer m) { + checkThread(); + mgl.glLoadMatrixf(m); + checkError(); + } + + public void glLoadMatrixx(int[] m, int offset) { + checkThread(); + mgl.glLoadMatrixx(m, offset); + checkError(); + } + + public void glLoadMatrixx(IntBuffer m) { + checkThread(); + mgl.glLoadMatrixx(m); + checkError(); + } + + public void glLogicOp(int opcode) { + checkThread(); + mgl.glLogicOp(opcode); + checkError(); + } + + public void glMaterialf(int face, int pname, float param) { + checkThread(); + mgl.glMaterialf(face, pname, param); + checkError(); + } + + public void glMaterialfv(int face, int pname, float[] params, int offset) { + checkThread(); + mgl.glMaterialfv(face, pname, params, offset); + checkError(); + } + + public void glMaterialfv(int face, int pname, FloatBuffer params) { + checkThread(); + mgl.glMaterialfv(face, pname, params); + checkError(); + } + + public void glMaterialx(int face, int pname, int param) { + checkThread(); + mgl.glMaterialx(face, pname, param); + checkError(); + } + + public void glMaterialxv(int face, int pname, int[] params, int offset) { + checkThread(); + mgl.glMaterialxv(face, pname, params, offset); + checkError(); + } + + public void glMaterialxv(int face, int pname, IntBuffer params) { + checkThread(); + mgl.glMaterialxv(face, pname, params); + checkError(); + } + + public void glMatrixMode(int mode) { + checkThread(); + mgl.glMatrixMode(mode); + checkError(); + } + + public void glMultMatrixf(float[] m, int offset) { + checkThread(); + mgl.glMultMatrixf(m, offset); + checkError(); + } + + public void glMultMatrixf(FloatBuffer m) { + checkThread(); + mgl.glMultMatrixf(m); + checkError(); + } + + public void glMultMatrixx(int[] m, int offset) { + checkThread(); + mgl.glMultMatrixx(m, offset); + checkError(); + } + + public void glMultMatrixx(IntBuffer m) { + checkThread(); + mgl.glMultMatrixx(m); + checkError(); + } + + public void glMultiTexCoord4f(int target, + float s, float t, float r, float q) { + checkThread(); + mgl.glMultiTexCoord4f(target, s, t, r, q); + checkError(); + } + + public void glMultiTexCoord4x(int target, int s, int t, int r, int q) { + checkThread(); + mgl.glMultiTexCoord4x(target, s, t, r, q); + checkError(); + } + + public void glNormal3f(float nx, float ny, float nz) { + checkThread(); + mgl.glNormal3f(nx, ny, nz); + checkError(); + } + + public void glNormal3x(int nx, int ny, int nz) { + checkThread(); + mgl.glNormal3x(nx, ny, nz); + checkError(); + } + + public void glNormalPointer(int type, int stride, Buffer pointer) { + checkThread(); + mgl.glNormalPointer(type, stride, pointer); + checkError(); + } + + public void glOrthof(float left, float right, float bottom, float top, + float near, float far) { + checkThread(); + mgl.glOrthof(left, right, bottom, top, near, far); + checkError(); + } + + public void glOrthox(int left, int right, int bottom, int top, int near, + int far) { + checkThread(); + mgl.glOrthox(left, right, bottom, top, near, far); + checkError(); + } + + public void glPixelStorei(int pname, int param) { + checkThread(); + mgl.glPixelStorei(pname, param); + checkError(); + } + + public void glPointSize(float size) { + checkThread(); + mgl.glPointSize(size); + checkError(); + } + + public void glPointSizex(int size) { + checkThread(); + mgl.glPointSizex(size); + checkError(); + } + + public void glPolygonOffset(float factor, float units) { + checkThread(); + mgl.glPolygonOffset(factor, units); + checkError(); + } + + public void glPolygonOffsetx(int factor, int units) { + checkThread(); + mgl.glPolygonOffsetx(factor, units); + checkError(); + } + + public void glPopMatrix() { + checkThread(); + mgl.glPopMatrix(); + checkError(); + } + + public void glPushMatrix() { + checkThread(); + mgl.glPushMatrix(); + checkError(); + } + + public void glReadPixels(int x, int y, int width, int height, int format, + int type, Buffer pixels) { + checkThread(); + mgl.glReadPixels(x, y, width, height, format, type, pixels); + checkError(); + } + + public void glRotatef(float angle, float x, float y, float z) { + checkThread(); + mgl.glRotatef(angle, x, y, z); + checkError(); + } + + public void glRotatex(int angle, int x, int y, int z) { + checkThread(); + mgl.glRotatex(angle, x, y, z); + checkError(); + } + + public void glSampleCoverage(float value, boolean invert) { + checkThread(); + mgl.glSampleCoverage(value, invert); + checkError(); + } + + public void glSampleCoveragex(int value, boolean invert) { + checkThread(); + mgl.glSampleCoveragex(value, invert); + checkError(); + } + + public void glScalef(float x, float y, float z) { + checkThread(); + mgl.glScalef(x, y, z); + checkError(); + } + + public void glScalex(int x, int y, int z) { + checkThread(); + mgl.glScalex(x, y, z); + checkError(); + } + + public void glScissor(int x, int y, int width, int height) { + checkThread(); + mgl.glScissor(x, y, width, height); + checkError(); + } + + public void glShadeModel(int mode) { + checkThread(); + mgl.glShadeModel(mode); + checkError(); + } + + public void glStencilFunc(int func, int ref, int mask) { + checkThread(); + mgl.glStencilFunc(func, ref, mask); + checkError(); + } + + public void glStencilMask(int mask) { + checkThread(); + mgl.glStencilMask(mask); + checkError(); + } + + public void glStencilOp(int fail, int zfail, int zpass) { + checkThread(); + mgl.glStencilOp(fail, zfail, zpass); + checkError(); + } + + public void glTexCoordPointer(int size, int type, + int stride, Buffer pointer) { + checkThread(); + mgl.glTexCoordPointer(size, type, stride, pointer); + checkError(); + } + + public void glTexEnvf(int target, int pname, float param) { + checkThread(); + mgl.glTexEnvf(target, pname, param); + checkError(); + } + + public void glTexEnvfv(int target, int pname, float[] params, int offset) { + checkThread(); + mgl.glTexEnvfv(target, pname, params, offset); + checkError(); + } + + public void glTexEnvfv(int target, int pname, FloatBuffer params) { + checkThread(); + mgl.glTexEnvfv(target, pname, params); + checkError(); + } + + public void glTexEnvx(int target, int pname, int param) { + checkThread(); + mgl.glTexEnvx(target, pname, param); + checkError(); + } + + public void glTexEnvxv(int target, int pname, int[] params, int offset) { + checkThread(); + mgl.glTexEnvxv(target, pname, params, offset); + checkError(); + } + + public void glTexEnvxv(int target, int pname, IntBuffer params) { + checkThread(); + mgl.glTexEnvxv(target, pname, params); + checkError(); + } + + public void glTexImage2D(int target, int level, int internalformat, + int width, int height, int border, int format, int type, + Buffer pixels) { + checkThread(); + mgl.glTexImage2D(target, level, internalformat, width, height, border, + format, type, pixels); + checkError(); + } + + public void glTexParameterf(int target, int pname, float param) { + checkThread(); + mgl.glTexParameterf(target, pname, param); + checkError(); + } + + public void glTexParameterx(int target, int pname, int param) { + checkThread(); + mgl.glTexParameterx(target, pname, param); + checkError(); + } + + public void glTexParameteriv(int target, int pname, int[] params, int offset) { + checkThread(); + mgl11.glTexParameteriv(target, pname, params, offset); + checkError(); + } + + public void glTexParameteriv(int target, int pname, IntBuffer params) { + checkThread(); + mgl11.glTexParameteriv(target, pname, params); + checkError(); + } + + public void glTexSubImage2D(int target, int level, int xoffset, + int yoffset, int width, int height, int format, int type, + Buffer pixels) { + checkThread(); + mgl.glTexSubImage2D(target, level, xoffset, yoffset, width, height, + format, type, pixels); + checkError(); + } + + public void glTranslatef(float x, float y, float z) { + checkThread(); + mgl.glTranslatef(x, y, z); + checkError(); + } + + public void glTranslatex(int x, int y, int z) { + checkThread(); + mgl.glTranslatex(x, y, z); + checkError(); + } + + public void glVertexPointer(int size, int type, + int stride, Buffer pointer) { + checkThread(); + mgl.glVertexPointer(size, type, stride, pointer); + checkError(); + } + + public void glViewport(int x, int y, int width, int height) { + checkThread(); + mgl.glViewport(x, y, width, height); + checkError(); + } + + public void glClipPlanef(int plane, float[] equation, int offset) { + checkThread(); + mgl11.glClipPlanef(plane, equation, offset); + checkError(); + } + + public void glClipPlanef(int plane, FloatBuffer equation) { + checkThread(); + mgl11.glClipPlanef(plane, equation); + checkError(); + } + + public void glClipPlanex(int plane, int[] equation, int offset) { + checkThread(); + mgl11.glClipPlanex(plane, equation, offset); + checkError(); + } + + public void glClipPlanex(int plane, IntBuffer equation) { + checkThread(); + mgl11.glClipPlanex(plane, equation); + checkError(); + } + + // Draw Texture Extension + + public void glDrawTexfOES(float x, float y, float z, + float width, float height) { + checkThread(); + mgl11Ext.glDrawTexfOES(x, y, z, width, height); + checkError(); + } + + public void glDrawTexfvOES(float[] coords, int offset) { + checkThread(); + mgl11Ext.glDrawTexfvOES(coords, offset); + checkError(); + } + + public void glDrawTexfvOES(FloatBuffer coords) { + checkThread(); + mgl11Ext.glDrawTexfvOES(coords); + checkError(); + } + + public void glDrawTexiOES(int x, int y, int z, int width, int height) { + checkThread(); + mgl11Ext.glDrawTexiOES(x, y, z, width, height); + checkError(); + } + + public void glDrawTexivOES(int[] coords, int offset) { + checkThread(); + mgl11Ext.glDrawTexivOES(coords, offset); + checkError(); + } + + public void glDrawTexivOES(IntBuffer coords) { + checkThread(); + mgl11Ext.glDrawTexivOES(coords); + checkError(); + } + + public void glDrawTexsOES(short x, short y, short z, + short width, short height) { + checkThread(); + mgl11Ext.glDrawTexsOES(x, y, z, width, height); + checkError(); + } + + public void glDrawTexsvOES(short[] coords, int offset) { + checkThread(); + mgl11Ext.glDrawTexsvOES(coords, offset); + checkError(); + } + + public void glDrawTexsvOES(ShortBuffer coords) { + checkThread(); + mgl11Ext.glDrawTexsvOES(coords); + checkError(); + } + + public void glDrawTexxOES(int x, int y, int z, int width, int height) { + checkThread(); + mgl11Ext.glDrawTexxOES(x, y, z, width, height); + checkError(); + } + + public void glDrawTexxvOES(int[] coords, int offset) { + checkThread(); + mgl11Ext.glDrawTexxvOES(coords, offset); + checkError(); + } + + public void glDrawTexxvOES(IntBuffer coords) { + checkThread(); + mgl11Ext.glDrawTexxvOES(coords); + checkError(); + } + + public int glQueryMatrixxOES(int[] mantissa, int mantissaOffset, + int[] exponent, int exponentOffset) { + checkThread(); + int valid = mgl10Ext.glQueryMatrixxOES(mantissa, mantissaOffset, + exponent, exponentOffset); + checkError(); + return valid; + } + + public int glQueryMatrixxOES(IntBuffer mantissa, IntBuffer exponent) { + checkThread(); + int valid = mgl10Ext.glQueryMatrixxOES(mantissa, exponent); + checkError(); + return valid; + } +} |