diff options
author | The Android Open Source Project <initial-contribution@android.com> | 2009-03-03 19:31:44 -0800 |
---|---|---|
committer | The Android Open Source Project <initial-contribution@android.com> | 2009-03-03 19:31:44 -0800 |
commit | 9066cfe9886ac131c34d59ed0e2d287b0e3c0087 (patch) | |
tree | d88beb88001f2482911e3d28e43833b50e4b4e97 /opengl/java | |
parent | d83a98f4ce9cfa908f5c54bbd70f03eec07e7553 (diff) | |
download | frameworks_base-9066cfe9886ac131c34d59ed0e2d287b0e3c0087.zip frameworks_base-9066cfe9886ac131c34d59ed0e2d287b0e3c0087.tar.gz frameworks_base-9066cfe9886ac131c34d59ed0e2d287b0e3c0087.tar.bz2 |
auto import from //depot/cupcake/@135843
Diffstat (limited to 'opengl/java')
35 files changed, 12549 insertions, 0 deletions
diff --git a/opengl/java/android/opengl/EGLLogWrapper.java b/opengl/java/android/opengl/EGLLogWrapper.java new file mode 100644 index 0000000..521fc8c --- /dev/null +++ b/opengl/java/android/opengl/EGLLogWrapper.java @@ -0,0 +1,545 @@ +package android.opengl; + +import java.io.IOException; +import java.io.Writer; + +import javax.microedition.khronos.egl.EGL; +import javax.microedition.khronos.egl.EGL10; +import javax.microedition.khronos.egl.EGL11; +import javax.microedition.khronos.egl.EGLConfig; +import javax.microedition.khronos.egl.EGLContext; +import javax.microedition.khronos.egl.EGLDisplay; +import javax.microedition.khronos.egl.EGLSurface; + +class EGLLogWrapper implements EGL11 { + private EGL10 mEgl10; + Writer mLog; + boolean mLogArgumentNames; + boolean mCheckError; + private int mArgCount; + + + public EGLLogWrapper(EGL egl, int configFlags, Writer log) { + mEgl10 = (EGL10) egl; + mLog = log; + mLogArgumentNames = + (GLDebugHelper.CONFIG_LOG_ARGUMENT_NAMES & configFlags) != 0; + mCheckError = + (GLDebugHelper.CONFIG_CHECK_GL_ERROR & configFlags) != 0; + } + + public boolean eglChooseConfig(EGLDisplay display, int[] attrib_list, + EGLConfig[] configs, int config_size, int[] num_config) { + begin("eglChooseConfig"); + arg("display", display); + arg("attrib_list", attrib_list); + arg("config_size", config_size); + end(); + + boolean result = mEgl10.eglChooseConfig(display, attrib_list, configs, + config_size, num_config); + arg("configs", configs); + arg("num_config", num_config); + returns(result); + checkError(); + return result; + } + + public boolean eglCopyBuffers(EGLDisplay display, EGLSurface surface, + Object native_pixmap) { + begin("eglCopyBuffers"); + arg("display", display); + arg("surface", surface); + arg("native_pixmap", native_pixmap); + end(); + + boolean result = mEgl10.eglCopyBuffers(display, surface, native_pixmap); + returns(result); + checkError(); + return result; + } + + public EGLContext eglCreateContext(EGLDisplay display, EGLConfig config, + EGLContext share_context, int[] attrib_list) { + begin("eglCreateContext"); + arg("display", display); + arg("config", config); + arg("share_context", share_context); + arg("attrib_list", attrib_list); + end(); + + EGLContext result = mEgl10.eglCreateContext(display, config, + share_context, attrib_list); + returns(result); + checkError(); + return result; + } + + public EGLSurface eglCreatePbufferSurface(EGLDisplay display, + EGLConfig config, int[] attrib_list) { + begin("eglCreatePbufferSurface"); + arg("display", display); + arg("config", config); + arg("attrib_list", attrib_list); + end(); + + EGLSurface result = mEgl10.eglCreatePbufferSurface(display, config, + attrib_list); + returns(result); + checkError(); + return result; + } + + public EGLSurface eglCreatePixmapSurface(EGLDisplay display, + EGLConfig config, Object native_pixmap, int[] attrib_list) { + begin("eglCreatePixmapSurface"); + arg("display", display); + arg("config", config); + arg("native_pixmap", native_pixmap); + arg("attrib_list", attrib_list); + end(); + + EGLSurface result = mEgl10.eglCreatePixmapSurface(display, config, + native_pixmap, attrib_list); + returns(result); + checkError(); + return result; + } + + public EGLSurface eglCreateWindowSurface(EGLDisplay display, + EGLConfig config, Object native_window, int[] attrib_list) { + begin("eglCreateWindowSurface"); + arg("display", display); + arg("config", config); + arg("native_window", native_window); + arg("attrib_list", attrib_list); + end(); + + EGLSurface result = mEgl10.eglCreateWindowSurface(display, config, + native_window, attrib_list); + returns(result); + checkError(); + return result; + } + + public boolean eglDestroyContext(EGLDisplay display, EGLContext context) { + begin("eglDestroyContext"); + arg("display", display); + arg("context", context); + end(); + + boolean result = mEgl10.eglDestroyContext(display, context); + returns(result); + checkError(); + return result; + } + + public boolean eglDestroySurface(EGLDisplay display, EGLSurface surface) { + begin("eglDestroySurface"); + arg("display", display); + arg("surface", surface); + end(); + + boolean result = mEgl10.eglDestroySurface(display, surface); + returns(result); + checkError(); + return result; + } + + public boolean eglGetConfigAttrib(EGLDisplay display, EGLConfig config, + int attribute, int[] value) { + begin("eglGetConfigAttrib"); + arg("display", display); + arg("config", config); + arg("attribute", attribute); + end(); + boolean result = mEgl10.eglGetConfigAttrib(display, config, attribute, + value); + arg("value", value); + returns(result); + checkError(); + return false; + } + + public boolean eglGetConfigs(EGLDisplay display, EGLConfig[] configs, + int config_size, int[] num_config) { + begin("eglGetConfigs"); + arg("display", display); + arg("config_size", config_size); + end(); + + boolean result = mEgl10.eglGetConfigs(display, configs, config_size, + num_config); + arg("configs", configs); + arg("num_config", num_config); + returns(result); + checkError(); + return result; + } + + public EGLContext eglGetCurrentContext() { + begin("eglGetCurrentContext"); + end(); + + EGLContext result = mEgl10.eglGetCurrentContext(); + returns(result); + + checkError(); + return result; + } + + public EGLDisplay eglGetCurrentDisplay() { + begin("eglGetCurrentDisplay"); + end(); + + EGLDisplay result = mEgl10.eglGetCurrentDisplay(); + returns(result); + + checkError(); + return result; + } + + public EGLSurface eglGetCurrentSurface(int readdraw) { + begin("eglGetCurrentSurface"); + arg("readdraw", readdraw); + end(); + + EGLSurface result = mEgl10.eglGetCurrentSurface(readdraw); + returns(result); + + checkError(); + return result; + } + + public EGLDisplay eglGetDisplay(Object native_display) { + begin("eglGetDisplay"); + arg("native_display", native_display); + end(); + + EGLDisplay result = mEgl10.eglGetDisplay(native_display); + returns(result); + + checkError(); + return result; + } + + public int eglGetError() { + begin("eglGetError"); + end(); + + int result = mEgl10.eglGetError(); + returns(getErrorString(result)); + + return result; + } + + public boolean eglInitialize(EGLDisplay display, int[] major_minor) { + begin("eglInitialize"); + arg("display", display); + end(); + boolean result = mEgl10.eglInitialize(display, major_minor); + returns(result); + arg("major_minor", major_minor); + checkError(); + return result; + } + + public boolean eglMakeCurrent(EGLDisplay display, EGLSurface draw, + EGLSurface read, EGLContext context) { + begin("eglMakeCurrent"); + arg("display", display); + arg("draw", draw); + arg("read", read); + arg("context", context); + end(); + boolean result = mEgl10.eglMakeCurrent(display, draw, read, context); + returns(result); + checkError(); + return result; + } + + public boolean eglQueryContext(EGLDisplay display, EGLContext context, + int attribute, int[] value) { + begin("eglQueryContext"); + arg("display", display); + arg("context", context); + arg("attribute", attribute); + end(); + boolean result = mEgl10.eglQueryContext(display, context, attribute, + value); + returns(value[0]); + returns(result); + checkError(); + return result; + } + + public String eglQueryString(EGLDisplay display, int name) { + begin("eglQueryString"); + arg("display", display); + arg("name", name); + end(); + String result = mEgl10.eglQueryString(display, name); + returns(result); + checkError(); + return result; + } + + public boolean eglQuerySurface(EGLDisplay display, EGLSurface surface, + int attribute, int[] value) { + begin("eglQuerySurface"); + arg("display", display); + arg("surface", surface); + arg("attribute", attribute); + end(); + boolean result = mEgl10.eglQuerySurface(display, surface, attribute, + value); + returns(value[0]); + returns(result); + checkError(); + return result; + } + + public boolean eglSwapBuffers(EGLDisplay display, EGLSurface surface) { + begin("eglInitialize"); + arg("display", display); + arg("surface", surface); + end(); + boolean result = mEgl10.eglSwapBuffers(display, surface); + returns(result); + checkError(); + return result; + } + + public boolean eglTerminate(EGLDisplay display) { + begin("eglTerminate"); + arg("display", display); + end(); + boolean result = mEgl10.eglTerminate(display); + returns(result); + checkError(); + return result; + } + + public boolean eglWaitGL() { + begin("eglWaitGL"); + end(); + boolean result = mEgl10.eglWaitGL(); + returns(result); + checkError(); + return result; + } + + public boolean eglWaitNative(int engine, Object bindTarget) { + begin("eglWaitNative"); + arg("engine", engine); + arg("bindTarget", bindTarget); + end(); + boolean result = mEgl10.eglWaitNative(engine, bindTarget); + returns(result); + checkError(); + return result; + } + + private void checkError() { + int eglError; + if ((eglError = mEgl10.eglGetError()) != EGL_SUCCESS) { + String errorMessage = "eglError: " + getErrorString(eglError); + logLine(errorMessage); + if (mCheckError) { + throw new GLException(eglError, errorMessage); + } + } + } + + private void logLine(String message) { + log(message + '\n'); + } + + private void log(String message) { + try { + mLog.write(message); + } catch (IOException e) { + // Ignore exception, keep on trying + } + } + + private void begin(String name) { + log(name + '('); + mArgCount = 0; + } + + private void arg(String name, String value) { + if (mArgCount++ > 0) { + log(", "); + } + if (mLogArgumentNames) { + log(name + "="); + } + log(value); + } + + private void end() { + log(");\n"); + flush(); + } + + private void flush() { + try { + mLog.flush(); + } catch (IOException e) { + mLog = null; + } + } + + private void arg(String name, int value) { + arg(name, Integer.toString(value)); + } + + private void arg(String name, Object object) { + arg(name, toString(object)); + } + + private void arg(String name, EGLDisplay object) { + if (object == EGL10.EGL_DEFAULT_DISPLAY) { + arg(name, "EGL10.EGL_DEFAULT_DISPLAY"); + } else if (object == EGL_NO_DISPLAY) { + arg(name, "EGL10.EGL_NO_DISPLAY"); + } else { + arg(name, toString(object)); + } + } + + private void arg(String name, EGLContext object) { + if (object == EGL10.EGL_NO_CONTEXT) { + arg(name, "EGL10.EGL_NO_CONTEXT"); + } else { + arg(name, toString(object)); + } + } + + private void arg(String name, EGLSurface object) { + if (object == EGL10.EGL_NO_SURFACE) { + arg(name, "EGL10.EGL_NO_SURFACE"); + } else { + arg(name, toString(object)); + } + } + + private void returns(String result) { + log(" returns " + result + ";\n"); + flush(); + } + + private void returns(int result) { + returns(Integer.toString(result)); + } + + private void returns(boolean result) { + returns(Boolean.toString(result)); + } + + private void returns(Object result) { + returns(toString(result)); + } + + private String toString(Object obj) { + if (obj == null) { + return "null"; + } else { + return obj.toString(); + } + } + + private void arg(String name, int[] arr) { + if (arr == null) { + arg(name, "null"); + } else { + arg(name, toString(arr.length, arr, 0)); + } + } + + private void arg(String name, Object[] arr) { + if (arr == null) { + arg(name, "null"); + } else { + arg(name, toString(arr.length, arr, 0)); + } + } + + private String toString(int n, int[] arr, int offset) { + StringBuilder buf = new StringBuilder(); + buf.append("{\n"); + int arrLen = arr.length; + for (int i = 0; i < n; i++) { + int index = offset + i; + buf.append(" [" + index + "] = "); + if (index < 0 || index >= arrLen) { + buf.append("out of bounds"); + } else { + buf.append(arr[index]); + } + buf.append('\n'); + } + buf.append("}"); + return buf.toString(); + } + + private String toString(int n, Object[] arr, int offset) { + StringBuilder buf = new StringBuilder(); + buf.append("{\n"); + int arrLen = arr.length; + for (int i = 0; i < n; i++) { + int index = offset + i; + buf.append(" [" + index + "] = "); + if (index < 0 || index >= arrLen) { + buf.append("out of bounds"); + } else { + buf.append(arr[index]); + } + buf.append('\n'); + } + buf.append("}"); + return buf.toString(); + } + + private static String getHex(int value) { + return "0x" + Integer.toHexString(value); + } + + public static String getErrorString(int error) { + switch (error) { + case EGL_SUCCESS: + return "EGL_SUCCESS"; + case EGL_NOT_INITIALIZED: + return "EGL_NOT_INITIALIZED"; + case EGL_BAD_ACCESS: + return "EGL_BAD_ACCESS"; + case EGL_BAD_ALLOC: + return "EGL_BAD_ALLOC"; + case EGL_BAD_ATTRIBUTE: + return "EGL_BAD_ATTRIBUTE"; + case EGL_BAD_CONFIG: + return "EGL_BAD_CONFIG"; + case EGL_BAD_CONTEXT: + return "EGL_BAD_CONTEXT"; + case EGL_BAD_CURRENT_SURFACE: + return "EGL_BAD_CURRENT_SURFACE"; + case EGL_BAD_DISPLAY: + return "EGL_BAD_DISPLAY"; + case EGL_BAD_MATCH: + return "EGL_BAD_MATCH"; + case EGL_BAD_NATIVE_PIXMAP: + return "EGL_BAD_NATIVE_PIXMAP"; + case EGL_BAD_NATIVE_WINDOW: + return "EGL_BAD_NATIVE_WINDOW"; + case EGL_BAD_PARAMETER: + return "EGL_BAD_PARAMETER"; + case EGL_BAD_SURFACE: + return "EGL_BAD_SURFACE"; + case EGL11.EGL_CONTEXT_LOST: + return "EGL_CONTEXT_LOST"; + default: + return getHex(error); + } + } +} diff --git a/opengl/java/android/opengl/GLDebugHelper.java b/opengl/java/android/opengl/GLDebugHelper.java new file mode 100644 index 0000000..18a1e73 --- /dev/null +++ b/opengl/java/android/opengl/GLDebugHelper.java @@ -0,0 +1,107 @@ +/* + * 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.io.Writer; + +import javax.microedition.khronos.egl.EGL; +import javax.microedition.khronos.opengles.GL; + +/** + * A helper class for debugging OpenGL ES applications. + * + * Wraps the supplied GL interface with a new GL interface that adds support for + * error checking and logging. + * + */ +public class GLDebugHelper { + + /** + * Wrap an existing GL interface in a new GL interface that adds support for + * error checking and/or logging. + * <p> + * Wrapping means that the GL instance that is passed in to this method is + * wrapped inside a new GL instance that optionally performs additional + * operations before and after calling the wrapped GL instance. + * <p> + * Error checking means that 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. + * <p> + * Logging means writing a text representation of each GL method call to + * a log. + * <p> + * @param gl the existing GL interface. Must implement GL and GL10. May + * optionally implement GL11 as well. + * @param configFlags A bitmask of error checking flags. + * @param log - null to disable logging, non-null to enable logging. + * @return the wrapped GL instance. + */ + + /** + * Check glError() after every call. + */ + public static final int CONFIG_CHECK_GL_ERROR = (1 << 0); + + /** + * Check if all calls are on the same thread. + */ + public static final int CONFIG_CHECK_THREAD = (1 << 1); + + /** + * Print argument names when logging GL Calls. + */ + public static final int CONFIG_LOG_ARGUMENT_NAMES = (1 << 2); + + /** + * The Error number used in the GLException that is thrown if + * CONFIG_CHECK_THREAD is enabled and you call OpenGL ES on the + * a different thread. + */ + public static final int ERROR_WRONG_THREAD = 0x7000; + + public static GL wrap(GL gl, int configFlags, Writer log) { + if ( configFlags != 0 ) { + gl = new GLErrorWrapper(gl, configFlags); + } + if ( log != null ) { + boolean logArgumentNames = + (CONFIG_LOG_ARGUMENT_NAMES & configFlags) != 0; + gl = new GLLogWrapper(gl, log, logArgumentNames); + } + return gl; + } + + /** + * Wrap an existing EGL interface in a new EGL interface that adds + * support for error checking and/or logging. + * @param egl the existing GL interface. Must implement EGL and EGL10. May + * optionally implement EGL11 as well. + * @param configFlags A bitmask of error checking flags. + * @param log - null to disable logging, non-null to enable logging. + * @return the wrapped EGL interface. + */ + public static EGL wrap(EGL egl, int configFlags, Writer log) { + if (log != null) { + egl = new EGLLogWrapper(egl, configFlags, log); + } + return egl; + } +} + diff --git a/opengl/java/android/opengl/GLErrorWrapper.java b/opengl/java/android/opengl/GLErrorWrapper.java new file mode 100644 index 0000000..884a1a0 --- /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; + } +} diff --git a/opengl/java/android/opengl/GLException.java b/opengl/java/android/opengl/GLException.java new file mode 100644 index 0000000..762fccf --- /dev/null +++ b/opengl/java/android/opengl/GLException.java @@ -0,0 +1,49 @@ +/* + * 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; + +/** + * An exception class for OpenGL errors. + * + */ +@SuppressWarnings("serial") +public class GLException extends RuntimeException { + public GLException(final int error) { + super(getErrorString(error)); + mError = error; + } + + public GLException(final int error, final String string) { + super(string); + mError = error; + } + + private static String getErrorString(int error) { + String errorString = GLU.gluErrorString(error); + if ( errorString == null ) { + errorString = "Unknown error 0x" + Integer.toHexString(error); + } + return errorString; + } + + int getError() { + return mError; + } + + private final int mError; +} + diff --git a/opengl/java/android/opengl/GLLogWrapper.java b/opengl/java/android/opengl/GLLogWrapper.java new file mode 100644 index 0000000..4119bf8 --- /dev/null +++ b/opengl/java/android/opengl/GLLogWrapper.java @@ -0,0 +1,3065 @@ +/* + * 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.io.IOException; +import java.io.Writer; +import java.nio.Buffer; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.CharBuffer; +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.nio.LongBuffer; +import java.nio.ShortBuffer; +import java.util.Arrays; + +import javax.microedition.khronos.opengles.GL; + +/** + * A wrapper that logs all GL calls (and results) in human-readable form. + * + */ +class GLLogWrapper extends GLWrapperBase { + private static final int FORMAT_INT = 0; + private static final int FORMAT_FLOAT = 1; + private static final int FORMAT_FIXED = 2; + + public GLLogWrapper(GL gl, Writer log, boolean logArgumentNames) { + super(gl); + mLog = log; + mLogArgumentNames = logArgumentNames; + } + + private void checkError() { + int glError; + if ((glError = mgl.glGetError()) != 0) { + String errorMessage = "glError: " + Integer.toString(glError); + logLine(errorMessage); + } + } + + private void logLine(String message) { + log(message + '\n'); + } + + private void log(String message) { + try { + mLog.write(message); + } catch (IOException e) { + // Ignore exception, keep on trying + } + } + + private void begin(String name) { + log(name + '('); + mArgCount = 0; + } + + private void arg(String name, String value) { + if (mArgCount++ > 0) { + log(", "); + } + if (mLogArgumentNames) { + log(name + "="); + } + log(value); + } + + private void end() { + log(");\n"); + flush(); + } + + private void flush() { + try { + mLog.flush(); + } catch (IOException e) { + mLog = null; + } + } + + private void arg(String name, boolean value) { + arg(name, Boolean.toString(value)); + } + + private void arg(String name, int value) { + arg(name, Integer.toString(value)); + } + + private void arg(String name, float value) { + arg(name, Float.toString(value)); + } + + private void returns(String result) { + log(") returns " + result + ";\n"); + flush(); + } + + private void returns(int result) { + returns(Integer.toString(result)); + } + + private void arg(String name, int n, int[] arr, int offset) { + arg(name, toString(n, FORMAT_INT, arr, offset)); + } + + private void arg(String name, int n, short[] arr, int offset) { + arg(name, toString(n, arr, offset)); + } + + private void arg(String name, int n, float[] arr, int offset) { + arg(name, toString(n, arr, offset)); + } + + private void formattedAppend(StringBuilder buf, int value, int format) { + switch (format) { + case FORMAT_INT: + buf.append(value); + break; + case FORMAT_FLOAT: + buf.append(Float.intBitsToFloat(value)); + break; + case FORMAT_FIXED: + buf.append(value / 65536.0f); + break; + } + } + + private String toString(int n, int format, int[] arr, int offset) { + StringBuilder buf = new StringBuilder(); + buf.append("{\n"); + int arrLen = arr.length; + for (int i = 0; i < n; i++) { + int index = offset + i; + buf.append(" [" + index + "] = "); + if (index < 0 || index >= arrLen) { + buf.append("out of bounds"); + } else { + formattedAppend(buf, arr[index], format); + } + buf.append('\n'); + } + buf.append("}"); + return buf.toString(); + } + + private String toString(int n, short[] arr, int offset) { + StringBuilder buf = new StringBuilder(); + buf.append("{\n"); + int arrLen = arr.length; + for (int i = 0; i < n; i++) { + int index = offset + i; + buf.append(" [" + index + "] = "); + if (index < 0 || index >= arrLen) { + buf.append("out of bounds"); + } else { + buf.append(arr[index]); + } + buf.append('\n'); + } + buf.append("}"); + return buf.toString(); + } + + private String toString(int n, float[] arr, int offset) { + StringBuilder buf = new StringBuilder(); + buf.append("{\n"); + int arrLen = arr.length; + for (int i = 0; i < n; i++) { + int index = offset + i; + buf.append("[" + index + "] = "); + if (index < 0 || index >= arrLen) { + buf.append("out of bounds"); + } else { + buf.append(arr[index]); + } + buf.append('\n'); + } + buf.append("}"); + return buf.toString(); + } + + private String toString(int n, FloatBuffer buf) { + StringBuilder builder = new StringBuilder(); + builder.append("{\n"); + for (int i = 0; i < n; i++) { + builder.append(" [" + i + "] = " + buf.get(i) + '\n'); + } + builder.append("}"); + return builder.toString(); + } + + private String toString(int n, int format, IntBuffer buf) { + StringBuilder builder = new StringBuilder(); + builder.append("{\n"); + for (int i = 0; i < n; i++) { + builder.append(" [" + i + "] = "); + formattedAppend(builder, buf.get(i), format); + builder.append('\n'); + } + builder.append("}"); + return builder.toString(); + } + + private String toString(int n, ShortBuffer buf) { + StringBuilder builder = new StringBuilder(); + builder.append("{\n"); + for (int i = 0; i < n; i++) { + builder.append(" [" + i + "] = " + buf.get(i) + '\n'); + } + builder.append("}"); + return builder.toString(); + } + + private void arg(String name, int n, FloatBuffer buf) { + arg(name, toString(n, buf)); + } + + private void arg(String name, int n, IntBuffer buf) { + arg(name, toString(n, FORMAT_INT, buf)); + } + + private void arg(String name, int n, ShortBuffer buf) { + arg(name, toString(n, buf)); + } + + private void argPointer(int size, int type, int stride, Buffer pointer) { + arg("size", size); + arg("type", getPointerTypeName(type)); + arg("stride", stride); + arg("pointer", pointer.toString()); + } + + private static String getHex(int value) { + return "0x" + Integer.toHexString(value); + } + + public static String getErrorString(int error) { + switch (error) { + case GL_NO_ERROR: + return "GL_NO_ERROR"; + case GL_INVALID_ENUM: + return "GL_INVALID_ENUM"; + case GL_INVALID_VALUE: + return "GL_INVALID_VALUE"; + case GL_INVALID_OPERATION: + return "GL_INVALID_OPERATION"; + case GL_STACK_OVERFLOW: + return "GL_STACK_OVERFLOW"; + case GL_STACK_UNDERFLOW: + return "GL_STACK_UNDERFLOW"; + case GL_OUT_OF_MEMORY: + return "GL_OUT_OF_MEMORY"; + default: + return getHex(error); + } + } + + private String getClearBufferMask(int mask) { + StringBuilder b = new StringBuilder(); + if ((mask & GL_DEPTH_BUFFER_BIT) != 0) { + b.append("GL_DEPTH_BUFFER_BIT"); + mask &= ~GL_DEPTH_BUFFER_BIT; + } + if ((mask & GL_STENCIL_BUFFER_BIT) != 0) { + if (b.length() > 0) { + b.append(" | "); + } + b.append("GL_STENCIL_BUFFER_BIT"); + mask &= ~GL_STENCIL_BUFFER_BIT; + } + if ((mask & GL_COLOR_BUFFER_BIT) != 0) { + if (b.length() > 0) { + b.append(" | "); + } + b.append("GL_COLOR_BUFFER_BIT"); + mask &= ~GL_COLOR_BUFFER_BIT; + } + if (mask != 0) { + if (b.length() > 0) { + b.append(" | "); + } + b.append(getHex(mask)); + } + return b.toString(); + } + + private String getFactor(int factor) { + switch(factor) { + case GL_ZERO: + return "GL_ZERO"; + case GL_ONE: + return "GL_ONE"; + case GL_SRC_COLOR: + return "GL_SRC_COLOR"; + case GL_ONE_MINUS_SRC_COLOR: + return "GL_ONE_MINUS_SRC_COLOR"; + case GL_DST_COLOR: + return "GL_DST_COLOR"; + case GL_ONE_MINUS_DST_COLOR: + return "GL_ONE_MINUS_DST_COLOR"; + case GL_SRC_ALPHA: + return "GL_SRC_ALPHA"; + case GL_ONE_MINUS_SRC_ALPHA: + return "GL_ONE_MINUS_SRC_ALPHA"; + case GL_DST_ALPHA: + return "GL_DST_ALPHA"; + case GL_ONE_MINUS_DST_ALPHA: + return "GL_ONE_MINUS_DST_ALPHA"; + case GL_SRC_ALPHA_SATURATE: + return "GL_SRC_ALPHA_SATURATE"; + + default: + return getHex(factor); + } + } + + private String getShadeModel(int model) { + switch(model) { + case GL_FLAT: + return "GL_FLAT"; + case GL_SMOOTH: + return "GL_SMOOTH"; + default: + return getHex(model); + } + } + + private String getTextureTarget(int target) { + switch (target) { + case GL_TEXTURE_2D: + return "GL_TEXTURE_2D"; + default: + return getHex(target); + } + } + + private String getTextureEnvTarget(int target) { + switch (target) { + case GL_TEXTURE_ENV: + return "GL_TEXTURE_ENV"; + default: + return getHex(target); + } + } + + private String getTextureEnvPName(int pname) { + switch (pname) { + case GL_TEXTURE_ENV_MODE: + return "GL_TEXTURE_ENV_MODE"; + case GL_TEXTURE_ENV_COLOR: + return "GL_TEXTURE_ENV_COLOR"; + default: + return getHex(pname); + } + } + + private int getTextureEnvParamCount(int pname) { + switch (pname) { + case GL_TEXTURE_ENV_MODE: + return 1; + case GL_TEXTURE_ENV_COLOR: + return 4; + default: + return 0; + } + } + + private String getTextureEnvParamName(float param) { + int iparam = (int) param; + if (param == (float) iparam) { + switch (iparam) { + case GL_REPLACE: + return "GL_REPLACE"; + case GL_MODULATE: + return "GL_MODULATE"; + case GL_DECAL: + return "GL_DECAL"; + case GL_BLEND: + return "GL_BLEND"; + case GL_ADD: + return "GL_ADD"; + case GL_COMBINE: + return "GL_COMBINE"; + default: + return getHex(iparam); + } + } + return Float.toString(param); + } + + private String getMatrixMode(int matrixMode) { + switch (matrixMode) { + case GL_MODELVIEW: + return "GL_MODELVIEW"; + case GL_PROJECTION: + return "GL_PROJECTION"; + case GL_TEXTURE: + return "GL_TEXTURE"; + default: + return getHex(matrixMode); + } + } + + private String getClientState(int clientState) { + switch (clientState) { + case GL_COLOR_ARRAY: + return "GL_COLOR_ARRAY"; + case GL_VERTEX_ARRAY: + return "GL_VERTEX_ARRAY"; + case GL_NORMAL_ARRAY: + return "GL_NORMAL_ARRAY"; + case GL_TEXTURE_COORD_ARRAY: + return "GL_TEXTURE_COORD_ARRAY"; + default: + return getHex(clientState); + } + } + + private String getCap(int cap) { + switch (cap) { + case GL_FOG: + return "GL_FOG"; + case GL_LIGHTING: + return "GL_LIGHTING"; + case GL_TEXTURE_2D: + return "GL_TEXTURE_2D"; + case GL_CULL_FACE: + return "GL_CULL_FACE"; + case GL_ALPHA_TEST: + return "GL_ALPHA_TEST"; + case GL_BLEND: + return "GL_BLEND"; + case GL_COLOR_LOGIC_OP: + return "GL_COLOR_LOGIC_OP"; + case GL_DITHER: + return "GL_DITHER"; + case GL_STENCIL_TEST: + return "GL_STENCIL_TEST"; + case GL_DEPTH_TEST: + return "GL_DEPTH_TEST"; + case GL_LIGHT0: + return "GL_LIGHT0"; + case GL_LIGHT1: + return "GL_LIGHT1"; + case GL_LIGHT2: + return "GL_LIGHT2"; + case GL_LIGHT3: + return "GL_LIGHT3"; + case GL_LIGHT4: + return "GL_LIGHT4"; + case GL_LIGHT5: + return "GL_LIGHT5"; + case GL_LIGHT6: + return "GL_LIGHT6"; + case GL_LIGHT7: + return "GL_LIGHT7"; + case GL_POINT_SMOOTH: + return "GL_POINT_SMOOTH"; + case GL_LINE_SMOOTH: + return "GL_LINE_SMOOTH"; + case GL_COLOR_MATERIAL: + return "GL_COLOR_MATERIAL"; + case GL_NORMALIZE: + return "GL_NORMALIZE"; + case GL_RESCALE_NORMAL: + return "GL_RESCALE_NORMAL"; + case GL_VERTEX_ARRAY: + return "GL_VERTEX_ARRAY"; + case GL_NORMAL_ARRAY: + return "GL_NORMAL_ARRAY"; + case GL_COLOR_ARRAY: + return "GL_COLOR_ARRAY"; + case GL_TEXTURE_COORD_ARRAY: + return "GL_TEXTURE_COORD_ARRAY"; + case GL_MULTISAMPLE: + return "GL_MULTISAMPLE"; + case GL_SAMPLE_ALPHA_TO_COVERAGE: + return "GL_SAMPLE_ALPHA_TO_COVERAGE"; + case GL_SAMPLE_ALPHA_TO_ONE: + return "GL_SAMPLE_ALPHA_TO_ONE"; + case GL_SAMPLE_COVERAGE: + return "GL_SAMPLE_COVERAGE"; + case GL_SCISSOR_TEST: + return "GL_SCISSOR_TEST"; + default: + return getHex(cap); + } + } + + private String getTexturePName(int pname) { + switch (pname) { + case GL_TEXTURE_MAG_FILTER: + return "GL_TEXTURE_MAG_FILTER"; + case GL_TEXTURE_MIN_FILTER: + return "GL_TEXTURE_MIN_FILTER"; + case GL_TEXTURE_WRAP_S: + return "GL_TEXTURE_WRAP_S"; + case GL_TEXTURE_WRAP_T: + return "GL_TEXTURE_WRAP_T"; + case GL_GENERATE_MIPMAP: + return "GL_GENERATE_MIPMAP"; + case GL_TEXTURE_CROP_RECT_OES: + return "GL_TEXTURE_CROP_RECT_OES"; + default: + return getHex(pname); + } + } + + private String getTextureParamName(float param) { + int iparam = (int) param; + if (param == (float) iparam) { + switch (iparam) { + case GL_CLAMP_TO_EDGE: + return "GL_CLAMP_TO_EDGE"; + case GL_REPEAT: + return "GL_REPEAT"; + case GL_NEAREST: + return "GL_NEAREST"; + case GL_LINEAR: + return "GL_LINEAR"; + case GL_NEAREST_MIPMAP_NEAREST: + return "GL_NEAREST_MIPMAP_NEAREST"; + case GL_LINEAR_MIPMAP_NEAREST: + return "GL_LINEAR_MIPMAP_NEAREST"; + case GL_NEAREST_MIPMAP_LINEAR: + return "GL_NEAREST_MIPMAP_LINEAR"; + case GL_LINEAR_MIPMAP_LINEAR: + return "GL_LINEAR_MIPMAP_LINEAR"; + default: + return getHex(iparam); + } + } + return Float.toString(param); + } + + private String getFogPName(int pname) { + switch (pname) { + case GL_FOG_DENSITY: + return "GL_FOG_DENSITY"; + case GL_FOG_START: + return "GL_FOG_START"; + case GL_FOG_END: + return "GL_FOG_END"; + case GL_FOG_MODE: + return "GL_FOG_MODE"; + case GL_FOG_COLOR: + return "GL_FOG_COLOR"; + default: + return getHex(pname); + } + } + + private int getFogParamCount(int pname) { + switch (pname) { + case GL_FOG_DENSITY: + return 1; + case GL_FOG_START: + return 1; + case GL_FOG_END: + return 1; + case GL_FOG_MODE: + return 1; + case GL_FOG_COLOR: + return 4; + default: + return 0; + } + } + + private String getBeginMode(int mode) { + switch (mode) { + case GL_POINTS: + return "GL_POINTS"; + case GL_LINES: + return "GL_LINES"; + case GL_LINE_LOOP: + return "GL_LINE_LOOP"; + case GL_LINE_STRIP: + return "GL_LINE_STRIP"; + case GL_TRIANGLES: + return "GL_TRIANGLES"; + case GL_TRIANGLE_STRIP: + return "GL_TRIANGLE_STRIP"; + case GL_TRIANGLE_FAN: + return "GL_TRIANGLE_FAN"; + default: + return getHex(mode); + } + } + + private String getIndexType(int type) { + switch (type) { + case GL_UNSIGNED_SHORT: + return "GL_UNSIGNED_SHORT"; + case GL_UNSIGNED_BYTE: + return "GL_UNSIGNED_BYTE"; + default: + return getHex(type); + } + } + + private String getIntegerStateName(int pname) { + switch (pname) { + case GL_ALPHA_BITS: + return "GL_ALPHA_BITS"; + case GL_ALIASED_LINE_WIDTH_RANGE: + return "GL_ALIASED_LINE_WIDTH_RANGE"; + case GL_ALIASED_POINT_SIZE_RANGE: + return "GL_ALIASED_POINT_SIZE_RANGE"; + case GL_BLUE_BITS: + return "GL_BLUE_BITS"; + case GL_COMPRESSED_TEXTURE_FORMATS: + return "GL_COMPRESSED_TEXTURE_FORMATS"; + case GL_DEPTH_BITS: + return "GL_DEPTH_BITS"; + case GL_GREEN_BITS: + return "GL_GREEN_BITS"; + case GL_MAX_ELEMENTS_INDICES: + return "GL_MAX_ELEMENTS_INDICES"; + case GL_MAX_ELEMENTS_VERTICES: + return "GL_MAX_ELEMENTS_VERTICES"; + case GL_MAX_LIGHTS: + return "GL_MAX_LIGHTS"; + case GL_MAX_TEXTURE_SIZE: + return "GL_MAX_TEXTURE_SIZE"; + case GL_MAX_VIEWPORT_DIMS: + return "GL_MAX_VIEWPORT_DIMS"; + case GL_MAX_MODELVIEW_STACK_DEPTH: + return "GL_MAX_MODELVIEW_STACK_DEPTH"; + case GL_MAX_PROJECTION_STACK_DEPTH: + return "GL_MAX_PROJECTION_STACK_DEPTH"; + case GL_MAX_TEXTURE_STACK_DEPTH: + return "GL_MAX_TEXTURE_STACK_DEPTH"; + case GL_MAX_TEXTURE_UNITS: + return "GL_MAX_TEXTURE_UNITS"; + case GL_NUM_COMPRESSED_TEXTURE_FORMATS: + return "GL_NUM_COMPRESSED_TEXTURE_FORMATS"; + case GL_RED_BITS: + return "GL_RED_BITS"; + case GL_SMOOTH_LINE_WIDTH_RANGE: + return "GL_SMOOTH_LINE_WIDTH_RANGE"; + case GL_SMOOTH_POINT_SIZE_RANGE: + return "GL_SMOOTH_POINT_SIZE_RANGE"; + case GL_STENCIL_BITS: + return "GL_STENCIL_BITS"; + case GL_SUBPIXEL_BITS: + return "GL_SUBPIXEL_BITS"; + + case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES: + return "GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES"; + case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES: + return "GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES"; + case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES: + return "GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES"; + + default: + return getHex(pname); + } + } + + private int getIntegerStateSize(int pname) { + switch (pname) { + case GL_ALPHA_BITS: + return 1; + case GL_ALIASED_LINE_WIDTH_RANGE: + return 2; + case GL_ALIASED_POINT_SIZE_RANGE: + return 2; + case GL_BLUE_BITS: + return 1; + case GL_COMPRESSED_TEXTURE_FORMATS: + // Have to ask the implementation for the size + { + int[] buffer = new int[1]; + mgl.glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, buffer, 0); + return buffer[0]; + } + case GL_DEPTH_BITS: + return 1; + case GL_GREEN_BITS: + return 1; + case GL_MAX_ELEMENTS_INDICES: + return 1; + case GL_MAX_ELEMENTS_VERTICES: + return 1; + case GL_MAX_LIGHTS: + return 1; + case GL_MAX_TEXTURE_SIZE: + return 1; + case GL_MAX_VIEWPORT_DIMS: + return 2; + case GL_MAX_MODELVIEW_STACK_DEPTH: + return 1; + case GL_MAX_PROJECTION_STACK_DEPTH: + return 1; + case GL_MAX_TEXTURE_STACK_DEPTH: + return 1; + case GL_MAX_TEXTURE_UNITS: + return 1; + case GL_NUM_COMPRESSED_TEXTURE_FORMATS: + return 1; + case GL_RED_BITS: + return 1; + case GL_SMOOTH_LINE_WIDTH_RANGE: + return 2; + case GL_SMOOTH_POINT_SIZE_RANGE: + return 2; + case GL_STENCIL_BITS: + return 1; + case GL_SUBPIXEL_BITS: + return 1; + + case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES: + case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES: + case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES: + return 16; + + default: + return 0; + } + } + + private int getIntegerStateFormat(int pname) { + switch (pname) { + case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES: + case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES: + case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES: + return FORMAT_FLOAT; + + default: + return FORMAT_INT; + } + } + + private String getHintTarget(int target) { + switch (target) { + case GL_FOG_HINT: + return "GL_FOG_HINT"; + case GL_LINE_SMOOTH_HINT: + return "GL_LINE_SMOOTH_HINT"; + case GL_PERSPECTIVE_CORRECTION_HINT: + return "GL_PERSPECTIVE_CORRECTION_HINT"; + case GL_POINT_SMOOTH_HINT: + return "GL_POINT_SMOOTH_HINT"; + case GL_POLYGON_SMOOTH_HINT: + return "GL_POLYGON_SMOOTH_HINT"; + case GL_GENERATE_MIPMAP_HINT: + return "GL_GENERATE_MIPMAP_HINT"; + default: + return getHex(target); + } + } + + private String getHintMode(int mode) { + switch (mode) { + case GL_FASTEST: + return "GL_FASTEST"; + case GL_NICEST: + return "GL_NICEST"; + case GL_DONT_CARE: + return "GL_DONT_CARE"; + default: + return getHex(mode); + } + } + + private String getFaceName(int face) { + switch (face) { + case GL_FRONT_AND_BACK: + return "GL_FRONT_AND_BACK"; + default: + return getHex(face); + } + } + + private String getMaterialPName(int pname) { + switch (pname) { + case GL_AMBIENT: + return "GL_AMBIENT"; + case GL_DIFFUSE: + return "GL_DIFFUSE"; + case GL_SPECULAR: + return "GL_SPECULAR"; + case GL_EMISSION: + return "GL_EMISSION"; + case GL_SHININESS: + return "GL_SHININESS"; + case GL_AMBIENT_AND_DIFFUSE: + return "GL_AMBIENT_AND_DIFFUSE"; + default: + return getHex(pname); + } + } + + private int getMaterialParamCount(int pname) { + switch (pname) { + case GL_AMBIENT: + return 4; + case GL_DIFFUSE: + return 4; + case GL_SPECULAR: + return 4; + case GL_EMISSION: + return 4; + case GL_SHININESS: + return 1; + case GL_AMBIENT_AND_DIFFUSE: + return 4; + default: + return 0; + } + } + + private String getLightName(int light) { + if (light >= GL_LIGHT0 && light <= GL_LIGHT7) { + return "GL_LIGHT" + Integer.toString(light); + } + return getHex(light); + } + + private String getLightPName(int pname) { + switch (pname) { + case GL_AMBIENT: + return "GL_AMBIENT"; + case GL_DIFFUSE: + return "GL_DIFFUSE"; + case GL_SPECULAR: + return "GL_SPECULAR"; + case GL_POSITION: + return "GL_POSITION"; + case GL_SPOT_DIRECTION: + return "GL_SPOT_DIRECTION"; + case GL_SPOT_EXPONENT: + return "GL_SPOT_EXPONENT"; + case GL_SPOT_CUTOFF: + return "GL_SPOT_CUTOFF"; + case GL_CONSTANT_ATTENUATION: + return "GL_CONSTANT_ATTENUATION"; + case GL_LINEAR_ATTENUATION: + return "GL_LINEAR_ATTENUATION"; + case GL_QUADRATIC_ATTENUATION: + return "GL_QUADRATIC_ATTENUATION"; + default: + return getHex(pname); + } + } + + private int getLightParamCount(int pname) { + switch (pname) { + case GL_AMBIENT: + return 4; + case GL_DIFFUSE: + return 4; + case GL_SPECULAR: + return 4; + case GL_POSITION: + return 4; + case GL_SPOT_DIRECTION: + return 3; + case GL_SPOT_EXPONENT: + return 1; + case GL_SPOT_CUTOFF: + return 1; + case GL_CONSTANT_ATTENUATION: + return 1; + case GL_LINEAR_ATTENUATION: + return 1; + case GL_QUADRATIC_ATTENUATION: + return 1; + default: + return 0; + } + } + + private String getLightModelPName(int pname) { + switch (pname) { + case GL_LIGHT_MODEL_AMBIENT: + return "GL_LIGHT_MODEL_AMBIENT"; + case GL_LIGHT_MODEL_TWO_SIDE: + return "GL_LIGHT_MODEL_TWO_SIDE"; + default: + return getHex(pname); + } + } + + private int getLightModelParamCount(int pname) { + switch (pname) { + case GL_LIGHT_MODEL_AMBIENT: + return 4; + case GL_LIGHT_MODEL_TWO_SIDE: + return 1; + default: + return 0; + } + } + + private String getPointerTypeName(int type) { + switch (type) { + case GL_BYTE: + return "GL_BYTE"; + case GL_UNSIGNED_BYTE: + return "GL_UNSIGNED_BYTE"; + case GL_SHORT: + return "GL_SHORT"; + case GL_FIXED: + return "GL_FIXED"; + case GL_FLOAT: + return "GL_FLOAT"; + default: + return getHex(type); + } + } + + private ByteBuffer toByteBuffer(int byteCount, Buffer input) { + ByteBuffer result = null; + boolean convertWholeBuffer = (byteCount < 0); + if (input instanceof ByteBuffer) { + ByteBuffer input2 = (ByteBuffer) input; + if (convertWholeBuffer) { + byteCount = input2.limit(); + } + result = ByteBuffer.allocate(byteCount).order(input2.order()); + int position = input2.position(); + for (int i = 0; i < byteCount; i++) { + result.put(input2.get()); + } + input2.position(position); + } else if (input instanceof CharBuffer) { + CharBuffer input2 = (CharBuffer) input; + if (convertWholeBuffer) { + byteCount = input2.limit() * 2; + } + result = ByteBuffer.allocate(byteCount).order(input2.order()); + CharBuffer result2 = result.asCharBuffer(); + int position = input2.position(); + for (int i = 0; i < byteCount / 2; i++) { + result2.put(input2.get()); + } + input2.position(position); + } else if (input instanceof ShortBuffer) { + ShortBuffer input2 = (ShortBuffer) input; + if (convertWholeBuffer) { + byteCount = input2.limit() * 2; + } + result = ByteBuffer.allocate(byteCount).order(input2.order()); + ShortBuffer result2 = result.asShortBuffer(); + int position = input2.position(); + for (int i = 0; i < byteCount / 2; i++) { + result2.put(input2.get()); + } + input2.position(position); + } else if (input instanceof IntBuffer) { + IntBuffer input2 = (IntBuffer) input; + if (convertWholeBuffer) { + byteCount = input2.limit() * 4; + } + result = ByteBuffer.allocate(byteCount).order(input2.order()); + IntBuffer result2 = result.asIntBuffer(); + int position = input2.position(); + for (int i = 0; i < byteCount / 4; i++) { + result2.put(input2.get()); + } + input2.position(position); + } else if (input instanceof FloatBuffer) { + FloatBuffer input2 = (FloatBuffer) input; + if (convertWholeBuffer) { + byteCount = input2.limit() * 4; + } + result = ByteBuffer.allocate(byteCount).order(input2.order()); + FloatBuffer result2 = result.asFloatBuffer(); + int position = input2.position(); + for (int i = 0; i < byteCount / 4; i++) { + result2.put(input2.get()); + } + input2.position(position); + } else if (input instanceof DoubleBuffer) { + DoubleBuffer input2 = (DoubleBuffer) input; + if (convertWholeBuffer) { + byteCount = input2.limit() * 8; + } + result = ByteBuffer.allocate(byteCount).order(input2.order()); + DoubleBuffer result2 = result.asDoubleBuffer(); + int position = input2.position(); + for (int i = 0; i < byteCount / 8; i++) { + result2.put(input2.get()); + } + input2.position(position); + } else if (input instanceof LongBuffer) { + LongBuffer input2 = (LongBuffer) input; + if (convertWholeBuffer) { + byteCount = input2.limit() * 8; + } + result = ByteBuffer.allocate(byteCount).order(input2.order()); + LongBuffer result2 = result.asLongBuffer(); + int position = input2.position(); + for (int i = 0; i < byteCount / 8; i++) { + result2.put(input2.get()); + } + input2.position(position); + } else { + throw new RuntimeException("Unimplemented Buffer subclass."); + } + result.rewind(); + // The OpenGL API will interpret the result in hardware byte order, + // so we better do that as well: + result.order(ByteOrder.nativeOrder()); + return result; + } + + private char[] toCharIndices(int count, int type, Buffer indices) { + char[] result = new char[count]; + switch (type) { + case GL_UNSIGNED_BYTE: { + ByteBuffer byteBuffer = toByteBuffer(count, indices); + byte[] array = byteBuffer.array(); + int offset = byteBuffer.arrayOffset(); + for (int i = 0; i < count; i++) { + result[i] = (char) (0xff & array[offset + i]); + } + } + break; + case GL_UNSIGNED_SHORT: { + CharBuffer charBuffer; + if (indices instanceof CharBuffer) { + charBuffer = (CharBuffer) indices; + } else { + ByteBuffer byteBuffer = toByteBuffer(count * 2, indices); + charBuffer = byteBuffer.asCharBuffer(); + } + int oldPosition = charBuffer.position(); + charBuffer.position(0); + charBuffer.get(result); + charBuffer.position(oldPosition); + } + break; + default: + // Don't throw an exception, because we don't want logging to + // change the behavior. + break; + } + return result; + } + + private void doArrayElement(StringBuilder builder, boolean enabled, + String name, PointerInfo pointer, int index) { + if (!enabled) { + return; + } + builder.append(" "); + builder.append(name + ":{"); + if (pointer == null) { + builder.append("undefined"); + return; + } + if (pointer.mStride < 0) { + builder.append("invalid stride"); + return; + } + + int stride = pointer.getStride(); + ByteBuffer byteBuffer = pointer.mTempByteBuffer; + int size = pointer.mSize; + int type = pointer.mType; + int sizeofType = pointer.sizeof(type); + int byteOffset = stride * index; + for (int i = 0; i < size; i++) { + if (i > 0) { + builder.append(", "); + } + switch (type) { + case GL_BYTE: { + byte d = byteBuffer.get(byteOffset); + builder.append(Integer.toString(d)); + } + break; + case GL_UNSIGNED_BYTE: { + byte d = byteBuffer.get(byteOffset); + builder.append(Integer.toString(0xff & d)); + } + break; + case GL_SHORT: { + ShortBuffer shortBuffer = byteBuffer.asShortBuffer(); + short d = shortBuffer.get(byteOffset / 2); + builder.append(Integer.toString(d)); + } + break; + case GL_FIXED: { + IntBuffer intBuffer = byteBuffer.asIntBuffer(); + int d = intBuffer.get(byteOffset / 4); + builder.append(Integer.toString(d)); + } + break; + case GL_FLOAT: { + FloatBuffer intBuffer = byteBuffer.asFloatBuffer(); + float d = intBuffer.get(byteOffset / 4); + builder.append(Float.toString(d)); + } + break; + default: + builder.append("?"); + break; + } + byteOffset += sizeofType; + } + builder.append("}"); + } + + private void doElement(StringBuilder builder, int ordinal, int vertexIndex) { + builder.append(" [" + ordinal + " : " + vertexIndex + "] ="); + doArrayElement(builder, mVertexArrayEnabled, "v", mVertexPointer, + vertexIndex); + doArrayElement(builder, mNormalArrayEnabled, "n", mNormalPointer, + vertexIndex); + doArrayElement(builder, mColorArrayEnabled, "c", mColorPointer, + vertexIndex); + doArrayElement(builder, mTextureCoordArrayEnabled, "t", + mTexCoordPointer, vertexIndex); + builder.append("\n"); + // Vertex + // Normal + // Color + // TexCoord + } + + private void bindArrays() { + if (mColorArrayEnabled) + mColorPointer.bindByteBuffer(); + if (mNormalArrayEnabled) + mNormalPointer.bindByteBuffer(); + if (mTextureCoordArrayEnabled) + mTexCoordPointer.bindByteBuffer(); + if (mVertexArrayEnabled) + mVertexPointer.bindByteBuffer(); + } + + private void unbindArrays() { + if (mColorArrayEnabled) + mColorPointer.unbindByteBuffer(); + if (mNormalArrayEnabled) + mNormalPointer.unbindByteBuffer(); + if (mTextureCoordArrayEnabled) + mTexCoordPointer.unbindByteBuffer(); + if (mVertexArrayEnabled) + mVertexPointer.unbindByteBuffer(); + } + + private void startLogIndices() { + mStringBuilder = new StringBuilder(); + mStringBuilder.append("\n"); + bindArrays(); + } + + private void endLogIndices() { + log(mStringBuilder.toString()); + unbindArrays(); + } + + // --------------------------------------------------------------------- + // GL10 methods: + + public void glActiveTexture(int texture) { + begin("glActiveTexture"); + arg("texture", texture); + end(); + mgl.glActiveTexture(texture); + checkError(); + } + + public void glAlphaFunc(int func, float ref) { + begin("glAlphaFunc"); + arg("func", func); + arg("ref", ref); + end(); + mgl.glAlphaFunc(func, ref); + checkError(); + } + + public void glAlphaFuncx(int func, int ref) { + begin("glAlphaFuncx"); + arg("func", func); + arg("ref", ref); + end(); + mgl.glAlphaFuncx(func, ref); + checkError(); + } + + public void glBindTexture(int target, int texture) { + begin("glBindTexture"); + arg("target", getTextureTarget(target)); + arg("texture", texture); + end(); + mgl.glBindTexture(target, texture); + checkError(); + } + + public void glBlendFunc(int sfactor, int dfactor) { + begin("glBlendFunc"); + arg("sfactor", getFactor(sfactor)); + arg("dfactor", getFactor(dfactor)); + end(); + + mgl.glBlendFunc(sfactor, dfactor); + checkError(); + } + + public void glClear(int mask) { + begin("glClear"); + arg("mask", getClearBufferMask(mask)); + end(); + + mgl.glClear(mask); + checkError(); + } + + public void glClearColor(float red, float green, float blue, float alpha) { + begin("glClearColor"); + arg("red", red); + arg("green", green); + arg("blue", blue); + arg("alpha", alpha); + end(); + + mgl.glClearColor(red, green, blue, alpha); + checkError(); + } + + public void glClearColorx(int red, int green, int blue, int alpha) { + begin("glClearColor"); + arg("red", red); + arg("green", green); + arg("blue", blue); + arg("alpha", alpha); + end(); + + mgl.glClearColorx(red, green, blue, alpha); + checkError(); + } + + public void glClearDepthf(float depth) { + begin("glClearDepthf"); + arg("depth", depth); + end(); + + mgl.glClearDepthf(depth); + checkError(); + } + + public void glClearDepthx(int depth) { + begin("glClearDepthx"); + arg("depth", depth); + end(); + + mgl.glClearDepthx(depth); + checkError(); + } + + public void glClearStencil(int s) { + begin("glClearStencil"); + arg("s", s); + end(); + + mgl.glClearStencil(s); + checkError(); + } + + public void glClientActiveTexture(int texture) { + begin("glClientActiveTexture"); + arg("texture", texture); + end(); + + mgl.glClientActiveTexture(texture); + checkError(); + } + + public void glColor4f(float red, float green, float blue, float alpha) { + begin("glColor4f"); + arg("red", red); + arg("green", green); + arg("blue", blue); + arg("alpha", alpha); + end(); + + mgl.glColor4f(red, green, blue, alpha); + checkError(); + } + + public void glColor4x(int red, int green, int blue, int alpha) { + begin("glColor4x"); + arg("red", red); + arg("green", green); + arg("blue", blue); + arg("alpha", alpha); + end(); + + mgl.glColor4x(red, green, blue, alpha); + checkError(); + } + + public void glColorMask(boolean red, boolean green, boolean blue, + boolean alpha) { + begin("glColorMask"); + arg("red", red); + arg("green", green); + arg("blue", blue); + arg("alpha", alpha); + end(); + + mgl.glColorMask(red, green, blue, alpha); + checkError(); + } + + public void glColorPointer(int size, int type, int stride, Buffer pointer) { + begin("glColorPointer"); + argPointer(size, type, stride, pointer); + end(); + mColorPointer = new PointerInfo(size, type, stride, pointer); + + 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) { + begin("glCompressedTexImage2D"); + arg("target", getTextureTarget(target)); + arg("level", level); + arg("internalformat", internalformat); + arg("width", width); + arg("height", height); + arg("border", border); + arg("imageSize", imageSize); + arg("data", data.toString()); + end(); + + 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) { + begin("glCompressedTexSubImage2D"); + arg("target", getTextureTarget(target)); + arg("level", level); + arg("xoffset", xoffset); + arg("yoffset", yoffset); + arg("width", width); + arg("height", height); + arg("format", format); + arg("imageSize", imageSize); + arg("data", data.toString()); + end(); + + 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) { + begin("glCopyTexImage2D"); + arg("target", getTextureTarget(target)); + arg("level", level); + arg("internalformat", internalformat); + arg("x", x); + arg("y", y); + arg("width", width); + arg("height", height); + arg("border", border); + end(); + + 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) { + begin("glCopyTexSubImage2D"); + arg("target", getTextureTarget(target)); + arg("level", level); + arg("xoffset", xoffset); + arg("yoffset", yoffset); + arg("x", x); + arg("y", y); + arg("width", width); + arg("height", height); + end(); + + mgl.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, + height); + checkError(); + } + + public void glCullFace(int mode) { + begin("glCullFace"); + arg("mode", mode); + end(); + + mgl.glCullFace(mode); + checkError(); + } + + public void glDeleteTextures(int n, int[] textures, int offset) { + begin("glDeleteTextures"); + arg("n", n); + arg("textures", n, textures, offset); + arg("offset", offset); + end(); + + mgl.glDeleteTextures(n, textures, offset); + checkError(); + } + + public void glDeleteTextures(int n, IntBuffer textures) { + begin("glDeleteTextures"); + arg("n", n); + arg("textures", n, textures); + end(); + + mgl.glDeleteTextures(n, textures); + checkError(); + } + + public void glDepthFunc(int func) { + begin("glDepthFunc"); + arg("func", func); + end(); + + mgl.glDepthFunc(func); + checkError(); + } + + public void glDepthMask(boolean flag) { + begin("glDepthMask"); + arg("flag", flag); + end(); + + mgl.glDepthMask(flag); + checkError(); + } + + public void glDepthRangef(float near, float far) { + begin("glDepthRangef"); + arg("near", near); + arg("far", far); + end(); + + mgl.glDepthRangef(near, far); + checkError(); + } + + public void glDepthRangex(int near, int far) { + begin("glDepthRangex"); + arg("near", near); + arg("far", far); + end(); + + mgl.glDepthRangex(near, far); + checkError(); + } + + public void glDisable(int cap) { + begin("glDisable"); + arg("cap", getCap(cap)); + end(); + + mgl.glDisable(cap); + checkError(); + } + + public void glDisableClientState(int array) { + begin("glDisableClientState"); + arg("array", getClientState(array)); + end(); + + switch (array) { + case GL_COLOR_ARRAY: + mColorArrayEnabled = false; + break; + case GL_NORMAL_ARRAY: + mNormalArrayEnabled = false; + break; + case GL_TEXTURE_COORD_ARRAY: + mTextureCoordArrayEnabled = false; + break; + case GL_VERTEX_ARRAY: + mVertexArrayEnabled = false; + break; + } + mgl.glDisableClientState(array); + checkError(); + } + + public void glDrawArrays(int mode, int first, int count) { + begin("glDrawArrays"); + arg("mode", mode); + arg("first", first); + arg("count", count); + startLogIndices(); + for (int i = 0; i < count; i++) { + doElement(mStringBuilder, i, first + count); + } + endLogIndices(); + end(); + + mgl.glDrawArrays(mode, first, count); + checkError(); + } + + public void glDrawElements(int mode, int count, int type, Buffer indices) { + begin("glDrawElements"); + arg("mode", getBeginMode(mode)); + arg("count", count); + arg("type", getIndexType(type)); + char[] indexArray = toCharIndices(count, type, indices); + int indexArrayLength = indexArray.length; + startLogIndices(); + for (int i = 0; i < indexArrayLength; i++) { + doElement(mStringBuilder, i, indexArray[i]); + } + endLogIndices(); + end(); + + mgl.glDrawElements(mode, count, type, indices); + checkError(); + } + + public void glEnable(int cap) { + begin("glEnable"); + arg("cap", getCap(cap)); + end(); + + mgl.glEnable(cap); + checkError(); + } + + public void glEnableClientState(int array) { + begin("glEnableClientState"); + arg("array", getClientState(array)); + end(); + + switch (array) { + case GL_COLOR_ARRAY: + mColorArrayEnabled = true; + break; + case GL_NORMAL_ARRAY: + mNormalArrayEnabled = true; + break; + case GL_TEXTURE_COORD_ARRAY: + mTextureCoordArrayEnabled = true; + break; + case GL_VERTEX_ARRAY: + mVertexArrayEnabled = true; + break; + } + mgl.glEnableClientState(array); + checkError(); + } + + public void glFinish() { + begin("glFinish"); + end(); + + mgl.glFinish(); + checkError(); + } + + public void glFlush() { + begin("glFlush"); + end(); + + mgl.glFlush(); + checkError(); + } + + public void glFogf(int pname, float param) { + begin("glFogf"); + arg("pname", pname); + arg("param", param); + end(); + + mgl.glFogf(pname, param); + checkError(); + } + + public void glFogfv(int pname, float[] params, int offset) { + begin("glFogfv"); + arg("pname", getFogPName(pname)); + arg("params", getFogParamCount(pname), params, offset); + arg("offset", offset); + end(); + + mgl.glFogfv(pname, params, offset); + checkError(); + } + + public void glFogfv(int pname, FloatBuffer params) { + begin("glFogfv"); + arg("pname", getFogPName(pname)); + arg("params", getFogParamCount(pname), params); + end(); + + mgl.glFogfv(pname, params); + checkError(); + } + + public void glFogx(int pname, int param) { + begin("glFogx"); + arg("pname", getFogPName(pname)); + arg("param", param); + end(); + + mgl.glFogx(pname, param); + checkError(); + } + + public void glFogxv(int pname, int[] params, int offset) { + begin("glFogxv"); + arg("pname", getFogPName(pname)); + arg("params", getFogParamCount(pname), params, offset); + arg("offset", offset); + end(); + + mgl.glFogxv(pname, params, offset); + checkError(); + } + + public void glFogxv(int pname, IntBuffer params) { + begin("glFogxv"); + arg("pname", getFogPName(pname)); + arg("params", getFogParamCount(pname), params); + end(); + + mgl.glFogxv(pname, params); + checkError(); + } + + public void glFrontFace(int mode) { + begin("glFrontFace"); + arg("mode", mode); + end(); + + mgl.glFrontFace(mode); + checkError(); + } + + public void glFrustumf(float left, float right, float bottom, float top, + float near, float far) { + begin("glFrustumf"); + arg("left", left); + arg("right", right); + arg("bottom", bottom); + arg("top", top); + arg("near", near); + arg("far", far); + end(); + + mgl.glFrustumf(left, right, bottom, top, near, far); + checkError(); + } + + public void glFrustumx(int left, int right, int bottom, int top, int near, + int far) { + begin("glFrustumx"); + arg("left", left); + arg("right", right); + arg("bottom", bottom); + arg("top", top); + arg("near", near); + arg("far", far); + end(); + + mgl.glFrustumx(left, right, bottom, top, near, far); + checkError(); + } + + public void glGenTextures(int n, int[] textures, int offset) { + begin("glGenTextures"); + arg("n", n); + arg("textures", Arrays.toString(textures)); + arg("offset", offset); + + mgl.glGenTextures(n, textures, offset); + + returns(toString(n, FORMAT_INT, textures, offset)); + + checkError(); + } + + public void glGenTextures(int n, IntBuffer textures) { + begin("glGenTextures"); + arg("n", n); + arg("textures", textures.toString()); + + mgl.glGenTextures(n, textures); + + returns(toString(n, FORMAT_INT, textures)); + + checkError(); + } + + public int glGetError() { + begin("glGetError"); + + int result = mgl.glGetError(); + + returns(result); + + return result; + } + + public void glGetIntegerv(int pname, int[] params, int offset) { + begin("glGetIntegerv"); + arg("pname", getIntegerStateName(pname)); + arg("params", Arrays.toString(params)); + arg("offset", offset); + + mgl.glGetIntegerv(pname, params, offset); + + returns(toString(getIntegerStateSize(pname), + getIntegerStateFormat(pname), params, offset)); + + checkError(); + } + + public void glGetIntegerv(int pname, IntBuffer params) { + begin("glGetIntegerv"); + arg("pname", getIntegerStateName(pname)); + arg("params", params.toString()); + + mgl.glGetIntegerv(pname, params); + + returns(toString(getIntegerStateSize(pname), + getIntegerStateFormat(pname), params)); + + checkError(); + } + + public String glGetString(int name) { + begin("glGetString"); + arg("name", name); + + String result = mgl.glGetString(name); + + returns(result); + + checkError(); + return result; + } + + public void glHint(int target, int mode) { + begin("glHint"); + arg("target", getHintTarget(target)); + arg("mode", getHintMode(mode)); + end(); + + mgl.glHint(target, mode); + checkError(); + } + + public void glLightModelf(int pname, float param) { + begin("glLightModelf"); + arg("pname", getLightModelPName(pname)); + arg("param", param); + end(); + + mgl.glLightModelf(pname, param); + checkError(); + } + + public void glLightModelfv(int pname, float[] params, int offset) { + begin("glLightModelfv"); + arg("pname", getLightModelPName(pname)); + arg("params", getLightModelParamCount(pname), params, offset); + arg("offset", offset); + end(); + + mgl.glLightModelfv(pname, params, offset); + checkError(); + } + + public void glLightModelfv(int pname, FloatBuffer params) { + begin("glLightModelfv"); + arg("pname", getLightModelPName(pname)); + arg("params", getLightModelParamCount(pname), params); + end(); + + mgl.glLightModelfv(pname, params); + checkError(); + } + + public void glLightModelx(int pname, int param) { + begin("glLightModelx"); + arg("pname", getLightModelPName(pname)); + arg("param", param); + end(); + + mgl.glLightModelx(pname, param); + checkError(); + } + + public void glLightModelxv(int pname, int[] params, int offset) { + begin("glLightModelxv"); + arg("pname", getLightModelPName(pname)); + arg("params", getLightModelParamCount(pname), params, offset); + arg("offset", offset); + end(); + + mgl.glLightModelxv(pname, params, offset); + checkError(); + } + + public void glLightModelxv(int pname, IntBuffer params) { + begin("glLightModelfv"); + arg("pname", getLightModelPName(pname)); + arg("params", getLightModelParamCount(pname), params); + end(); + + mgl.glLightModelxv(pname, params); + checkError(); + } + + public void glLightf(int light, int pname, float param) { + begin("glLightf"); + arg("light", getLightName(light)); + arg("pname", getLightPName(pname)); + arg("param", param); + end(); + + mgl.glLightf(light, pname, param); + checkError(); + } + + public void glLightfv(int light, int pname, float[] params, int offset) { + begin("glLightfv"); + arg("light", getLightName(light)); + arg("pname", getLightPName(pname)); + arg("params", getLightParamCount(pname), params, offset); + arg("offset", offset); + end(); + + mgl.glLightfv(light, pname, params, offset); + checkError(); + } + + public void glLightfv(int light, int pname, FloatBuffer params) { + begin("glLightfv"); + arg("light", getLightName(light)); + arg("pname", getLightPName(pname)); + arg("params", getLightParamCount(pname), params); + end(); + + mgl.glLightfv(light, pname, params); + checkError(); + } + + public void glLightx(int light, int pname, int param) { + begin("glLightx"); + arg("light", getLightName(light)); + arg("pname", getLightPName(pname)); + arg("param", param); + end(); + + mgl.glLightx(light, pname, param); + checkError(); + } + + public void glLightxv(int light, int pname, int[] params, int offset) { + begin("glLightxv"); + arg("light", getLightName(light)); + arg("pname", getLightPName(pname)); + arg("params", getLightParamCount(pname), params, offset); + arg("offset", offset); + end(); + + mgl.glLightxv(light, pname, params, offset); + checkError(); + } + + public void glLightxv(int light, int pname, IntBuffer params) { + begin("glLightxv"); + arg("light", getLightName(light)); + arg("pname", getLightPName(pname)); + arg("params", getLightParamCount(pname), params); + end(); + + mgl.glLightxv(light, pname, params); + checkError(); + } + + public void glLineWidth(float width) { + begin("glLineWidth"); + arg("width", width); + end(); + + mgl.glLineWidth(width); + checkError(); + } + + public void glLineWidthx(int width) { + begin("glLineWidthx"); + arg("width", width); + end(); + + mgl.glLineWidthx(width); + checkError(); + } + + public void glLoadIdentity() { + begin("glLoadIdentity"); + end(); + + mgl.glLoadIdentity(); + checkError(); + } + + public void glLoadMatrixf(float[] m, int offset) { + begin("glLoadMatrixf"); + arg("m", 16, m, offset); + arg("offset", offset); + end(); + + mgl.glLoadMatrixf(m, offset); + checkError(); + } + + public void glLoadMatrixf(FloatBuffer m) { + begin("glLoadMatrixf"); + arg("m", 16, m); + end(); + + mgl.glLoadMatrixf(m); + checkError(); + } + + public void glLoadMatrixx(int[] m, int offset) { + begin("glLoadMatrixx"); + arg("m", 16, m, offset); + arg("offset", offset); + end(); + + mgl.glLoadMatrixx(m, offset); + checkError(); + } + + public void glLoadMatrixx(IntBuffer m) { + begin("glLoadMatrixx"); + arg("m", 16, m); + end(); + + mgl.glLoadMatrixx(m); + checkError(); + } + + public void glLogicOp(int opcode) { + begin("glLogicOp"); + arg("opcode", opcode); + end(); + + mgl.glLogicOp(opcode); + checkError(); + } + + public void glMaterialf(int face, int pname, float param) { + begin("glMaterialf"); + arg("face", getFaceName(face)); + arg("pname", getMaterialPName(pname)); + arg("param", param); + end(); + + mgl.glMaterialf(face, pname, param); + checkError(); + } + + public void glMaterialfv(int face, int pname, float[] params, int offset) { + begin("glMaterialfv"); + arg("face", getFaceName(face)); + arg("pname", getMaterialPName(pname)); + arg("params", getMaterialParamCount(pname), params, offset); + arg("offset", offset); + end(); + + mgl.glMaterialfv(face, pname, params, offset); + checkError(); + } + + public void glMaterialfv(int face, int pname, FloatBuffer params) { + begin("glMaterialfv"); + arg("face", getFaceName(face)); + arg("pname", getMaterialPName(pname)); + arg("params", getMaterialParamCount(pname), params); + end(); + + mgl.glMaterialfv(face, pname, params); + checkError(); + } + + public void glMaterialx(int face, int pname, int param) { + begin("glMaterialx"); + arg("face", getFaceName(face)); + arg("pname", getMaterialPName(pname)); + arg("param", param); + end(); + + mgl.glMaterialx(face, pname, param); + checkError(); + } + + public void glMaterialxv(int face, int pname, int[] params, int offset) { + begin("glMaterialxv"); + arg("face", getFaceName(face)); + arg("pname", getMaterialPName(pname)); + arg("params", getMaterialParamCount(pname), params, offset); + arg("offset", offset); + end(); + + mgl.glMaterialxv(face, pname, params, offset); + checkError(); + } + + public void glMaterialxv(int face, int pname, IntBuffer params) { + begin("glMaterialxv"); + arg("face", getFaceName(face)); + arg("pname", getMaterialPName(pname)); + arg("params", getMaterialParamCount(pname), params); + end(); + + mgl.glMaterialxv(face, pname, params); + checkError(); + } + + public void glMatrixMode(int mode) { + begin("glMatrixMode"); + arg("mode", getMatrixMode(mode)); + end(); + + mgl.glMatrixMode(mode); + checkError(); + } + + public void glMultMatrixf(float[] m, int offset) { + begin("glMultMatrixf"); + arg("m", 16, m, offset); + arg("offset", offset); + end(); + + mgl.glMultMatrixf(m, offset); + checkError(); + } + + public void glMultMatrixf(FloatBuffer m) { + begin("glMultMatrixf"); + arg("m", 16, m); + end(); + + mgl.glMultMatrixf(m); + checkError(); + } + + public void glMultMatrixx(int[] m, int offset) { + begin("glMultMatrixx"); + arg("m", 16, m, offset); + arg("offset", offset); + end(); + + mgl.glMultMatrixx(m, offset); + checkError(); + } + + public void glMultMatrixx(IntBuffer m) { + begin("glMultMatrixx"); + arg("m", 16, m); + end(); + + mgl.glMultMatrixx(m); + checkError(); + } + + public void glMultiTexCoord4f(int target, float s, float t, float r, float q) { + begin("glMultiTexCoord4f"); + arg("target", target); + arg("s", s); + arg("t", t); + arg("r", r); + arg("q", q); + end(); + + mgl.glMultiTexCoord4f(target, s, t, r, q); + checkError(); + } + + public void glMultiTexCoord4x(int target, int s, int t, int r, int q) { + begin("glMultiTexCoord4x"); + arg("target", target); + arg("s", s); + arg("t", t); + arg("r", r); + arg("q", q); + end(); + + mgl.glMultiTexCoord4x(target, s, t, r, q); + checkError(); + } + + public void glNormal3f(float nx, float ny, float nz) { + begin("glNormal3f"); + arg("nx", nx); + arg("ny", ny); + arg("nz", nz); + end(); + + mgl.glNormal3f(nx, ny, nz); + checkError(); + } + + public void glNormal3x(int nx, int ny, int nz) { + begin("glNormal3x"); + arg("nx", nx); + arg("ny", ny); + arg("nz", nz); + end(); + + mgl.glNormal3x(nx, ny, nz); + checkError(); + } + + public void glNormalPointer(int type, int stride, Buffer pointer) { + begin("glNormalPointer"); + arg("type", type); + arg("stride", stride); + arg("pointer", pointer.toString()); + end(); + mNormalPointer = new PointerInfo(3, type, stride, pointer); + + mgl.glNormalPointer(type, stride, pointer); + checkError(); + } + + public void glOrthof(float left, float right, float bottom, float top, + float near, float far) { + begin("glOrthof"); + arg("left", left); + arg("right", right); + arg("bottom", bottom); + arg("top", top); + arg("near", near); + arg("far", far); + end(); + + mgl.glOrthof(left, right, bottom, top, near, far); + checkError(); + } + + public void glOrthox(int left, int right, int bottom, int top, int near, + int far) { + begin("glOrthox"); + arg("left", left); + arg("right", right); + arg("bottom", bottom); + arg("top", top); + arg("near", near); + arg("far", far); + end(); + + mgl.glOrthox(left, right, bottom, top, near, far); + checkError(); + } + + public void glPixelStorei(int pname, int param) { + begin("glPixelStorei"); + arg("pname", pname); + arg("param", param); + end(); + + mgl.glPixelStorei(pname, param); + checkError(); + } + + public void glPointSize(float size) { + begin("glPointSize"); + arg("size", size); + end(); + + mgl.glPointSize(size); + checkError(); + } + + public void glPointSizex(int size) { + begin("glPointSizex"); + arg("size", size); + end(); + + mgl.glPointSizex(size); + checkError(); + } + + public void glPolygonOffset(float factor, float units) { + begin("glPolygonOffset"); + arg("factor", factor); + arg("units", units); + end(); + mgl.glPolygonOffset(factor, units); + checkError(); + } + + public void glPolygonOffsetx(int factor, int units) { + begin("glPolygonOffsetx"); + arg("factor", factor); + arg("units", units); + end(); + + mgl.glPolygonOffsetx(factor, units); + checkError(); + } + + public void glPopMatrix() { + begin("glPopMatrix"); + end(); + + mgl.glPopMatrix(); + checkError(); + } + + public void glPushMatrix() { + begin("glPushMatrix"); + end(); + + mgl.glPushMatrix(); + checkError(); + } + + public void glReadPixels(int x, int y, int width, int height, int format, + int type, Buffer pixels) { + begin("glReadPixels"); + arg("x", x); + arg("y", y); + arg("width", width); + arg("height", height); + arg("format", format); + arg("type", type); + arg("pixels", pixels.toString()); + end(); + + mgl.glReadPixels(x, y, width, height, format, type, pixels); + checkError(); + } + + public void glRotatef(float angle, float x, float y, float z) { + begin("glRotatef"); + arg("angle", angle); + arg("x", x); + arg("y", y); + arg("z", z); + end(); + + mgl.glRotatef(angle, x, y, z); + checkError(); + } + + public void glRotatex(int angle, int x, int y, int z) { + begin("glRotatex"); + arg("angle", angle); + arg("x", x); + arg("y", y); + arg("z", z); + end(); + + mgl.glRotatex(angle, x, y, z); + checkError(); + } + + public void glSampleCoverage(float value, boolean invert) { + begin("glSampleCoveragex"); + arg("value", value); + arg("invert", invert); + end(); + + mgl.glSampleCoverage(value, invert); + checkError(); + } + + public void glSampleCoveragex(int value, boolean invert) { + begin("glSampleCoveragex"); + arg("value", value); + arg("invert", invert); + end(); + + mgl.glSampleCoveragex(value, invert); + checkError(); + } + + public void glScalef(float x, float y, float z) { + begin("glScalef"); + arg("x", x); + arg("y", y); + arg("z", z); + end(); + + mgl.glScalef(x, y, z); + checkError(); + } + + public void glScalex(int x, int y, int z) { + begin("glScalex"); + arg("x", x); + arg("y", y); + arg("z", z); + end(); + + mgl.glScalex(x, y, z); + checkError(); + } + + public void glScissor(int x, int y, int width, int height) { + begin("glScissor"); + arg("x", x); + arg("y", y); + arg("width", width); + arg("height", height); + end(); + + mgl.glScissor(x, y, width, height); + checkError(); + } + + public void glShadeModel(int mode) { + begin("glShadeModel"); + arg("mode", getShadeModel(mode)); + end(); + + mgl.glShadeModel(mode); + checkError(); + } + + public void glStencilFunc(int func, int ref, int mask) { + begin("glStencilFunc"); + arg("func", func); + arg("ref", ref); + arg("mask", mask); + end(); + + mgl.glStencilFunc(func, ref, mask); + checkError(); + } + + public void glStencilMask(int mask) { + begin("glStencilMask"); + arg("mask", mask); + end(); + + mgl.glStencilMask(mask); + checkError(); + } + + public void glStencilOp(int fail, int zfail, int zpass) { + begin("glStencilOp"); + arg("fail", fail); + arg("zfail", zfail); + arg("zpass", zpass); + end(); + + mgl.glStencilOp(fail, zfail, zpass); + checkError(); + } + + public void glTexCoordPointer(int size, int type, int stride, Buffer pointer) { + begin("glTexCoordPointer"); + argPointer(size, type, stride, pointer); + end(); + mTexCoordPointer = new PointerInfo(size, type, stride, pointer); + + mgl.glTexCoordPointer(size, type, stride, pointer); + checkError(); + } + + public void glTexEnvf(int target, int pname, float param) { + begin("glTexEnvf"); + arg("target", getTextureEnvTarget(target)); + arg("pname", getTextureEnvPName(pname)); + arg("param", getTextureEnvParamName(param)); + end(); + + mgl.glTexEnvf(target, pname, param); + checkError(); + } + + public void glTexEnvfv(int target, int pname, float[] params, int offset) { + begin("glTexEnvfv"); + arg("target", getTextureEnvTarget(target)); + arg("pname", getTextureEnvPName(pname)); + arg("params", getTextureEnvParamCount(pname), params, offset); + arg("offset", offset); + end(); + + mgl.glTexEnvfv(target, pname, params, offset); + checkError(); + } + + public void glTexEnvfv(int target, int pname, FloatBuffer params) { + begin("glTexEnvfv"); + arg("target", getTextureEnvTarget(target)); + arg("pname", getTextureEnvPName(pname)); + arg("params", getTextureEnvParamCount(pname), params); + end(); + + mgl.glTexEnvfv(target, pname, params); + checkError(); + } + + public void glTexEnvx(int target, int pname, int param) { + begin("glTexEnvx"); + arg("target", getTextureEnvTarget(target)); + arg("pname", getTextureEnvPName(pname)); + arg("param", param); + end(); + + mgl.glTexEnvx(target, pname, param); + checkError(); + } + + public void glTexEnvxv(int target, int pname, int[] params, int offset) { + begin("glTexEnvxv"); + arg("target", getTextureEnvTarget(target)); + arg("pname", getTextureEnvPName(pname)); + arg("params", getTextureEnvParamCount(pname), params, offset); + arg("offset", offset); + end(); + + mgl.glTexEnvxv(target, pname, params, offset); + checkError(); + } + + public void glTexEnvxv(int target, int pname, IntBuffer params) { + begin("glTexEnvxv"); + arg("target", getTextureEnvTarget(target)); + arg("pname", getTextureEnvPName(pname)); + arg("params", getTextureEnvParamCount(pname), params); + end(); + + 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) { + begin("glTexImage2D"); + arg("target", target); + arg("level", level); + arg("internalformat", internalformat); + arg("width", width); + arg("height", height); + arg("border", border); + arg("format", format); + arg("type", type); + arg("pixels", pixels.toString()); + end(); + + mgl.glTexImage2D(target, level, internalformat, width, height, border, + format, type, pixels); + checkError(); + } + + public void glTexParameterf(int target, int pname, float param) { + begin("glTexParameterf"); + arg("target", getTextureTarget(target)); + arg("pname", getTexturePName(pname)); + arg("param", getTextureParamName(param)); + end(); + + mgl.glTexParameterf(target, pname, param); + checkError(); + } + + public void glTexParameterx(int target, int pname, int param) { + begin("glTexParameterx"); + arg("target", getTextureTarget(target)); + arg("pname", getTexturePName(pname)); + arg("param", param); + end(); + + mgl.glTexParameterx(target, pname, param); + checkError(); + } + + public void glTexParameteriv(int target, int pname, int[] params, int offset) { + begin("glTexParameteriv"); + arg("target", getTextureTarget(target)); + arg("pname", getTexturePName(pname)); + arg("params", 4, params, offset); + end(); + + mgl11.glTexParameteriv(target, pname, params, offset); + checkError(); + } + + public void glTexParameteriv(int target, int pname, IntBuffer params) { + begin("glTexParameteriv"); + arg("target", getTextureTarget(target)); + arg("pname", getTexturePName(pname)); + arg("params", 4, params); + end(); + + 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) { + begin("glTexSubImage2D"); + arg("target", getTextureTarget(target)); + arg("level", level); + arg("xoffset", xoffset); + arg("yoffset", yoffset); + arg("width", width); + arg("height", height); + arg("format", format); + arg("type", type); + arg("pixels", pixels.toString()); + end(); + mgl.glTexSubImage2D(target, level, xoffset, yoffset, width, height, + format, type, pixels); + checkError(); + } + + public void glTranslatef(float x, float y, float z) { + begin("glTranslatef"); + arg("x", x); + arg("y", y); + arg("z", z); + end(); + mgl.glTranslatef(x, y, z); + checkError(); + } + + public void glTranslatex(int x, int y, int z) { + begin("glTranslatex"); + arg("x", x); + arg("y", y); + arg("z", z); + end(); + mgl.glTranslatex(x, y, z); + checkError(); + } + + public void glVertexPointer(int size, int type, int stride, Buffer pointer) { + begin("glVertexPointer"); + argPointer(size, type, stride, pointer); + end(); + mVertexPointer = new PointerInfo(size, type, stride, pointer); + mgl.glVertexPointer(size, type, stride, pointer); + checkError(); + } + + public void glViewport(int x, int y, int width, int height) { + begin("glViewport"); + arg("x", x); + arg("y", y); + arg("width", width); + arg("height", height); + end(); + mgl.glViewport(x, y, width, height); + checkError(); + } + + public void glClipPlanef(int plane, float[] equation, int offset) { + begin("glClipPlanef"); + arg("plane", plane); + arg("equation", 4, equation, offset); + arg("offset", offset); + end(); + mgl11.glClipPlanef(plane, equation, offset); + checkError(); + } + + public void glClipPlanef(int plane, FloatBuffer equation) { + begin("glClipPlanef"); + arg("plane", plane); + arg("equation", 4, equation); + end(); + mgl11.glClipPlanef(plane, equation); + checkError(); + } + + public void glClipPlanex(int plane, int[] equation, int offset) { + begin("glClipPlanex"); + arg("plane", plane); + arg("equation", 4, equation, offset); + arg("offset", offset); + end(); + mgl11.glClipPlanex(plane, equation, offset); + checkError(); + } + + public void glClipPlanex(int plane, IntBuffer equation) { + begin("glClipPlanef"); + arg("plane", plane); + arg("equation", 4, equation); + end(); + mgl11.glClipPlanex(plane, equation); + checkError(); + } + + // Draw Texture Extension + + public void glDrawTexfOES(float x, float y, float z, + float width, float height) { + begin("glDrawTexfOES"); + arg("x", x); + arg("y", y); + arg("z", z); + arg("width", width); + arg("height", height); + end(); + mgl11Ext.glDrawTexfOES(x, y, z, width, height); + checkError(); + } + + public void glDrawTexfvOES(float[] coords, int offset) { + begin("glDrawTexfvOES"); + arg("coords", 5, coords, offset); + arg("offset", offset); + end(); + mgl11Ext.glDrawTexfvOES(coords, offset); + checkError(); + } + + public void glDrawTexfvOES(FloatBuffer coords) { + begin("glDrawTexfvOES"); + arg("coords", 5, coords); + end(); + mgl11Ext.glDrawTexfvOES(coords); + checkError(); + } + + public void glDrawTexiOES(int x, int y, int z, int width, int height) { + begin("glDrawTexiOES"); + arg("x", x); + arg("y", y); + arg("z", z); + arg("width", width); + arg("height", height); + end(); + mgl11Ext.glDrawTexiOES(x, y, z, width, height); + checkError(); + } + + public void glDrawTexivOES(int[] coords, int offset) { + begin("glDrawTexivOES"); + arg("coords", 5, coords, offset); + arg("offset", offset); + end(); + mgl11Ext.glDrawTexivOES(coords, offset); + checkError(); + } + + public void glDrawTexivOES(IntBuffer coords) { + begin("glDrawTexivOES"); + arg("coords", 5, coords); + end(); + mgl11Ext.glDrawTexivOES(coords); + checkError(); + } + + public void glDrawTexsOES(short x, short y, short z, + short width, short height) { + begin("glDrawTexsOES"); + arg("x", x); + arg("y", y); + arg("z", z); + arg("width", width); + arg("height", height); + end(); + mgl11Ext.glDrawTexsOES(x, y, z, width, height); + checkError(); + } + + public void glDrawTexsvOES(short[] coords, int offset) { + begin("glDrawTexsvOES"); + arg("coords", 5, coords, offset); + arg("offset", offset); + end(); + mgl11Ext.glDrawTexsvOES(coords, offset); + checkError(); + } + + public void glDrawTexsvOES(ShortBuffer coords) { + begin("glDrawTexsvOES"); + arg("coords", 5, coords); + end(); + mgl11Ext.glDrawTexsvOES(coords); + checkError(); + } + + public void glDrawTexxOES(int x, int y, int z, int width, int height) { + begin("glDrawTexxOES"); + arg("x", x); + arg("y", y); + arg("z", z); + arg("width", width); + arg("height", height); + end(); + mgl11Ext.glDrawTexxOES(x, y, z, width, height); + checkError(); + } + + public void glDrawTexxvOES(int[] coords, int offset) { + begin("glDrawTexxvOES"); + arg("coords", 5, coords, offset); + arg("offset", offset); + end(); + mgl11Ext.glDrawTexxvOES(coords, offset); + checkError(); + } + + public void glDrawTexxvOES(IntBuffer coords) { + begin("glDrawTexxvOES"); + arg("coords", 5, coords); + end(); + mgl11Ext.glDrawTexxvOES(coords); + checkError(); + } + + public int glQueryMatrixxOES(int[] mantissa, int mantissaOffset, + int[] exponent, int exponentOffset) { + begin("glQueryMatrixxOES"); + arg("mantissa", Arrays.toString(mantissa)); + arg("exponent", Arrays.toString(exponent)); + end(); + int valid = mgl10Ext.glQueryMatrixxOES(mantissa, mantissaOffset, + exponent, exponentOffset); + returns(toString(16, FORMAT_FIXED, mantissa, mantissaOffset)); + returns(toString(16, FORMAT_INT, exponent, exponentOffset)); + checkError(); + return valid; + } + + public int glQueryMatrixxOES(IntBuffer mantissa, IntBuffer exponent) { + begin("glQueryMatrixxOES"); + arg("mantissa", mantissa.toString()); + arg("exponent", exponent.toString()); + end(); + int valid = mgl10Ext.glQueryMatrixxOES(mantissa, exponent); + returns(toString(16, FORMAT_FIXED, mantissa)); + returns(toString(16, FORMAT_INT, exponent)); + checkError(); + return valid; + } + + // Unsupported GL11 methods + + public void glBindBuffer(int target, int buffer) { + throw new UnsupportedOperationException(); + } + + public void glBufferData(int target, int size, Buffer data, int usage) { + throw new UnsupportedOperationException(); + } + + public void glBufferSubData(int target, int offset, int size, Buffer data) { + throw new UnsupportedOperationException(); + } + + public void glColor4ub(byte red, byte green, byte blue, byte alpha) { + throw new UnsupportedOperationException(); + } + + public void glDeleteBuffers(int n, int[] buffers, int offset) { + throw new UnsupportedOperationException(); + } + + public void glDeleteBuffers(int n, IntBuffer buffers) { + throw new UnsupportedOperationException(); + } + + public void glGenBuffers(int n, int[] buffers, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGenBuffers(int n, IntBuffer buffers) { + throw new UnsupportedOperationException(); + } + + public void glGetBooleanv(int pname, boolean[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetBooleanv(int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetBufferParameteriv(int target, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetBufferParameteriv(int target, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetClipPlanef(int pname, float[] eqn, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetClipPlanef(int pname, FloatBuffer eqn) { + throw new UnsupportedOperationException(); + } + + public void glGetClipPlanex(int pname, int[] eqn, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetClipPlanex(int pname, IntBuffer eqn) { + throw new UnsupportedOperationException(); + } + + public void glGetFixedv(int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetFixedv(int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetFloatv(int pname, float[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetFloatv(int pname, FloatBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetLightfv(int light, int pname, float[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetLightfv(int light, int pname, FloatBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetLightxv(int light, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetLightxv(int light, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetMaterialfv(int face, int pname, float[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetMaterialfv(int face, int pname, FloatBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetMaterialxv(int face, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetMaterialxv(int face, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetTexEnviv(int env, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetTexEnviv(int env, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetTexEnvxv(int env, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetTexEnvxv(int env, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetTexParameterfv(int target, int pname, float[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetTexParameterfv(int target, int pname, FloatBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetTexParameteriv(int target, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetTexParameteriv(int target, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetTexParameterxv(int target, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetTexParameterxv(int target, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public boolean glIsBuffer(int buffer) { + throw new UnsupportedOperationException(); + } + + public boolean glIsEnabled(int cap) { + throw new UnsupportedOperationException(); + } + + public boolean glIsTexture(int texture) { + throw new UnsupportedOperationException(); + } + + public void glPointParameterf(int pname, float param) { + throw new UnsupportedOperationException(); + } + + public void glPointParameterfv(int pname, float[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glPointParameterfv(int pname, FloatBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glPointParameterx(int pname, int param) { + throw new UnsupportedOperationException(); + } + + public void glPointParameterxv(int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glPointParameterxv(int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glPointSizePointerOES(int type, int stride, Buffer pointer) { + throw new UnsupportedOperationException(); + } + + public void glTexEnvi(int target, int pname, int param) { + throw new UnsupportedOperationException(); + } + + public void glTexEnviv(int target, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glTexEnviv(int target, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glTexParameterfv(int target, int pname, float[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glTexParameterfv(int target, int pname, FloatBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glTexParameteri(int target, int pname, int param) { + throw new UnsupportedOperationException(); + } + + public void glTexParameterxv(int target, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glTexParameterxv(int target, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + private class PointerInfo { + /** + * The number of coordinates per vertex. 1..4 + */ + public int mSize; + /** + * The type of each coordinate. + */ + public int mType; + /** + * The byte offset between consecutive vertices. 0 means mSize * + * sizeof(mType) + */ + public int mStride; + public Buffer mPointer; + public ByteBuffer mTempByteBuffer; // Only valid during glDrawXXX calls + + public PointerInfo(int size, int type, int stride, Buffer pointer) { + mSize = size; + mType = type; + mStride = stride; + mPointer = pointer; + } + + public int sizeof(int type) { + switch (type) { + case GL_UNSIGNED_BYTE: + return 1; + case GL_BYTE: + return 1; + case GL_SHORT: + return 2; + case GL_FIXED: + return 4; + case GL_FLOAT: + return 4; + default: + return 0; + } + } + + public int getStride() { + return mStride > 0 ? mStride : sizeof(mType) * mSize; + } + + public void bindByteBuffer() { + mTempByteBuffer = toByteBuffer(-1, mPointer); + } + + public void unbindByteBuffer() { + mTempByteBuffer = null; + } + } + + private Writer mLog; + private boolean mLogArgumentNames; + private int mArgCount; + + private PointerInfo mColorPointer; + private PointerInfo mNormalPointer; + private PointerInfo mTexCoordPointer; + private PointerInfo mVertexPointer; + + boolean mColorArrayEnabled; + boolean mNormalArrayEnabled; + boolean mTextureCoordArrayEnabled; + boolean mVertexArrayEnabled; + + StringBuilder mStringBuilder; +} diff --git a/opengl/java/android/opengl/GLSurfaceView.java b/opengl/java/android/opengl/GLSurfaceView.java new file mode 100644 index 0000000..42c53f9 --- /dev/null +++ b/opengl/java/android/opengl/GLSurfaceView.java @@ -0,0 +1,661 @@ +/* + * Copyright (C) 2008 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.io.IOException; +import java.io.Writer; +import java.util.ArrayList; +import java.util.concurrent.Semaphore; + +import javax.microedition.khronos.egl.EGL10; +import javax.microedition.khronos.egl.EGL11; +import javax.microedition.khronos.egl.EGLConfig; +import javax.microedition.khronos.egl.EGLContext; +import javax.microedition.khronos.egl.EGLDisplay; +import javax.microedition.khronos.egl.EGLSurface; +import javax.microedition.khronos.opengles.GL; +import javax.microedition.khronos.opengles.GL10; + +import android.content.Context; +import android.util.AttributeSet; +import android.util.Log; +import android.view.SurfaceHolder; +import android.view.SurfaceView; + +/** + * An implementation of SurfaceView that uses the dedicated surface for + * displaying an OpenGL animation. This allows the animation to run in a + * separate thread, without requiring that it be driven by the update mechanism + * of the view hierarchy. + * + * The application-specific rendering code is delegated to a GLView.Renderer + * instance. + */ +public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback { + public final static int RENDERMODE_WHEN_DIRTY = 0; + public final static int RENDERMODE_CONTUOUSLY = 1; + + /** + * Check glError() after every GL call. + */ + public final static int DEBUG_CHECK_GL_ERROR = 1; + + /** + * Log GL calls to the system log at "verbose" level with tag "GLSurfaceView". + */ + public final static int DEBUG_LOG_GL_CALLS = 2; + + public GLSurfaceView(Context context) { + super(context); + init(); + } + + public GLSurfaceView(Context context, AttributeSet attrs) { + super(context, attrs); + init(); + } + + private void init() { + // Install a SurfaceHolder.Callback so we get notified when the + // underlying surface is created and destroyed + SurfaceHolder holder = getHolder(); + holder.addCallback(this); + holder.setType(SurfaceHolder.SURFACE_TYPE_GPU); + } + + /** + * Set the glWrapper to a new value. The current glWrapper is used + * whenever a surface is created. The default value is null. + * @param glWrapper the new GLWrapper + */ + public void setGLWrapper(GLWrapper glWrapper) { + mGLWrapper = glWrapper; + } + + /** + * Set the debug flags to a new value. The debug flags take effect + * whenever a surface is created. The default value is zero. + * @param debugFlags the new debug flags + * @see #DEBUG_CHECK_GL_ERROR + * @see #DEBUG_LOG_GL_CALLS + */ + public void setDebugFlags(int debugFlags) { + mDebugFlags = debugFlags; + } + + public int getDebugFlags() { + return mDebugFlags; + } + + /** + * Set the renderer associated with this view. Can only be called once. + * @param renderer + */ + public void setRenderer(Renderer renderer) { + if (mGLThread != null) { + throw new IllegalStateException("setRenderer has already been called for this instance."); + } + mGLThread = new GLThread(renderer); + mGLThread.start(); + } + + /** + * Set the rendering mode. When the renderMode is + * RENDERMODE_CONTINUOUSLY, the renderer is called + * repeatedly to re-render the scene. When the rendermode + * is RENDERMODE_WHEN_DIRTY, the renderer only rendered when the surface + * is created, or when requestRender is called. Defaults to RENDERMODE_CONTINUOUSLY. + * @param renderMode one of the RENDERMODE_X constants + */ + public void setRenderMode(int renderMode) { + mGLThread.setRenderMode(renderMode); + } + + /** + * Get the current rendering mode. May be called + * from any thread. Must not be called before a renderer has been set. + * @return true if the renderer will render continuously. + */ + public int getRenderMode() { + return mGLThread.getRenderMode(); + } + + /** + * Request that the renderer render a frame. May be called + * from any thread. Must not be called before a renderer has been set. + * This method is typically used when the render mode has been set to + * false, so that frames are only rendered on demand. + */ + public void requestRender() { + mGLThread.requestRender(); + } + + public void surfaceCreated(SurfaceHolder holder) { + mGLThread.surfaceCreated(); + } + + public void surfaceDestroyed(SurfaceHolder holder) { + // Surface will be destroyed when we return + mGLThread.surfaceDestroyed(); + } + + public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { + mGLThread.onWindowResize(w, h); + } + + /** + * Inform the view that the activity is paused. The owner of this view must + * call this method when the activity is paused. + */ + public void onPause() { + mGLThread.onPause(); + } + + /** + * Inform the view that the activity is resumed. The owner of this view must + * call this method when the activity is resumed. + */ + public void onResume() { + mGLThread.onResume(); + } + + /** + * Queue an "event" to be run on the GL rendering thread. + * @param r the runnable to be run on the GL rendering thread. + */ + public void queueEvent(Runnable r) { + mGLThread.queueEvent(r); + } + + @Override + protected void onDetachedFromWindow() { + super.onDetachedFromWindow(); + mGLThread.requestExitAndWait(); + } + + // ---------------------------------------------------------------------- + + public interface GLWrapper { + GL wrap(GL gl); + } + + // ---------------------------------------------------------------------- + + /** + * A generic renderer interface. + */ + public interface Renderer { + /** + * @return the EGL configuration specification desired by the renderer. + */ + int[] getConfigSpec(); + + /** + * Surface created. + * Called when the surface is created. Called when the application + * starts, and whenever the GPU is reinitialized. This will + * typically happen when the device awakes after going to sleep. + * Set your textures here. + * @param gl the GL interface. Use <code>instanceof</code> to + * test if the interface supports GL11 or higher interfaces. + * @param config the EGLConfig of the created surface. Can be used + * to create matching pbuffers. + */ + void onSurfaceCreated(GL10 gl, EGLConfig config); + /** + * Surface changed size. + * Called after the surface is created and whenever + * the OpenGL ES surface size changes. Set your viewport here. + * @param gl the GL interface. Use <code>instanceof</code> to + * test if the interface supports GL11 or higher interfaces. + * @param width + * @param height + */ + void onSurfaceChanged(GL10 gl, int width, int height); + /** + * Draw the current frame. + * @param gl the GL interface. Use <code>instanceof</code> to + * test if the interface supports GL11 or higher interfaces. + */ + void onDrawFrame(GL10 gl); + } + + /** + * An EGL helper class. + */ + + private class EglHelper { + public EglHelper() { + + } + + /** + * Initialize EGL for a given configuration spec. + * @param configSpec + */ + public void start(int[] configSpec){ + /* + * Get an EGL instance + */ + mEgl = (EGL10) EGLContext.getEGL(); + + /* + * Get to the default display. + */ + mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY); + + /* + * We can now initialize EGL for that display + */ + int[] version = new int[2]; + mEgl.eglInitialize(mEglDisplay, version); + + EGLConfig[] configs = new EGLConfig[1]; + int[] num_config = new int[1]; + mEgl.eglChooseConfig(mEglDisplay, configSpec, configs, 1, + num_config); + mEglConfig = configs[0]; + + /* + * Create an OpenGL ES context. This must be done only once, an + * OpenGL context is a somewhat heavy object. + */ + mEglContext = mEgl.eglCreateContext(mEglDisplay, mEglConfig, + EGL10.EGL_NO_CONTEXT, null); + + mEglSurface = null; + } + + /* + * React to the creation of a new surface by creating and returning an + * OpenGL interface that renders to that surface. + */ + public GL createSurface(SurfaceHolder holder) { + /* + * The window size has changed, so we need to create a new + * surface. + */ + if (mEglSurface != null) { + + /* + * Unbind and destroy the old EGL surface, if + * there is one. + */ + mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE, + EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT); + mEgl.eglDestroySurface(mEglDisplay, mEglSurface); + } + + /* + * Create an EGL surface we can render into. + */ + mEglSurface = mEgl.eglCreateWindowSurface(mEglDisplay, + mEglConfig, holder, null); + + /* + * Before we can issue GL commands, we need to make sure + * the context is current and bound to a surface. + */ + mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, + mEglContext); + + + GL gl = mEglContext.getGL(); + if (mGLWrapper != null) { + gl = mGLWrapper.wrap(gl); + } + + if ((mDebugFlags & (DEBUG_CHECK_GL_ERROR | DEBUG_LOG_GL_CALLS))!= 0) { + int configFlags = 0; + Writer log = null; + if ((mDebugFlags & DEBUG_CHECK_GL_ERROR) != 0) { + configFlags |= GLDebugHelper.CONFIG_CHECK_GL_ERROR; + } + if ((mDebugFlags & DEBUG_LOG_GL_CALLS) != 0) { + log = new LogWriter(); + } + gl = GLDebugHelper.wrap(gl, configFlags, log); + } + return gl; + } + + /** + * Display the current render surface. + * @return false if the context has been lost. + */ + public boolean swap() { + mEgl.eglSwapBuffers(mEglDisplay, mEglSurface); + + /* + * Always check for EGL_CONTEXT_LOST, which means the context + * and all associated data were lost (For instance because + * the device went to sleep). We need to sleep until we + * get a new surface. + */ + return mEgl.eglGetError() != EGL11.EGL_CONTEXT_LOST; + } + + public void finish() { + if (mEglSurface != null) { + mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE, + EGL10.EGL_NO_SURFACE, + EGL10.EGL_NO_CONTEXT); + mEgl.eglDestroySurface(mEglDisplay, mEglSurface); + mEglSurface = null; + } + if (mEglContext != null) { + mEgl.eglDestroyContext(mEglDisplay, mEglContext); + mEglContext = null; + } + if (mEglDisplay != null) { + mEgl.eglTerminate(mEglDisplay); + mEglDisplay = null; + } + } + + EGL10 mEgl; + EGLDisplay mEglDisplay; + EGLSurface mEglSurface; + EGLConfig mEglConfig; + EGLContext mEglContext; + } + + /** + * A generic GL Thread. Takes care of initializing EGL and GL. Delegates + * to a Renderer instance to do the actual drawing. Can be configured to + * render continuously or on request. + * + */ + class GLThread extends Thread { + GLThread(Renderer renderer) { + super(); + mDone = false; + mWidth = 0; + mHeight = 0; + mRequestRender = true; + mRenderMode = RENDERMODE_CONTUOUSLY; + mRenderer = renderer; + setName("GLThread"); + } + + @Override + public void run() { + /* + * When the android framework launches a second instance of + * an activity, the new instance's onCreate() method may be + * called before the first instance returns from onDestroy(). + * + * This semaphore ensures that only one instance at a time + * accesses EGL. + */ + try { + try { + sEglSemaphore.acquire(); + } catch (InterruptedException e) { + return; + } + guardedRun(); + } catch (InterruptedException e) { + // fall thru and exit normally + } finally { + sEglSemaphore.release(); + } + } + + private void guardedRun() throws InterruptedException { + mEglHelper = new EglHelper(); + /* + * Specify a configuration for our opengl session + * and grab the first configuration that matches is + */ + int[] configSpec = mRenderer.getConfigSpec(); + mEglHelper.start(configSpec); + + GL10 gl = null; + boolean tellRendererSurfaceCreated = true; + boolean tellRendererSurfaceChanged = true; + + /* + * This is our main activity thread's loop, we go until + * asked to quit. + */ + while (!mDone) { + + /* + * Update the asynchronous state (window size) + */ + int w, h; + boolean changed; + boolean needStart = false; + synchronized (this) { + Runnable r; + while ((r = getEvent()) != null) { + r.run(); + } + if (mPaused) { + mEglHelper.finish(); + needStart = true; + } + while (needToWait()) { + wait(); + } + if (mDone) { + break; + } + changed = mSizeChanged; + w = mWidth; + h = mHeight; + mSizeChanged = false; + mRequestRender = false; + } + if (needStart) { + mEglHelper.start(configSpec); + tellRendererSurfaceCreated = true; + changed = true; + } + if (changed) { + gl = (GL10) mEglHelper.createSurface(getHolder()); + tellRendererSurfaceChanged = true; + } + if (tellRendererSurfaceCreated) { + mRenderer.onSurfaceCreated(gl, mEglHelper.mEglConfig); + tellRendererSurfaceCreated = false; + } + if (tellRendererSurfaceChanged) { + mRenderer.onSurfaceChanged(gl, w, h); + tellRendererSurfaceChanged = false; + } + if ((w > 0) && (h > 0)) { + /* draw a frame here */ + mRenderer.onDrawFrame(gl); + + /* + * Once we're done with GL, we need to call swapBuffers() + * to instruct the system to display the rendered frame + */ + mEglHelper.swap(); + } + } + + /* + * clean-up everything... + */ + mEglHelper.finish(); + } + + private boolean needToWait() { + if (mDone) { + return false; + } + + if (mPaused || (! mHasSurface)) { + return true; + } + + if ((mWidth > 0) && (mHeight > 0) && (mRequestRender || (mRenderMode == RENDERMODE_CONTUOUSLY))) { + return false; + } + + return true; + } + + public void setRenderMode(int renderMode) { + if ( !((RENDERMODE_WHEN_DIRTY <= renderMode) && (renderMode <= RENDERMODE_CONTUOUSLY)) ) { + throw new IllegalArgumentException("renderMode"); + } + synchronized(this) { + mRenderMode = renderMode; + if (renderMode == RENDERMODE_CONTUOUSLY) { + notify(); + } + } + } + + public int getRenderMode() { + synchronized(this) { + return mRenderMode; + } + } + + public void requestRender() { + synchronized(this) { + mRequestRender = true; + notify(); + } + } + + public void surfaceCreated() { + synchronized(this) { + mHasSurface = true; + notify(); + } + } + + public void surfaceDestroyed() { + synchronized(this) { + mHasSurface = false; + notify(); + } + } + + public void onPause() { + synchronized (this) { + mPaused = true; + } + } + + public void onResume() { + synchronized (this) { + mPaused = false; + notify(); + } + } + + public void onWindowResize(int w, int h) { + synchronized (this) { + mWidth = w; + mHeight = h; + mSizeChanged = true; + notify(); + } + } + + public void requestExitAndWait() { + // don't call this from GLThread thread or it is a guaranteed + // deadlock! + synchronized(this) { + mDone = true; + notify(); + } + try { + join(); + } catch (InterruptedException ex) { + Thread.currentThread().interrupt(); + } + } + + /** + * Queue an "event" to be run on the GL rendering thread. + * @param r the runnable to be run on the GL rendering thread. + */ + public void queueEvent(Runnable r) { + synchronized(this) { + mEventQueue.add(r); + } + } + + private Runnable getEvent() { + synchronized(this) { + if (mEventQueue.size() > 0) { + return mEventQueue.remove(0); + } + + } + return null; + } + + private boolean mDone; + private boolean mPaused; + private boolean mHasSurface; + private int mWidth; + private int mHeight; + private int mRenderMode; + private boolean mRequestRender; + private Renderer mRenderer; + private ArrayList<Runnable> mEventQueue = new ArrayList<Runnable>(); + private EglHelper mEglHelper; + } + + static class LogWriter extends Writer { + + @Override public void close() { + flushBuilder(); + } + + @Override public void flush() { + flushBuilder(); + } + + @Override public void write(char[] buf, int offset, int count) { + for(int i = 0; i < count; i++) { + char c = buf[offset + i]; + if ( c == '\n') { + flushBuilder(); + } + else { + mBuilder.append(c); + } + } + } + + private void flushBuilder() { + if (mBuilder.length() > 0) { + Log.v("GLSurfaceView", mBuilder.toString()); + mBuilder.delete(0, mBuilder.length()); + } + } + + private StringBuilder mBuilder = new StringBuilder(); + } + + private static final Semaphore sEglSemaphore = new Semaphore(1); + private boolean mSizeChanged = true; + + private GLThread mGLThread; + private GLWrapper mGLWrapper; + private int mDebugFlags; +} diff --git a/opengl/java/android/opengl/GLU.java b/opengl/java/android/opengl/GLU.java new file mode 100644 index 0000000..0152f42 --- /dev/null +++ b/opengl/java/android/opengl/GLU.java @@ -0,0 +1,288 @@ +/* + * 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 javax.microedition.khronos.opengles.GL10; + +/** + * A set of GL utilities inspired by the OpenGL Utility Toolkit. + * + */ + +public class GLU { + + /** + * Return an error string from a GL or GLU error code. + * + * @param error - a GL or GLU error code. + * @return the error string for the input error code, or NULL if the input + * was not a valid GL or GLU error code. + */ + public static String gluErrorString(int error) { + switch (error) { + case GL10.GL_NO_ERROR: + return "no error"; + case GL10.GL_INVALID_ENUM: + return "invalid enum"; + case GL10.GL_INVALID_VALUE: + return "invalid value"; + case GL10.GL_INVALID_OPERATION: + return "invalid operation"; + case GL10.GL_STACK_OVERFLOW: + return "stack overflow"; + case GL10.GL_STACK_UNDERFLOW: + return "stack underflow"; + case GL10.GL_OUT_OF_MEMORY: + return "out of memory"; + default: + return null; + } + } + + /** + * Define a viewing transformation in terms of an eye point, a center of + * view, and an up vector. + * + * @param gl a GL10 interface + * @param eyeX eye point X + * @param eyeY eye point Y + * @param eyeZ eye point Z + * @param centerX center of view X + * @param centerY center of view Y + * @param centerZ center of view Z + * @param upX up vector X + * @param upY up vector Y + * @param upZ up vector Z + */ + public static void gluLookAt(GL10 gl, float eyeX, float eyeY, float eyeZ, + float centerX, float centerY, float centerZ, float upX, float upY, + float upZ) { + + // See the OpenGL GLUT documentation for gluLookAt for a description + // of the algorithm. We implement it in a straightforward way: + + float fx = centerX - eyeX; + float fy = centerY - eyeY; + float fz = centerZ - eyeZ; + + // Normalize f + float rlf = 1.0f / Matrix.length(fx, fy, fz); + fx *= rlf; + fy *= rlf; + fz *= rlf; + + // compute s = f x up (x means "cross product") + float sx = fy * upZ - fz * upY; + float sy = fz * upX - fx * upZ; + float sz = fx * upY - fy * upX; + + // and normalize s + float rls = 1.0f / Matrix.length(sx, sy, sz); + sx *= rls; + sy *= rls; + sz *= rls; + + // compute u = s x f + float ux = sy * fz - sz * fy; + float uy = sz * fx - sx * fz; + float uz = sx * fy - sy * fx; + + float[] m = new float[16]; + m[0] = sx; + m[1] = ux; + m[2] = -fx; + m[3] = 0.0f; + + m[4] = sy; + m[5] = uy; + m[6] = -fy; + m[7] = 0.0f; + + m[8] = sz; + m[9] = uz; + m[10] = -fz; + m[11] = 0.0f; + + m[12] = 0.0f; + m[13] = 0.0f; + m[14] = 0.0f; + m[15] = 1.0f; + + gl.glMultMatrixf(m, 0); + gl.glTranslatef(-eyeX, -eyeY, -eyeZ); + } + + /** + * Set up a 2D orthographic projection matrix + * + * @param gl + * @param left + * @param right + * @param bottom + * @param top + */ + public static void gluOrtho2D(GL10 gl, float left, float right, + float bottom, float top) { + gl.glOrthof(left, right, bottom, top, -1.0f, 1.0f); + } + + /** + * Set up a perspective projection matrix + * + * @param gl a GL10 interface + * @param fovy specifies the field of view angle, in degrees, in the Y + * direction. + * @param aspect specifies the aspect ration that determins the field of + * view in the x direction. The aspect ratio is the ratio of x + * (width) to y (height). + * @param zNear specifies the distance from the viewer to the near clipping + * plane (always positive). + * @param zFar specifies the distance from the viewer to the far clipping + * plane (always positive). + */ + public static void gluPerspective(GL10 gl, float fovy, float aspect, + float zNear, float zFar) { + float top = zNear * (float) Math.tan(fovy * (Math.PI / 360.0)); + float bottom = -top; + float left = bottom * aspect; + float right = top * aspect; + gl.glFrustumf(left, right, bottom, top, zNear, zFar); + } + + /** + * Map object coordinates into window coordinates. gluProject transforms the + * specified object coordinates into window coordinates using model, proj, + * and view. The result is stored in win. + * <p> + * Note that you can use the OES_matrix_get extension, if present, to get + * the current modelView and projection matrices. + * + * @param objX object coordinates X + * @param objY object coordinates Y + * @param objZ object coordinates Z + * @param model the current modelview matrix + * @param modelOffset the offset into the model array where the modelview + * maxtrix data starts. + * @param project the current projection matrix + * @param projectOffset the offset into the project array where the project + * matrix data starts. + * @param view the current view, {x, y, width, height} + * @param viewOffset the offset into the view array where the view vector + * data starts. + * @param win the output vector {winX, winY, winZ}, that returns the + * computed window coordinates. + * @param winOffset the offset into the win array where the win vector data + * starts. + * @return A return value of GL_TRUE indicates success, a return value of + * GL_FALSE indicates failure. + */ + public static int gluProject(float objX, float objY, float objZ, + float[] model, int modelOffset, float[] project, int projectOffset, + int[] view, int viewOffset, float[] win, int winOffset) { + float[] m = new float[16]; + Matrix.multiplyMM(m, 0, project, projectOffset, model, modelOffset); + + float[] v = new float[4]; + + v[0] = objX; + v[1] = objY; + v[2] = objZ; + v[3] = 1.0f; + + float[] v2 = new float[4]; + + Matrix.multiplyMV(v2, 0, m, 0, v, 0); + + float w = v2[3]; + if (w == 0.0f) { + return GL10.GL_FALSE; + } + + float rw = 1.0f / w; + + win[winOffset] = + view[viewOffset] + view[viewOffset + 2] * (v2[0] * rw + 1.0f) + * 0.5f; + win[winOffset + 1] = + view[viewOffset + 1] + view[viewOffset + 3] + * (v2[1] * rw + 1.0f) * 0.5f; + win[winOffset + 2] = (v2[2] * rw + 1.0f) * 0.5f; + + return GL10.GL_TRUE; + } + + /** + * Map window coordinates to object coordinates. gluUnProject maps the + * specified window coordinates into object coordinates using model, proj, + * and view. The result is stored in obj. + * <p> + * Note that you can use the OES_matrix_get extension, if present, to get + * the current modelView and projection matrices. + * + * @param winX window coordinates X + * @param winY window coordinates Y + * @param winZ window coordinates Z + * @param model the current modelview matrix + * @param modelOffset the offset into the model array where the modelview + * maxtrix data starts. + * @param project the current projection matrix + * @param projectOffset the offset into the project array where the project + * matrix data starts. + * @param view the current view, {x, y, width, height} + * @param viewOffset the offset into the view array where the view vector + * data starts. + * @param obj the output vector {objX, objY, objZ}, that returns the + * computed object coordinates. + * @param objOffset the offset into the obj array where the obj vector data + * starts. + * @return A return value of GL10.GL_TRUE indicates success, a return value + * of GL10.GL_FALSE indicates failure. + */ + public static int gluUnProject(float winX, float winY, float winZ, + float[] model, int modelOffset, float[] project, int projectOffset, + int[] view, int viewOffset, float[] obj, int objOffset) { + float[] pm = new float[16]; + Matrix.multiplyMM(pm, 0, project, projectOffset, model, modelOffset); + + float[] invPM = new float[16]; + if (!Matrix.invertM(invPM, 0, pm, 0)) { + return GL10.GL_FALSE; + } + + float[] v = new float[4]; + + v[0] = + 2.0f * (winX - view[viewOffset + 0]) / view[viewOffset + 2] + - 1.0f; + v[1] = + 2.0f * (winY - view[viewOffset + 1]) / view[viewOffset + 3] + - 1.0f; + v[2] = 2.0f * winZ - 1.0f; + v[3] = 1.0f; + + float[] v2 = new float[4]; + + Matrix.multiplyMV(v2, 0, invPM, 0, v, 0); + + obj[objOffset] = v2[0]; + obj[objOffset + 1] = v2[1]; + obj[objOffset + 2] = v2[2]; + + return GL10.GL_TRUE; + } + + } diff --git a/opengl/java/android/opengl/GLUtils.java b/opengl/java/android/opengl/GLUtils.java new file mode 100644 index 0000000..df6c557 --- /dev/null +++ b/opengl/java/android/opengl/GLUtils.java @@ -0,0 +1,220 @@ +/* + * Copyright (C) 2006 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 javax.microedition.khronos.opengles.GL10; +import android.graphics.Bitmap; + +/** + * + * Utility class to help bridging OpenGL ES and Android APIs. + * + */ + +public final class GLUtils { + + /* + * We use a class initializer to allow the native code to cache some + * field offsets. + */ + static { + nativeClassInit(); + } + + private GLUtils() { + } + + /** + * return the internal format as defined by OpenGL ES of the supplied bitmap. + * + * @param bitmap + * @return the internal format of the bitmap. + */ + public static int getInternalFormat(Bitmap bitmap) { + if (bitmap == null) { + throw new NullPointerException("getInternalFormat can't be used with a null Bitmap"); + } + switch (bitmap.getConfig()) { + case ALPHA_8: + return GL10.GL_ALPHA; + case ARGB_4444: + case ARGB_8888: + return GL10.GL_RGBA; + case RGB_565: + return GL10.GL_RGB; + } + throw new IllegalArgumentException("Unknown internalformat"); + } + + /** + * Return the type as defined by OpenGL ES of the supplied bitmap. + */ + public static int getType(Bitmap bitmap) { + if (bitmap == null) { + throw new NullPointerException("getType can't be used with a null Bitmap"); + } + int type; + switch(bitmap.getConfig()) { + case ARGB_4444: + type = GL10.GL_UNSIGNED_SHORT_4_4_4_4; + break; + case RGB_565: + type = GL10.GL_UNSIGNED_SHORT_5_6_5; + break; + case ALPHA_8: + case ARGB_8888: + default: + type = GL10.GL_UNSIGNED_BYTE; + break; + } + return type; + } + + /** + * Calls glTexImage2D() on the current OpenGL context. If no context is + * current the behavior is the same as calling glTexImage2D() with no + * current context, that is, eglGetError() will return the appropriate + * error. + * Unlike glTexImage2D() bitmap cannot be null and will raise an exception + * in that case. + * All other parameters are identical to those used for glTexImage2D(). + * + * NOTE: this method doesn't change GL_UNPACK_ALIGNMENT, you must make + * sure to set it properly according to the supplied bitmap. + * + * Whether or not bitmap can have non power of two dimensions depends on + * the current OpenGL context. Always check glGetError() some time + * after calling this method, just like when using OpenGL directly. + * + * @param target + * @param level + * @param internalformat + * @param bitmap + * @param border + */ + public static void texImage2D(int target, int level, int internalformat, + Bitmap bitmap, int border) { + if (bitmap == null) { + throw new NullPointerException("texImage2D can't be used with a null Bitmap"); + } + int type = getType(bitmap); + if (native_texImage2D(target, level, internalformat, bitmap, type, border)!=0) { + throw new IllegalArgumentException("invalid Bitmap format"); + } + } + + /** + * A version of texImage2D() that takes an explicit type parameter + * as defined by the OpenGL ES specification. + * + * @param target + * @param level + * @param internalformat + * @param bitmap + * @param type + * @param border + */ + public static void texImage2D(int target, int level, int internalformat, + Bitmap bitmap, int type, int border) { + if (bitmap == null) { + throw new NullPointerException("texImage2D can't be used with a null Bitmap"); + } + if (native_texImage2D(target, level, internalformat, bitmap, type, border)!=0) { + throw new IllegalArgumentException("invalid Bitmap format"); + } + } + + /** + * A version of texImage2D that determines the internalFormat automatically. + * + * @param target + * @param level + * @param bitmap + * @param border + */ + public static void texImage2D(int target, int level, Bitmap bitmap, + int border) { + if (bitmap == null) { + throw new NullPointerException("texImage2D can't be used with a null Bitmap"); + } + int type = getType(bitmap); + if (native_texImage2D(target, level, -1, bitmap, type, border)!=0) { + throw new IllegalArgumentException("invalid Bitmap format"); + } + } + + /** + * Calls glTexSubImage2D() on the current OpenGL context. If no context is + * current the behavior is the same as calling glTexSubImage2D() with no + * current context, that is, eglGetError() will return the appropriate + * error. + * Unlike glTexSubImage2D() bitmap cannot be null and will raise an exception + * in that case. + * All other parameters are identical to those used for glTexSubImage2D(). + * + * NOTE: this method doesn't change GL_UNPACK_ALIGNMENT, you must make + * sure to set it properly according to the supplied bitmap. + * + * Whether or not bitmap can have non power of two dimensions depends on + * the current OpenGL context. Always check glGetError() some time + * after calling this method, just like when using OpenGL directly. + * + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param bitmap + */ + public static void texSubImage2D(int target, int level, int xoffset, int yoffset, + Bitmap bitmap) { + if (bitmap == null) { + throw new NullPointerException("texSubImage2D can't be used with a null Bitmap"); + } + int type = getType(bitmap); + if (native_texSubImage2D(target, level, xoffset, yoffset, bitmap, -1, type)!=0) { + throw new IllegalArgumentException("invalid Bitmap format"); + } + } + + /** + * A version of texSubImage2D() that takes an explicit type parameter + * as defined by the OpenGL ES specification. + * + * @param target + * @param level + * @param xoffset + * @param yoffset + * @param bitmap + * @param type + */ + public static void texSubImage2D(int target, int level, int xoffset, int yoffset, + Bitmap bitmap, int format, int type) { + if (bitmap == null) { + throw new NullPointerException("texSubImage2D can't be used with a null Bitmap"); + } + if (native_texSubImage2D(target, level, xoffset, yoffset, bitmap, format, type)!=0) { + throw new IllegalArgumentException("invalid Bitmap format"); + } + } + + native private static void nativeClassInit(); + + native private static int native_texImage2D(int target, int level, int internalformat, + Bitmap bitmap, int type, int border); + native private static int native_texSubImage2D(int target, int level, int xoffset, int yoffset, + Bitmap bitmap, int format, int type); +} diff --git a/opengl/java/android/opengl/GLWrapperBase.java b/opengl/java/android/opengl/GLWrapperBase.java new file mode 100644 index 0000000..067f95f --- /dev/null +++ b/opengl/java/android/opengl/GLWrapperBase.java @@ -0,0 +1,495 @@ +/* + * 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 javax.microedition.khronos.opengles.GL; +import javax.microedition.khronos.opengles.GL10; +import javax.microedition.khronos.opengles.GL10Ext; +import javax.microedition.khronos.opengles.GL11; +import javax.microedition.khronos.opengles.GL11Ext; +import javax.microedition.khronos.opengles.GL11ExtensionPack; + +/** + * The abstract base class for a GL wrapper. Provides + * some convenient instance variables and default implementations. + */ +abstract class GLWrapperBase + implements GL, GL10, GL10Ext, GL11, GL11Ext { + public GLWrapperBase(GL gl) { + mgl = (GL10) gl; + if (gl instanceof GL10Ext) { + mgl10Ext = (GL10Ext) gl; + } + if (gl instanceof GL11) { + mgl11 = (GL11) gl; + } + if (gl instanceof GL11Ext) { + mgl11Ext = (GL11Ext) gl; + } + if (gl instanceof GL11ExtensionPack) { + mgl11ExtensionPack = (GL11ExtensionPack) gl; + } + } + + protected GL10 mgl; + protected GL10Ext mgl10Ext; + protected GL11 mgl11; + protected GL11Ext mgl11Ext; + protected GL11ExtensionPack mgl11ExtensionPack; + + // Unsupported GL11 methods + + public void glGetPointerv(int pname, java.nio.Buffer[] params) { + throw new UnsupportedOperationException(); + } + + // VBO versions of *Pointer and *Elements methods + public void glColorPointer(int size, int type, int stride, int offset) { + throw new UnsupportedOperationException(); + } + + public void glNormalPointer(int type, int stride, int offset) { + throw new UnsupportedOperationException(); + } + + public void glTexCoordPointer(int size, int type, int stride, int offset) { + throw new UnsupportedOperationException(); + } + + public void glVertexPointer(int size, int type, int stride, int offset) { + throw new UnsupportedOperationException(); + } + + public void glDrawElements(int mode, int count, int type, int offset) { + throw new UnsupportedOperationException(); + } + + public void glBindBuffer(int target, int buffer) { + throw new UnsupportedOperationException(); + } + + public void glBufferData(int target, int size, Buffer data, int usage) { + throw new UnsupportedOperationException(); + } + + public void glBufferSubData(int target, int offset, int size, Buffer data) { + throw new UnsupportedOperationException(); + } + + public void glColor4ub(byte red, byte green, byte blue, byte alpha) { + throw new UnsupportedOperationException(); + } + + public void glDeleteBuffers(int n, int[] buffers, int offset) { + throw new UnsupportedOperationException(); + } + + public void glDeleteBuffers(int n, IntBuffer buffers) { + throw new UnsupportedOperationException(); + } + + public void glGenBuffers(int n, int[] buffers, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGenBuffers(int n, IntBuffer buffers) { + throw new UnsupportedOperationException(); + } + + public void glGetBooleanv(int pname, boolean[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetBooleanv(int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetBufferParameteriv(int target, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetBufferParameteriv(int target, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetClipPlanef(int pname, float[] eqn, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetClipPlanef(int pname, FloatBuffer eqn) { + throw new UnsupportedOperationException(); + } + + public void glGetClipPlanex(int pname, int[] eqn, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetClipPlanex(int pname, IntBuffer eqn) { + throw new UnsupportedOperationException(); + } + + public void glGetFixedv(int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetFixedv(int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetFloatv(int pname, float[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetFloatv(int pname, FloatBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetLightfv(int light, int pname, float[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetLightfv(int light, int pname, FloatBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetLightxv(int light, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetLightxv(int light, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetMaterialfv(int face, int pname, float[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetMaterialfv(int face, int pname, FloatBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetMaterialxv(int face, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetMaterialxv(int face, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetTexEnviv(int env, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetTexEnviv(int env, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetTexEnvxv(int env, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetTexEnvxv(int env, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetTexParameterfv(int target, int pname, float[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetTexParameterfv(int target, int pname, FloatBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetTexParameteriv(int target, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetTexParameteriv(int target, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetTexParameterxv(int target, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetTexParameterxv(int target, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public boolean glIsBuffer(int buffer) { + throw new UnsupportedOperationException(); + } + + public boolean glIsEnabled(int cap) { + throw new UnsupportedOperationException(); + } + + public boolean glIsTexture(int texture) { + throw new UnsupportedOperationException(); + } + + public void glPointParameterf(int pname, float param) { + throw new UnsupportedOperationException(); + } + + public void glPointParameterfv(int pname, float[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glPointParameterfv(int pname, FloatBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glPointParameterx(int pname, int param) { + throw new UnsupportedOperationException(); + } + + public void glPointParameterxv(int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glPointParameterxv(int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glPointSizePointerOES(int type, int stride, Buffer pointer) { + throw new UnsupportedOperationException(); + } + + public void glTexEnvi(int target, int pname, int param) { + throw new UnsupportedOperationException(); + } + + public void glTexEnviv(int target, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glTexEnviv(int target, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glTexParameterfv(int target, int pname, float[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glTexParameterfv(int target, int pname, FloatBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glTexParameteri(int target, int pname, int param) { + throw new UnsupportedOperationException(); + } + + public void glTexParameterxv(int target, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glTexParameterxv(int target, int pname, IntBuffer params) { + throw new UnsupportedOperationException(); + } + + // Unsupported GL11Ext methods + + public void glCurrentPaletteMatrixOES(int matrixpaletteindex) { + throw new UnsupportedOperationException(); + } + + public void glLoadPaletteFromModelViewMatrixOES() { + throw new UnsupportedOperationException(); + } + + public void glMatrixIndexPointerOES(int size, int type, int stride, Buffer pointer) { + throw new UnsupportedOperationException(); + } + + public void glMatrixIndexPointerOES(int size, int type, int stride, int offset) { + throw new UnsupportedOperationException(); + } + + public void glWeightPointerOES(int size, int type, int stride, Buffer pointer) { + throw new UnsupportedOperationException(); + } + + public void glWeightPointerOES(int size, int type, int stride, int offset) { + throw new UnsupportedOperationException(); + } + + // Unsupported GL11ExtensionPack methods + + public void glBindFramebufferOES(int target, int framebuffer) { + throw new UnsupportedOperationException(); + } + + public void glBindRenderbufferOES(int target, int renderbuffer) { + throw new UnsupportedOperationException(); + } + + public void glBlendEquation(int mode) { + throw new UnsupportedOperationException(); + } + + public void glBlendEquationSeparate(int modeRGB, int modeAlpha) { + throw new UnsupportedOperationException(); + } + + public void glBlendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) { + throw new UnsupportedOperationException(); + } + + int glCheckFramebufferStatusOES(int target) { + throw new UnsupportedOperationException(); + } + + public void glCompressedTexImage2D(int target, int level, int internalformat, int width, int height, int border, int imageSize) { + throw new UnsupportedOperationException(); + } + + public void glDeleteFramebuffersOES(int n, int[] framebuffers, int offset) { + throw new UnsupportedOperationException(); + } + + public void glDeleteFramebuffersOES(int n, java.nio.IntBuffer framebuffers) { + throw new UnsupportedOperationException(); + } + + public void glDeleteRenderbuffersOES(int n, int[] renderbuffers, int offset) { + throw new UnsupportedOperationException(); + } + + public void glDeleteRenderbuffersOES(int n, java.nio.IntBuffer renderbuffers) { + throw new UnsupportedOperationException(); + } + + public void glFramebufferRenderbufferOES(int target, int attachment, int renderbuffertarget, int renderbuffer) { + throw new UnsupportedOperationException(); + } + + public void glFramebufferTexture2DOES(int target, int attachment, int textarget, int texture, int level) { + throw new UnsupportedOperationException(); + } + + public void glGenerateMipmapOES(int target) { + throw new UnsupportedOperationException(); + } + + public void glGenFramebuffersOES(int n, int[] framebuffers, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGenFramebuffersOES(int n, java.nio.IntBuffer framebuffers) { + throw new UnsupportedOperationException(); + } + + public void glGenRenderbuffersOES(int n, int[] renderbuffers, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGenRenderbuffersOES(int n, java.nio.IntBuffer renderbuffers) { + throw new UnsupportedOperationException(); + } + + public void glGetFramebufferAttachmentParameterivOES(int target, int attachment, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetFramebufferAttachmentParameterivOES(int target, int attachment, int pname, java.nio.IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetRenderbufferParameterivOES(int target, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetRenderbufferParameterivOES(int target, int pname, java.nio.IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetTexGenfv(int coord, int pname, float[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetTexGenfv(int coord, int pname, java.nio.FloatBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetTexGeniv(int coord, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetTexGeniv(int coord, int pname, java.nio.IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glGetTexGenxv(int coord, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glGetTexGenxv(int coord, int pname, java.nio.IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public boolean glIsFramebufferOES(int framebuffer) { + throw new UnsupportedOperationException(); + } + + public boolean glIsRenderbufferOES(int renderbuffer) { + throw new UnsupportedOperationException(); + } + + public void glRenderbufferStorageOES(int target, int internalformat, int width, int height) { + throw new UnsupportedOperationException(); + } + + public void glTexGenf(int coord, int pname, float param) { + throw new UnsupportedOperationException(); + } + + public void glTexGenfv(int coord, int pname, float[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glTexGenfv(int coord, int pname, java.nio.FloatBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glTexGeni(int coord, int pname, int param) { + throw new UnsupportedOperationException(); + } + + public void glTexGeniv(int coord, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glTexGeniv(int coord, int pname, java.nio.IntBuffer params) { + throw new UnsupportedOperationException(); + } + + public void glTexGenx(int coord, int pname, int param) { + throw new UnsupportedOperationException(); + } + + public void glTexGenxv(int coord, int pname, int[] params, int offset) { + throw new UnsupportedOperationException(); + } + + public void glTexGenxv(int coord, int pname, java.nio.IntBuffer params) { + throw new UnsupportedOperationException(); + } +} diff --git a/opengl/java/android/opengl/Group.java b/opengl/java/android/opengl/Group.java new file mode 100644 index 0000000..1ef2953 --- /dev/null +++ b/opengl/java/android/opengl/Group.java @@ -0,0 +1,155 @@ +/* + * Copyright (C) 2006 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.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.ShortBuffer; +import java.io.DataInputStream; +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import java.util.Iterator; +import javax.microedition.khronos.opengles.*; + +class MaterialIndices { + + private Material material = null; + private ShortBuffer indexBuffer = null; + + public MaterialIndices(Material material, ShortBuffer indexBuffer) { + this.material = material; + this.indexBuffer = indexBuffer; + } + + public Material getMaterial() { + return material; + } + + public ShortBuffer getIndexBuffer() { + return indexBuffer; + } +} + +/** + * {@hide} + */ +public class Group { + + private Object3D parent; + private String name; + + private List<MaterialIndices> materialIndices = + new ArrayList<MaterialIndices>(); + + public Group(Object3D parent) { + this.parent = parent; + } + + public String getName() { + return name; + } + + public void load(DataInputStream dis) throws IOException { + dis.readInt(); // name length + this.name = dis.readUTF(); + + int numMaterials = dis.readInt(); + + for (int i = 0; i < numMaterials; i++) { + dis.readInt(); // material name length + String matName = dis.readUTF(); + Material material = parent.getMaterial(matName); + + int numIndices = dis.readInt(); + byte[] indicesBytes = new byte[numIndices * 2]; + dis.readFully(indicesBytes); + + // Swap bytes from network to native order if necessary + if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) { + int idx = 0; + for (int j = 0; j < numIndices; j++) { + byte b0 = indicesBytes[idx]; + byte b1 = indicesBytes[idx + 1]; + indicesBytes[idx] = b1; + indicesBytes[idx + 1] = b0; + idx += 2; + } + } + + ByteBuffer ibb = ByteBuffer.allocateDirect(2*numIndices); + ibb.order(ByteOrder.nativeOrder()); + ibb.put(indicesBytes); + ibb.position(0); + + ShortBuffer sb = ibb.asShortBuffer(); + materialIndices.add(new MaterialIndices(material, sb)); + } + } + + public int getNumTriangles() { + int numTriangles = 0; + Iterator<MaterialIndices> iter = materialIndices.iterator(); + while (iter.hasNext()) { + MaterialIndices matIdx = iter.next(); + ShortBuffer indexBuffer = matIdx.getIndexBuffer(); + numTriangles += indexBuffer.capacity()/3; + } + return numTriangles; + } + + public void draw(GL10 gl) { + gl.glDisableClientState(gl.GL_COLOR_ARRAY); + + gl.glVertexPointer(3, gl.GL_FIXED, 0, parent.getVertexBuffer()); + gl.glEnableClientState(gl.GL_VERTEX_ARRAY); + + gl.glNormalPointer(gl.GL_FIXED, 0, parent.getNormalBuffer()); + gl.glEnableClientState(gl.GL_NORMAL_ARRAY); + + if (parent.hasTexcoords()) { + gl.glTexCoordPointer(2, gl.GL_FIXED, 0, parent.getTexcoordBuffer()); + gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY); + gl.glEnable(gl.GL_TEXTURE_2D); + } else { + gl.glDisable(gl.GL_TEXTURE_2D); + } + + Iterator<MaterialIndices> iter = materialIndices.iterator(); + while (iter.hasNext()) { + MaterialIndices matIdx = iter.next(); + ShortBuffer indexBuffer = matIdx.getIndexBuffer(); + Material mat = matIdx.getMaterial(); + mat.setMaterialParameters(gl); + if (parent.hasTexcoords() && mat.getMap_Kd().length() > 0) { + Texture texture = parent.getTexture(mat.getMap_Kd()); + texture.setTextureParameters(gl); + } + + gl.glDrawElements(gl.GL_TRIANGLES, + indexBuffer.capacity(), + gl.GL_UNSIGNED_SHORT, + indexBuffer); + } + } + + public String toString() { + return "Group[" + + "name=" + name + + "]"; + } +} diff --git a/opengl/java/android/opengl/Material.java b/opengl/java/android/opengl/Material.java new file mode 100644 index 0000000..60a3e72 --- /dev/null +++ b/opengl/java/android/opengl/Material.java @@ -0,0 +1,120 @@ +/* + * Copyright (C) 2006 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.io.DataInputStream; +import java.io.IOException; +import javax.microedition.khronos.opengles.GL10; + +/** + * {@hide} + */ +public class Material { + + private Object3D parent; + private String name; + private String map_kd; + private float[] ka = new float[4]; + private float[] kd = new float[4]; + private float[] ks = new float[4]; + private float ns; + private int illum; + private float d; + + private static float[] black = { 0.0f, 0.0f, 0.0f, 1.0f }; + + public Material(Object3D parent) { + this.parent = parent; + } + + public String getName() { + return name; + } + + public String getMap_Kd() { + return map_kd; + } + + public void setMaterialParameters(GL10 gl) { + gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT, kd, 0); + gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_DIFFUSE, kd, 0); + gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_SPECULAR, ks, 0); + gl.glMaterialf(gl.GL_FRONT_AND_BACK, gl.GL_SHININESS, + Math.min(Math.max(ns, 0), 128)); + +// if (illum == 0) { +// gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT, kd, 0); +// } else { +// gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT, ka, 0); +// gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_DIFFUSE, kd, 0); +// } + +// if (illum > 1) { +// gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_SPECULAR, ks, 0); +// gl.glMaterialf(gl.GL_FRONT_AND_BACK, gl.GL_SHININESS, +// Math.min(Math.max(ns, 0), 128)); +// } else { +// gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_SPECULAR, black, 0); +// } + } + + public void load(DataInputStream dis) throws IOException { + dis.readInt(); // name length + this.name = dis.readUTF(); + + dis.readInt(); // map_kdLength + this.map_kd = dis.readUTF(); + + if (parent.hasTexcoords() && map_kd.length() > 0) { + parent.loadTexture(map_kd); + } + + this.ka[0] = dis.readFloat(); + this.ka[1] = dis.readFloat(); + this.ka[2] = dis.readFloat(); + this.ka[3] = dis.readFloat(); + + this.kd[0] = dis.readFloat(); + this.kd[1] = dis.readFloat(); + this.kd[2] = dis.readFloat(); + this.kd[3] = dis.readFloat(); + + this.ks[0] = dis.readFloat(); + this.ks[1] = dis.readFloat(); + this.ks[2] = dis.readFloat(); + this.ks[3] = dis.readFloat(); + + this.ns = dis.readFloat(); + this.illum = dis.readInt(); + this.d = dis.readFloat(); + } + + public String toString() { + return "Material[" + + "name=\"" + name + "\"," + + "ka={" + ka[0] + "," + ka[1] + "," + ka[2] + "}," + + "kd={" + kd[0] + "," + kd[1] + "," + kd[2] + "}," + + "ks={" + ks[0] + "," + ks[1] + "," + ks[2] + "}," + + "ns=" + ns + "," + + "map_kd=\"" + + (map_kd == null ? "" : map_kd) + + "\"," + + "illum=" + illum + "," + + "d=" + d + + "]"; + } +} diff --git a/opengl/java/android/opengl/Matrix.java b/opengl/java/android/opengl/Matrix.java new file mode 100644 index 0000000..13ba36e --- /dev/null +++ b/opengl/java/android/opengl/Matrix.java @@ -0,0 +1,585 @@ +/* + * 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; + +/** + * Matrix math utilities. These methods operate on OpenGL ES format + * matrices and vectors stored in float arrays. + * + * Matrices are 4 x 4 column-vector matrices stored in column-major + * order: + * <pre> + * m[offset + 0] m[offset + 4] m[offset + 8] m[offset + 12] + * m[offset + 1] m[offset + 5] m[offset + 9] m[offset + 13] + * m[offset + 2] m[offset + 6] m[offset + 10] m[offset + 14] + * m[offset + 3] m[offset + 7] m[offset + 11] m[offset + 15] + * </pre> + * + * Vectors are 4 row x 1 column column-vectors stored in order: + * <pre> + * v[offset + 0] + * v[offset + 1] + * v[offset + 2] + * v[offset + 3] + * </pre> + * + */ +public class Matrix { + /** + * Multiply two 4x4 matrices together and store the result in a third 4x4 + * matrix. In matrix notation: result = lhs x rhs. Due to the way + * matrix multiplication works, the result matrix will have the same + * effect as first multiplying by the rhs matrix, then multiplying by + * the lhs matrix. This is the opposite of what you might expect. + * + * The same float array may be passed for result, lhs, and/or rhs. However, + * the result element values are undefined if the result elements overlap + * either the lhs or rhs elements. + * + * @param result The float array that holds the result. + * @param resultOffset The offset into the result array where the result is + * stored. + * @param lhs The float array that holds the left-hand-side matrix. + * @param lhsOffset The offset into the lhs array where the lhs is stored + * @param rhs The float array that holds the right-hand-side matrix. + * @param rhsOffset The offset into the rhs array where the rhs is stored. + * + * @throws IllegalArgumentException if result, lhs, or rhs are null, or if + * resultOffset + 16 > result.length or lhsOffset + 16 > lhs.length or + * rhsOffset + 16 > rhs.length. + */ + public static native void multiplyMM(float[] result, int resultOffset, + float[] lhs, int lhsOffset, float[] rhs, int rhsOffset); + + /** + * Multiply a 4 element vector by a 4x4 matrix and store the result in a 4 + * element column vector. In matrix notation: result = lhs x rhs + * + * The same float array may be passed for resultVec, lhsMat, and/or rhsVec. + * However, the resultVec element values are undefined if the resultVec + * elements overlap either the lhsMat or rhsVec elements. + * + * @param resultVec The float array that holds the result vector. + * @param resultVecOffset The offset into the result array where the result + * vector is stored. + * @param lhsMat The float array that holds the left-hand-side matrix. + * @param lhsMatOffset The offset into the lhs array where the lhs is stored + * @param rhsVec The float array that holds the right-hand-side vector. + * @param rhsVecOffset The offset into the rhs vector where the rhs vector + * is stored. + * + * @throws IllegalArgumentException if resultVec, lhsMat, + * or rhsVec are null, or if resultVecOffset + 4 > resultVec.length + * or lhsMatOffset + 16 > lhsMat.length or + * rhsVecOffset + 4 > rhsVec.length. + */ + public static native void multiplyMV(float[] resultVec, + int resultVecOffset, float[] lhsMat, int lhsMatOffset, + float[] rhsVec, int rhsVecOffset); + + /** + * Transposes a 4 x 4 matrix. + * + * @param mTrans the array that holds the output inverted matrix + * @param mTransOffset an offset into mInv where the inverted matrix is + * stored. + * @param m the input array + * @param mOffset an offset into m where the matrix is stored. + */ + public static void transposeM(float[] mTrans, int mTransOffset, float[] m, + int mOffset) { + for (int i = 0; i < 4; i++) { + int mBase = i * 4 + mOffset; + mTrans[i + mTransOffset] = m[mBase]; + mTrans[i + 4 + mTransOffset] = m[mBase + 1]; + mTrans[i + 8 + mTransOffset] = m[mBase + 2]; + mTrans[i + 12 + mTransOffset] = m[mBase + 3]; + } + } + + /** + * Inverts a 4 x 4 matrix. + * + * @param mInv the array that holds the output inverted matrix + * @param mInvOffset an offset into mInv where the inverted matrix is + * stored. + * @param m the input array + * @param mOffset an offset into m where the matrix is stored. + * @return true if the matrix could be inverted, false if it could not. + */ + public static boolean invertM(float[] mInv, int mInvOffset, float[] m, + int mOffset) { + // Invert a 4 x 4 matrix using Cramer's Rule + + // array of transpose source matrix + float[] src = new float[16]; + + // transpose matrix + transposeM(src, 0, m, mOffset); + + // temp array for pairs + float[] tmp = new float[12]; + + // calculate pairs for first 8 elements (cofactors) + tmp[0] = src[10] * src[15]; + tmp[1] = src[11] * src[14]; + tmp[2] = src[9] * src[15]; + tmp[3] = src[11] * src[13]; + tmp[4] = src[9] * src[14]; + tmp[5] = src[10] * src[13]; + tmp[6] = src[8] * src[15]; + tmp[7] = src[11] * src[12]; + tmp[8] = src[8] * src[14]; + tmp[9] = src[10] * src[12]; + tmp[10] = src[8] * src[13]; + tmp[11] = src[9] * src[12]; + + // Holds the destination matrix while we're building it up. + float[] dst = new float[16]; + + // calculate first 8 elements (cofactors) + dst[0] = tmp[0] * src[5] + tmp[3] * src[6] + tmp[4] * src[7]; + dst[0] -= tmp[1] * src[5] + tmp[2] * src[6] + tmp[5] * src[7]; + dst[1] = tmp[1] * src[4] + tmp[6] * src[6] + tmp[9] * src[7]; + dst[1] -= tmp[0] * src[4] + tmp[7] * src[6] + tmp[8] * src[7]; + dst[2] = tmp[2] * src[4] + tmp[7] * src[5] + tmp[10] * src[7]; + dst[2] -= tmp[3] * src[4] + tmp[6] * src[5] + tmp[11] * src[7]; + dst[3] = tmp[5] * src[4] + tmp[8] * src[5] + tmp[11] * src[6]; + dst[3] -= tmp[4] * src[4] + tmp[9] * src[5] + tmp[10] * src[6]; + dst[4] = tmp[1] * src[1] + tmp[2] * src[2] + tmp[5] * src[3]; + dst[4] -= tmp[0] * src[1] + tmp[3] * src[2] + tmp[4] * src[3]; + dst[5] = tmp[0] * src[0] + tmp[7] * src[2] + tmp[8] * src[3]; + dst[5] -= tmp[1] * src[0] + tmp[6] * src[2] + tmp[9] * src[3]; + dst[6] = tmp[3] * src[0] + tmp[6] * src[1] + tmp[11] * src[3]; + dst[6] -= tmp[2] * src[0] + tmp[7] * src[1] + tmp[10] * src[3]; + dst[7] = tmp[4] * src[0] + tmp[9] * src[1] + tmp[10] * src[2]; + dst[7] -= tmp[5] * src[0] + tmp[8] * src[1] + tmp[11] * src[2]; + + // calculate pairs for second 8 elements (cofactors) + tmp[0] = src[2] * src[7]; + tmp[1] = src[3] * src[6]; + tmp[2] = src[1] * src[7]; + tmp[3] = src[3] * src[5]; + tmp[4] = src[1] * src[6]; + tmp[5] = src[2] * src[5]; + tmp[6] = src[0] * src[7]; + tmp[7] = src[3] * src[4]; + tmp[8] = src[0] * src[6]; + tmp[9] = src[2] * src[4]; + tmp[10] = src[0] * src[5]; + tmp[11] = src[1] * src[4]; + + // calculate second 8 elements (cofactors) + dst[8] = tmp[0] * src[13] + tmp[3] * src[14] + tmp[4] * src[15]; + dst[8] -= tmp[1] * src[13] + tmp[2] * src[14] + tmp[5] * src[15]; + dst[9] = tmp[1] * src[12] + tmp[6] * src[14] + tmp[9] * src[15]; + dst[9] -= tmp[0] * src[12] + tmp[7] * src[14] + tmp[8] * src[15]; + dst[10] = tmp[2] * src[12] + tmp[7] * src[13] + tmp[10] * src[15]; + dst[10] -= tmp[3] * src[12] + tmp[6] * src[13] + tmp[11] * src[15]; + dst[11] = tmp[5] * src[12] + tmp[8] * src[13] + tmp[11] * src[14]; + dst[11] -= tmp[4] * src[12] + tmp[9] * src[13] + tmp[10] * src[14]; + dst[12] = tmp[2] * src[10] + tmp[5] * src[11] + tmp[1] * src[9]; + dst[12] -= tmp[4] * src[11] + tmp[0] * src[9] + tmp[3] * src[10]; + dst[13] = tmp[8] * src[11] + tmp[0] * src[8] + tmp[7] * src[10]; + dst[13] -= tmp[6] * src[10] + tmp[9] * src[11] + tmp[1] * src[8]; + dst[14] = tmp[6] * src[9] + tmp[11] * src[11] + tmp[3] * src[8]; + dst[14] -= tmp[10] * src[11] + tmp[2] * src[8] + tmp[7] * src[9]; + dst[15] = tmp[10] * src[10] + tmp[4] * src[8] + tmp[9] * src[9]; + dst[15] -= tmp[8] * src[9] + tmp[11] * src[10] + tmp[5] * src[8]; + + // calculate determinant + float det = + src[0] * dst[0] + src[1] * dst[1] + src[2] * dst[2] + src[3] + * dst[3]; + + if (det == 0.0f) { + + } + + // calculate matrix inverse + det = 1 / det; + for (int j = 0; j < 16; j++) + mInv[j + mInvOffset] = dst[j] * det; + + return true; + } + + /** + * Computes an orthographic projection matrix. + * + * @param m returns the result + * @param mOffset + * @param left + * @param right + * @param bottom + * @param top + * @param near + * @param far + */ + public static void orthoM(float[] m, int mOffset, + float left, float right, float bottom, float top, + float near, float far) { + if (left == right) { + throw new IllegalArgumentException("left == right"); + } + if (bottom == top) { + throw new IllegalArgumentException("bottom == top"); + } + if (near == far) { + throw new IllegalArgumentException("near == far"); + } + + final float r_width = 1.0f / (right - left); + final float r_height = 1.0f / (top - bottom); + final float r_depth = 1.0f / (far - near); + final float x = 2.0f * (r_width); + final float y = 2.0f * (r_height); + final float z = -2.0f * (r_depth); + final float tx = -(right + left) * r_width; + final float ty = -(top + bottom) * r_height; + final float tz = -(far + near) * r_depth; + m[mOffset + 0] = x; + m[mOffset + 5] = y; + m[mOffset +10] = z; + m[mOffset +12] = tx; + m[mOffset +13] = ty; + m[mOffset +14] = tz; + m[mOffset +15] = 1.0f; + m[mOffset + 1] = 0.0f; + m[mOffset + 2] = 0.0f; + m[mOffset + 3] = 0.0f; + m[mOffset + 4] = 0.0f; + m[mOffset + 6] = 0.0f; + m[mOffset + 7] = 0.0f; + m[mOffset + 8] = 0.0f; + m[mOffset + 9] = 0.0f; + m[mOffset + 11] = 0.0f; + } + + + /** + * Define a projection matrix in terms of six clip planes + * @param m the float array that holds the perspective matrix + * @param offset the offset into float array m where the perspective + * matrix data is written + * @param left + * @param right + * @param bottom + * @param top + * @param near + * @param far + */ + + public static void frustumM(float[] m, int offset, + float left, float right, float bottom, float top, + float near, float far) { + if (left == right) { + throw new IllegalArgumentException("left == right"); + } + if (top == bottom) { + throw new IllegalArgumentException("top == bottom"); + } + if (near == far) { + throw new IllegalArgumentException("near == far"); + } + if (near <= 0.0f) { + throw new IllegalArgumentException("near <= 0.0f"); + } + if (far <= 0.0f) { + throw new IllegalArgumentException("far <= 0.0f"); + } + final float r_width = 1.0f / (right - left); + final float r_height = 1.0f / (top - bottom); + final float r_depth = 1.0f / (near - far); + final float x = 2.0f * (near * r_width); + final float y = 2.0f * (near * r_height); + final float A = 2.0f * ((right + left) * r_width); + final float B = (top + bottom) * r_height; + final float C = (far + near) * r_depth; + final float D = 2.0f * (far * near * r_depth); + m[offset + 0] = x; + m[offset + 5] = y; + m[offset + 8] = A; + m[offset + 9] = B; + m[offset + 10] = C; + m[offset + 14] = D; + m[offset + 11] = -1.0f; + m[offset + 1] = 0.0f; + m[offset + 2] = 0.0f; + m[offset + 3] = 0.0f; + m[offset + 4] = 0.0f; + m[offset + 6] = 0.0f; + m[offset + 7] = 0.0f; + m[offset + 12] = 0.0f; + m[offset + 13] = 0.0f; + m[offset + 15] = 0.0f; + } + + /** + * Computes the length of a vector + * + * @param x x coordinate of a vector + * @param y y coordinate of a vector + * @param z z coordinate of a vector + * @return the length of a vector + */ + public static float length(float x, float y, float z) { + return (float) Math.sqrt(x * x + y * y + z * z); + } + + /** + * Sets matrix m to the identity matrix. + * @param sm returns the result + * @param smOffset index into sm where the result matrix starts + */ + public static void setIdentityM(float[] sm, int smOffset) { + for (int i=0 ; i<16 ; i++) { + sm[smOffset + i] = 0; + } + for(int i = 0; i < 16; i += 5) { + sm[smOffset + i] = 1.0f; + } + } + + /** + * Scales matrix m by x, y, and z, putting the result in sm + * @param sm returns the result + * @param smOffset index into sm where the result matrix starts + * @param m source matrix + * @param mOffset index into m where the source matrix starts + * @param x scale factor x + * @param y scale factor y + * @param z scale factor z + */ + public static void scaleM(float[] sm, int smOffset, + float[] m, int mOffset, + float x, float y, float z) { + for (int i=0 ; i<4 ; i++) { + int smi = smOffset + i; + int mi = mOffset + i; + sm[ smi] = m[ mi] * x; + sm[ 4 + smi] = m[ 4 + mi] * y; + sm[ 8 + smi] = m[ 8 + mi] * z; + sm[12 + smi] = m[12 + mi]; + } + } + + /** + * Scales matrix m in place by sx, sy, and sz + * @param m matrix to scale + * @param mOffset index into m where the matrix starts + * @param x scale factor x + * @param y scale factor y + * @param z scale factor z + */ + public static void scaleM(float[] m, int mOffset, + float x, float y, float z) { + for (int i=0 ; i<4 ; i++) { + int mi = mOffset + i; + m[ mi] *= x; + m[ 4 + mi] *= y; + m[ 8 + mi] *= z; + } + } + + /** + * Translates matrix m by x, y, and z, putting the result in tm + * @param tm returns the result + * @param tmOffset index into sm where the result matrix starts + * @param m source matrix + * @param mOffset index into m where the source matrix starts + * @param x translation factor x + * @param y translation factor y + * @param z translation factor z + */ + public static void translateM(float[] tm, int tmOffset, + float[] m, int mOffset, + float x, float y, float z) { + for (int i=0 ; i<12 ; i++) { + tm[tmOffset + i] = m[mOffset + i]; + } + for (int i=0 ; i<4 ; i++) { + int tmi = tmOffset + i; + int mi = mOffset + i; + tm[12 + tmi] = m[mi] * x + m[4 + mi] * y + m[8 + mi] * z + + m[12 + mi]; + } + } + + /** + * Translates matrix m by x, y, and z in place. + * @param m matrix + * @param mOffset index into m where the matrix starts + * @param x translation factor x + * @param y translation factor y + * @param z translation factor z + */ + public static void translateM( + float[] m, int mOffset, + float x, float y, float z) { + for (int i=0 ; i<4 ; i++) { + int mi = mOffset + i; + m[12 + mi] += m[mi] * x + m[4 + mi] * y + m[8 + mi] * z; + } + } + + /** + * Rotates matrix m by angle a (in degrees) around the axis (x, y, z) + * @param rm returns the result + * @param rmOffset index into rm where the result matrix starts + * @param m source matrix + * @param mOffset index into m where the source matrix starts + * @param a angle to rotate in degrees + * @param x scale factor x + * @param y scale factor y + * @param z scale factor z + */ + public static void rotateM(float[] rm, int rmOffset, + float[] m, int mOffset, + float a, float x, float y, float z) { + float[] r = new float[16]; + setRotateM(r, 0, a, x, y, z); + multiplyMM(rm, rmOffset, m, mOffset, r, 0); + } + + /** + * Rotates matrix m in place by angle a (in degrees) + * around the axis (x, y, z) + * @param m source matrix + * @param mOffset index into m where the matrix starts + * @param a angle to rotate in degrees + * @param x scale factor x + * @param y scale factor y + * @param z scale factor z + */ + public static void rotateM(float[] m, int mOffset, + float a, float x, float y, float z) { + float[] temp = new float[32]; + setRotateM(temp, 0, a, x, y, z); + multiplyMM(temp, 16, m, mOffset, temp, 0); + System.arraycopy(temp, 16, m, mOffset, 16); + } + + /** + * Rotates matrix m by angle a (in degrees) around the axis (x, y, z) + * @param rm returns the result + * @param rmOffset index into rm where the result matrix starts + * @param a angle to rotate in degrees + * @param x scale factor x + * @param y scale factor y + * @param z scale factor z + */ + public static void setRotateM(float[] rm, int rmOffset, + float a, float x, float y, float z) { + rm[rmOffset + 3] = 0; + rm[rmOffset + 7] = 0; + rm[rmOffset + 11]= 0; + rm[rmOffset + 12]= 0; + rm[rmOffset + 13]= 0; + rm[rmOffset + 14]= 0; + rm[rmOffset + 15]= 1; + a *= (float) (Math.PI / 180.0f); + float s = (float) Math.sin(a); + float c = (float) Math.cos(a); + if (1.0f == x && 0.0f == y && 0.0f == z) { + rm[rmOffset + 5] = c; rm[rmOffset + 10]= c; + rm[rmOffset + 6] = s; rm[rmOffset + 9] = -s; + rm[rmOffset + 1] = 0; rm[rmOffset + 2] = 0; + rm[rmOffset + 4] = 0; rm[rmOffset + 8] = 0; + rm[rmOffset + 0] = 1; + } else if (0.0f == x && 1.0f == y && 0.0f == z) { + rm[rmOffset + 0] = c; rm[rmOffset + 10]= c; + rm[rmOffset + 8] = s; rm[rmOffset + 2] = -s; + rm[rmOffset + 1] = 0; rm[rmOffset + 4] = 0; + rm[rmOffset + 6] = 0; rm[rmOffset + 9] = 0; + rm[rmOffset + 5] = 1; + } else if (0.0f == x && 0.0f == y && 1.0f == z) { + rm[rmOffset + 0] = c; rm[rmOffset + 5] = c; + rm[rmOffset + 1] = s; rm[rmOffset + 4] = -s; + rm[rmOffset + 2] = 0; rm[rmOffset + 6] = 0; + rm[rmOffset + 8] = 0; rm[rmOffset + 9] = 0; + rm[rmOffset + 10]= 1; + } else { + float len = length(x, y, z); + if (1.0f != len) { + float recipLen = 1.0f / len; + x *= recipLen; + y *= recipLen; + z *= recipLen; + } + float nc = 1.0f - c; + float xy = x * y; + float yz = y * z; + float zx = z * x; + float xs = x * s; + float ys = y * s; + float zs = z * s; + rm[rmOffset + 0] = x*x*nc + c; + rm[rmOffset + 4] = xy*nc - zs; + rm[rmOffset + 8] = zx*nc + ys; + rm[rmOffset + 1] = xy*nc + zs; + rm[rmOffset + 5] = y*y*nc + c; + rm[rmOffset + 9] = yz*nc - xs; + rm[rmOffset + 2] = zx*nc - ys; + rm[rmOffset + 6] = yz*nc + xs; + rm[rmOffset + 10] = z*z*nc + c; + } + } + + /** + * Converts Euler angles to a rotation matrix + * @param rm returns the result + * @param rmOffset index into rm where the result matrix starts + * @param x angle of rotation, in degrees + * @param y angle of rotation, in degrees + * @param z angle of rotation, in degrees + */ + public static void setRotateEulerM(float[] rm, int rmOffset, + float x, float y, float z) { + x *= (float) (Math.PI / 180.0f); + y *= (float) (Math.PI / 180.0f); + z *= (float) (Math.PI / 180.0f); + float cx = (float) Math.cos(x); + float sx = (float) Math.sin(x); + float cy = (float) Math.cos(y); + float sy = (float) Math.sin(y); + float cz = (float) Math.cos(z); + float sz = (float) Math.sin(z); + float cxsy = cx * sy; + float sxsy = sx * sy; + + rm[rmOffset + 0] = cy * cz; + rm[rmOffset + 1] = -cy * sz; + rm[rmOffset + 2] = sy; + rm[rmOffset + 3] = 0.0f; + + rm[rmOffset + 4] = cxsy * cz + cx * sz; + rm[rmOffset + 5] = -cxsy * sz + cx * cz; + rm[rmOffset + 6] = -sx * cy; + rm[rmOffset + 7] = 0.0f; + + rm[rmOffset + 8] = -sxsy * cz + sx * sz; + rm[rmOffset + 9] = sxsy * sz + sx * cz; + rm[rmOffset + 10] = cx * cy; + rm[rmOffset + 11] = 0.0f; + + rm[rmOffset + 12] = 0.0f; + rm[rmOffset + 13] = 0.0f; + rm[rmOffset + 14] = 0.0f; + rm[rmOffset + 15] = 1.0f; + } +} diff --git a/opengl/java/android/opengl/Object3D.java b/opengl/java/android/opengl/Object3D.java new file mode 100644 index 0000000..340c6a7 --- /dev/null +++ b/opengl/java/android/opengl/Object3D.java @@ -0,0 +1,245 @@ +/* + * Copyright (C) 2006 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.io.BufferedReader; +import java.io.DataInputStream; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.IntBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import javax.microedition.khronos.opengles.*; + +/** + * {@hide} + */ +public abstract class Object3D { + + private boolean mHasTexcoords = false; + + private float mBoundsMinX = Float.MAX_VALUE; + private float mBoundsMaxX = Float.MIN_VALUE; + private float mBoundsMinY = Float.MAX_VALUE; + private float mBoundsMaxY = Float.MIN_VALUE; + private float mBoundsMinZ = Float.MAX_VALUE; + private float mBoundsMaxZ = Float.MIN_VALUE; + + private IntBuffer mVertexBuffer; + private IntBuffer mNormalBuffer; + private IntBuffer mTexcoordBuffer; + + // All groups, by name + private Map<String, Group> mGroups; + + // All materials, by name + private Map<String, Material> mMaterials; + + // All texture maps, by name + private Map<String, Texture> mTextures; + + public Object3D() { + reset(); + } + + /** + * Override this method with an implementation that contructs + * and InputStream from the given filename. For example, if the + * source files are to be retrieved using an AssetManager, + * the implementation would use AssetManager.load() to + * get the input stream. + */ + public abstract InputStream readFile(String filename) throws IOException; + + private void reset() { + mVertexBuffer = mNormalBuffer = mTexcoordBuffer = null; + + mGroups = new HashMap<String,Group>(); + mMaterials = new HashMap<String,Material>(); + mTextures = new HashMap<String,Texture>(); + } + + public Material getMaterial(String name) { + Material mat = mMaterials.get(name); + return mat; + } + + public Texture getTexture(String name) { + return mTextures.get(name); + } + + public IntBuffer getVertexBuffer() { + return mVertexBuffer; + } + + public IntBuffer getNormalBuffer() { + return mNormalBuffer; + } + + public IntBuffer getTexcoordBuffer() { + return mTexcoordBuffer; + } + + public int getNumTriangles() { + int numTriangles = 0; + Iterator<Group> iter = mGroups.values().iterator(); + while (iter.hasNext()) { + numTriangles += iter.next().getNumTriangles(); + } + return numTriangles; + } + + public boolean hasTexcoords() { + return mHasTexcoords; + } + + public float getBoundsMinX() { + return mBoundsMinX; + } + + public float getBoundsMaxX() { + return mBoundsMaxX; + } + + public float getBoundsMinY() { + return mBoundsMinY; + } + + public float getBoundsMaxY() { + return mBoundsMaxY; + } + + public float getBoundsMinZ() { + return mBoundsMinZ; + } + + public float getBoundsMaxZ() { + return mBoundsMaxZ; + } + + public void loadTexture(String name) throws IOException { + InputStream is = readFile(name + ".raw"); + Texture texture = new Texture(is); + mTextures.put(name, texture); + } + + private static void verifyByte(DataInputStream dis, int b) + throws IOException { + int x = dis.read() & 0xff; + if (x != b) { + throw new RuntimeException("Bad byte: " + + x + + " (expected " + b + ")"); + } + } + + public void load(String filename) throws IOException { + reset(); + + DataInputStream dis = new DataInputStream(readFile(filename)); + verifyByte(dis, 'g' + 128); + verifyByte(dis, 'l'); + verifyByte(dis, 'e'); + verifyByte(dis, 's'); + + int numTuples = dis.readInt(); + + this.mBoundsMinX = dis.readFloat(); + this.mBoundsMaxX = dis.readFloat(); + this.mBoundsMinY = dis.readFloat(); + this.mBoundsMaxY = dis.readFloat(); + this.mBoundsMinZ = dis.readFloat(); + this.mBoundsMaxZ = dis.readFloat(); + + this.mHasTexcoords = dis.readInt() == 1; + + int intsPerTuple = mHasTexcoords ? 8 : 6; + int numInts = numTuples*intsPerTuple; + + int len = 4*numTuples*(mHasTexcoords ? 8 : 6); + + byte[] tmp = new byte[len]; + int tidx = 0; + while (tidx < len) { + tidx += dis.read(tmp, tidx, len - tidx); + } + if (ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) { + for (int i = 0; i < len; i += 4) { + byte tmp0 = tmp[i]; + byte tmp1 = tmp[i + 1]; + byte tmp2 = tmp[i + 2]; + byte tmp3 = tmp[i + 3]; + tmp[i] = tmp3; + tmp[i + 1] = tmp2; + tmp[i + 2] = tmp1; + tmp[i + 3] = tmp0; + } + } + + ByteBuffer allbb = ByteBuffer.allocateDirect(len); + allbb.order(ByteOrder.nativeOrder()); + allbb.put(tmp); + + allbb.position(0); + allbb.limit(4*3*numTuples); + ByteBuffer vbb = allbb.slice(); + this.mVertexBuffer = vbb.asIntBuffer(); + mVertexBuffer.position(0); + + if (mHasTexcoords) { + allbb.position(allbb.limit()); + allbb.limit(allbb.position() + 4*2*numTuples); + ByteBuffer tbb = allbb.slice(); + this.mTexcoordBuffer = tbb.asIntBuffer(); + mTexcoordBuffer.position(0); + } + + allbb.position(allbb.limit()); + allbb.limit(allbb.position() + 4*3*numTuples); + ByteBuffer nbb = allbb.slice(); + this.mNormalBuffer = nbb.asIntBuffer(); + mNormalBuffer.position(0); + + int numMaterials = dis.readInt(); + for (int i = 0; i < numMaterials; i++) { + Material mat = new Material(this); + mat.load(dis); + mMaterials.put(mat.getName(), mat); + } + + int numGroups = dis.readInt(); + for (int i = 0; i < numGroups; i++) { + Group g = new Group(this); + g.load(dis); + mGroups.put(g.getName(), g); + } + } + + public void draw(GL10 gl) { + Iterator<Group> iter = mGroups.values().iterator(); + while (iter.hasNext()) { + iter.next().draw(gl); + } + } +} + diff --git a/opengl/java/android/opengl/Texture.java b/opengl/java/android/opengl/Texture.java new file mode 100644 index 0000000..dcd894d --- /dev/null +++ b/opengl/java/android/opengl/Texture.java @@ -0,0 +1,135 @@ +/* + * Copyright (C) 2006 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.io.InputStream; +import java.io.IOException; +import java.nio.Buffer; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import javax.microedition.khronos.opengles.GL10; + +import android.content.res.AssetManager; + +/** + * {@hide} + */ +public class Texture { + + private int width, height, bpp; + private ByteBuffer data; + private int name = -1; + + // Texture maps have the following format. All integers + // are 16 bits, high byte first. Pixels are in 5/6/5 + // RGB format, low byte first. + // + // width + // height + // pixel (0, 0) + // pixel (1, 0) + // ... + // pixel (width - 1, height - 1) + + private int readInt16(InputStream is) throws IOException { + return is.read() | (is.read() << 8); + } + + public Texture(InputStream is) throws IOException { + this.width = readInt16(is); + this.height = readInt16(is); + this.bpp = 2; + + int npixels = width*height; + int nbytes = npixels*bpp; + byte[] arr = new byte[nbytes]; + + int idx = 0; + while (idx < nbytes) { + int nread = is.read(arr, idx, nbytes - idx); + idx += nread; + } + + if (ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) { + // Swap pairs of bytes on big-endian platforms + for (int i = 0; i < npixels; i++) { + int j = i*2; + int k = j + 1; + + byte tmp = arr[j]; + arr[j] = arr[k]; + arr[k] = tmp; + } + } + + this.data = ByteBuffer.allocateDirect(arr.length); + this.data.order(ByteOrder.nativeOrder()); + data.put(arr); + data.position(0); + } + + private int loadTexture(GL10 gl, + int textureUnit, + int minFilter, int magFilter, + int wrapS, int wrapT, + int mode, + int width, int height, + int dataType, + Buffer data) { + int[] texture = new int[1]; + gl.glGenTextures(1, texture, 0); + + gl.glEnable(gl.GL_TEXTURE_2D); + gl.glClientActiveTexture(textureUnit); + gl.glBindTexture(gl.GL_TEXTURE_2D, texture[0]); + gl.glTexParameterf(gl.GL_TEXTURE_2D, + gl.GL_TEXTURE_MIN_FILTER, + minFilter); + gl.glTexParameterf(gl.GL_TEXTURE_2D, + gl.GL_TEXTURE_MAG_FILTER, + magFilter); + gl.glTexParameterf(gl.GL_TEXTURE_2D, + gl.GL_TEXTURE_WRAP_S, + wrapS); + gl.glTexParameterf(gl.GL_TEXTURE_2D, + gl.GL_TEXTURE_WRAP_T, + wrapT); + gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, mode); + + gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, + width, height, + 0, gl.GL_RGB, dataType, + data); + + return texture[0]; + } + + public void setTextureParameters(GL10 gl) { + if (name < 0) { + name = loadTexture(gl, + gl.GL_TEXTURE0, + gl.GL_NEAREST, gl.GL_NEAREST, + gl.GL_REPEAT, gl.GL_REPEAT, + gl.GL_MODULATE, + width, height, + gl.GL_UNSIGNED_SHORT_5_6_5, + data); + } + + gl.glBindTexture(gl.GL_TEXTURE_2D, name); + } +} diff --git a/opengl/java/android/opengl/Visibility.java b/opengl/java/android/opengl/Visibility.java new file mode 100644 index 0000000..40e446f --- /dev/null +++ b/opengl/java/android/opengl/Visibility.java @@ -0,0 +1,123 @@ +/* + * 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; + +/** + * A collection of utility methods for computing the visibility of triangle + * meshes. + * + */ +public class Visibility { + /** + * Test whether a given triangle mesh is visible on the screen. The mesh + * is specified as an indexed triangle list. + * + * @param ws the world space to screen space transform matrix, as an OpenGL + * column matrix. + * @param wsOffset an index into the ws array where the data starts. + * @param positions the vertex positions (x, y, z). + * @param positionsOffset the index in the positions array where the data + * starts. + * @param indices the indices of the triangle list. The indices are + * expressed as chars because they are unsigned 16-bit values. + * @param indicesOffset the index in the indices array where the index data + * starts. + * @param indexCount the number of indices in use. Typically a multiple of + * three. If not a multiple of three, the remaining one or two indices will + * be ignored. + * @return 2 if all of the mesh is visible, 1 if some part of the mesh is + * visible, 0 if no part is visible. + * + * @throws IllegalArgumentException if ws is null, wsOffset < 0, + * positions is null, positionsOffset < 0, indices is null, + * indicesOffset < 0, indicesOffset > indices.length - indexCount + */ + public static native int visibilityTest(float[] ws, int wsOffset, + float[] positions, int positionsOffset, char[] indices, + int indicesOffset, int indexCount); + + /** + * Given an OpenGL ES ModelView-Projection matrix (which implicitly + * describes a frustum) and a list of spheres, determine which spheres + * intersect the frustum. + * <p> + * A ModelView-Projection matrix can be computed by multiplying the + * a Projection matrix by the a ModelView matrix (in that order.). There + * are several possible ways to obtain the current ModelView and + * Projection matrices. The most generally applicable way is to keep + * track of the current matrices in application code. If that is not + * convenient, there are two optional OpenGL ES extensions which may + * be used to read the current matrices from OpenGL ES: + * <ul> + * <li>GL10Ext.glQueryMatrixxOES + * <li>GL11.GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES and + * GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES + * </ul> + * The problem with reading back the matrices is that your application + * will only work with devices that support the extension(s) that + * it uses. + * <p> + * A frustum is a six-sided truncated pyramid that defines the portion of + * world space that is visible in the view. + * <p> + * Spheres are described as four floating point values: x, y, z, and r, in + * world-space coordinates. R is the radius of the sphere. + * <p> + * @param mvp a float array containing the mode-view-projection matrix + * @param mvpOffset The offset of the mvp data within the mvp array. + * @param spheres a float array containing the sphere data. + * @param spheresOffset an offset into the sphere array where the sphere + * data starts + * @param spheresCount the number of spheres to cull. + * @param results an integer array containing the indices of the spheres + * that are either contained entirely within or intersect the frustum. + * @param resultsOffset an offset into the results array where the results + * start. + * @param resultsCapacity the number of array elements available for storing + * results. + * @return the number of spheres that intersected the frustum. Can be + * larger than resultsCapacity, in which case only the first resultsCapacity + * results are written into the results array. + * + * @throws IllegalArgumentException if mvp is null, mvpOffset < 0, + * mvpOffset > mvp.length - 16, spheres is null, spheresOffset < 0, + * spheresOffset > spheres.length - sphereCount, + * results is null, resultsOffset < 0, resultsOffset > results.length - + * resultsCapacity. + */ + public static native int frustumCullSpheres(float[] mvp, int mvpOffset, + float[] spheres, int spheresOffset, int spheresCount, + int[] results, int resultsOffset, int resultsCapacity); + + /** + * Compute a bounding sphere for a set of points. It is approximately the + * minimal bounding sphere of an axis-aligned box that bounds the points. + * + * @param positions positions in x, y, z triples + * @param positionsOffset offset into positions array + * @param positionsCount number of position triples to process + * @param sphere array containing the output as (x, y, z, r) + * @param sphereOffset offset where the sphere data will be written + * + * @throws IllegalArgumentException if positions is null, + * positionsOffset < 0, positionsOffset > positions.length - positionsCount, + * sphere is null, sphereOffset < 0, sphereOffset > sphere.length - 4. + */ + public static native void computeBoundingSphere(float[] positions, + int positionsOffset, int positionsCount, float[] sphere, + int sphereOffset); +} diff --git a/opengl/java/android/opengl/package.html b/opengl/java/android/opengl/package.html new file mode 100644 index 0000000..7175b33 --- /dev/null +++ b/opengl/java/android/opengl/package.html @@ -0,0 +1,5 @@ +<HTML> +<BODY> +Provides OpenGL utilities. +</BODY> +</HTML> diff --git a/opengl/java/com/google/android/gles_jni/EGLConfigImpl.java b/opengl/java/com/google/android/gles_jni/EGLConfigImpl.java new file mode 100644 index 0000000..b03392e --- /dev/null +++ b/opengl/java/com/google/android/gles_jni/EGLConfigImpl.java @@ -0,0 +1,32 @@ +/* +** +** Copyright 2006, 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 com.google.android.gles_jni; + +import javax.microedition.khronos.egl.*; + +public class EGLConfigImpl extends EGLConfig { + private int mEGLConfig; + + EGLConfigImpl(int config) { + mEGLConfig = config; + } + + int get() { + return mEGLConfig; + } +} diff --git a/opengl/java/com/google/android/gles_jni/EGLContextImpl.java b/opengl/java/com/google/android/gles_jni/EGLContextImpl.java new file mode 100644 index 0000000..f10c02f --- /dev/null +++ b/opengl/java/com/google/android/gles_jni/EGLContextImpl.java @@ -0,0 +1,36 @@ +/* +** +** Copyright 2006, 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 com.google.android.gles_jni; + +import javax.microedition.khronos.egl.*; +import javax.microedition.khronos.opengles.GL; + +public class EGLContextImpl extends EGLContext { + private GLImpl mGLContext; + int mEGLContext; + + public EGLContextImpl(int ctx) { + mEGLContext = ctx; + mGLContext = new GLImpl(); + } + + @Override + public GL getGL() { + return mGLContext; + } +} diff --git a/opengl/java/com/google/android/gles_jni/EGLDisplayImpl.java b/opengl/java/com/google/android/gles_jni/EGLDisplayImpl.java new file mode 100644 index 0000000..6321632 --- /dev/null +++ b/opengl/java/com/google/android/gles_jni/EGLDisplayImpl.java @@ -0,0 +1,28 @@ +/* +** +** Copyright 2006, 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 com.google.android.gles_jni; + +import javax.microedition.khronos.egl.*; + +public class EGLDisplayImpl extends EGLDisplay { + int mEGLDisplay; + + public EGLDisplayImpl(int dpy) { + mEGLDisplay = dpy; + } +} diff --git a/opengl/java/com/google/android/gles_jni/EGLImpl.java b/opengl/java/com/google/android/gles_jni/EGLImpl.java new file mode 100644 index 0000000..a667e8d --- /dev/null +++ b/opengl/java/com/google/android/gles_jni/EGLImpl.java @@ -0,0 +1,118 @@ +/* +** +** Copyright 2006, 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 com.google.android.gles_jni; + +import javax.microedition.khronos.egl.*; + +import android.view.Surface; +import android.view.SurfaceView; +import android.view.SurfaceHolder; +import android.view.View; + +public class EGLImpl implements EGL10 { + private EGLContextImpl mContext = new EGLContextImpl(-1); + private EGLDisplayImpl mDisplay = new EGLDisplayImpl(-1); + private EGLSurfaceImpl mSurface = new EGLSurfaceImpl(-1); + + public native boolean eglInitialize(EGLDisplay display, int[] major_minor); + public native boolean eglQueryContext(EGLDisplay display, EGLContext context, int attribute, int[] value); + public native boolean eglQuerySurface(EGLDisplay display, EGLSurface surface, int attribute, int[] value); + public native boolean eglChooseConfig(EGLDisplay display, int[] attrib_list, EGLConfig[] configs, int config_size, int[] num_config); + public native boolean eglGetConfigAttrib(EGLDisplay display, EGLConfig config, int attribute, int[] value); + public native boolean eglGetConfigs(EGLDisplay display, EGLConfig[] configs, int config_size, int[] num_config); + public native int eglGetError(); + public native boolean eglDestroyContext(EGLDisplay display, EGLContext context); + public native boolean eglDestroySurface(EGLDisplay display, EGLSurface surface); + public native boolean eglMakeCurrent(EGLDisplay display, EGLSurface draw, EGLSurface read, EGLContext context); + public native String eglQueryString(EGLDisplay display, int name); + public native boolean eglSwapBuffers(EGLDisplay display, EGLSurface surface); + public native boolean eglTerminate(EGLDisplay display); + public native boolean eglCopyBuffers(EGLDisplay display, EGLSurface surface, Object native_pixmap); + public native boolean eglWaitGL(); + public native boolean eglWaitNative(int engine, Object bindTarget); + + public EGLContext eglCreateContext(EGLDisplay display, EGLConfig config, EGLContext share_context, int[] attrib_list) { + return new EGLContextImpl( _eglCreateContext(display, config, share_context, attrib_list) ); + } + + public EGLSurface eglCreatePbufferSurface(EGLDisplay display, EGLConfig config, int[] attrib_list) { + return new EGLSurfaceImpl( _eglCreatePbufferSurface(display, config, attrib_list) ); + } + + public EGLSurface eglCreatePixmapSurface(EGLDisplay display, EGLConfig config, Object native_pixmap, int[] attrib_list) { + EGLSurfaceImpl sur = new EGLSurfaceImpl(); + _eglCreatePixmapSurface(sur, display, config, native_pixmap, attrib_list); + return sur; + } + + public EGLSurface eglCreateWindowSurface(EGLDisplay display, EGLConfig config, Object native_window, int[] attrib_list) { + Surface sur; + if (native_window instanceof SurfaceView) { + SurfaceView surfaceView = (SurfaceView)native_window; + sur = surfaceView.getHolder().getSurface(); + } else if (native_window instanceof SurfaceHolder) { + SurfaceHolder holder = (SurfaceHolder)native_window; + sur = holder.getSurface(); + } else { + throw new java.lang.UnsupportedOperationException( + "eglCreateWindowSurface() can only be called with an instance of " + + "SurfaceView or SurfaceHolder at the moment, this will be fixed later."); + } + return new EGLSurfaceImpl( _eglCreateWindowSurface(display, config, sur, attrib_list) ); + } + + public synchronized EGLDisplay eglGetDisplay(Object native_display) { + int value = _eglGetDisplay(native_display); + if (mDisplay.mEGLDisplay != value) + mDisplay = new EGLDisplayImpl(value); + return mDisplay; + } + + public synchronized EGLContext eglGetCurrentContext() { + int value = _eglGetCurrentContext(); + if (mContext.mEGLContext != value) + mContext = new EGLContextImpl(value); + return mContext; + } + + public synchronized EGLDisplay eglGetCurrentDisplay() { + int value = _eglGetCurrentDisplay(); + if (mDisplay.mEGLDisplay != value) + mDisplay = new EGLDisplayImpl(value); + return mDisplay; + } + + public synchronized EGLSurface eglGetCurrentSurface(int readdraw) { + int value = _eglGetCurrentSurface(readdraw); + if (mSurface.mEGLSurface != value) + mSurface = new EGLSurfaceImpl(value); + return mSurface; + } + + private native int _eglCreateContext(EGLDisplay display, EGLConfig config, EGLContext share_context, int[] attrib_list); + private native int _eglCreatePbufferSurface(EGLDisplay display, EGLConfig config, int[] attrib_list); + private native void _eglCreatePixmapSurface(EGLSurface sur, EGLDisplay display, EGLConfig config, Object native_pixmap, int[] attrib_list); + private native int _eglCreateWindowSurface(EGLDisplay display, EGLConfig config, Object native_window, int[] attrib_list); + private native int _eglGetDisplay(Object native_display); + private native int _eglGetCurrentContext(); + private native int _eglGetCurrentDisplay(); + private native int _eglGetCurrentSurface(int readdraw); + + native private static void _nativeClassInit(); + static { _nativeClassInit(); } +} diff --git a/opengl/java/com/google/android/gles_jni/EGLSurfaceImpl.java b/opengl/java/com/google/android/gles_jni/EGLSurfaceImpl.java new file mode 100644 index 0000000..66cc200 --- /dev/null +++ b/opengl/java/com/google/android/gles_jni/EGLSurfaceImpl.java @@ -0,0 +1,33 @@ +/* +** +** Copyright 2006, 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 com.google.android.gles_jni; + +import javax.microedition.khronos.egl.*; + +public class EGLSurfaceImpl extends EGLSurface { + int mEGLSurface; + private int mNativePixelRef; + public EGLSurfaceImpl() { + mEGLSurface = 0; + mNativePixelRef = 0; + } + public EGLSurfaceImpl(int surface) { + mEGLSurface = surface; + mNativePixelRef = 0; + } +} diff --git a/opengl/java/com/google/android/gles_jni/GLImpl.java b/opengl/java/com/google/android/gles_jni/GLImpl.java new file mode 100644 index 0000000..47f07d0 --- /dev/null +++ b/opengl/java/com/google/android/gles_jni/GLImpl.java @@ -0,0 +1,2115 @@ +/* //device/java/android/com/google/android/gles_jni/GLImpl.java +** +** Copyright 2006, 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 + +package com.google.android.gles_jni; + +import java.nio.Buffer; +import javax.microedition.khronos.opengles.GL10; +import javax.microedition.khronos.opengles.GL10Ext; +import javax.microedition.khronos.opengles.GL11; +import javax.microedition.khronos.opengles.GL11Ext; +import javax.microedition.khronos.opengles.GL11ExtensionPack; + +public class GLImpl implements GL10, GL10Ext, GL11, GL11Ext, GL11ExtensionPack { + + // Private accessors for native code + + native private static void _nativeClassInit(); + static { + _nativeClassInit(); + } + + Buffer _colorPointer = null; + Buffer _normalPointer = null; + Buffer _texCoordPointer = null; + Buffer _vertexPointer = null; + + public GLImpl() { + } + + public void glGetPointerv(int pname, java.nio.Buffer[] params) { + throw new UnsupportedOperationException("glGetPointerv"); + } + + // C function void glActiveTexture ( GLenum texture ) + + public native void glActiveTexture( + int texture + ); + + // C function void glAlphaFunc ( GLenum func, GLclampf ref ) + + public native void glAlphaFunc( + int func, + float ref + ); + + // C function void glAlphaFuncx ( GLenum func, GLclampx ref ) + + public native void glAlphaFuncx( + int func, + int ref + ); + + // C function void glBindTexture ( GLenum target, GLuint texture ) + + public native void glBindTexture( + int target, + int texture + ); + + // C function void glBlendFunc ( GLenum sfactor, GLenum dfactor ) + + public native void glBlendFunc( + int sfactor, + int dfactor + ); + + // C function void glClear ( GLbitfield mask ) + + public native void glClear( + int mask + ); + + // C function void glClearColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) + + public native void glClearColor( + float red, + float green, + float blue, + float alpha + ); + + // C function void glClearColorx ( GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha ) + + public native void glClearColorx( + int red, + int green, + int blue, + int alpha + ); + + // C function void glClearDepthf ( GLclampf depth ) + + public native void glClearDepthf( + float depth + ); + + // C function void glClearDepthx ( GLclampx depth ) + + public native void glClearDepthx( + int depth + ); + + // C function void glClearStencil ( GLint s ) + + public native void glClearStencil( + int s + ); + + // C function void glClientActiveTexture ( GLenum texture ) + + public native void glClientActiveTexture( + int texture + ); + + // C function void glColor4f ( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) + + public native void glColor4f( + float red, + float green, + float blue, + float alpha + ); + + // C function void glColor4x ( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) + + public native void glColor4x( + int red, + int green, + int blue, + int alpha + ); + + // C function void glColorMask ( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) + + public native void glColorMask( + boolean red, + boolean green, + boolean blue, + boolean alpha + ); + + // C function void glColorPointer ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) + + private native void glColorPointerBounds( + int size, + int type, + int stride, + java.nio.Buffer pointer, + int remaining + ); + + public void glColorPointer( + int size, + int type, + int stride, + java.nio.Buffer pointer + ) { + if ((size == 4) && + ((type == GL_FLOAT) || + (type == GL_UNSIGNED_BYTE) || + (type == GL_FIXED)) && + (stride >= 0)) { + _colorPointer = pointer; + } + glColorPointerBounds( + size, + type, + stride, + pointer, + pointer.remaining() + ); + } + + // C function void glCompressedTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data ) + + public native void glCompressedTexImage2D( + int target, + int level, + int internalformat, + int width, + int height, + int border, + int imageSize, + java.nio.Buffer data + ); + + // C function void glCompressedTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data ) + + public native void glCompressedTexSubImage2D( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int imageSize, + java.nio.Buffer data + ); + + // C function void glCopyTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) + + public native void glCopyTexImage2D( + int target, + int level, + int internalformat, + int x, + int y, + int width, + int height, + int border + ); + + // C function void glCopyTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) + + public native void glCopyTexSubImage2D( + int target, + int level, + int xoffset, + int yoffset, + int x, + int y, + int width, + int height + ); + + // C function void glCullFace ( GLenum mode ) + + public native void glCullFace( + int mode + ); + + // C function void glDeleteTextures ( GLsizei n, const GLuint *textures ) + + public native void glDeleteTextures( + int n, + int[] textures, + int offset + ); + + // C function void glDeleteTextures ( GLsizei n, const GLuint *textures ) + + public native void glDeleteTextures( + int n, + java.nio.IntBuffer textures + ); + + // C function void glDepthFunc ( GLenum func ) + + public native void glDepthFunc( + int func + ); + + // C function void glDepthMask ( GLboolean flag ) + + public native void glDepthMask( + boolean flag + ); + + // C function void glDepthRangef ( GLclampf zNear, GLclampf zFar ) + + public native void glDepthRangef( + float zNear, + float zFar + ); + + // C function void glDepthRangex ( GLclampx zNear, GLclampx zFar ) + + public native void glDepthRangex( + int zNear, + int zFar + ); + + // C function void glDisable ( GLenum cap ) + + public native void glDisable( + int cap + ); + + // C function void glDisableClientState ( GLenum array ) + + public native void glDisableClientState( + int array + ); + + // C function void glDrawArrays ( GLenum mode, GLint first, GLsizei count ) + + public native void glDrawArrays( + int mode, + int first, + int count + ); + + // C function void glDrawElements ( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices ) + + public native void glDrawElements( + int mode, + int count, + int type, + java.nio.Buffer indices + ); + + // C function void glEnable ( GLenum cap ) + + public native void glEnable( + int cap + ); + + // C function void glEnableClientState ( GLenum array ) + + public native void glEnableClientState( + int array + ); + + // C function void glFinish ( void ) + + public native void glFinish( + ); + + // C function void glFlush ( void ) + + public native void glFlush( + ); + + // C function void glFogf ( GLenum pname, GLfloat param ) + + public native void glFogf( + int pname, + float param + ); + + // C function void glFogfv ( GLenum pname, const GLfloat *params ) + + public native void glFogfv( + int pname, + float[] params, + int offset + ); + + // C function void glFogfv ( GLenum pname, const GLfloat *params ) + + public native void glFogfv( + int pname, + java.nio.FloatBuffer params + ); + + // C function void glFogx ( GLenum pname, GLfixed param ) + + public native void glFogx( + int pname, + int param + ); + + // C function void glFogxv ( GLenum pname, const GLfixed *params ) + + public native void glFogxv( + int pname, + int[] params, + int offset + ); + + // C function void glFogxv ( GLenum pname, const GLfixed *params ) + + public native void glFogxv( + int pname, + java.nio.IntBuffer params + ); + + // C function void glFrontFace ( GLenum mode ) + + public native void glFrontFace( + int mode + ); + + // C function void glFrustumf ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) + + public native void glFrustumf( + float left, + float right, + float bottom, + float top, + float zNear, + float zFar + ); + + // C function void glFrustumx ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) + + public native void glFrustumx( + int left, + int right, + int bottom, + int top, + int zNear, + int zFar + ); + + // C function void glGenTextures ( GLsizei n, GLuint *textures ) + + public native void glGenTextures( + int n, + int[] textures, + int offset + ); + + // C function void glGenTextures ( GLsizei n, GLuint *textures ) + + public native void glGenTextures( + int n, + java.nio.IntBuffer textures + ); + + // C function GLenum glGetError ( void ) + + public native int glGetError( + ); + + // C function void glGetIntegerv ( GLenum pname, GLint *params ) + + public native void glGetIntegerv( + int pname, + int[] params, + int offset + ); + + // C function void glGetIntegerv ( GLenum pname, GLint *params ) + + public native void glGetIntegerv( + int pname, + java.nio.IntBuffer params + ); + + // C function const GLubyte * glGetString ( GLenum name ) + + public native String _glGetString( + int name + ); + + public String glGetString( + int name + ) { + String returnValue; + returnValue = _glGetString( + name + ); + return returnValue; + } + + // C function void glHint ( GLenum target, GLenum mode ) + + public native void glHint( + int target, + int mode + ); + + // C function void glLightModelf ( GLenum pname, GLfloat param ) + + public native void glLightModelf( + int pname, + float param + ); + + // C function void glLightModelfv ( GLenum pname, const GLfloat *params ) + + public native void glLightModelfv( + int pname, + float[] params, + int offset + ); + + // C function void glLightModelfv ( GLenum pname, const GLfloat *params ) + + public native void glLightModelfv( + int pname, + java.nio.FloatBuffer params + ); + + // C function void glLightModelx ( GLenum pname, GLfixed param ) + + public native void glLightModelx( + int pname, + int param + ); + + // C function void glLightModelxv ( GLenum pname, const GLfixed *params ) + + public native void glLightModelxv( + int pname, + int[] params, + int offset + ); + + // C function void glLightModelxv ( GLenum pname, const GLfixed *params ) + + public native void glLightModelxv( + int pname, + java.nio.IntBuffer params + ); + + // C function void glLightf ( GLenum light, GLenum pname, GLfloat param ) + + public native void glLightf( + int light, + int pname, + float param + ); + + // C function void glLightfv ( GLenum light, GLenum pname, const GLfloat *params ) + + public native void glLightfv( + int light, + int pname, + float[] params, + int offset + ); + + // C function void glLightfv ( GLenum light, GLenum pname, const GLfloat *params ) + + public native void glLightfv( + int light, + int pname, + java.nio.FloatBuffer params + ); + + // C function void glLightx ( GLenum light, GLenum pname, GLfixed param ) + + public native void glLightx( + int light, + int pname, + int param + ); + + // C function void glLightxv ( GLenum light, GLenum pname, const GLfixed *params ) + + public native void glLightxv( + int light, + int pname, + int[] params, + int offset + ); + + // C function void glLightxv ( GLenum light, GLenum pname, const GLfixed *params ) + + public native void glLightxv( + int light, + int pname, + java.nio.IntBuffer params + ); + + // C function void glLineWidth ( GLfloat width ) + + public native void glLineWidth( + float width + ); + + // C function void glLineWidthx ( GLfixed width ) + + public native void glLineWidthx( + int width + ); + + // C function void glLoadIdentity ( void ) + + public native void glLoadIdentity( + ); + + // C function void glLoadMatrixf ( const GLfloat *m ) + + public native void glLoadMatrixf( + float[] m, + int offset + ); + + // C function void glLoadMatrixf ( const GLfloat *m ) + + public native void glLoadMatrixf( + java.nio.FloatBuffer m + ); + + // C function void glLoadMatrixx ( const GLfixed *m ) + + public native void glLoadMatrixx( + int[] m, + int offset + ); + + // C function void glLoadMatrixx ( const GLfixed *m ) + + public native void glLoadMatrixx( + java.nio.IntBuffer m + ); + + // C function void glLogicOp ( GLenum opcode ) + + public native void glLogicOp( + int opcode + ); + + // C function void glMaterialf ( GLenum face, GLenum pname, GLfloat param ) + + public native void glMaterialf( + int face, + int pname, + float param + ); + + // C function void glMaterialfv ( GLenum face, GLenum pname, const GLfloat *params ) + + public native void glMaterialfv( + int face, + int pname, + float[] params, + int offset + ); + + // C function void glMaterialfv ( GLenum face, GLenum pname, const GLfloat *params ) + + public native void glMaterialfv( + int face, + int pname, + java.nio.FloatBuffer params + ); + + // C function void glMaterialx ( GLenum face, GLenum pname, GLfixed param ) + + public native void glMaterialx( + int face, + int pname, + int param + ); + + // C function void glMaterialxv ( GLenum face, GLenum pname, const GLfixed *params ) + + public native void glMaterialxv( + int face, + int pname, + int[] params, + int offset + ); + + // C function void glMaterialxv ( GLenum face, GLenum pname, const GLfixed *params ) + + public native void glMaterialxv( + int face, + int pname, + java.nio.IntBuffer params + ); + + // C function void glMatrixMode ( GLenum mode ) + + public native void glMatrixMode( + int mode + ); + + // C function void glMultMatrixf ( const GLfloat *m ) + + public native void glMultMatrixf( + float[] m, + int offset + ); + + // C function void glMultMatrixf ( const GLfloat *m ) + + public native void glMultMatrixf( + java.nio.FloatBuffer m + ); + + // C function void glMultMatrixx ( const GLfixed *m ) + + public native void glMultMatrixx( + int[] m, + int offset + ); + + // C function void glMultMatrixx ( const GLfixed *m ) + + public native void glMultMatrixx( + java.nio.IntBuffer m + ); + + // C function void glMultiTexCoord4f ( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q ) + + public native void glMultiTexCoord4f( + int target, + float s, + float t, + float r, + float q + ); + + // C function void glMultiTexCoord4x ( GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q ) + + public native void glMultiTexCoord4x( + int target, + int s, + int t, + int r, + int q + ); + + // C function void glNormal3f ( GLfloat nx, GLfloat ny, GLfloat nz ) + + public native void glNormal3f( + float nx, + float ny, + float nz + ); + + // C function void glNormal3x ( GLfixed nx, GLfixed ny, GLfixed nz ) + + public native void glNormal3x( + int nx, + int ny, + int nz + ); + + // C function void glNormalPointer ( GLenum type, GLsizei stride, const GLvoid *pointer ) + + private native void glNormalPointerBounds( + int type, + int stride, + java.nio.Buffer pointer, + int remaining + ); + + public void glNormalPointer( + int type, + int stride, + java.nio.Buffer pointer + ) { + if (((type == GL_FLOAT) || + (type == GL_BYTE) || + (type == GL_SHORT) || + (type == GL_FIXED)) && + (stride >= 0)) { + _normalPointer = pointer; + } + glNormalPointerBounds( + type, + stride, + pointer, + pointer.remaining() + ); + } + + // C function void glOrthof ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) + + public native void glOrthof( + float left, + float right, + float bottom, + float top, + float zNear, + float zFar + ); + + // C function void glOrthox ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) + + public native void glOrthox( + int left, + int right, + int bottom, + int top, + int zNear, + int zFar + ); + + // C function void glPixelStorei ( GLenum pname, GLint param ) + + public native void glPixelStorei( + int pname, + int param + ); + + // C function void glPointSize ( GLfloat size ) + + public native void glPointSize( + float size + ); + + // C function void glPointSizex ( GLfixed size ) + + public native void glPointSizex( + int size + ); + + // C function void glPolygonOffset ( GLfloat factor, GLfloat units ) + + public native void glPolygonOffset( + float factor, + float units + ); + + // C function void glPolygonOffsetx ( GLfixed factor, GLfixed units ) + + public native void glPolygonOffsetx( + int factor, + int units + ); + + // C function void glPopMatrix ( void ) + + public native void glPopMatrix( + ); + + // C function void glPushMatrix ( void ) + + public native void glPushMatrix( + ); + + // C function void glReadPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) + + public native void glReadPixels( + int x, + int y, + int width, + int height, + int format, + int type, + java.nio.Buffer pixels + ); + + // C function void glRotatef ( GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) + + public native void glRotatef( + float angle, + float x, + float y, + float z + ); + + // C function void glRotatex ( GLfixed angle, GLfixed x, GLfixed y, GLfixed z ) + + public native void glRotatex( + int angle, + int x, + int y, + int z + ); + + // C function void glSampleCoverage ( GLclampf value, GLboolean invert ) + + public native void glSampleCoverage( + float value, + boolean invert + ); + + // C function void glSampleCoveragex ( GLclampx value, GLboolean invert ) + + public native void glSampleCoveragex( + int value, + boolean invert + ); + + // C function void glScalef ( GLfloat x, GLfloat y, GLfloat z ) + + public native void glScalef( + float x, + float y, + float z + ); + + // C function void glScalex ( GLfixed x, GLfixed y, GLfixed z ) + + public native void glScalex( + int x, + int y, + int z + ); + + // C function void glScissor ( GLint x, GLint y, GLsizei width, GLsizei height ) + + public native void glScissor( + int x, + int y, + int width, + int height + ); + + // C function void glShadeModel ( GLenum mode ) + + public native void glShadeModel( + int mode + ); + + // C function void glStencilFunc ( GLenum func, GLint ref, GLuint mask ) + + public native void glStencilFunc( + int func, + int ref, + int mask + ); + + // C function void glStencilMask ( GLuint mask ) + + public native void glStencilMask( + int mask + ); + + // C function void glStencilOp ( GLenum fail, GLenum zfail, GLenum zpass ) + + public native void glStencilOp( + int fail, + int zfail, + int zpass + ); + + // C function void glTexCoordPointer ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) + + private native void glTexCoordPointerBounds( + int size, + int type, + int stride, + java.nio.Buffer pointer, + int remaining + ); + + public void glTexCoordPointer( + int size, + int type, + int stride, + java.nio.Buffer pointer + ) { + if (((size == 2) || + (size == 3) || + (size == 4)) && + ((type == GL_FLOAT) || + (type == GL_BYTE) || + (type == GL_SHORT) || + (type == GL_FIXED)) && + (stride >= 0)) { + _texCoordPointer = pointer; + } + glTexCoordPointerBounds( + size, + type, + stride, + pointer, + pointer.remaining() + ); + } + + // C function void glTexEnvf ( GLenum target, GLenum pname, GLfloat param ) + + public native void glTexEnvf( + int target, + int pname, + float param + ); + + // C function void glTexEnvfv ( GLenum target, GLenum pname, const GLfloat *params ) + + public native void glTexEnvfv( + int target, + int pname, + float[] params, + int offset + ); + + // C function void glTexEnvfv ( GLenum target, GLenum pname, const GLfloat *params ) + + public native void glTexEnvfv( + int target, + int pname, + java.nio.FloatBuffer params + ); + + // C function void glTexEnvx ( GLenum target, GLenum pname, GLfixed param ) + + public native void glTexEnvx( + int target, + int pname, + int param + ); + + // C function void glTexEnvxv ( GLenum target, GLenum pname, const GLfixed *params ) + + public native void glTexEnvxv( + int target, + int pname, + int[] params, + int offset + ); + + // C function void glTexEnvxv ( GLenum target, GLenum pname, const GLfixed *params ) + + public native void glTexEnvxv( + int target, + int pname, + java.nio.IntBuffer params + ); + + // C function void glTexImage2D ( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) + + public native void glTexImage2D( + int target, + int level, + int internalformat, + int width, + int height, + int border, + int format, + int type, + java.nio.Buffer pixels + ); + + // C function void glTexParameterf ( GLenum target, GLenum pname, GLfloat param ) + + public native void glTexParameterf( + int target, + int pname, + float param + ); + + // C function void glTexParameterx ( GLenum target, GLenum pname, GLfixed param ) + + public native void glTexParameterx( + int target, + int pname, + int param + ); + + // C function void glTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels ) + + public native void glTexSubImage2D( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + java.nio.Buffer pixels + ); + + // C function void glTranslatef ( GLfloat x, GLfloat y, GLfloat z ) + + public native void glTranslatef( + float x, + float y, + float z + ); + + // C function void glTranslatex ( GLfixed x, GLfixed y, GLfixed z ) + + public native void glTranslatex( + int x, + int y, + int z + ); + + // C function void glVertexPointer ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) + + private native void glVertexPointerBounds( + int size, + int type, + int stride, + java.nio.Buffer pointer, + int remaining + ); + + public void glVertexPointer( + int size, + int type, + int stride, + java.nio.Buffer pointer + ) { + if (((size == 2) || + (size == 3) || + (size == 4)) && + ((type == GL_FLOAT) || + (type == GL_BYTE) || + (type == GL_SHORT) || + (type == GL_FIXED)) && + (stride >= 0)) { + _vertexPointer = pointer; + } + glVertexPointerBounds( + size, + type, + stride, + pointer, + pointer.remaining() + ); + } + + // C function void glViewport ( GLint x, GLint y, GLsizei width, GLsizei height ) + + public native void glViewport( + int x, + int y, + int width, + int height + ); + + // C function GLbitfield glQueryMatrixxOES ( GLfixed *mantissa, GLint *exponent ) + + public native int glQueryMatrixxOES( + int[] mantissa, + int mantissaOffset, + int[] exponent, + int exponentOffset + ); + + // C function GLbitfield glQueryMatrixxOES ( GLfixed *mantissa, GLint *exponent ) + + public native int glQueryMatrixxOES( + java.nio.IntBuffer mantissa, + java.nio.IntBuffer exponent + ); + + // C function void glBindBuffer ( GLenum target, GLuint buffer ) + + public native void glBindBuffer( + int target, + int buffer + ); + + // C function void glBufferData ( GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage ) + + public native void glBufferData( + int target, + int size, + java.nio.Buffer data, + int usage + ); + + // C function void glBufferSubData ( GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data ) + + public native void glBufferSubData( + int target, + int offset, + int size, + java.nio.Buffer data + ); + + // C function void glClipPlanef ( GLenum plane, const GLfloat *equation ) + + public native void glClipPlanef( + int plane, + float[] equation, + int offset + ); + + // C function void glClipPlanef ( GLenum plane, const GLfloat *equation ) + + public native void glClipPlanef( + int plane, + java.nio.FloatBuffer equation + ); + + // C function void glClipPlanex ( GLenum plane, const GLfixed *equation ) + + public native void glClipPlanex( + int plane, + int[] equation, + int offset + ); + + // C function void glClipPlanex ( GLenum plane, const GLfixed *equation ) + + public native void glClipPlanex( + int plane, + java.nio.IntBuffer equation + ); + + // C function void glColor4ub ( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha ) + + public native void glColor4ub( + byte red, + byte green, + byte blue, + byte alpha + ); + + // C function void glColorPointer ( GLint size, GLenum type, GLsizei stride, GLint offset ) + + public native void glColorPointer( + int size, + int type, + int stride, + int offset + ); + + // C function void glDeleteBuffers ( GLsizei n, const GLuint *buffers ) + + public native void glDeleteBuffers( + int n, + int[] buffers, + int offset + ); + + // C function void glDeleteBuffers ( GLsizei n, const GLuint *buffers ) + + public native void glDeleteBuffers( + int n, + java.nio.IntBuffer buffers + ); + + // C function void glDrawElements ( GLenum mode, GLsizei count, GLenum type, GLint offset ) + + public native void glDrawElements( + int mode, + int count, + int type, + int offset + ); + + // C function void glGenBuffers ( GLsizei n, GLuint *buffers ) + + public native void glGenBuffers( + int n, + int[] buffers, + int offset + ); + + // C function void glGenBuffers ( GLsizei n, GLuint *buffers ) + + public native void glGenBuffers( + int n, + java.nio.IntBuffer buffers + ); + + // C function void glGetBooleanv ( GLenum pname, GLboolean *params ) + + public native void glGetBooleanv( + int pname, + boolean[] params, + int offset + ); + + // C function void glGetBooleanv ( GLenum pname, GLboolean *params ) + + public native void glGetBooleanv( + int pname, + java.nio.IntBuffer params + ); + + // C function void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params ) + + public native void glGetBufferParameteriv( + int target, + int pname, + int[] params, + int offset + ); + + // C function void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params ) + + public native void glGetBufferParameteriv( + int target, + int pname, + java.nio.IntBuffer params + ); + + // C function void glGetClipPlanef ( GLenum pname, GLfloat *eqn ) + + public native void glGetClipPlanef( + int pname, + float[] eqn, + int offset + ); + + // C function void glGetClipPlanef ( GLenum pname, GLfloat *eqn ) + + public native void glGetClipPlanef( + int pname, + java.nio.FloatBuffer eqn + ); + + // C function void glGetClipPlanex ( GLenum pname, GLfixed *eqn ) + + public native void glGetClipPlanex( + int pname, + int[] eqn, + int offset + ); + + // C function void glGetClipPlanex ( GLenum pname, GLfixed *eqn ) + + public native void glGetClipPlanex( + int pname, + java.nio.IntBuffer eqn + ); + + // C function void glGetFixedv ( GLenum pname, GLfixed *params ) + + public native void glGetFixedv( + int pname, + int[] params, + int offset + ); + + // C function void glGetFixedv ( GLenum pname, GLfixed *params ) + + public native void glGetFixedv( + int pname, + java.nio.IntBuffer params + ); + + // C function void glGetFloatv ( GLenum pname, GLfloat *params ) + + public native void glGetFloatv( + int pname, + float[] params, + int offset + ); + + // C function void glGetFloatv ( GLenum pname, GLfloat *params ) + + public native void glGetFloatv( + int pname, + java.nio.FloatBuffer params + ); + + // C function void glGetLightfv ( GLenum light, GLenum pname, GLfloat *params ) + + public native void glGetLightfv( + int light, + int pname, + float[] params, + int offset + ); + + // C function void glGetLightfv ( GLenum light, GLenum pname, GLfloat *params ) + + public native void glGetLightfv( + int light, + int pname, + java.nio.FloatBuffer params + ); + + // C function void glGetLightxv ( GLenum light, GLenum pname, GLfixed *params ) + + public native void glGetLightxv( + int light, + int pname, + int[] params, + int offset + ); + + // C function void glGetLightxv ( GLenum light, GLenum pname, GLfixed *params ) + + public native void glGetLightxv( + int light, + int pname, + java.nio.IntBuffer params + ); + + // C function void glGetMaterialfv ( GLenum face, GLenum pname, GLfloat *params ) + + public native void glGetMaterialfv( + int face, + int pname, + float[] params, + int offset + ); + + // C function void glGetMaterialfv ( GLenum face, GLenum pname, GLfloat *params ) + + public native void glGetMaterialfv( + int face, + int pname, + java.nio.FloatBuffer params + ); + + // C function void glGetMaterialxv ( GLenum face, GLenum pname, GLfixed *params ) + + public native void glGetMaterialxv( + int face, + int pname, + int[] params, + int offset + ); + + // C function void glGetMaterialxv ( GLenum face, GLenum pname, GLfixed *params ) + + public native void glGetMaterialxv( + int face, + int pname, + java.nio.IntBuffer params + ); + + // C function void glGetTexEnviv ( GLenum env, GLenum pname, GLint *params ) + + public native void glGetTexEnviv( + int env, + int pname, + int[] params, + int offset + ); + + // C function void glGetTexEnviv ( GLenum env, GLenum pname, GLint *params ) + + public native void glGetTexEnviv( + int env, + int pname, + java.nio.IntBuffer params + ); + + // C function void glGetTexEnvxv ( GLenum env, GLenum pname, GLfixed *params ) + + public native void glGetTexEnvxv( + int env, + int pname, + int[] params, + int offset + ); + + // C function void glGetTexEnvxv ( GLenum env, GLenum pname, GLfixed *params ) + + public native void glGetTexEnvxv( + int env, + int pname, + java.nio.IntBuffer params + ); + + // C function void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) + + public native void glGetTexParameterfv( + int target, + int pname, + float[] params, + int offset + ); + + // C function void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) + + public native void glGetTexParameterfv( + int target, + int pname, + java.nio.FloatBuffer params + ); + + // C function void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) + + public native void glGetTexParameteriv( + int target, + int pname, + int[] params, + int offset + ); + + // C function void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) + + public native void glGetTexParameteriv( + int target, + int pname, + java.nio.IntBuffer params + ); + + // C function void glGetTexParameterxv ( GLenum target, GLenum pname, GLfixed *params ) + + public native void glGetTexParameterxv( + int target, + int pname, + int[] params, + int offset + ); + + // C function void glGetTexParameterxv ( GLenum target, GLenum pname, GLfixed *params ) + + public native void glGetTexParameterxv( + int target, + int pname, + java.nio.IntBuffer params + ); + + // C function GLboolean glIsBuffer ( GLuint buffer ) + + public native boolean glIsBuffer( + int buffer + ); + + // C function GLboolean glIsEnabled ( GLenum cap ) + + public native boolean glIsEnabled( + int cap + ); + + // C function GLboolean glIsTexture ( GLuint texture ) + + public native boolean glIsTexture( + int texture + ); + + // C function void glNormalPointer ( GLenum type, GLsizei stride, GLint offset ) + + public native void glNormalPointer( + int type, + int stride, + int offset + ); + + // C function void glPointParameterf ( GLenum pname, GLfloat param ) + + public native void glPointParameterf( + int pname, + float param + ); + + // C function void glPointParameterfv ( GLenum pname, const GLfloat *params ) + + public native void glPointParameterfv( + int pname, + float[] params, + int offset + ); + + // C function void glPointParameterfv ( GLenum pname, const GLfloat *params ) + + public native void glPointParameterfv( + int pname, + java.nio.FloatBuffer params + ); + + // C function void glPointParameterx ( GLenum pname, GLfixed param ) + + public native void glPointParameterx( + int pname, + int param + ); + + // C function void glPointParameterxv ( GLenum pname, const GLfixed *params ) + + public native void glPointParameterxv( + int pname, + int[] params, + int offset + ); + + // C function void glPointParameterxv ( GLenum pname, const GLfixed *params ) + + public native void glPointParameterxv( + int pname, + java.nio.IntBuffer params + ); + + // C function void glPointSizePointerOES ( GLenum type, GLsizei stride, const GLvoid *pointer ) + + public native void glPointSizePointerOES( + int type, + int stride, + java.nio.Buffer pointer + ); + + // C function void glTexCoordPointer ( GLint size, GLenum type, GLsizei stride, GLint offset ) + + public native void glTexCoordPointer( + int size, + int type, + int stride, + int offset + ); + + // C function void glTexEnvi ( GLenum target, GLenum pname, GLint param ) + + public native void glTexEnvi( + int target, + int pname, + int param + ); + + // C function void glTexEnviv ( GLenum target, GLenum pname, const GLint *params ) + + public native void glTexEnviv( + int target, + int pname, + int[] params, + int offset + ); + + // C function void glTexEnviv ( GLenum target, GLenum pname, const GLint *params ) + + public native void glTexEnviv( + int target, + int pname, + java.nio.IntBuffer params + ); + + // C function void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params ) + + public native void glTexParameterfv( + int target, + int pname, + float[] params, + int offset + ); + + // C function void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params ) + + public native void glTexParameterfv( + int target, + int pname, + java.nio.FloatBuffer params + ); + + // C function void glTexParameteri ( GLenum target, GLenum pname, GLint param ) + + public native void glTexParameteri( + int target, + int pname, + int param + ); + + // C function void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params ) + + public native void glTexParameteriv( + int target, + int pname, + int[] params, + int offset + ); + + // C function void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params ) + + public native void glTexParameteriv( + int target, + int pname, + java.nio.IntBuffer params + ); + + // C function void glTexParameterxv ( GLenum target, GLenum pname, const GLfixed *params ) + + public native void glTexParameterxv( + int target, + int pname, + int[] params, + int offset + ); + + // C function void glTexParameterxv ( GLenum target, GLenum pname, const GLfixed *params ) + + public native void glTexParameterxv( + int target, + int pname, + java.nio.IntBuffer params + ); + + // C function void glVertexPointer ( GLint size, GLenum type, GLsizei stride, GLint offset ) + + public native void glVertexPointer( + int size, + int type, + int stride, + int offset + ); + + // C function void glCurrentPaletteMatrixOES ( GLuint matrixpaletteindex ) + + public native void glCurrentPaletteMatrixOES( + int matrixpaletteindex + ); + + // C function void glDrawTexfOES ( GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height ) + + public native void glDrawTexfOES( + float x, + float y, + float z, + float width, + float height + ); + + // C function void glDrawTexfvOES ( const GLfloat *coords ) + + public native void glDrawTexfvOES( + float[] coords, + int offset + ); + + // C function void glDrawTexfvOES ( const GLfloat *coords ) + + public native void glDrawTexfvOES( + java.nio.FloatBuffer coords + ); + + // C function void glDrawTexiOES ( GLint x, GLint y, GLint z, GLint width, GLint height ) + + public native void glDrawTexiOES( + int x, + int y, + int z, + int width, + int height + ); + + // C function void glDrawTexivOES ( const GLint *coords ) + + public native void glDrawTexivOES( + int[] coords, + int offset + ); + + // C function void glDrawTexivOES ( const GLint *coords ) + + public native void glDrawTexivOES( + java.nio.IntBuffer coords + ); + + // C function void glDrawTexsOES ( GLshort x, GLshort y, GLshort z, GLshort width, GLshort height ) + + public native void glDrawTexsOES( + short x, + short y, + short z, + short width, + short height + ); + + // C function void glDrawTexsvOES ( const GLshort *coords ) + + public native void glDrawTexsvOES( + short[] coords, + int offset + ); + + // C function void glDrawTexsvOES ( const GLshort *coords ) + + public native void glDrawTexsvOES( + java.nio.ShortBuffer coords + ); + + // C function void glDrawTexxOES ( GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height ) + + public native void glDrawTexxOES( + int x, + int y, + int z, + int width, + int height + ); + + // C function void glDrawTexxvOES ( const GLfixed *coords ) + + public native void glDrawTexxvOES( + int[] coords, + int offset + ); + + // C function void glDrawTexxvOES ( const GLfixed *coords ) + + public native void glDrawTexxvOES( + java.nio.IntBuffer coords + ); + + // C function void glLoadPaletteFromModelViewMatrixOES ( void ) + + public native void glLoadPaletteFromModelViewMatrixOES( + ); + + // C function void glMatrixIndexPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) + + public native void glMatrixIndexPointerOES( + int size, + int type, + int stride, + java.nio.Buffer pointer + ); + + // C function void glMatrixIndexPointerOES ( GLint size, GLenum type, GLsizei stride, GLint offset ) + + public native void glMatrixIndexPointerOES( + int size, + int type, + int stride, + int offset + ); + + // C function void glWeightPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) + + public native void glWeightPointerOES( + int size, + int type, + int stride, + java.nio.Buffer pointer + ); + + // C function void glWeightPointerOES ( GLint size, GLenum type, GLsizei stride, GLint offset ) + + public native void glWeightPointerOES( + int size, + int type, + int stride, + int offset + ); + + // C function void glBindFramebufferOES ( GLint target, GLint framebuffer ) + + public native void glBindFramebufferOES( + int target, + int framebuffer + ); + + // C function void glBindRenderbufferOES ( GLint target, GLint renderbuffer ) + + public native void glBindRenderbufferOES( + int target, + int renderbuffer + ); + + // C function void glBlendEquation ( GLint mode ) + + public native void glBlendEquation( + int mode + ); + + // C function void glBlendEquationSeparate ( GLint modeRGB, GLint modeAlpha ) + + public native void glBlendEquationSeparate( + int modeRGB, + int modeAlpha + ); + + // C function void glBlendFuncSeparate ( GLint srcRGB, GLint dstRGB, GLint srcAlpha, GLint dstAlpha ) + + public native void glBlendFuncSeparate( + int srcRGB, + int dstRGB, + int srcAlpha, + int dstAlpha + ); + + // C function GLint glCheckFramebufferStatusOES ( GLint target ) + + public native int glCheckFramebufferStatusOES( + int target + ); + + // C function void glDeleteFramebuffersOES ( GLint n, GLint *framebuffers ) + + public native void glDeleteFramebuffersOES( + int n, + int[] framebuffers, + int offset + ); + + // C function void glDeleteFramebuffersOES ( GLint n, GLint *framebuffers ) + + public native void glDeleteFramebuffersOES( + int n, + java.nio.IntBuffer framebuffers + ); + + // C function void glDeleteRenderbuffersOES ( GLint n, GLint *renderbuffers ) + + public native void glDeleteRenderbuffersOES( + int n, + int[] renderbuffers, + int offset + ); + + // C function void glDeleteRenderbuffersOES ( GLint n, GLint *renderbuffers ) + + public native void glDeleteRenderbuffersOES( + int n, + java.nio.IntBuffer renderbuffers + ); + + // C function void glFramebufferRenderbufferOES ( GLint target, GLint attachment, GLint renderbuffertarget, GLint renderbuffer ) + + public native void glFramebufferRenderbufferOES( + int target, + int attachment, + int renderbuffertarget, + int renderbuffer + ); + + // C function void glFramebufferTexture2DOES ( GLint target, GLint attachment, GLint textarget, GLint texture, GLint level ) + + public native void glFramebufferTexture2DOES( + int target, + int attachment, + int textarget, + int texture, + int level + ); + + // C function void glGenerateMipmapOES ( GLint target ) + + public native void glGenerateMipmapOES( + int target + ); + + // C function void glGenFramebuffersOES ( GLint n, GLint *framebuffers ) + + public native void glGenFramebuffersOES( + int n, + int[] framebuffers, + int offset + ); + + // C function void glGenFramebuffersOES ( GLint n, GLint *framebuffers ) + + public native void glGenFramebuffersOES( + int n, + java.nio.IntBuffer framebuffers + ); + + // C function void glGenRenderbuffersOES ( GLint n, GLint *renderbuffers ) + + public native void glGenRenderbuffersOES( + int n, + int[] renderbuffers, + int offset + ); + + // C function void glGenRenderbuffersOES ( GLint n, GLint *renderbuffers ) + + public native void glGenRenderbuffersOES( + int n, + java.nio.IntBuffer renderbuffers + ); + + // C function void glGetFramebufferAttachmentParameterivOES ( GLint target, GLint attachment, GLint pname, GLint *params ) + + public native void glGetFramebufferAttachmentParameterivOES( + int target, + int attachment, + int pname, + int[] params, + int offset + ); + + // C function void glGetFramebufferAttachmentParameterivOES ( GLint target, GLint attachment, GLint pname, GLint *params ) + + public native void glGetFramebufferAttachmentParameterivOES( + int target, + int attachment, + int pname, + java.nio.IntBuffer params + ); + + // C function void glGetRenderbufferParameterivOES ( GLint target, GLint pname, GLint *params ) + + public native void glGetRenderbufferParameterivOES( + int target, + int pname, + int[] params, + int offset + ); + + // C function void glGetRenderbufferParameterivOES ( GLint target, GLint pname, GLint *params ) + + public native void glGetRenderbufferParameterivOES( + int target, + int pname, + java.nio.IntBuffer params + ); + + // C function void glGetTexGenfv ( GLint coord, GLint pname, GLfloat *params ) + + public native void glGetTexGenfv( + int coord, + int pname, + float[] params, + int offset + ); + + // C function void glGetTexGenfv ( GLint coord, GLint pname, GLfloat *params ) + + public native void glGetTexGenfv( + int coord, + int pname, + java.nio.FloatBuffer params + ); + + // C function void glGetTexGeniv ( GLint coord, GLint pname, GLint *params ) + + public native void glGetTexGeniv( + int coord, + int pname, + int[] params, + int offset + ); + + // C function void glGetTexGeniv ( GLint coord, GLint pname, GLint *params ) + + public native void glGetTexGeniv( + int coord, + int pname, + java.nio.IntBuffer params + ); + + // C function void glGetTexGenxv ( GLint coord, GLint pname, GLint *params ) + + public native void glGetTexGenxv( + int coord, + int pname, + int[] params, + int offset + ); + + // C function void glGetTexGenxv ( GLint coord, GLint pname, GLint *params ) + + public native void glGetTexGenxv( + int coord, + int pname, + java.nio.IntBuffer params + ); + + // C function GLboolean glIsFramebufferOES ( GLint framebuffer ) + + public native boolean glIsFramebufferOES( + int framebuffer + ); + + // C function GLboolean glIsRenderbufferOES ( GLint renderbuffer ) + + public native boolean glIsRenderbufferOES( + int renderbuffer + ); + + // C function void glRenderbufferStorageOES ( GLint target, GLint internalformat, GLint width, GLint height ) + + public native void glRenderbufferStorageOES( + int target, + int internalformat, + int width, + int height + ); + + // C function void glTexGenf ( GLint coord, GLint pname, GLfloat param ) + + public native void glTexGenf( + int coord, + int pname, + float param + ); + + // C function void glTexGenfv ( GLint coord, GLint pname, GLfloat *params ) + + public native void glTexGenfv( + int coord, + int pname, + float[] params, + int offset + ); + + // C function void glTexGenfv ( GLint coord, GLint pname, GLfloat *params ) + + public native void glTexGenfv( + int coord, + int pname, + java.nio.FloatBuffer params + ); + + // C function void glTexGeni ( GLint coord, GLint pname, GLint param ) + + public native void glTexGeni( + int coord, + int pname, + int param + ); + + // C function void glTexGeniv ( GLint coord, GLint pname, GLint *params ) + + public native void glTexGeniv( + int coord, + int pname, + int[] params, + int offset + ); + + // C function void glTexGeniv ( GLint coord, GLint pname, GLint *params ) + + public native void glTexGeniv( + int coord, + int pname, + java.nio.IntBuffer params + ); + + // C function void glTexGenx ( GLint coord, GLint pname, GLint param ) + + public native void glTexGenx( + int coord, + int pname, + int param + ); + + // C function void glTexGenxv ( GLint coord, GLint pname, GLint *params ) + + public native void glTexGenxv( + int coord, + int pname, + int[] params, + int offset + ); + + // C function void glTexGenxv ( GLint coord, GLint pname, GLint *params ) + + public native void glTexGenxv( + int coord, + int pname, + java.nio.IntBuffer params + ); + +} diff --git a/opengl/java/javax/microedition/khronos/egl/EGL.java b/opengl/java/javax/microedition/khronos/egl/EGL.java new file mode 100644 index 0000000..b743968 --- /dev/null +++ b/opengl/java/javax/microedition/khronos/egl/EGL.java @@ -0,0 +1,22 @@ +/* +** +** Copyright 2006, 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 javax.microedition.khronos.egl; + +public interface EGL { +} + diff --git a/opengl/java/javax/microedition/khronos/egl/EGL10.java b/opengl/java/javax/microedition/khronos/egl/EGL10.java new file mode 100644 index 0000000..2ae793a --- /dev/null +++ b/opengl/java/javax/microedition/khronos/egl/EGL10.java @@ -0,0 +1,121 @@ +/* + * Copyright (C) 2006 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 javax.microedition.khronos.egl; + +import java.lang.String; + +public interface EGL10 extends EGL { + int EGL_SUCCESS = 0x3000; + int EGL_NOT_INITIALIZED = 0x3001; + int EGL_BAD_ACCESS = 0x3002; + int EGL_BAD_ALLOC = 0x3003; + int EGL_BAD_ATTRIBUTE = 0x3004; + int EGL_BAD_CONFIG = 0x3005; + int EGL_BAD_CONTEXT = 0x3006; + int EGL_BAD_CURRENT_SURFACE = 0x3007; + int EGL_BAD_DISPLAY = 0x3008; + int EGL_BAD_MATCH = 0x3009; + int EGL_BAD_NATIVE_PIXMAP = 0x300A; + int EGL_BAD_NATIVE_WINDOW = 0x300B; + int EGL_BAD_PARAMETER = 0x300C; + int EGL_BAD_SURFACE = 0x300D; + int EGL_BUFFER_SIZE = 0x3020; + int EGL_ALPHA_SIZE = 0x3021; + int EGL_BLUE_SIZE = 0x3022; + int EGL_GREEN_SIZE = 0x3023; + int EGL_RED_SIZE = 0x3024; + int EGL_DEPTH_SIZE = 0x3025; + int EGL_STENCIL_SIZE = 0x3026; + int EGL_CONFIG_CAVEAT = 0x3027; + int EGL_CONFIG_ID = 0x3028; + int EGL_LEVEL = 0x3029; + int EGL_MAX_PBUFFER_HEIGHT = 0x302A; + int EGL_MAX_PBUFFER_PIXELS = 0x302B; + int EGL_MAX_PBUFFER_WIDTH = 0x302C; + int EGL_NATIVE_RENDERABLE = 0x302D; + int EGL_NATIVE_VISUAL_ID = 0x302E; + int EGL_NATIVE_VISUAL_TYPE = 0x302F; + int EGL_SAMPLES = 0x3031; + int EGL_SAMPLE_BUFFERS = 0x3032; + int EGL_SURFACE_TYPE = 0x3033; + int EGL_TRANSPARENT_TYPE = 0x3034; + int EGL_TRANSPARENT_BLUE_VALUE = 0x3035; + int EGL_TRANSPARENT_GREEN_VALUE = 0x3036; + int EGL_TRANSPARENT_RED_VALUE = 0x3037; + int EGL_NONE = 0x3038; + int EGL_LUMINANCE_SIZE = 0x303D; + int EGL_ALPHA_MASK_SIZE = 0x303E; + int EGL_COLOR_BUFFER_TYPE = 0x303F; + int EGL_RENDERABLE_TYPE = 0x3040; + int EGL_SLOW_CONFIG = 0x3050; + int EGL_NON_CONFORMANT_CONFIG = 0x3051; + int EGL_TRANSPARENT_RGB = 0x3052; + int EGL_RGB_BUFFER = 0x308E; + int EGL_LUMINANCE_BUFFER = 0x308F; + int EGL_VENDOR = 0x3053; + int EGL_VERSION = 0x3054; + int EGL_EXTENSIONS = 0x3055; + int EGL_HEIGHT = 0x3056; + int EGL_WIDTH = 0x3057; + int EGL_LARGEST_PBUFFER = 0x3058; + int EGL_RENDER_BUFFER = 0x3086; + int EGL_COLORSPACE = 0x3087; + int EGL_ALPHA_FORMAT = 0x3088; + int EGL_HORIZONTAL_RESOLUTION = 0x3090; + int EGL_VERTICAL_RESOLUTION = 0x3091; + int EGL_PIXEL_ASPECT_RATIO = 0x3092; + int EGL_SINGLE_BUFFER = 0x3085; + int EGL_CORE_NATIVE_ENGINE = 0x305B; + int EGL_DRAW = 0x3059; + int EGL_READ = 0x305A; + + int EGL_DONT_CARE = -1; + + int EGL_PBUFFER_BIT = 0x01; + int EGL_PIXMAP_BIT = 0x02; + int EGL_WINDOW_BIT = 0x04; + + Object EGL_DEFAULT_DISPLAY = null; + EGLDisplay EGL_NO_DISPLAY = new com.google.android.gles_jni.EGLDisplayImpl(0); + EGLContext EGL_NO_CONTEXT = new com.google.android.gles_jni.EGLContextImpl(0); + EGLSurface EGL_NO_SURFACE = new com.google.android.gles_jni.EGLSurfaceImpl(0); + + boolean eglChooseConfig(EGLDisplay display, int[] attrib_list, EGLConfig[] configs, int config_size, int[] num_config); + boolean eglCopyBuffers(EGLDisplay display, EGLSurface surface, Object native_pixmap); + EGLContext eglCreateContext(EGLDisplay display, EGLConfig config, EGLContext share_context, int[] attrib_list); + EGLSurface eglCreatePbufferSurface(EGLDisplay display, EGLConfig config, int[] attrib_list); + EGLSurface eglCreatePixmapSurface(EGLDisplay display, EGLConfig config, Object native_pixmap, int[] attrib_list); + EGLSurface eglCreateWindowSurface(EGLDisplay display, EGLConfig config, Object native_window, int[] attrib_list); + boolean eglDestroyContext(EGLDisplay display, EGLContext context); + boolean eglDestroySurface(EGLDisplay display, EGLSurface surface); + boolean eglGetConfigAttrib(EGLDisplay display, EGLConfig config, int attribute, int[] value); + boolean eglGetConfigs(EGLDisplay display, EGLConfig[] configs, int config_size, int[] num_config); + EGLContext eglGetCurrentContext(); + EGLDisplay eglGetCurrentDisplay(); + EGLSurface eglGetCurrentSurface(int readdraw); + EGLDisplay eglGetDisplay(Object native_display); + int eglGetError(); + boolean eglInitialize(EGLDisplay display, int[] major_minor); + boolean eglMakeCurrent(EGLDisplay display, EGLSurface draw, EGLSurface read, EGLContext context); + boolean eglQueryContext(EGLDisplay display, EGLContext context, int attribute, int[] value); + String eglQueryString(EGLDisplay display, int name); + boolean eglQuerySurface(EGLDisplay display, EGLSurface surface, int attribute, int[] value); + boolean eglSwapBuffers(EGLDisplay display, EGLSurface surface); + boolean eglTerminate(EGLDisplay display); + boolean eglWaitGL(); + boolean eglWaitNative(int engine, Object bindTarget); +} diff --git a/opengl/java/javax/microedition/khronos/egl/EGL11.java b/opengl/java/javax/microedition/khronos/egl/EGL11.java new file mode 100644 index 0000000..41d62e6 --- /dev/null +++ b/opengl/java/javax/microedition/khronos/egl/EGL11.java @@ -0,0 +1,21 @@ +/* + * Copyright (C) 2006 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 javax.microedition.khronos.egl; + +public interface EGL11 extends EGL10 { + int EGL_CONTEXT_LOST = 0x300E; +} diff --git a/opengl/java/javax/microedition/khronos/egl/EGLConfig.java b/opengl/java/javax/microedition/khronos/egl/EGLConfig.java new file mode 100644 index 0000000..a1e496c --- /dev/null +++ b/opengl/java/javax/microedition/khronos/egl/EGLConfig.java @@ -0,0 +1,22 @@ +/* +** +** Copyright 2006, 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 javax.microedition.khronos.egl; + +public abstract class EGLConfig +{ +} diff --git a/opengl/java/javax/microedition/khronos/egl/EGLContext.java b/opengl/java/javax/microedition/khronos/egl/EGLContext.java new file mode 100644 index 0000000..fc94492 --- /dev/null +++ b/opengl/java/javax/microedition/khronos/egl/EGLContext.java @@ -0,0 +1,31 @@ +/* +** +** Copyright 2006, 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 javax.microedition.khronos.egl; + +import javax.microedition.khronos.opengles.GL; + +public abstract class EGLContext +{ + private static final EGL EGL_INSTANCE = new com.google.android.gles_jni.EGLImpl(); + + public static EGL getEGL() { + return EGL_INSTANCE; + } + + public abstract GL getGL(); +} diff --git a/opengl/java/javax/microedition/khronos/egl/EGLDisplay.java b/opengl/java/javax/microedition/khronos/egl/EGLDisplay.java new file mode 100644 index 0000000..cd8a755 --- /dev/null +++ b/opengl/java/javax/microedition/khronos/egl/EGLDisplay.java @@ -0,0 +1,22 @@ +/* +** +** Copyright 2006, 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 javax.microedition.khronos.egl; + +public abstract class EGLDisplay +{ +} diff --git a/opengl/java/javax/microedition/khronos/egl/EGLSurface.java b/opengl/java/javax/microedition/khronos/egl/EGLSurface.java new file mode 100644 index 0000000..5349bc1 --- /dev/null +++ b/opengl/java/javax/microedition/khronos/egl/EGLSurface.java @@ -0,0 +1,22 @@ +/* +** +** Copyright 2006, 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 javax.microedition.khronos.egl; + +public abstract class EGLSurface +{ +} diff --git a/opengl/java/javax/microedition/khronos/opengles/GL.java b/opengl/java/javax/microedition/khronos/opengles/GL.java new file mode 100644 index 0000000..3b78f3d --- /dev/null +++ b/opengl/java/javax/microedition/khronos/opengles/GL.java @@ -0,0 +1,22 @@ +/* //device/java/android/javax/microedition/khronos/opengles/GL.java +** +** Copyright 2006, 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 javax.microedition.khronos.opengles; + +public interface GL { +} + diff --git a/opengl/java/javax/microedition/khronos/opengles/GL10.java b/opengl/java/javax/microedition/khronos/opengles/GL10.java new file mode 100644 index 0000000..4fcfb52 --- /dev/null +++ b/opengl/java/javax/microedition/khronos/opengles/GL10.java @@ -0,0 +1,972 @@ +/* //device/java/android/javax/microedition/khronos/opengles/GL10.java +** +** Copyright 2006, 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 + +package javax.microedition.khronos.opengles; + +public interface GL10 extends GL { + int GL_ADD = 0x0104; + int GL_ALIASED_LINE_WIDTH_RANGE = 0x846E; + int GL_ALIASED_POINT_SIZE_RANGE = 0x846D; + int GL_ALPHA = 0x1906; + int GL_ALPHA_BITS = 0x0D55; + int GL_ALPHA_TEST = 0x0BC0; + int GL_ALWAYS = 0x0207; + int GL_AMBIENT = 0x1200; + int GL_AMBIENT_AND_DIFFUSE = 0x1602; + int GL_AND = 0x1501; + int GL_AND_INVERTED = 0x1504; + int GL_AND_REVERSE = 0x1502; + int GL_BACK = 0x0405; + int GL_BLEND = 0x0BE2; + int GL_BLUE_BITS = 0x0D54; + int GL_BYTE = 0x1400; + int GL_CCW = 0x0901; + int GL_CLAMP_TO_EDGE = 0x812F; + int GL_CLEAR = 0x1500; + int GL_COLOR_ARRAY = 0x8076; + int GL_COLOR_BUFFER_BIT = 0x4000; + int GL_COLOR_LOGIC_OP = 0x0BF2; + int GL_COLOR_MATERIAL = 0x0B57; + int GL_COMPRESSED_TEXTURE_FORMATS = 0x86A3; + int GL_CONSTANT_ATTENUATION = 0x1207; + int GL_COPY = 0x1503; + int GL_COPY_INVERTED = 0x150C; + int GL_CULL_FACE = 0x0B44; + int GL_CW = 0x0900; + int GL_DECAL = 0x2101; + int GL_DECR = 0x1E03; + int GL_DEPTH_BITS = 0x0D56; + int GL_DEPTH_BUFFER_BIT = 0x0100; + int GL_DEPTH_TEST = 0x0B71; + int GL_DIFFUSE = 0x1201; + int GL_DITHER = 0x0BD0; + int GL_DONT_CARE = 0x1100; + int GL_DST_ALPHA = 0x0304; + int GL_DST_COLOR = 0x0306; + int GL_EMISSION = 0x1600; + int GL_EQUAL = 0x0202; + int GL_EQUIV = 0x1509; + int GL_EXP = 0x0800; + int GL_EXP2 = 0x0801; + int GL_EXTENSIONS = 0x1F03; + int GL_FALSE = 0; + int GL_FASTEST = 0x1101; + int GL_FIXED = 0x140C; + int GL_FLAT = 0x1D00; + int GL_FLOAT = 0x1406; + int GL_FOG = 0x0B60; + int GL_FOG_COLOR = 0x0B66; + int GL_FOG_DENSITY = 0x0B62; + int GL_FOG_END = 0x0B64; + int GL_FOG_HINT = 0x0C54; + int GL_FOG_MODE = 0x0B65; + int GL_FOG_START = 0x0B63; + int GL_FRONT = 0x0404; + int GL_FRONT_AND_BACK = 0x0408; + int GL_GEQUAL = 0x0206; + int GL_GREATER = 0x0204; + int GL_GREEN_BITS = 0x0D53; + int GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES = 0x8B9B; + int GL_IMPLEMENTATION_COLOR_READ_TYPE_OES = 0x8B9A; + int GL_INCR = 0x1E02; + int GL_INVALID_ENUM = 0x0500; + int GL_INVALID_OPERATION = 0x0502; + int GL_INVALID_VALUE = 0x0501; + int GL_INVERT = 0x150A; + int GL_KEEP = 0x1E00; + int GL_LEQUAL = 0x0203; + int GL_LESS = 0x0201; + int GL_LIGHT_MODEL_AMBIENT = 0x0B53; + int GL_LIGHT_MODEL_TWO_SIDE = 0x0B52; + int GL_LIGHT0 = 0x4000; + int GL_LIGHT1 = 0x4001; + int GL_LIGHT2 = 0x4002; + int GL_LIGHT3 = 0x4003; + int GL_LIGHT4 = 0x4004; + int GL_LIGHT5 = 0x4005; + int GL_LIGHT6 = 0x4006; + int GL_LIGHT7 = 0x4007; + int GL_LIGHTING = 0x0B50; + int GL_LINE_LOOP = 0x0002; + int GL_LINE_SMOOTH = 0x0B20; + int GL_LINE_SMOOTH_HINT = 0x0C52; + int GL_LINE_STRIP = 0x0003; + int GL_LINEAR = 0x2601; + int GL_LINEAR_ATTENUATION = 0x1208; + int GL_LINEAR_MIPMAP_LINEAR = 0x2703; + int GL_LINEAR_MIPMAP_NEAREST = 0x2701; + int GL_LINES = 0x0001; + int GL_LUMINANCE = 0x1909; + int GL_LUMINANCE_ALPHA = 0x190A; + int GL_MAX_ELEMENTS_INDICES = 0x80E9; + int GL_MAX_ELEMENTS_VERTICES = 0x80E8; + int GL_MAX_LIGHTS = 0x0D31; + int GL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36; + int GL_MAX_PROJECTION_STACK_DEPTH = 0x0D38; + int GL_MAX_TEXTURE_SIZE = 0x0D33; + int GL_MAX_TEXTURE_STACK_DEPTH = 0x0D39; + int GL_MAX_TEXTURE_UNITS = 0x84E2; + int GL_MAX_VIEWPORT_DIMS = 0x0D3A; + int GL_MODELVIEW = 0x1700; + int GL_MODULATE = 0x2100; + int GL_MULTISAMPLE = 0x809D; + int GL_NAND = 0x150E; + int GL_NEAREST = 0x2600; + int GL_NEAREST_MIPMAP_LINEAR = 0x2702; + int GL_NEAREST_MIPMAP_NEAREST = 0x2700; + int GL_NEVER = 0x0200; + int GL_NICEST = 0x1102; + int GL_NO_ERROR = 0; + int GL_NOOP = 0x1505; + int GL_NOR = 0x1508; + int GL_NORMAL_ARRAY = 0x8075; + int GL_NORMALIZE = 0x0BA1; + int GL_NOTEQUAL = 0x0205; + int GL_NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2; + int GL_ONE = 1; + int GL_ONE_MINUS_DST_ALPHA = 0x0305; + int GL_ONE_MINUS_DST_COLOR = 0x0307; + int GL_ONE_MINUS_SRC_ALPHA = 0x0303; + int GL_ONE_MINUS_SRC_COLOR = 0x0301; + int GL_OR = 0x1507; + int GL_OR_INVERTED = 0x150D; + int GL_OR_REVERSE = 0x150B; + int GL_OUT_OF_MEMORY = 0x0505; + int GL_PACK_ALIGNMENT = 0x0D05; + int GL_PALETTE4_R5_G6_B5_OES = 0x8B92; + int GL_PALETTE4_RGB5_A1_OES = 0x8B94; + int GL_PALETTE4_RGB8_OES = 0x8B90; + int GL_PALETTE4_RGBA4_OES = 0x8B93; + int GL_PALETTE4_RGBA8_OES = 0x8B91; + int GL_PALETTE8_R5_G6_B5_OES = 0x8B97; + int GL_PALETTE8_RGB5_A1_OES = 0x8B99; + int GL_PALETTE8_RGB8_OES = 0x8B95; + int GL_PALETTE8_RGBA4_OES = 0x8B98; + int GL_PALETTE8_RGBA8_OES = 0x8B96; + int GL_PERSPECTIVE_CORRECTION_HINT = 0x0C50; + int GL_POINT_SMOOTH = 0x0B10; + int GL_POINT_SMOOTH_HINT = 0x0C51; + int GL_POINTS = 0x0000; + int GL_POINT_FADE_THRESHOLD_SIZE = 0x8128; + int GL_POINT_SIZE = 0x0B11; + int GL_POLYGON_OFFSET_FILL = 0x8037; + int GL_POLYGON_SMOOTH_HINT = 0x0C53; + int GL_POSITION = 0x1203; + int GL_PROJECTION = 0x1701; + int GL_QUADRATIC_ATTENUATION = 0x1209; + int GL_RED_BITS = 0x0D52; + int GL_RENDERER = 0x1F01; + int GL_REPEAT = 0x2901; + int GL_REPLACE = 0x1E01; + int GL_RESCALE_NORMAL = 0x803A; + int GL_RGB = 0x1907; + int GL_RGBA = 0x1908; + int GL_SAMPLE_ALPHA_TO_COVERAGE = 0x809E; + int GL_SAMPLE_ALPHA_TO_ONE = 0x809F; + int GL_SAMPLE_COVERAGE = 0x80A0; + int GL_SCISSOR_TEST = 0x0C11; + int GL_SET = 0x150F; + int GL_SHININESS = 0x1601; + int GL_SHORT = 0x1402; + int GL_SMOOTH = 0x1D01; + int GL_SMOOTH_LINE_WIDTH_RANGE = 0x0B22; + int GL_SMOOTH_POINT_SIZE_RANGE = 0x0B12; + int GL_SPECULAR = 0x1202; + int GL_SPOT_CUTOFF = 0x1206; + int GL_SPOT_DIRECTION = 0x1204; + int GL_SPOT_EXPONENT = 0x1205; + int GL_SRC_ALPHA = 0x0302; + int GL_SRC_ALPHA_SATURATE = 0x0308; + int GL_SRC_COLOR = 0x0300; + int GL_STACK_OVERFLOW = 0x0503; + int GL_STACK_UNDERFLOW = 0x0504; + int GL_STENCIL_BITS = 0x0D57; + int GL_STENCIL_BUFFER_BIT = 0x0400; + int GL_STENCIL_TEST = 0x0B90; + int GL_SUBPIXEL_BITS = 0x0D50; + int GL_TEXTURE = 0x1702; + int GL_TEXTURE_2D = 0x0DE1; + int GL_TEXTURE_COORD_ARRAY = 0x8078; + int GL_TEXTURE_ENV = 0x2300; + int GL_TEXTURE_ENV_COLOR = 0x2201; + int GL_TEXTURE_ENV_MODE = 0x2200; + int GL_TEXTURE_MAG_FILTER = 0x2800; + int GL_TEXTURE_MIN_FILTER = 0x2801; + int GL_TEXTURE_WRAP_S = 0x2802; + int GL_TEXTURE_WRAP_T = 0x2803; + int GL_TEXTURE0 = 0x84C0; + int GL_TEXTURE1 = 0x84C1; + int GL_TEXTURE2 = 0x84C2; + int GL_TEXTURE3 = 0x84C3; + int GL_TEXTURE4 = 0x84C4; + int GL_TEXTURE5 = 0x84C5; + int GL_TEXTURE6 = 0x84C6; + int GL_TEXTURE7 = 0x84C7; + int GL_TEXTURE8 = 0x84C8; + int GL_TEXTURE9 = 0x84C9; + int GL_TEXTURE10 = 0x84CA; + int GL_TEXTURE11 = 0x84CB; + int GL_TEXTURE12 = 0x84CC; + int GL_TEXTURE13 = 0x84CD; + int GL_TEXTURE14 = 0x84CE; + int GL_TEXTURE15 = 0x84CF; + int GL_TEXTURE16 = 0x84D0; + int GL_TEXTURE17 = 0x84D1; + int GL_TEXTURE18 = 0x84D2; + int GL_TEXTURE19 = 0x84D3; + int GL_TEXTURE20 = 0x84D4; + int GL_TEXTURE21 = 0x84D5; + int GL_TEXTURE22 = 0x84D6; + int GL_TEXTURE23 = 0x84D7; + int GL_TEXTURE24 = 0x84D8; + int GL_TEXTURE25 = 0x84D9; + int GL_TEXTURE26 = 0x84DA; + int GL_TEXTURE27 = 0x84DB; + int GL_TEXTURE28 = 0x84DC; + int GL_TEXTURE29 = 0x84DD; + int GL_TEXTURE30 = 0x84DE; + int GL_TEXTURE31 = 0x84DF; + int GL_TRIANGLE_FAN = 0x0006; + int GL_TRIANGLE_STRIP = 0x0005; + int GL_TRIANGLES = 0x0004; + int GL_TRUE = 1; + int GL_UNPACK_ALIGNMENT = 0x0CF5; + int GL_UNSIGNED_BYTE = 0x1401; + int GL_UNSIGNED_SHORT = 0x1403; + int GL_UNSIGNED_SHORT_4_4_4_4 = 0x8033; + int GL_UNSIGNED_SHORT_5_5_5_1 = 0x8034; + int GL_UNSIGNED_SHORT_5_6_5 = 0x8363; + int GL_VENDOR = 0x1F00; + int GL_VERSION = 0x1F02; + int GL_VERTEX_ARRAY = 0x8074; + int GL_XOR = 0x1506; + int GL_ZERO = 0; + + void glActiveTexture( + int texture + ); + + void glAlphaFunc( + int func, + float ref + ); + + void glAlphaFuncx( + int func, + int ref + ); + + void glBindTexture( + int target, + int texture + ); + + void glBlendFunc( + int sfactor, + int dfactor + ); + + void glClear( + int mask + ); + + void glClearColor( + float red, + float green, + float blue, + float alpha + ); + + void glClearColorx( + int red, + int green, + int blue, + int alpha + ); + + void glClearDepthf( + float depth + ); + + void glClearDepthx( + int depth + ); + + void glClearStencil( + int s + ); + + void glClientActiveTexture( + int texture + ); + + void glColor4f( + float red, + float green, + float blue, + float alpha + ); + + void glColor4x( + int red, + int green, + int blue, + int alpha + ); + + void glColorMask( + boolean red, + boolean green, + boolean blue, + boolean alpha + ); + + void glColorPointer( + int size, + int type, + int stride, + java.nio.Buffer pointer + ); + + void glCompressedTexImage2D( + int target, + int level, + int internalformat, + int width, + int height, + int border, + int imageSize, + java.nio.Buffer data + ); + + void glCompressedTexSubImage2D( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int imageSize, + java.nio.Buffer data + ); + + void glCopyTexImage2D( + int target, + int level, + int internalformat, + int x, + int y, + int width, + int height, + int border + ); + + void glCopyTexSubImage2D( + int target, + int level, + int xoffset, + int yoffset, + int x, + int y, + int width, + int height + ); + + void glCullFace( + int mode + ); + + void glDeleteTextures( + int n, + int[] textures, + int offset + ); + + void glDeleteTextures( + int n, + java.nio.IntBuffer textures + ); + + void glDepthFunc( + int func + ); + + void glDepthMask( + boolean flag + ); + + void glDepthRangef( + float zNear, + float zFar + ); + + void glDepthRangex( + int zNear, + int zFar + ); + + void glDisable( + int cap + ); + + void glDisableClientState( + int array + ); + + void glDrawArrays( + int mode, + int first, + int count + ); + + void glDrawElements( + int mode, + int count, + int type, + java.nio.Buffer indices + ); + + void glEnable( + int cap + ); + + void glEnableClientState( + int array + ); + + void glFinish( + ); + + void glFlush( + ); + + void glFogf( + int pname, + float param + ); + + void glFogfv( + int pname, + float[] params, + int offset + ); + + void glFogfv( + int pname, + java.nio.FloatBuffer params + ); + + void glFogx( + int pname, + int param + ); + + void glFogxv( + int pname, + int[] params, + int offset + ); + + void glFogxv( + int pname, + java.nio.IntBuffer params + ); + + void glFrontFace( + int mode + ); + + void glFrustumf( + float left, + float right, + float bottom, + float top, + float zNear, + float zFar + ); + + void glFrustumx( + int left, + int right, + int bottom, + int top, + int zNear, + int zFar + ); + + void glGenTextures( + int n, + int[] textures, + int offset + ); + + void glGenTextures( + int n, + java.nio.IntBuffer textures + ); + + int glGetError( + ); + + void glGetIntegerv( + int pname, + int[] params, + int offset + ); + + void glGetIntegerv( + int pname, + java.nio.IntBuffer params + ); + + public String glGetString( + int name + ); + + void glHint( + int target, + int mode + ); + + void glLightModelf( + int pname, + float param + ); + + void glLightModelfv( + int pname, + float[] params, + int offset + ); + + void glLightModelfv( + int pname, + java.nio.FloatBuffer params + ); + + void glLightModelx( + int pname, + int param + ); + + void glLightModelxv( + int pname, + int[] params, + int offset + ); + + void glLightModelxv( + int pname, + java.nio.IntBuffer params + ); + + void glLightf( + int light, + int pname, + float param + ); + + void glLightfv( + int light, + int pname, + float[] params, + int offset + ); + + void glLightfv( + int light, + int pname, + java.nio.FloatBuffer params + ); + + void glLightx( + int light, + int pname, + int param + ); + + void glLightxv( + int light, + int pname, + int[] params, + int offset + ); + + void glLightxv( + int light, + int pname, + java.nio.IntBuffer params + ); + + void glLineWidth( + float width + ); + + void glLineWidthx( + int width + ); + + void glLoadIdentity( + ); + + void glLoadMatrixf( + float[] m, + int offset + ); + + void glLoadMatrixf( + java.nio.FloatBuffer m + ); + + void glLoadMatrixx( + int[] m, + int offset + ); + + void glLoadMatrixx( + java.nio.IntBuffer m + ); + + void glLogicOp( + int opcode + ); + + void glMaterialf( + int face, + int pname, + float param + ); + + void glMaterialfv( + int face, + int pname, + float[] params, + int offset + ); + + void glMaterialfv( + int face, + int pname, + java.nio.FloatBuffer params + ); + + void glMaterialx( + int face, + int pname, + int param + ); + + void glMaterialxv( + int face, + int pname, + int[] params, + int offset + ); + + void glMaterialxv( + int face, + int pname, + java.nio.IntBuffer params + ); + + void glMatrixMode( + int mode + ); + + void glMultMatrixf( + float[] m, + int offset + ); + + void glMultMatrixf( + java.nio.FloatBuffer m + ); + + void glMultMatrixx( + int[] m, + int offset + ); + + void glMultMatrixx( + java.nio.IntBuffer m + ); + + void glMultiTexCoord4f( + int target, + float s, + float t, + float r, + float q + ); + + void glMultiTexCoord4x( + int target, + int s, + int t, + int r, + int q + ); + + void glNormal3f( + float nx, + float ny, + float nz + ); + + void glNormal3x( + int nx, + int ny, + int nz + ); + + void glNormalPointer( + int type, + int stride, + java.nio.Buffer pointer + ); + + void glOrthof( + float left, + float right, + float bottom, + float top, + float zNear, + float zFar + ); + + void glOrthox( + int left, + int right, + int bottom, + int top, + int zNear, + int zFar + ); + + void glPixelStorei( + int pname, + int param + ); + + void glPointSize( + float size + ); + + void glPointSizex( + int size + ); + + void glPolygonOffset( + float factor, + float units + ); + + void glPolygonOffsetx( + int factor, + int units + ); + + void glPopMatrix( + ); + + void glPushMatrix( + ); + + void glReadPixels( + int x, + int y, + int width, + int height, + int format, + int type, + java.nio.Buffer pixels + ); + + void glRotatef( + float angle, + float x, + float y, + float z + ); + + void glRotatex( + int angle, + int x, + int y, + int z + ); + + void glSampleCoverage( + float value, + boolean invert + ); + + void glSampleCoveragex( + int value, + boolean invert + ); + + void glScalef( + float x, + float y, + float z + ); + + void glScalex( + int x, + int y, + int z + ); + + void glScissor( + int x, + int y, + int width, + int height + ); + + void glShadeModel( + int mode + ); + + void glStencilFunc( + int func, + int ref, + int mask + ); + + void glStencilMask( + int mask + ); + + void glStencilOp( + int fail, + int zfail, + int zpass + ); + + void glTexCoordPointer( + int size, + int type, + int stride, + java.nio.Buffer pointer + ); + + void glTexEnvf( + int target, + int pname, + float param + ); + + void glTexEnvfv( + int target, + int pname, + float[] params, + int offset + ); + + void glTexEnvfv( + int target, + int pname, + java.nio.FloatBuffer params + ); + + void glTexEnvx( + int target, + int pname, + int param + ); + + void glTexEnvxv( + int target, + int pname, + int[] params, + int offset + ); + + void glTexEnvxv( + int target, + int pname, + java.nio.IntBuffer params + ); + + void glTexImage2D( + int target, + int level, + int internalformat, + int width, + int height, + int border, + int format, + int type, + java.nio.Buffer pixels + ); + + void glTexParameterf( + int target, + int pname, + float param + ); + + void glTexParameterx( + int target, + int pname, + int param + ); + + void glTexSubImage2D( + int target, + int level, + int xoffset, + int yoffset, + int width, + int height, + int format, + int type, + java.nio.Buffer pixels + ); + + void glTranslatef( + float x, + float y, + float z + ); + + void glTranslatex( + int x, + int y, + int z + ); + + void glVertexPointer( + int size, + int type, + int stride, + java.nio.Buffer pointer + ); + + void glViewport( + int x, + int y, + int width, + int height + ); + +} diff --git a/opengl/java/javax/microedition/khronos/opengles/GL10Ext.java b/opengl/java/javax/microedition/khronos/opengles/GL10Ext.java new file mode 100644 index 0000000..562b20a --- /dev/null +++ b/opengl/java/javax/microedition/khronos/opengles/GL10Ext.java @@ -0,0 +1,36 @@ +/* //device/java/android/javax/microedition/khronos/opengles/GL10Ext.java +** +** Copyright 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. +*/ + +// This source file is automatically generated + +package javax.microedition.khronos.opengles; + +public interface GL10Ext extends GL { + + int glQueryMatrixxOES( + int[] mantissa, + int mantissaOffset, + int[] exponent, + int exponentOffset + ); + + int glQueryMatrixxOES( + java.nio.IntBuffer mantissa, + java.nio.IntBuffer exponent + ); + +} diff --git a/opengl/java/javax/microedition/khronos/opengles/GL11.java b/opengl/java/javax/microedition/khronos/opengles/GL11.java new file mode 100644 index 0000000..3ba110c --- /dev/null +++ b/opengl/java/javax/microedition/khronos/opengles/GL11.java @@ -0,0 +1,550 @@ +/* //device/java/android/javax/microedition/khronos/opengles/GL11.java +** +** Copyright 2006, 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 + +package javax.microedition.khronos.opengles; + +public interface GL11 extends GL10 { + int GL_ACTIVE_TEXTURE = 0x84E0; + int GL_ADD_SIGNED = 0x8574; + int GL_ALPHA_SCALE = 0x0D1C; + int GL_ALPHA_TEST_FUNC = 0x0BC1; + int GL_ALPHA_TEST_REF = 0x0BC2; + int GL_ARRAY_BUFFER = 0x8892; + int GL_ARRAY_BUFFER_BINDING = 0x8894; + int GL_BLEND_DST = 0x0BE0; + int GL_BLEND_SRC = 0x0BE1; + int GL_BUFFER_ACCESS = 0x88BB; + int GL_BUFFER_SIZE = 0x8764; + int GL_BUFFER_USAGE = 0x8765; + int GL_CLIENT_ACTIVE_TEXTURE = 0x84E1; + int GL_CLIP_PLANE0 = 0x3000; + int GL_CLIP_PLANE1 = 0x3001; + int GL_CLIP_PLANE2 = 0x3002; + int GL_CLIP_PLANE3 = 0x3003; + int GL_CLIP_PLANE4 = 0x3004; + int GL_CLIP_PLANE5 = 0x3005; + int GL_COLOR_ARRAY_BUFFER_BINDING = 0x8898; + int GL_COLOR_ARRAY_POINTER = 0x8090; + int GL_COLOR_ARRAY_SIZE = 0x8081; + int GL_COLOR_ARRAY_STRIDE = 0x8083; + int GL_COLOR_ARRAY_TYPE = 0x8082; + int GL_COLOR_CLEAR_VALUE = 0x0C22; + int GL_COLOR_WRITEMASK = 0x0C23; + int GL_COMBINE = 0x8570; + int GL_COMBINE_ALPHA = 0x8572; + int GL_COMBINE_RGB = 0x8571; + int GL_CONSTANT = 0x8576; + int GL_COORD_REPLACE_OES = 0x8862; + int GL_CULL_FACE_MODE = 0x0B45; + int GL_CURRENT_COLOR = 0x0B00; + int GL_CURRENT_NORMAL = 0x0B02; + int GL_CURRENT_TEXTURE_COORDS = 0x0B03; + int GL_DEPTH_CLEAR_VALUE = 0x0B73; + int GL_DEPTH_FUNC = 0x0B74; + int GL_DEPTH_RANGE = 0x0B70; + int GL_DEPTH_WRITEMASK = 0x0B72; + int GL_DOT3_RGB = 0x86AE; + int GL_DOT3_RGBA = 0x86AF; + int GL_DYNAMIC_DRAW = 0x88E8; + int GL_ELEMENT_ARRAY_BUFFER = 0x8893; + int GL_ELEMENT_ARRAY_BUFFER_BINDING = 0x8895; + int GL_FRONT_FACE = 0x0B46; + int GL_GENERATE_MIPMAP = 0x8191; + int GL_GENERATE_MIPMAP_HINT = 0x8192; + int GL_INTERPOLATE = 0x8575; + int GL_LINE_WIDTH = 0x0B21; + int GL_LOGIC_OP_MODE = 0x0BF0; + int GL_MATRIX_MODE = 0x0BA0; + int GL_MAX_CLIP_PLANES = 0x0D32; + int GL_MODELVIEW_MATRIX = 0x0BA6; + int GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES = 0x898D; + int GL_MODELVIEW_STACK_DEPTH = 0x0BA3; + int GL_NORMAL_ARRAY_BUFFER_BINDING = 0x8897; + int GL_NORMAL_ARRAY_POINTER = 0x808F; + int GL_NORMAL_ARRAY_STRIDE = 0x807F; + int GL_NORMAL_ARRAY_TYPE = 0x807E; + int GL_OPERAND0_ALPHA = 0x8598; + int GL_OPERAND0_RGB = 0x8590; + int GL_OPERAND1_ALPHA = 0x8599; + int GL_OPERAND1_RGB = 0x8591; + int GL_OPERAND2_ALPHA = 0x859A; + int GL_OPERAND2_RGB = 0x8592; + int GL_POINT_DISTANCE_ATTENUATION = 0x8129; + int GL_POINT_FADE_THRESHOLD_SIZE = 0x8128; + int GL_POINT_SIZE = 0x0B11; + int GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES = 0x8B9F; + int GL_POINT_SIZE_ARRAY_OES = 0x8B9C; + int GL_POINT_SIZE_ARRAY_POINTER_OES = 0x898C; + int GL_POINT_SIZE_ARRAY_STRIDE_OES = 0x898B; + int GL_POINT_SIZE_ARRAY_TYPE_OES = 0x898A; + int GL_POINT_SIZE_MAX = 0x8127; + int GL_POINT_SIZE_MIN = 0x8126; + int GL_POINT_SPRITE_OES = 0x8861; + int GL_POLYGON_OFFSET_FACTOR = 0x8038; + int GL_POLYGON_OFFSET_UNITS = 0x2A00; + int GL_PREVIOUS = 0x8578; + int GL_PRIMARY_COLOR = 0x8577; + int GL_PROJECTION_MATRIX = 0x0BA7; + int GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES = 0x898E; + int GL_PROJECTION_STACK_DEPTH = 0x0BA4; + int GL_RGB_SCALE = 0x8573; + int GL_SAMPLE_BUFFERS = 0x80A8; + int GL_SAMPLE_COVERAGE_INVERT = 0x80AB; + int GL_SAMPLE_COVERAGE_VALUE = 0x80AA; + int GL_SAMPLES = 0x80A9; + int GL_SCISSOR_BOX = 0x0C10; + int GL_SHADE_MODEL = 0x0B54; + int GL_SRC0_ALPHA = 0x8588; + int GL_SRC0_RGB = 0x8580; + int GL_SRC1_ALPHA = 0x8589; + int GL_SRC1_RGB = 0x8581; + int GL_SRC2_ALPHA = 0x858A; + int GL_SRC2_RGB = 0x8582; + int GL_STATIC_DRAW = 0x88E4; + int GL_STENCIL_CLEAR_VALUE = 0x0B91; + int GL_STENCIL_FAIL = 0x0B94; + int GL_STENCIL_FUNC = 0x0B92; + int GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95; + int GL_STENCIL_PASS_DEPTH_PASS = 0x0B96; + int GL_STENCIL_REF = 0x0B97; + int GL_STENCIL_VALUE_MASK = 0x0B93; + int GL_STENCIL_WRITEMASK = 0x0B98; + int GL_SUBTRACT = 0x84E7; + int GL_TEXTURE_BINDING_2D = 0x8069; + int GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A; + int GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092; + int GL_TEXTURE_COORD_ARRAY_SIZE = 0x8088; + int GL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A; + int GL_TEXTURE_COORD_ARRAY_TYPE = 0x8089; + int GL_TEXTURE_MATRIX = 0x0BA8; + int GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES = 0x898F; + int GL_TEXTURE_STACK_DEPTH = 0x0BA5; + int GL_VERTEX_ARRAY_BUFFER_BINDING = 0x8896; + int GL_VERTEX_ARRAY_POINTER = 0x808E; + int GL_VERTEX_ARRAY_SIZE = 0x807A; + int GL_VERTEX_ARRAY_STRIDE = 0x807C; + int GL_VERTEX_ARRAY_TYPE = 0x807B; + int GL_VIEWPORT = 0x0BA2; + int GL_WRITE_ONLY = 0x88B9; + + void glGetPointerv(int pname, java.nio.Buffer[] params); + void glBindBuffer( + int target, + int buffer + ); + + void glBufferData( + int target, + int size, + java.nio.Buffer data, + int usage + ); + + void glBufferSubData( + int target, + int offset, + int size, + java.nio.Buffer data + ); + + void glClipPlanef( + int plane, + float[] equation, + int offset + ); + + void glClipPlanef( + int plane, + java.nio.FloatBuffer equation + ); + + void glClipPlanex( + int plane, + int[] equation, + int offset + ); + + void glClipPlanex( + int plane, + java.nio.IntBuffer equation + ); + + void glColor4ub( + byte red, + byte green, + byte blue, + byte alpha + ); + + void glColorPointer( + int size, + int type, + int stride, + int offset + ); + + void glDeleteBuffers( + int n, + int[] buffers, + int offset + ); + + void glDeleteBuffers( + int n, + java.nio.IntBuffer buffers + ); + + void glDrawElements( + int mode, + int count, + int type, + int offset + ); + + void glGenBuffers( + int n, + int[] buffers, + int offset + ); + + void glGenBuffers( + int n, + java.nio.IntBuffer buffers + ); + + void glGetBooleanv( + int pname, + boolean[] params, + int offset + ); + + void glGetBooleanv( + int pname, + java.nio.IntBuffer params + ); + + void glGetBufferParameteriv( + int target, + int pname, + int[] params, + int offset + ); + + void glGetBufferParameteriv( + int target, + int pname, + java.nio.IntBuffer params + ); + + void glGetClipPlanef( + int pname, + float[] eqn, + int offset + ); + + void glGetClipPlanef( + int pname, + java.nio.FloatBuffer eqn + ); + + void glGetClipPlanex( + int pname, + int[] eqn, + int offset + ); + + void glGetClipPlanex( + int pname, + java.nio.IntBuffer eqn + ); + + void glGetFixedv( + int pname, + int[] params, + int offset + ); + + void glGetFixedv( + int pname, + java.nio.IntBuffer params + ); + + void glGetFloatv( + int pname, + float[] params, + int offset + ); + + void glGetFloatv( + int pname, + java.nio.FloatBuffer params + ); + + void glGetLightfv( + int light, + int pname, + float[] params, + int offset + ); + + void glGetLightfv( + int light, + int pname, + java.nio.FloatBuffer params + ); + + void glGetLightxv( + int light, + int pname, + int[] params, + int offset + ); + + void glGetLightxv( + int light, + int pname, + java.nio.IntBuffer params + ); + + void glGetMaterialfv( + int face, + int pname, + float[] params, + int offset + ); + + void glGetMaterialfv( + int face, + int pname, + java.nio.FloatBuffer params + ); + + void glGetMaterialxv( + int face, + int pname, + int[] params, + int offset + ); + + void glGetMaterialxv( + int face, + int pname, + java.nio.IntBuffer params + ); + + void glGetTexEnviv( + int env, + int pname, + int[] params, + int offset + ); + + void glGetTexEnviv( + int env, + int pname, + java.nio.IntBuffer params + ); + + void glGetTexEnvxv( + int env, + int pname, + int[] params, + int offset + ); + + void glGetTexEnvxv( + int env, + int pname, + java.nio.IntBuffer params + ); + + void glGetTexParameterfv( + int target, + int pname, + float[] params, + int offset + ); + + void glGetTexParameterfv( + int target, + int pname, + java.nio.FloatBuffer params + ); + + void glGetTexParameteriv( + int target, + int pname, + int[] params, + int offset + ); + + void glGetTexParameteriv( + int target, + int pname, + java.nio.IntBuffer params + ); + + void glGetTexParameterxv( + int target, + int pname, + int[] params, + int offset + ); + + void glGetTexParameterxv( + int target, + int pname, + java.nio.IntBuffer params + ); + + boolean glIsBuffer( + int buffer + ); + + boolean glIsEnabled( + int cap + ); + + boolean glIsTexture( + int texture + ); + + void glNormalPointer( + int type, + int stride, + int offset + ); + + void glPointParameterf( + int pname, + float param + ); + + void glPointParameterfv( + int pname, + float[] params, + int offset + ); + + void glPointParameterfv( + int pname, + java.nio.FloatBuffer params + ); + + void glPointParameterx( + int pname, + int param + ); + + void glPointParameterxv( + int pname, + int[] params, + int offset + ); + + void glPointParameterxv( + int pname, + java.nio.IntBuffer params + ); + + void glPointSizePointerOES( + int type, + int stride, + java.nio.Buffer pointer + ); + + void glTexCoordPointer( + int size, + int type, + int stride, + int offset + ); + + void glTexEnvi( + int target, + int pname, + int param + ); + + void glTexEnviv( + int target, + int pname, + int[] params, + int offset + ); + + void glTexEnviv( + int target, + int pname, + java.nio.IntBuffer params + ); + + void glTexParameterfv( + int target, + int pname, + float[] params, + int offset + ); + + void glTexParameterfv( + int target, + int pname, + java.nio.FloatBuffer params + ); + + void glTexParameteri( + int target, + int pname, + int param + ); + + void glTexParameteriv( + int target, + int pname, + int[] params, + int offset + ); + + void glTexParameteriv( + int target, + int pname, + java.nio.IntBuffer params + ); + + void glTexParameterxv( + int target, + int pname, + int[] params, + int offset + ); + + void glTexParameterxv( + int target, + int pname, + java.nio.IntBuffer params + ); + + void glVertexPointer( + int size, + int type, + int stride, + int offset + ); + +} diff --git a/opengl/java/javax/microedition/khronos/opengles/GL11Ext.java b/opengl/java/javax/microedition/khronos/opengles/GL11Ext.java new file mode 100644 index 0000000..459a1ab --- /dev/null +++ b/opengl/java/javax/microedition/khronos/opengles/GL11Ext.java @@ -0,0 +1,153 @@ +/* //device/java/android/javax/microedition/khronos/opengles/GL11Ext.java +** +** Copyright 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. +*/ + +// This source file is automatically generated + +package javax.microedition.khronos.opengles; + +public interface GL11Ext extends GL { + int GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES = 0x8B9E; + int GL_MATRIX_INDEX_ARRAY_OES = 0x8844; + int GL_MATRIX_INDEX_ARRAY_POINTER_OES = 0x8849; + int GL_MATRIX_INDEX_ARRAY_SIZE_OES = 0x8846; + int GL_MATRIX_INDEX_ARRAY_STRIDE_OES = 0x8848; + int GL_MATRIX_INDEX_ARRAY_TYPE_OES = 0x8847; + int GL_MATRIX_PALETTE_OES = 0x8840; + int GL_MAX_PALETTE_MATRICES_OES = 0x8842; + int GL_MAX_VERTEX_UNITS_OES = 0x86A4; + int GL_TEXTURE_CROP_RECT_OES = 0x8B9D; + int GL_WEIGHT_ARRAY_BUFFER_BINDING_OES = 0x889E; + int GL_WEIGHT_ARRAY_OES = 0x86AD; + int GL_WEIGHT_ARRAY_POINTER_OES = 0x86AC; + int GL_WEIGHT_ARRAY_SIZE_OES = 0x86AB; + int GL_WEIGHT_ARRAY_STRIDE_OES = 0x86AA; + int GL_WEIGHT_ARRAY_TYPE_OES = 0x86A9; + + void glTexParameterfv(int target, int pname, float[] param, int offset); + + void glCurrentPaletteMatrixOES( + int matrixpaletteindex + ); + + void glDrawTexfOES( + float x, + float y, + float z, + float width, + float height + ); + + void glDrawTexfvOES( + float[] coords, + int offset + ); + + void glDrawTexfvOES( + java.nio.FloatBuffer coords + ); + + void glDrawTexiOES( + int x, + int y, + int z, + int width, + int height + ); + + void glDrawTexivOES( + int[] coords, + int offset + ); + + void glDrawTexivOES( + java.nio.IntBuffer coords + ); + + void glDrawTexsOES( + short x, + short y, + short z, + short width, + short height + ); + + void glDrawTexsvOES( + short[] coords, + int offset + ); + + void glDrawTexsvOES( + java.nio.ShortBuffer coords + ); + + void glDrawTexxOES( + int x, + int y, + int z, + int width, + int height + ); + + void glDrawTexxvOES( + int[] coords, + int offset + ); + + void glDrawTexxvOES( + java.nio.IntBuffer coords + ); + + void glEnable( + int cap + ); + + void glEnableClientState( + int array + ); + + void glLoadPaletteFromModelViewMatrixOES( + ); + + void glMatrixIndexPointerOES( + int size, + int type, + int stride, + java.nio.Buffer pointer + ); + + void glMatrixIndexPointerOES( + int size, + int type, + int stride, + int offset + ); + + void glWeightPointerOES( + int size, + int type, + int stride, + java.nio.Buffer pointer + ); + + void glWeightPointerOES( + int size, + int type, + int stride, + int offset + ); + +} diff --git a/opengl/java/javax/microedition/khronos/opengles/GL11ExtensionPack.java b/opengl/java/javax/microedition/khronos/opengles/GL11ExtensionPack.java new file mode 100644 index 0000000..933c91e --- /dev/null +++ b/opengl/java/javax/microedition/khronos/opengles/GL11ExtensionPack.java @@ -0,0 +1,434 @@ +/* //device/java/android/javax/microedition/khronos/opengles/GL11ExtensionPack.java +** +** Copyright 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. +*/ + +// This source file is automatically generated + +package javax.microedition.khronos.opengles; + +public interface GL11ExtensionPack extends GL { + int GL_BLEND_DST_ALPHA = 0x80CA; + int GL_BLEND_DST_RGB = 0x80C8; + int GL_BLEND_EQUATION = 0x8009; + int GL_BLEND_EQUATION_ALPHA = 0x883D; + int GL_BLEND_EQUATION_RGB = 0x8009; + int GL_BLEND_SRC_ALPHA = 0x80CB; + int GL_BLEND_SRC_RGB = 0x80C9; + int GL_COLOR_ATTACHMENT0_OES = 0x8CE0; + int GL_COLOR_ATTACHMENT1_OES = 0x8CE1; + int GL_COLOR_ATTACHMENT2_OES = 0x8CE2; + int GL_COLOR_ATTACHMENT3_OES = 0x8CE3; + int GL_COLOR_ATTACHMENT4_OES = 0x8CE4; + int GL_COLOR_ATTACHMENT5_OES = 0x8CE5; + int GL_COLOR_ATTACHMENT6_OES = 0x8CE6; + int GL_COLOR_ATTACHMENT7_OES = 0x8CE7; + int GL_COLOR_ATTACHMENT8_OES = 0x8CE8; + int GL_COLOR_ATTACHMENT9_OES = 0x8CE9; + int GL_COLOR_ATTACHMENT10_OES = 0x8CEA; + int GL_COLOR_ATTACHMENT11_OES = 0x8CEB; + int GL_COLOR_ATTACHMENT12_OES = 0x8CEC; + int GL_COLOR_ATTACHMENT13_OES = 0x8CED; + int GL_COLOR_ATTACHMENT14_OES = 0x8CEE; + int GL_COLOR_ATTACHMENT15_OES = 0x8CEF; + int GL_DECR_WRAP = 0x8508; + int GL_DEPTH_ATTACHMENT_OES = 0x8D00; + int GL_DEPTH_COMPONENT = 0x1902; + int GL_DEPTH_COMPONENT16 = 0x81A5; + int GL_DEPTH_COMPONENT24 = 0x81A6; + int GL_DEPTH_COMPONENT32 = 0x81A7; + int GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES = 0x8CD1; + int GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES = 0x8CD0; + int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES = 0x8CD3; + int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES = 0x8CD2; + int GL_FRAMEBUFFER_BINDING_OES = 0x8CA6; + int GL_FRAMEBUFFER_COMPLETE_OES = 0x8CD5; + int GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES = 0x8CD6; + int GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES = 0x8CD9; + int GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES = 0x8CDB; + int GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES = 0x8CDA; + int GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES = 0x8CD7; + int GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES = 0x8CDC; + int GL_FRAMEBUFFER_OES = 0x8D40; + int GL_FRAMEBUFFER_UNSUPPORTED_OES = 0x8CDD; + int GL_FUNC_ADD = 0x8006; + int GL_FUNC_REVERSE_SUBTRACT = 0x800B; + int GL_FUNC_SUBTRACT = 0x800A; + int GL_INCR_WRAP = 0x8507; + int GL_INVALID_FRAMEBUFFER_OPERATION_OES = 0x0506; + int GL_MAX_COLOR_ATTACHMENTS_OES = 0x8CDF; + int GL_MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C; + int GL_MAX_RENDERBUFFER_SIZE_OES = 0x84E8; + int GL_MIRRORED_REPEAT = 0x8370; + int GL_NORMAL_MAP = 0x8511; + int GL_REFLECTION_MAP = 0x8512; + int GL_RENDERBUFFER_ALPHA_SIZE_OES = 0x8D53; + int GL_RENDERBUFFER_BINDING_OES = 0x8CA7; + int GL_RENDERBUFFER_BLUE_SIZE_OES = 0x8D52; + int GL_RENDERBUFFER_DEPTH_SIZE_OES = 0x8D54; + int GL_RENDERBUFFER_GREEN_SIZE_OES = 0x8D51; + int GL_RENDERBUFFER_HEIGHT_OES = 0x8D43; + int GL_RENDERBUFFER_INTERNAL_FORMAT_OES = 0x8D44; + int GL_RENDERBUFFER_OES = 0x8D41; + int GL_RENDERBUFFER_RED_SIZE_OES = 0x8D50; + int GL_RENDERBUFFER_STENCIL_SIZE_OES = 0x8D55; + int GL_RENDERBUFFER_WIDTH_OES = 0x8D42; + int GL_RGB5_A1 = 0x8057; + int GL_RGB565_OES = 0x8D62; + int GL_RGB8 = 0x8051; + int GL_RGBA4 = 0x8056; + int GL_RGBA8 = 0x8058; + int GL_STENCIL_ATTACHMENT_OES = 0x8D20; + int GL_STENCIL_INDEX = 0x1901; + int GL_STENCIL_INDEX1_OES = 0x8D46; + int GL_STENCIL_INDEX4_OES = 0x8D47; + int GL_STENCIL_INDEX8_OES = 0x8D48; + int GL_STR = -1; + int GL_TEXTURE_BINDING_CUBE_MAP = 0x8514; + int GL_TEXTURE_CUBE_MAP = 0x8513; + int GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516; + int GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518; + int GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A; + int GL_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515; + int GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517; + int GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519; + int GL_TEXTURE_GEN_MODE = 0x2500; + int GL_TEXTURE_GEN_STR = 0x8D60; + + void glBindFramebufferOES( + int target, + int framebuffer + ); + + void glBindRenderbufferOES( + int target, + int renderbuffer + ); + + void glBindTexture( + int target, + int texture + ); + + void glBlendEquation( + int mode + ); + + void glBlendEquationSeparate( + int modeRGB, + int modeAlpha + ); + + void glBlendFuncSeparate( + int srcRGB, + int dstRGB, + int srcAlpha, + int dstAlpha + ); + + int glCheckFramebufferStatusOES( + int target + ); + + void glCompressedTexImage2D( + int target, + int level, + int internalformat, + int width, + int height, + int border, + int imageSize, + java.nio.Buffer data + ); + + void glCopyTexImage2D( + int target, + int level, + int internalformat, + int x, + int y, + int width, + int height, + int border + ); + + void glDeleteFramebuffersOES( + int n, + int[] framebuffers, + int offset + ); + + void glDeleteFramebuffersOES( + int n, + java.nio.IntBuffer framebuffers + ); + + void glDeleteRenderbuffersOES( + int n, + int[] renderbuffers, + int offset + ); + + void glDeleteRenderbuffersOES( + int n, + java.nio.IntBuffer renderbuffers + ); + + void glEnable( + int cap + ); + + void glFramebufferRenderbufferOES( + int target, + int attachment, + int renderbuffertarget, + int renderbuffer + ); + + void glFramebufferTexture2DOES( + int target, + int attachment, + int textarget, + int texture, + int level + ); + + void glGenerateMipmapOES( + int target + ); + + void glGenFramebuffersOES( + int n, + int[] framebuffers, + int offset + ); + + void glGenFramebuffersOES( + int n, + java.nio.IntBuffer framebuffers + ); + + void glGenRenderbuffersOES( + int n, + int[] renderbuffers, + int offset + ); + + void glGenRenderbuffersOES( + int n, + java.nio.IntBuffer renderbuffers + ); + + void glGetFramebufferAttachmentParameterivOES( + int target, + int attachment, + int pname, + int[] params, + int offset + ); + + void glGetFramebufferAttachmentParameterivOES( + int target, + int attachment, + int pname, + java.nio.IntBuffer params + ); + + void glGetIntegerv( + int pname, + int[] params, + int offset + ); + + void glGetIntegerv( + int pname, + java.nio.IntBuffer params + ); + + void glGetRenderbufferParameterivOES( + int target, + int pname, + int[] params, + int offset + ); + + void glGetRenderbufferParameterivOES( + int target, + int pname, + java.nio.IntBuffer params + ); + + void glGetTexGenfv( + int coord, + int pname, + float[] params, + int offset + ); + + void glGetTexGenfv( + int coord, + int pname, + java.nio.FloatBuffer params + ); + + void glGetTexGeniv( + int coord, + int pname, + int[] params, + int offset + ); + + void glGetTexGeniv( + int coord, + int pname, + java.nio.IntBuffer params + ); + + void glGetTexGenxv( + int coord, + int pname, + int[] params, + int offset + ); + + void glGetTexGenxv( + int coord, + int pname, + java.nio.IntBuffer params + ); + + boolean glIsFramebufferOES( + int framebuffer + ); + + boolean glIsRenderbufferOES( + int renderbuffer + ); + + void glRenderbufferStorageOES( + int target, + int internalformat, + int width, + int height + ); + + void glStencilOp( + int fail, + int zfail, + int zpass + ); + + void glTexEnvf( + int target, + int pname, + float param + ); + + void glTexEnvfv( + int target, + int pname, + float[] params, + int offset + ); + + void glTexEnvfv( + int target, + int pname, + java.nio.FloatBuffer params + ); + + void glTexEnvx( + int target, + int pname, + int param + ); + + void glTexEnvxv( + int target, + int pname, + int[] params, + int offset + ); + + void glTexEnvxv( + int target, + int pname, + java.nio.IntBuffer params + ); + + void glTexGenf( + int coord, + int pname, + float param + ); + + void glTexGenfv( + int coord, + int pname, + float[] params, + int offset + ); + + void glTexGenfv( + int coord, + int pname, + java.nio.FloatBuffer params + ); + + void glTexGeni( + int coord, + int pname, + int param + ); + + void glTexGeniv( + int coord, + int pname, + int[] params, + int offset + ); + + void glTexGeniv( + int coord, + int pname, + java.nio.IntBuffer params + ); + + void glTexGenx( + int coord, + int pname, + int param + ); + + void glTexGenxv( + int coord, + int pname, + int[] params, + int offset + ); + + void glTexGenxv( + int coord, + int pname, + java.nio.IntBuffer params + ); + + void glTexParameterf( + int target, + int pname, + float param + ); + +} |