///*
// * 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 com.cooliris.media;
//
//import java.io.Writer;
//import java.util.ArrayList;
//
//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 OpenGL rendering.
// * <p>
// * A GLSurfaceView provides the following features:
// * <p>
// * <ul>
// * <li>Manages a surface, which is a special piece of memory that can be
// * composited into the Android view system.
// * <li>Manages an EGL display, which enables OpenGL to render into a surface.
// * <li>Accepts a user-provided Renderer object that does the actual rendering.
// * <li>Renders on a dedicated thread to decouple rendering performance from the
// * UI thread.
// * <li>Supports both on-demand and continuous rendering.
// * <li>Optionally wraps, traces, and/or error-checks the renderer's OpenGL calls.
// * </ul>
// *
// * <h3>Using GLSurfaceView</h3>
// * <p>
// * Typically you use GLSurfaceView by subclassing it and overriding one or more of the
// * View system input event methods. If your application does not need to override event
// * methods then GLSurfaceView can be used as-is. For the most part
// * GLSurfaceView behavior is customized by calling "set" methods rather than by subclassing.
// * For example, unlike a regular View, drawing is delegated to a separate Renderer object which
// * is registered with the GLSurfaceView
// * using the {@link #setRenderer(Renderer)} call.
// * <p>
// * <h3>Initializing GLSurfaceView</h3>
// * All you have to do to initialize a GLSurfaceView is call {@link #setRenderer(Renderer)}.
// * However, if desired, you can modify the default behavior of GLSurfaceView by calling one or
// * more of these methods before calling setRenderer:
// * <ul>
// * <li>{@link #setDebugFlags(int)}
// * <li>{@link #setEGLConfigChooser(boolean)}
// * <li>{@link #setEGLConfigChooser(EGLConfigChooser)}
// * <li>{@link #setEGLConfigChooser(int, int, int, int, int, int)}
// * <li>{@link #setGLWrapper(GLWrapper)}
// * </ul>
// * <p>
// * <h4>Choosing an EGL Configuration</h4>
// * A given Android device may support multiple possible types of drawing surfaces.
// * The available surfaces may differ in how may channels of data are present, as
// * well as how many bits are allocated to each channel. Therefore, the first thing
// * GLSurfaceView has to do when starting to render is choose what type of surface to use.
// * <p>
// * By default GLSurfaceView chooses an available surface that's closest to a 16-bit R5G6B5 surface
// * with a 16-bit depth buffer and no stencil. If you would prefer a different surface (for example,
// * if you do not need a depth buffer) you can override the default behavior by calling one of the
// * setEGLConfigChooser methods.
// * <p>
// * <h4>Debug Behavior</h4>
// * You can optionally modify the behavior of GLSurfaceView by calling
// * one or more of the debugging methods {@link #setDebugFlags(int)},
// * and {@link #setGLWrapper}. These methods may be called before and/or after setRenderer, but
// * typically they are called before setRenderer so that they take effect immediately.
// * <p>
// * <h4>Setting a Renderer</h4>
// * Finally, you must call {@link #setRenderer} to register a {@link Renderer}.
// * The renderer is
// * responsible for doing the actual OpenGL rendering.
// * <p>
// * <h3>Rendering Mode</h3>
// * Once the renderer is set, you can control whether the renderer draws
// * continuously or on-demand by calling
// * {@link #setRenderMode}. The default is continuous rendering.
// * <p>
// * <h3>Activity Life-cycle</h3>
// * A GLSurfaceView must be notified when the activity is paused and resumed. GLSurfaceView clients
// * are required to call {@link #onPause()} when the activity pauses and
// * {@link #onResume()} when the activity resumes. These calls allow GLSurfaceView to
// * pause and resume the rendering thread, and also allow GLSurfaceView to release and recreate
// * the OpenGL display.
// * <p>
// * <h3>Handling events</h3>
// * <p>
// * To handle an event you will typically subclass GLSurfaceView and override the
// * appropriate method, just as you would with any other View. However, when handling
// * the event, you may need to communicate with the Renderer object
// * that's running in the rendering thread. You can do this using any
// * standard Java cross-thread communication mechanism. In addition,
// * one relatively easy way to communicate with your renderer is
// * to call
// * {@link #queueEvent(Runnable)}. For example:
// * <pre class="prettyprint">
// * class MyGLSurfaceView extends GLSurfaceView {
// *
// * private MyRenderer mMyRenderer;
// *
// * public void start() {
// * mMyRenderer = ...;
// * setRenderer(mMyRenderer);
// * }
// *
// * public boolean onKeyDown(int keyCode, KeyEvent event) {
// * if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
// * queueEvent(new Runnable() {
// * // This method will be called on the rendering
// * // thread:
// * public void run() {
// * mMyRenderer.handleDpadCenter();
// * }});
// * return true;
// * }
// * return super.onKeyDown(keyCode, event);
// * }
// * }
// * </pre>
// *
// */
//public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback {
// private final static boolean LOG_THREADS = false;
// /**
// * The renderer only renders
// * when the surface is created, or when {@link #requestRender} is called.
// *
// * @see #getRenderMode()
// * @see #setRenderMode(int)
// */
// public final static int RENDERMODE_WHEN_DIRTY = 0;
// /**
// * The renderer is called
// * continuously to re-render the scene.
// *
// * @see #getRenderMode()
// * @see #setRenderMode(int)
// * @see #requestRender()
// */
// public final static int RENDERMODE_CONTINUOUSLY = 1;
//
// /**
// * Check glError() after every GL call and throw an exception if glError indicates
// * that an error has occurred. This can be used to help track down which OpenGL ES call
// * is causing an error.
// *
// * @see #getDebugFlags
// * @see #setDebugFlags
// */
// public final static int DEBUG_CHECK_GL_ERROR = 1;
//
// /**
// * Log GL calls to the system log at "verbose" level with tag "GLSurfaceView".
// *
// * @see #getDebugFlags
// * @see #setDebugFlags
// */
// public final static int DEBUG_LOG_GL_CALLS = 2;
//
// /**
// * Standard View constructor. In order to render something, you
// * must call {@link #setRenderer} to register a renderer.
// */
// public GLSurfaceView(Context context) {
// super(context);
// init();
// }
//
// /**
// * Standard View constructor. In order to render something, you
// * must call {@link #setRenderer} to register a renderer.
// */
// 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);
// }
//
// /**
// * Set the glWrapper. If the glWrapper is not null, its
// * {@link GLWrapper#wrap(GL)} method is called
// * whenever a surface is created. A GLWrapper can be used to wrap
// * the GL object that's passed to the renderer. Wrapping a GL
// * object enables examining and modifying the behavior of the
// * GL calls made by the renderer.
// * <p>
// * Wrapping is typically used for debugging purposes.
// * <p>
// * 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 value is
// * constructed by OR-together zero or more
// * of the DEBUG_CHECK_* constants. 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;
// }
//
// /**
// * Get the current value of the debug flags.
// * @return the current value of the debug flags.
// */
// public int getDebugFlags() {
// return mDebugFlags;
// }
//
// /**
// * Set the renderer associated with this view. Also starts the thread that
// * will call the renderer, which in turn causes the rendering to start.
// * <p>This method should be called once and only once in the life-cycle of
// * a GLSurfaceView.
// * <p>The following GLSurfaceView methods can only be called <em>before</em>
// * setRenderer is called:
// * <ul>
// * <li>{@link #setEGLConfigChooser(boolean)}
// * <li>{@link #setEGLConfigChooser(EGLConfigChooser)}
// * <li>{@link #setEGLConfigChooser(int, int, int, int, int, int)}
// * </ul>
// * <p>
// * The following GLSurfaceView methods can only be called <em>after</em>
// * setRenderer is called:
// * <ul>
// * <li>{@link #getRenderMode()}
// * <li>{@link #onPause()}
// * <li>{@link #onResume()}
// * <li>{@link #queueEvent(Runnable)}
// * <li>{@link #requestRender()}
// * <li>{@link #setRenderMode(int)}
// * </ul>
// *
// * @param renderer the renderer to use to perform OpenGL drawing.
// */
// public void setRenderer(Renderer renderer) {
// checkRenderThreadState();
// if (mEGLConfigChooser == null) {
// mEGLConfigChooser = new SimpleEGLConfigChooser(true);
// }
// if (mEGLContextFactory == null) {
// mEGLContextFactory = new DefaultContextFactory();
// }
// if (mEGLWindowSurfaceFactory == null) {
// mEGLWindowSurfaceFactory = new DefaultWindowSurfaceFactory();
// }
// mGLThread = new GLThread(renderer);
// mGLThread.start();
// }
//
// /**
// * Install a custom EGLContextFactory.
// * <p>If this method is
// * called, it must be called before {@link #setRenderer(Renderer)}
// * is called.
// * <p>
// * If this method is not called, then by default
// * a context will be created with no shared context and
// * with a null attribute list.
// */
// public void setEGLContextFactory(EGLContextFactory factory) {
// checkRenderThreadState();
// mEGLContextFactory = factory;
// }
//
// /**
// * Install a custom EGLWindowSurfaceFactory.
// * <p>If this method is
// * called, it must be called before {@link #setRenderer(Renderer)}
// * is called.
// * <p>
// * If this method is not called, then by default
// * a window surface will be created with a null attribute list.
// */
// public void setEGLWindowSurfaceFactory(EGLWindowSurfaceFactory factory) {
// checkRenderThreadState();
// mEGLWindowSurfaceFactory = factory;
// }
//
// /**
// * Install a custom EGLConfigChooser.
// * <p>If this method is
// * called, it must be called before {@link #setRenderer(Renderer)}
// * is called.
// * <p>
// * If no setEGLConfigChooser method is called, then by default the
// * view will choose a config as close to 16-bit RGB as possible, with
// * a depth buffer as close to 16 bits as possible.
// * @param configChooser
// */
// public void setEGLConfigChooser(EGLConfigChooser configChooser) {
// checkRenderThreadState();
// mEGLConfigChooser = configChooser;
// }
//
// /**
// * Install a config chooser which will choose a config
// * as close to 16-bit RGB as possible, with or without an optional depth
// * buffer as close to 16-bits as possible.
// * <p>If this method is
// * called, it must be called before {@link #setRenderer(Renderer)}
// * is called.
// * <p>
// * If no setEGLConfigChooser method is called, then by default the
// * view will choose a config as close to 16-bit RGB as possible, with
// * a depth buffer as close to 16 bits as possible.
// *
// * @param needDepth
// */
// public void setEGLConfigChooser(boolean needDepth) {
// setEGLConfigChooser(new SimpleEGLConfigChooser(needDepth));
// }
//
// /**
// * Install a config chooser which will choose a config
// * with at least the specified component sizes, and as close
// * to the specified component sizes as possible.
// * <p>If this method is
// * called, it must be called before {@link #setRenderer(Renderer)}
// * is called.
// * <p>
// * If no setEGLConfigChooser method is called, then by default the
// * view will choose a config as close to 16-bit RGB as possible, with
// * a depth buffer as close to 16 bits as possible.
// *
// */
// public void setEGLConfigChooser(int redSize, int greenSize, int blueSize,
// int alphaSize, int depthSize, int stencilSize) {
// setEGLConfigChooser(new ComponentSizeChooser(redSize, greenSize,
// blueSize, alphaSize, depthSize, stencilSize));
// }
// /**
// * Set the rendering mode. When renderMode is
// * RENDERMODE_CONTINUOUSLY, the renderer is called
// * repeatedly to re-render the scene. When renderMode
// * is RENDERMODE_WHEN_DIRTY, the renderer only rendered when the surface
// * is created, or when {@link #requestRender} is called. Defaults to RENDERMODE_CONTINUOUSLY.
// * <p>
// * Using RENDERMODE_WHEN_DIRTY can improve battery life and overall system performance
// * by allowing the GPU and CPU to idle when the view does not need to be updated.
// * <p>
// * This method can only be called after {@link #setRenderer(Renderer)}
// *
// * @param renderMode one of the RENDERMODE_X constants
// * @see #RENDERMODE_CONTINUOUSLY
// * @see #RENDERMODE_WHEN_DIRTY
// */
// 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 the current rendering mode.
// * @see #RENDERMODE_CONTINUOUSLY
// * @see #RENDERMODE_WHEN_DIRTY
// */
// public int getRenderMode() {
// return mGLThread.getRenderMode();
// }
//
// /**
// * Request that the renderer render a frame.
// * This method is typically used when the render mode has been set to
// * {@link #RENDERMODE_WHEN_DIRTY}, so that frames are only rendered on demand.
// * May be called
// * from any thread. Must not be called before a renderer has been set.
// */
// public void requestRender() {
// mGLThread.requestRender();
// }
//
// /**
// * This method is part of the SurfaceHolder.Callback interface, and is
// * not normally called or subclassed by clients of GLSurfaceView.
// */
// public void surfaceCreated(SurfaceHolder holder) {
// mGLThread.surfaceCreated();
// }
//
// /**
// * This method is part of the SurfaceHolder.Callback interface, and is
// * not normally called or subclassed by clients of GLSurfaceView.
// */
// public void surfaceDestroyed(SurfaceHolder holder) {
// // Surface will be destroyed when we return
// mGLThread.surfaceDestroyed();
// }
//
// /**
// * This method is part of the SurfaceHolder.Callback interface, and is
// * not normally called or subclassed by clients of GLSurfaceView.
// */
// 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. Calling this method will
// * pause the rendering thread.
// * Must not be called before a renderer has been set.
// */
// 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. Calling this method will
// * recreate the OpenGL display and resume the rendering
// * thread.
// * Must not be called before a renderer has been set.
// */
// public void onResume() {
// mGLThread.onResume();
// }
//
// /**
// * Queue a runnable to be run on the GL rendering thread. This can be used
// * to communicate with the Renderer on the rendering thread.
// * Must not be called before a renderer has been set.
// * @param r the runnable to be run on the GL rendering thread.
// */
// public void queueEvent(Runnable r) {
// mGLThread.queueEvent(r);
// }
//
// /**
// * This method is used as part of the View class and is not normally
// * called or subclassed by clients of GLSurfaceView.
// * Must not be called before a renderer has been set.
// */
// @Override
// protected void onDetachedFromWindow() {
// super.onDetachedFromWindow();
// mGLThread.requestExitAndWait();
// }
//
// // ----------------------------------------------------------------------
//
// /**
// * An interface used to wrap a GL interface.
// * <p>Typically
// * used for implementing debugging and tracing on top of the default
// * GL interface. You would typically use this by creating your own class
// * that implemented all the GL methods by delegating to another GL instance.
// * Then you could add your own behavior before or after calling the
// * delegate. All the GLWrapper would do was instantiate and return the
// * wrapper GL instance:
// * <pre class="prettyprint">
// * class MyGLWrapper implements GLWrapper {
// * GL wrap(GL gl) {
// * return new MyGLImplementation(gl);
// * }
// * static class MyGLImplementation implements GL,GL10,GL11,... {
// * ...
// * }
// * }
// * </pre>
// * @see #setGLWrapper(GLWrapper)
// */
// public interface GLWrapper {
// /**
// * Wraps a gl interface in another gl interface.
// * @param gl a GL interface that is to be wrapped.
// * @return either the input argument or another GL object that wraps the input argument.
// */
// GL wrap(GL gl);
// }
//
// /**
// * A generic renderer interface.
// * <p>
// * The renderer is responsible for making OpenGL calls to render a frame.
// * <p>
// * GLSurfaceView clients typically create their own classes that implement
// * this interface, and then call {@link GLSurfaceView#setRenderer} to
// * register the renderer with the GLSurfaceView.
// * <p>
// * <h3>Threading</h3>
// * The renderer will be called on a separate thread, so that rendering
// * performance is decoupled from the UI thread. Clients typically need to
// * communicate with the renderer from the UI thread, because that's where
// * input events are received. Clients can communicate using any of the
// * standard Java techniques for cross-thread communication, or they can
// * use the {@link GLSurfaceView#queueEvent(Runnable)} convenience method.
// * <p>
// * <h3>EGL Context Lost</h3>
// * There are situations where the EGL rendering context will be lost. This
// * typically happens when device wakes up after going to sleep. When
// * the EGL context is lost, all OpenGL resources (such as textures) that are
// * associated with that context will be automatically deleted. In order to
// * keep rendering correctly, a renderer must recreate any lost resources
// * that it still needs. The {@link #onSurfaceCreated(GL10, EGLConfig)} method
// * is a convenient place to do this.
// *
// *
// * @see #setRenderer(Renderer)
// */
// public interface Renderer {
// /**
// * Called when the surface is created or recreated.
// * <p>
// * Called when the rendering thread
// * starts and whenever the EGL context is lost. The context will typically
// * be lost when the Android device awakes after going to sleep.
// * <p>
// * Since this method is called at the beginning of rendering, as well as
// * every time the EGL context is lost, this method is a convenient place to put
// * code to create resources that need to be created when the rendering
// * starts, and that need to be recreated when the EGL context is lost.
// * Textures are an example of a resource that you might want to create
// * here.
// * <p>
// * Note that when the EGL context is lost, all OpenGL resources associated
// * with that context will be automatically deleted. You do not need to call
// * the corresponding "glDelete" methods such as glDeleteTextures to
// * manually delete these lost resources.
// * <p>
// * @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);
//
// /**
// * Called when the surface changed size.
// * <p>
// * Called after the surface is created and whenever
// * the OpenGL ES surface size changes.
// * <p>
// * Typically you will set your viewport here. If your camera
// * is fixed then you could also set your projection matrix here:
// * <pre class="prettyprint">
// * void onSurfaceChanged(GL10 gl, int width, int height) {
// * gl.glViewport(0, 0, width, height);
// * // for a fixed camera, set the projection too
// * float ratio = (float) width / height;
// * gl.glMatrixMode(GL10.GL_PROJECTION);
// * gl.glLoadIdentity();
// * gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10);
// * }
// * </pre>
// * @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);
//
// /**
// * Called to draw the current frame.
// * <p>
// * This method is responsible for drawing the current frame.
// * <p>
// * The implementation of this method typically looks like this:
// * <pre class="prettyprint">
// * void onDrawFrame(GL10 gl) {
// * gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
// * //... other gl calls to render the scene ...
// * }
// * </pre>
// * @param gl the GL interface. Use <code>instanceof</code> to
// * test if the interface supports GL11 or higher interfaces.
// */
// void onDrawFrame(GL10 gl);
// }
//
// /**
// * An interface for customizing the eglCreateContext and eglDestroyContext calls.
// * <p>
// * This interface must be implemented by clients wishing to call
// * {@link GLSurfaceView#setEGLContextFactory(EGLContextFactory)}
// */
// public interface EGLContextFactory {
// EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig);
// void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context);
// }
//
// private static class DefaultContextFactory implements EGLContextFactory {
//
// public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig config) {
// return egl.eglCreateContext(display, config, EGL10.EGL_NO_CONTEXT, null);
// }
//
// public void destroyContext(EGL10 egl, EGLDisplay display,
// EGLContext context) {
// egl.eglDestroyContext(display, context);
// }
// }
//
// /**
// * An interface for customizing the eglCreateWindowSurface and eglDestroySurface calls.
// * <p>
// * This interface must be implemented by clients wishing to call
// * {@link GLSurfaceView#setEGLWindowSurfaceFactory(EGLWindowSurfaceFactory)}
// */
// public interface EGLWindowSurfaceFactory {
// EGLSurface createWindowSurface(EGL10 egl, EGLDisplay display, EGLConfig config,
// Object nativeWindow);
// void destroySurface(EGL10 egl, EGLDisplay display, EGLSurface surface);
// }
//
// private static class DefaultWindowSurfaceFactory implements EGLWindowSurfaceFactory {
//
// public EGLSurface createWindowSurface(EGL10 egl, EGLDisplay display,
// EGLConfig config, Object nativeWindow) {
// return egl.eglCreateWindowSurface(display, config, nativeWindow, null);
// }
//
// public void destroySurface(EGL10 egl, EGLDisplay display,
// EGLSurface surface) {
// egl.eglDestroySurface(display, surface);
// }
// }
//
// /**
// * An interface for choosing an EGLConfig configuration from a list of
// * potential configurations.
// * <p>
// * This interface must be implemented by clients wishing to call
// * {@link GLSurfaceView#setEGLConfigChooser(EGLConfigChooser)}
// */
// public interface EGLConfigChooser {
// /**
// * Choose a configuration from the list. Implementors typically
// * implement this method by calling
// * {@link EGL10#eglChooseConfig} and iterating through the results. Please consult the
// * EGL specification available from The Khronos Group to learn how to call eglChooseConfig.
// * @param egl the EGL10 for the current display.
// * @param display the current display.
// * @return the chosen configuration.
// */
// EGLConfig chooseConfig(EGL10 egl, EGLDisplay display);
// }
//
// private static abstract class BaseConfigChooser
// implements EGLConfigChooser {
// public BaseConfigChooser(int[] configSpec) {
// mConfigSpec = configSpec;
// }
// public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
// int[] num_config = new int[1];
// egl.eglChooseConfig(display, mConfigSpec, null, 0, num_config);
//
// int numConfigs = num_config[0];
//
// if (numConfigs <= 0) {
// throw new IllegalArgumentException(
// "No configs match configSpec");
// }
//
// EGLConfig[] configs = new EGLConfig[numConfigs];
// egl.eglChooseConfig(display, mConfigSpec, configs, numConfigs,
// num_config);
// EGLConfig config = chooseConfig(egl, display, configs);
// if (config == null) {
// throw new IllegalArgumentException("No config chosen");
// }
// return config;
// }
//
// abstract EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
// EGLConfig[] configs);
//
// protected int[] mConfigSpec;
// }
//
// private static class ComponentSizeChooser extends BaseConfigChooser {
// public ComponentSizeChooser(int redSize, int greenSize, int blueSize,
// int alphaSize, int depthSize, int stencilSize) {
// super(new int[] {
// EGL10.EGL_RED_SIZE, redSize,
// EGL10.EGL_GREEN_SIZE, greenSize,
// EGL10.EGL_BLUE_SIZE, blueSize,
// EGL10.EGL_ALPHA_SIZE, alphaSize,
// EGL10.EGL_DEPTH_SIZE, depthSize,
// EGL10.EGL_STENCIL_SIZE, stencilSize,
// EGL10.EGL_NONE});
// mValue = new int[1];
// mRedSize = redSize;
// mGreenSize = greenSize;
// mBlueSize = blueSize;
// mAlphaSize = alphaSize;
// mDepthSize = depthSize;
// mStencilSize = stencilSize;
// }
//
// @Override
// public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
// EGLConfig[] configs) {
// EGLConfig closestConfig = null;
// int closestDistance = 1000;
// for(EGLConfig config : configs) {
// int d = findConfigAttrib(egl, display, config,
// EGL10.EGL_DEPTH_SIZE, 0);
// int s = findConfigAttrib(egl, display, config,
// EGL10.EGL_STENCIL_SIZE, 0);
// if (d >= mDepthSize && s>= mStencilSize) {
// int r = findConfigAttrib(egl, display, config,
// EGL10.EGL_RED_SIZE, 0);
// int g = findConfigAttrib(egl, display, config,
// EGL10.EGL_GREEN_SIZE, 0);
// int b = findConfigAttrib(egl, display, config,
// EGL10.EGL_BLUE_SIZE, 0);
// int a = findConfigAttrib(egl, display, config,
// EGL10.EGL_ALPHA_SIZE, 0);
// int distance = Math.abs(r - mRedSize)
// + Math.abs(g - mGreenSize)
// + Math.abs(b - mBlueSize)
// + Math.abs(a - mAlphaSize);
// if (distance < closestDistance) {
// closestDistance = distance;
// closestConfig = config;
// }
// }
// }
// return closestConfig;
// }
//
// private int findConfigAttrib(EGL10 egl, EGLDisplay display,
// EGLConfig config, int attribute, int defaultValue) {
//
// if (egl.eglGetConfigAttrib(display, config, attribute, mValue)) {
// return mValue[0];
// }
// return defaultValue;
// }
//
// private int[] mValue;
// // Subclasses can adjust these values:
// protected int mRedSize;
// protected int mGreenSize;
// protected int mBlueSize;
// protected int mAlphaSize;
// protected int mDepthSize;
// protected int mStencilSize;
// }
//
// /**
// * This class will choose a supported surface as close to
// * RGB565 as possible, with or without a depth buffer.
// *
// */
// private static class SimpleEGLConfigChooser extends ComponentSizeChooser {
// public SimpleEGLConfigChooser(boolean withDepthBuffer) {
// super(4, 4, 4, 0, withDepthBuffer ? 16 : 0, 0);
// // Adjust target values. This way we'll accept a 4444 or
// // 555 buffer if there's no 565 buffer available.
// mRedSize = 5;
// mGreenSize = 6;
// mBlueSize = 5;
// }
// }
//
// /**
// * An EGL helper class.
// */
//
// private class EglHelper {
// public EglHelper() {
//
// }
//
// /**
// * Initialize EGL for a given configuration spec.
// * @param configSpec
// */
// public void start(){
// /*
// * 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);
// mEglConfig = mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
//
// /*
// * Create an OpenGL ES context. This must be done only once, an
// * OpenGL context is a somewhat heavy object.
// */
// mEglContext = mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig);
// if (mEglContext == null || mEglContext == EGL10.EGL_NO_CONTEXT) {
// throw new RuntimeException("createContext failed");
// }
//
// 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 && mEglSurface != EGL10.EGL_NO_SURFACE) {
//
// /*
// * 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);
// mEGLWindowSurfaceFactory.destroySurface(mEgl, mEglDisplay, mEglSurface);
// }
//
// /*
// * Create an EGL surface we can render into.
// */
// mEglSurface = mEGLWindowSurfaceFactory.createWindowSurface(mEgl,
// mEglDisplay, mEglConfig, holder);
//
// if (mEglSurface == null || mEglSurface == EGL10.EGL_NO_SURFACE) {
// throw new RuntimeException("createWindowSurface failed");
// }
//
// /*
// * Before we can issue GL commands, we need to make sure
// * the context is current and bound to a surface.
// */
// if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
// throw new RuntimeException("eglMakeCurrent failed.");
// }
//
// 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 destroySurface() {
// if (mEglSurface != null && mEglSurface != EGL10.EGL_NO_SURFACE) {
// mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE,
// EGL10.EGL_NO_SURFACE,
// EGL10.EGL_NO_CONTEXT);
// mEGLWindowSurfaceFactory.destroySurface(mEgl, mEglDisplay, mEglSurface);
// mEglSurface = null;
// }
// }
//
// public void finish() {
// if (mEglContext != null) {
// mEGLContextFactory.destroyContext(mEgl, 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.
// *
// * All potentially blocking synchronization is done through the
// * sGLThreadManager object. This avoids multiple-lock ordering issues.
// *
// */
// class GLThread extends Thread {
// GLThread(Renderer renderer) {
// super();
// mWidth = 0;
// mHeight = 0;
// mRequestRender = true;
// mRenderMode = RENDERMODE_CONTINUOUSLY;
// mRenderer = renderer;
// }
//
// @Override
// public void run() {
// setName("GLThread " + getId());
// if (LOG_THREADS) {
// Log.i("GLThread", "starting tid=" + getId());
// }
//
// try {
// guardedRun();
// } catch (InterruptedException e) {
// // fall thru and exit normally
// } finally {
// sGLThreadManager.threadExiting(this);
// }
// }
//
// /*
// * This private method should only be called inside a
// * synchronized(sGLThreadManager) block.
// */
// private void stopEglLocked() {
// if (mHaveEgl) {
// mHaveEgl = false;
// mEglHelper.destroySurface();
// mEglHelper.finish();
// sGLThreadManager.releaseEglSurfaceLocked(this);
// }
// }
//
// private void guardedRun() throws InterruptedException {
// mEglHelper = new EglHelper();
// try {
// GL10 gl = null;
// boolean createEglSurface = false;
// int w = 0;
// int h = 0;
// Runnable event = null;
//
// while (true) {
// synchronized (sGLThreadManager) {
// while (true) {
// if (mShouldExit) {
// return;
// }
//
// if (! mEventQueue.isEmpty()) {
// event = mEventQueue.remove(0);
// break;
// }
//
// // Do we need to release the EGL surface?
// if (mHaveEgl && mPaused) {
// stopEglLocked();
// }
//
// // Have we lost the surface view surface?
// if ((! mHasSurface) && (! mWaitingForSurface)) {
// if (mHaveEgl) {
// stopEglLocked();
// }
// mWaitingForSurface = true;
// sGLThreadManager.notifyAll();
// }
//
// // Have we acquired the surface view surface?
// if (mHasSurface && mWaitingForSurface) {
// mWaitingForSurface = false;
// sGLThreadManager.notifyAll();
// }
//
// // Ready to draw?
// if ((!mPaused) && mHasSurface
// && (mWidth > 0) && (mHeight > 0)
// && (mRequestRender || (mRenderMode == RENDERMODE_CONTINUOUSLY))) {
//
// // If we don't have an egl surface, try to acquire one.
// if ((! mHaveEgl) && sGLThreadManager.tryAcquireEglSurfaceLocked(this)) {
// mHaveEgl = true;
// mEglHelper.start();
// createEglSurface = true;
// sGLThreadManager.notifyAll();
// }
//
// if (mHaveEgl) {
// if ( mSizeChanged) {
// createEglSurface = true;
// w = mWidth;
// h = mHeight;
// mSizeChanged = false;
// }
// mRequestRender = false;
// sGLThreadManager.notifyAll();
// break;
// }
// }
//
// // By design, this is the only place in a GLThread thread where we wait().
// if (LOG_THREADS) {
// Log.i("GLThread", "waiting tid=" + getId());
// }
// sGLThreadManager.wait();
// }
// } // end of synchronized(sGLThreadManager)
//
// if (event != null) {
// event.run();
// event = null;
// continue;
// }
//
// if (createEglSurface) {
// gl = (GL10) mEglHelper.createSurface(getHolder());
// mRenderer.onSurfaceCreated(gl, mEglHelper.mEglConfig);
// mRenderer.onSurfaceChanged(gl, w, h);
// createEglSurface = false;
// }
//
// mRenderer.onDrawFrame(gl);
// mEglHelper.swap();
// }
// } finally {
// /*
// * clean-up everything...
// */
// synchronized (sGLThreadManager) {
// stopEglLocked();
// }
// }
// }
//
// public void setRenderMode(int renderMode) {
// if ( !((RENDERMODE_WHEN_DIRTY <= renderMode) && (renderMode <= RENDERMODE_CONTINUOUSLY)) ) {
// throw new IllegalArgumentException("renderMode");
// }
// synchronized(sGLThreadManager) {
// mRenderMode = renderMode;
// sGLThreadManager.notifyAll();
// }
// }
//
// public int getRenderMode() {
// synchronized(sGLThreadManager) {
// return mRenderMode;
// }
// }
//
// public void requestRender() {
// synchronized(sGLThreadManager) {
// mRequestRender = true;
// sGLThreadManager.notifyAll();
// }
// }
//
// public void surfaceCreated() {
// synchronized(sGLThreadManager) {
// if (LOG_THREADS) {
// Log.i("GLThread", "surfaceCreated tid=" + getId());
// }
// mHasSurface = true;
// sGLThreadManager.notifyAll();
// }
// }
//
// public void surfaceDestroyed() {
// synchronized(sGLThreadManager) {
// if (LOG_THREADS) {
// Log.i("GLThread", "surfaceDestroyed tid=" + getId());
// }
// mHasSurface = false;
// sGLThreadManager.notifyAll();
// while((!mWaitingForSurface) && (!mExited)) {
// try {
// sGLThreadManager.wait();
// } catch (InterruptedException e) {
// Thread.currentThread().interrupt();
// }
// }
// }
// }
//
// public void onPause() {
// synchronized (sGLThreadManager) {
// mPaused = true;
// sGLThreadManager.notifyAll();
// }
// }
//
// public void onResume() {
// synchronized (sGLThreadManager) {
// mPaused = false;
// mRequestRender = true;
// sGLThreadManager.notifyAll();
// }
// }
//
// public void onWindowResize(int w, int h) {
// synchronized (sGLThreadManager) {
// mWidth = w;
// mHeight = h;
// mSizeChanged = true;
// sGLThreadManager.notifyAll();
// }
// }
//
// public void requestExitAndWait() {
// // don't call this from GLThread thread or it is a guaranteed
// // deadlock!
// synchronized(sGLThreadManager) {
// mShouldExit = true;
// sGLThreadManager.notifyAll();
// while (! mExited) {
// try {
// sGLThreadManager.wait();
// } 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) {
// if (r == null) {
// throw new IllegalArgumentException("r must not be null");
// }
// synchronized(sGLThreadManager) {
// mEventQueue.add(r);
// sGLThreadManager.notifyAll();
// }
// }
//
// // Once the thread is started, all accesses to the following member
// // variables are protected by the sGLThreadManager monitor
// private boolean mShouldExit;
// private boolean mExited;
// private boolean mPaused;
// private boolean mHasSurface;
// private boolean mWaitingForSurface;
// private boolean mHaveEgl;
// private int mWidth;
// private int mHeight;
// private int mRenderMode;
// private boolean mRequestRender;
// private ArrayList<Runnable> mEventQueue = new ArrayList<Runnable>();
// // End of member variables protected by the sGLThreadManager monitor.
//
// private Renderer mRenderer;
// 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 void checkRenderThreadState() {
// if (mGLThread != null) {
// throw new IllegalStateException(
// "setRenderer has already been called for this instance.");
// }
// }
//
// private static class GLThreadManager {
//
// public synchronized void threadExiting(GLThread thread) {
// if (LOG_THREADS) {
// Log.i("GLThread", "exiting tid=" + thread.getId());
// }
// thread.mExited = true;
// if (mEglOwner == thread) {
// mEglOwner = null;
// }
// notifyAll();
// }
//
// /*
// * Tries once to acquire the right to use an EGL
// * surface. Does not block. Requires that we are already
// * in the sGLThreadManager monitor when this is called.
// * @return true if the right to use an EGL surface was acquired.
// */
// public boolean tryAcquireEglSurfaceLocked(GLThread thread) {
// if (mEglOwner == thread || mEglOwner == null) {
// mEglOwner = thread;
// notifyAll();
// return true;
// }
// return false;
// }
// /*
// * Releases the EGL surface. Requires that we are already in the
// * sGLThreadManager monitor when this is called.
// */
// public void releaseEglSurfaceLocked(GLThread thread) {
// if (mEglOwner == thread) {
// mEglOwner = null;
// }
// notifyAll();
// }
//
// private GLThread mEglOwner;
// }
//
// private static final GLThreadManager sGLThreadManager = new GLThreadManager();
// private boolean mSizeChanged = true;
//
// private GLThread mGLThread;
// private EGLConfigChooser mEGLConfigChooser;
// private EGLContextFactory mEGLContextFactory;
// private EGLWindowSurfaceFactory mEGLWindowSurfaceFactory;
// private GLWrapper mGLWrapper;
// private int mDebugFlags;
//}