| /* |
| * 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 android.compat.annotation.UnsupportedAppUsage; |
| import android.content.Context; |
| import android.os.Trace; |
| import android.util.AttributeSet; |
| import android.util.Log; |
| import android.view.SurfaceHolder; |
| import android.view.SurfaceView; |
| |
| import java.io.Writer; |
| import java.lang.ref.WeakReference; |
| 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; |
| |
| /** |
| * 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> |
| * |
| * <div class="special reference"> |
| * <h3>Developer Guides</h3> |
| * <p>For more information about how to use OpenGL, read the |
| * <a href="{@docRoot}guide/topics/graphics/opengl.html">OpenGL</a> developer guide.</p> |
| * </div> |
| * |
| * <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>Specifying the android.view.Surface</h4> |
| * By default GLSurfaceView will create a PixelFormat.RGB_888 format surface. If a translucent |
| * surface is required, call getHolder().setFormat(PixelFormat.TRANSLUCENT). |
| * The exact format of a TRANSLUCENT surface is device dependent, but it will be |
| * a 32-bit-per-pixel surface with 8 bits per component. |
| * <p> |
| * <h4>Choosing an EGL Configuration</h4> |
| * A given Android device may support multiple EGLConfig rendering configurations. |
| * The available configurations may differ in how many 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 EGLConfig to use. |
| * <p> |
| * By default GLSurfaceView chooses a EGLConfig that has an RGB_888 pixel format, |
| * with at least a 16-bit depth buffer and no stencil. |
| * <p> |
| * If you would prefer a different EGLConfig |
| * 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 to pause and resume rendering. GLSurfaceView clients |
| * are required to call {@link #onPause()} when the activity stops and |
| * {@link #onResume()} when the activity starts. 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.Callback2 { |
| private final static String TAG = "GLSurfaceView"; |
| private final static boolean LOG_ATTACH_DETACH = false; |
| private final static boolean LOG_THREADS = false; |
| private final static boolean LOG_PAUSE_RESUME = false; |
| private final static boolean LOG_SURFACE = false; |
| private final static boolean LOG_RENDERER = false; |
| private final static boolean LOG_RENDERER_DRAW_FRAME = false; |
| private final static boolean LOG_EGL = false; |
| /** |
| * The renderer only renders |
| * when the surface is created, or when {@link #requestRender} is called. |
| * |
| * @see #getRenderMode() |
| * @see #setRenderMode(int) |
| * @see #requestRender() |
| */ |
| public final static int RENDERMODE_WHEN_DIRTY = 0; |
| /** |
| * The renderer is called |
| * continuously to re-render the scene. |
| * |
| * @see #getRenderMode() |
| * @see #setRenderMode(int) |
| */ |
| 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(); |
| } |
| |
| @Override |
| protected void finalize() throws Throwable { |
| try { |
| if (mGLThread != null) { |
| // GLThread may still be running if this view was never |
| // attached to a window. |
| mGLThread.requestExitAndWait(); |
| } |
| } finally { |
| super.finalize(); |
| } |
| } |
| |
| 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); |
| // setFormat is done by SurfaceView in SDK 2.3 and newer. Uncomment |
| // this statement if back-porting to 2.2 or older: |
| // holder.setFormat(PixelFormat.RGB_565); |
| // |
| // setType is not needed for SDK 2.0 or newer. Uncomment this |
| // statement if back-porting this code to older SDKs. |
| // holder.setType(SurfaceHolder.SURFACE_TYPE_GPU); |
| } |
| |
| /** |
| * 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; |
| } |
| |
| /** |
| * Control whether the EGL context is preserved when the GLSurfaceView is paused and |
| * resumed. |
| * <p> |
| * If set to true, then the EGL context may be preserved when the GLSurfaceView is paused. |
| * <p> |
| * Prior to API level 11, whether the EGL context is actually preserved or not |
| * depends upon whether the Android device can support an arbitrary number of |
| * EGL contexts or not. Devices that can only support a limited number of EGL |
| * contexts must release the EGL context in order to allow multiple applications |
| * to share the GPU. |
| * <p> |
| * If set to false, the EGL context will be released when the GLSurfaceView is paused, |
| * and recreated when the GLSurfaceView is resumed. |
| * <p> |
| * |
| * The default is false. |
| * |
| * @param preserveOnPause preserve the EGL context when paused |
| */ |
| public void setPreserveEGLContextOnPause(boolean preserveOnPause) { |
| mPreserveEGLContextOnPause = preserveOnPause; |
| } |
| |
| /** |
| * @return true if the EGL context will be preserved when paused |
| */ |
| public boolean getPreserveEGLContextOnPause() { |
| return mPreserveEGLContextOnPause; |
| } |
| |
| /** |
| * 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(); |
| } |
| mRenderer = renderer; |
| mGLThread = new GLThread(mThisWeakRef); |
| 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 an EGLConfig that is compatible with the current |
| * android.view.Surface, with a depth buffer depth of |
| * at least 16 bits. |
| * @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 an RGB_888 surface with a depth buffer depth of |
| * at least 16 bits. |
| * |
| * @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 depthSize and stencilSize, |
| * and exactly the specified redSize, greenSize, blueSize and alphaSize. |
| * <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 an RGB_888 surface with a depth buffer depth of |
| * at least 16 bits. |
| * |
| */ |
| public void setEGLConfigChooser(int redSize, int greenSize, int blueSize, |
| int alphaSize, int depthSize, int stencilSize) { |
| setEGLConfigChooser(new ComponentSizeChooser(redSize, greenSize, |
| blueSize, alphaSize, depthSize, stencilSize)); |
| } |
| |
| /** |
| * Inform the default EGLContextFactory and default EGLConfigChooser |
| * which EGLContext client version to pick. |
| * <p>Use this method to create an OpenGL ES 2.0-compatible context. |
| * Example: |
| * <pre class="prettyprint"> |
| * public MyView(Context context) { |
| * super(context); |
| * setEGLContextClientVersion(2); // Pick an OpenGL ES 2.0 context. |
| * setRenderer(new MyRenderer()); |
| * } |
| * </pre> |
| * <p>Note: Activities which require OpenGL ES 2.0 should indicate this by |
| * setting @lt;uses-feature android:glEsVersion="0x00020000" /> in the activity's |
| * AndroidManifest.xml file. |
| * <p>If this method is called, it must be called before {@link #setRenderer(Renderer)} |
| * is called. |
| * <p>This method only affects the behavior of the default EGLContexFactory and the |
| * default EGLConfigChooser. If |
| * {@link #setEGLContextFactory(EGLContextFactory)} has been called, then the supplied |
| * EGLContextFactory is responsible for creating an OpenGL ES 2.0-compatible context. |
| * If |
| * {@link #setEGLConfigChooser(EGLConfigChooser)} has been called, then the supplied |
| * EGLConfigChooser is responsible for choosing an OpenGL ES 2.0-compatible config. |
| * @param version The EGLContext client version to choose. Use 2 for OpenGL ES 2.0 |
| */ |
| public void setEGLContextClientVersion(int version) { |
| checkRenderThreadState(); |
| mEGLContextClientVersion = version; |
| } |
| |
| /** |
| * 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); |
| } |
| |
| /** |
| * This method is part of the SurfaceHolder.Callback2 interface, and is |
| * not normally called or subclassed by clients of GLSurfaceView. |
| */ |
| @Override |
| public void surfaceRedrawNeededAsync(SurfaceHolder holder, Runnable finishDrawing) { |
| if (mGLThread != null) { |
| mGLThread.requestRenderAndNotify(finishDrawing); |
| } |
| } |
| |
| /** |
| * This method is part of the SurfaceHolder.Callback2 interface, and is |
| * not normally called or subclassed by clients of GLSurfaceView. |
| */ |
| @Deprecated |
| @Override |
| public void surfaceRedrawNeeded(SurfaceHolder holder) { |
| // Since we are part of the framework we know only surfaceRedrawNeededAsync |
| // will be called. |
| } |
| |
| |
| /** |
| * Pause the rendering thread, optionally tearing down the EGL context |
| * depending upon the value of {@link #setPreserveEGLContextOnPause(boolean)}. |
| * |
| * This method should be called when it is no longer desirable for the |
| * GLSurfaceView to continue rendering, such as in response to |
| * {@link android.app.Activity#onStop Activity.onStop}. |
| * |
| * Must not be called before a renderer has been set. |
| */ |
| public void onPause() { |
| mGLThread.onPause(); |
| } |
| |
| /** |
| * Resumes the rendering thread, re-creating the OpenGL context if necessary. It |
| * is the counterpart to {@link #onPause()}. |
| * |
| * This method should typically be called in |
| * {@link android.app.Activity#onStart Activity.onStart}. |
| * |
| * 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. |
| */ |
| @Override |
| protected void onAttachedToWindow() { |
| super.onAttachedToWindow(); |
| if (LOG_ATTACH_DETACH) { |
| Log.d(TAG, "onAttachedToWindow reattach =" + mDetached); |
| } |
| if (mDetached && (mRenderer != null)) { |
| int renderMode = RENDERMODE_CONTINUOUSLY; |
| if (mGLThread != null) { |
| renderMode = mGLThread.getRenderMode(); |
| } |
| mGLThread = new GLThread(mThisWeakRef); |
| if (renderMode != RENDERMODE_CONTINUOUSLY) { |
| mGLThread.setRenderMode(renderMode); |
| } |
| mGLThread.start(); |
| } |
| mDetached = false; |
| } |
| |
| @Override |
| protected void onDetachedFromWindow() { |
| if (LOG_ATTACH_DETACH) { |
| Log.d(TAG, "onDetachedFromWindow"); |
| } |
| if (mGLThread != null) { |
| mGLThread.requestExitAndWait(); |
| } |
| mDetached = true; |
| super.onDetachedFromWindow(); |
| } |
| |
| // ---------------------------------------------------------------------- |
| |
| /** |
| * 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> |
| * |
| * <div class="special reference"> |
| * <h3>Developer Guides</h3> |
| * <p>For more information about how to use OpenGL, read the |
| * <a href="{@docRoot}guide/topics/graphics/opengl.html">OpenGL</a> developer guide.</p> |
| * </div> |
| * |
| * <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 EGL 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 class DefaultContextFactory implements EGLContextFactory { |
| private int EGL_CONTEXT_CLIENT_VERSION = 0x3098; |
| |
| public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig config) { |
| int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, mEGLContextClientVersion, |
| EGL10.EGL_NONE }; |
| |
| return egl.eglCreateContext(display, config, EGL10.EGL_NO_CONTEXT, |
| mEGLContextClientVersion != 0 ? attrib_list : null); |
| } |
| |
| public void destroyContext(EGL10 egl, EGLDisplay display, |
| EGLContext context) { |
| if (!egl.eglDestroyContext(display, context)) { |
| Log.e("DefaultContextFactory", "display:" + display + " context: " + context); |
| if (LOG_THREADS) { |
| Log.i("DefaultContextFactory", "tid=" + Thread.currentThread().getId()); |
| } |
| EglHelper.throwEglException("eglDestroyContex", egl.eglGetError()); |
| } |
| } |
| } |
| |
| /** |
| * 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 { |
| /** |
| * @return null if the surface cannot be constructed. |
| */ |
| 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) { |
| EGLSurface result = null; |
| try { |
| result = egl.eglCreateWindowSurface(display, config, nativeWindow, null); |
| } catch (IllegalArgumentException e) { |
| // This exception indicates that the surface flinger surface |
| // is not valid. This can happen if the surface flinger surface has |
| // been torn down, but the application has not yet been |
| // notified via SurfaceHolder.Callback.surfaceDestroyed. |
| // In theory the application should be notified first, |
| // but in practice sometimes it is not. See b/4588890 |
| Log.e(TAG, "eglCreateWindowSurface", e); |
| } |
| return result; |
| } |
| |
| 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 abstract class BaseConfigChooser |
| implements EGLConfigChooser { |
| public BaseConfigChooser(int[] configSpec) { |
| mConfigSpec = filterConfigSpec(configSpec); |
| } |
| |
| public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) { |
| int[] num_config = new int[1]; |
| if (!egl.eglChooseConfig(display, mConfigSpec, null, 0, |
| num_config)) { |
| throw new IllegalArgumentException("eglChooseConfig failed"); |
| } |
| |
| int numConfigs = num_config[0]; |
| |
| if (numConfigs <= 0) { |
| throw new IllegalArgumentException( |
| "No configs match configSpec"); |
| } |
| |
| EGLConfig[] configs = new EGLConfig[numConfigs]; |
| if (!egl.eglChooseConfig(display, mConfigSpec, configs, numConfigs, |
| num_config)) { |
| throw new IllegalArgumentException("eglChooseConfig#2 failed"); |
| } |
| 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 int[] filterConfigSpec(int[] configSpec) { |
| if (mEGLContextClientVersion != 2 && mEGLContextClientVersion != 3) { |
| return configSpec; |
| } |
| /* We know none of the subclasses define EGL_RENDERABLE_TYPE. |
| * And we know the configSpec is well formed. |
| */ |
| int len = configSpec.length; |
| int[] newConfigSpec = new int[len + 2]; |
| System.arraycopy(configSpec, 0, newConfigSpec, 0, len-1); |
| newConfigSpec[len-1] = EGL10.EGL_RENDERABLE_TYPE; |
| if (mEGLContextClientVersion == 2) { |
| newConfigSpec[len] = EGL14.EGL_OPENGL_ES2_BIT; /* EGL_OPENGL_ES2_BIT */ |
| } else { |
| newConfigSpec[len] = EGLExt.EGL_OPENGL_ES3_BIT_KHR; /* EGL_OPENGL_ES3_BIT_KHR */ |
| } |
| newConfigSpec[len+1] = EGL10.EGL_NONE; |
| return newConfigSpec; |
| } |
| } |
| |
| /** |
| * Choose a configuration with exactly the specified r,g,b,a sizes, |
| * and at least the specified depth and stencil sizes. |
| */ |
| private 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) { |
| 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); |
| if ((r == mRedSize) && (g == mGreenSize) |
| && (b == mBlueSize) && (a == mAlphaSize)) { |
| return config; |
| } |
| } |
| } |
| return null; |
| } |
| |
| 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 RGB_888 surface with |
| * or without a depth buffer. |
| * |
| */ |
| private class SimpleEGLConfigChooser extends ComponentSizeChooser { |
| public SimpleEGLConfigChooser(boolean withDepthBuffer) { |
| super(8, 8, 8, 0, withDepthBuffer ? 16 : 0, 0); |
| } |
| } |
| |
| /** |
| * An EGL helper class. |
| */ |
| |
| private static class EglHelper { |
| public EglHelper(WeakReference<GLSurfaceView> glSurfaceViewWeakRef) { |
| mGLSurfaceViewWeakRef = glSurfaceViewWeakRef; |
| } |
| |
| /** |
| * Initialize EGL for a given configuration spec. |
| * @param configSpec |
| */ |
| public void start() { |
| if (LOG_EGL) { |
| Log.w("EglHelper", "start() tid=" + Thread.currentThread().getId()); |
| } |
| /* |
| * Get an EGL instance |
| */ |
| mEgl = (EGL10) EGLContext.getEGL(); |
| |
| /* |
| * Get to the default display. |
| */ |
| mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY); |
| |
| if (mEglDisplay == EGL10.EGL_NO_DISPLAY) { |
| throw new RuntimeException("eglGetDisplay failed"); |
| } |
| |
| /* |
| * We can now initialize EGL for that display |
| */ |
| int[] version = new int[2]; |
| if(!mEgl.eglInitialize(mEglDisplay, version)) { |
| throw new RuntimeException("eglInitialize failed"); |
| } |
| GLSurfaceView view = mGLSurfaceViewWeakRef.get(); |
| if (view == null) { |
| mEglConfig = null; |
| mEglContext = null; |
| } else { |
| mEglConfig = view.mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay); |
| |
| /* |
| * Create an EGL context. We want to do this as rarely as we can, because an |
| * EGL context is a somewhat heavy object. |
| */ |
| mEglContext = view.mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig); |
| } |
| if (mEglContext == null || mEglContext == EGL10.EGL_NO_CONTEXT) { |
| mEglContext = null; |
| throwEglException("createContext"); |
| } |
| if (LOG_EGL) { |
| Log.w("EglHelper", "createContext " + mEglContext + " tid=" + Thread.currentThread().getId()); |
| } |
| |
| mEglSurface = null; |
| } |
| |
| /** |
| * Create an egl surface for the current SurfaceHolder surface. If a surface |
| * already exists, destroy it before creating the new surface. |
| * |
| * @return true if the surface was created successfully. |
| */ |
| public boolean createSurface() { |
| if (LOG_EGL) { |
| Log.w("EglHelper", "createSurface() tid=" + Thread.currentThread().getId()); |
| } |
| /* |
| * Check preconditions. |
| */ |
| if (mEgl == null) { |
| throw new RuntimeException("egl not initialized"); |
| } |
| if (mEglDisplay == null) { |
| throw new RuntimeException("eglDisplay not initialized"); |
| } |
| if (mEglConfig == null) { |
| throw new RuntimeException("mEglConfig not initialized"); |
| } |
| |
| /* |
| * The window size has changed, so we need to create a new |
| * surface. |
| */ |
| destroySurfaceImp(); |
| |
| /* |
| * Create an EGL surface we can render into. |
| */ |
| GLSurfaceView view = mGLSurfaceViewWeakRef.get(); |
| if (view != null) { |
| mEglSurface = view.mEGLWindowSurfaceFactory.createWindowSurface(mEgl, |
| mEglDisplay, mEglConfig, view.getHolder()); |
| } else { |
| mEglSurface = null; |
| } |
| |
| if (mEglSurface == null || mEglSurface == EGL10.EGL_NO_SURFACE) { |
| int error = mEgl.eglGetError(); |
| if (error == EGL10.EGL_BAD_NATIVE_WINDOW) { |
| Log.e("EglHelper", "createWindowSurface returned EGL_BAD_NATIVE_WINDOW."); |
| } |
| return false; |
| } |
| |
| /* |
| * 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)) { |
| /* |
| * Could not make the context current, probably because the underlying |
| * SurfaceView surface has been destroyed. |
| */ |
| logEglErrorAsWarning("EGLHelper", "eglMakeCurrent", mEgl.eglGetError()); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Create a GL object for the current EGL context. |
| * @return |
| */ |
| GL createGL() { |
| |
| GL gl = mEglContext.getGL(); |
| GLSurfaceView view = mGLSurfaceViewWeakRef.get(); |
| if (view != null) { |
| if (view.mGLWrapper != null) { |
| gl = view.mGLWrapper.wrap(gl); |
| } |
| |
| if ((view.mDebugFlags & (DEBUG_CHECK_GL_ERROR | DEBUG_LOG_GL_CALLS)) != 0) { |
| int configFlags = 0; |
| Writer log = null; |
| if ((view.mDebugFlags & DEBUG_CHECK_GL_ERROR) != 0) { |
| configFlags |= GLDebugHelper.CONFIG_CHECK_GL_ERROR; |
| } |
| if ((view.mDebugFlags & DEBUG_LOG_GL_CALLS) != 0) { |
| log = new LogWriter(); |
| } |
| gl = GLDebugHelper.wrap(gl, configFlags, log); |
| } |
| } |
| return gl; |
| } |
| |
| /** |
| * Display the current render surface. |
| * @return the EGL error code from eglSwapBuffers. |
| */ |
| public int swap() { |
| if (! mEgl.eglSwapBuffers(mEglDisplay, mEglSurface)) { |
| return mEgl.eglGetError(); |
| } |
| return EGL10.EGL_SUCCESS; |
| } |
| |
| public void destroySurface() { |
| if (LOG_EGL) { |
| Log.w("EglHelper", "destroySurface() tid=" + Thread.currentThread().getId()); |
| } |
| destroySurfaceImp(); |
| } |
| |
| private void destroySurfaceImp() { |
| if (mEglSurface != null && mEglSurface != EGL10.EGL_NO_SURFACE) { |
| mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE, |
| EGL10.EGL_NO_SURFACE, |
| EGL10.EGL_NO_CONTEXT); |
| GLSurfaceView view = mGLSurfaceViewWeakRef.get(); |
| if (view != null) { |
| view.mEGLWindowSurfaceFactory.destroySurface(mEgl, mEglDisplay, mEglSurface); |
| } |
| mEglSurface = null; |
| } |
| } |
| |
| public void finish() { |
| if (LOG_EGL) { |
| Log.w("EglHelper", "finish() tid=" + Thread.currentThread().getId()); |
| } |
| if (mEglContext != null) { |
| GLSurfaceView view = mGLSurfaceViewWeakRef.get(); |
| if (view != null) { |
| view.mEGLContextFactory.destroyContext(mEgl, mEglDisplay, mEglContext); |
| } |
| mEglContext = null; |
| } |
| if (mEglDisplay != null) { |
| mEgl.eglTerminate(mEglDisplay); |
| mEglDisplay = null; |
| } |
| } |
| |
| private void throwEglException(String function) { |
| throwEglException(function, mEgl.eglGetError()); |
| } |
| |
| public static void throwEglException(String function, int error) { |
| String message = formatEglError(function, error); |
| if (LOG_THREADS) { |
| Log.e("EglHelper", "throwEglException tid=" + Thread.currentThread().getId() + " " |
| + message); |
| } |
| throw new RuntimeException(message); |
| } |
| |
| public static void logEglErrorAsWarning(String tag, String function, int error) { |
| Log.w(tag, formatEglError(function, error)); |
| } |
| |
| public static String formatEglError(String function, int error) { |
| return function + " failed: " + EGLLogWrapper.getErrorString(error); |
| } |
| |
| private WeakReference<GLSurfaceView> mGLSurfaceViewWeakRef; |
| EGL10 mEgl; |
| EGLDisplay mEglDisplay; |
| EGLSurface mEglSurface; |
| EGLConfig mEglConfig; |
| @UnsupportedAppUsage |
| 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. |
| * |
| */ |
| static class GLThread extends Thread { |
| GLThread(WeakReference<GLSurfaceView> glSurfaceViewWeakRef) { |
| super(); |
| mWidth = 0; |
| mHeight = 0; |
| mRequestRender = true; |
| mRenderMode = RENDERMODE_CONTINUOUSLY; |
| mWantRenderNotification = false; |
| mGLSurfaceViewWeakRef = glSurfaceViewWeakRef; |
| } |
| |
| @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 stopEglSurfaceLocked() { |
| if (mHaveEglSurface) { |
| mHaveEglSurface = false; |
| mEglHelper.destroySurface(); |
| } |
| } |
| |
| /* |
| * This private method should only be called inside a |
| * synchronized(sGLThreadManager) block. |
| */ |
| private void stopEglContextLocked() { |
| if (mHaveEglContext) { |
| mEglHelper.finish(); |
| mHaveEglContext = false; |
| sGLThreadManager.releaseEglContextLocked(this); |
| } |
| } |
| private void guardedRun() throws InterruptedException { |
| mEglHelper = new EglHelper(mGLSurfaceViewWeakRef); |
| mHaveEglContext = false; |
| mHaveEglSurface = false; |
| mWantRenderNotification = false; |
| |
| try { |
| GL10 gl = null; |
| boolean createEglContext = false; |
| boolean createEglSurface = false; |
| boolean createGlInterface = false; |
| boolean lostEglContext = false; |
| boolean sizeChanged = false; |
| boolean wantRenderNotification = false; |
| boolean doRenderNotification = false; |
| boolean askedToReleaseEglContext = false; |
| int w = 0; |
| int h = 0; |
| Runnable event = null; |
| Runnable finishDrawingRunnable = null; |
| |
| while (true) { |
| synchronized (sGLThreadManager) { |
| while (true) { |
| if (mShouldExit) { |
| return; |
| } |
| |
| if (! mEventQueue.isEmpty()) { |
| event = mEventQueue.remove(0); |
| break; |
| } |
| |
| // Update the pause state. |
| boolean pausing = false; |
| if (mPaused != mRequestPaused) { |
| pausing = mRequestPaused; |
| mPaused = mRequestPaused; |
| sGLThreadManager.notifyAll(); |
| if (LOG_PAUSE_RESUME) { |
| Log.i("GLThread", "mPaused is now " + mPaused + " tid=" + getId()); |
| } |
| } |
| |
| // Do we need to give up the EGL context? |
| if (mShouldReleaseEglContext) { |
| if (LOG_SURFACE) { |
| Log.i("GLThread", "releasing EGL context because asked to tid=" + getId()); |
| } |
| stopEglSurfaceLocked(); |
| stopEglContextLocked(); |
| mShouldReleaseEglContext = false; |
| askedToReleaseEglContext = true; |
| } |
| |
| // Have we lost the EGL context? |
| if (lostEglContext) { |
| stopEglSurfaceLocked(); |
| stopEglContextLocked(); |
| lostEglContext = false; |
| } |
| |
| // When pausing, release the EGL surface: |
| if (pausing && mHaveEglSurface) { |
| if (LOG_SURFACE) { |
| Log.i("GLThread", "releasing EGL surface because paused tid=" + getId()); |
| } |
| stopEglSurfaceLocked(); |
| } |
| |
| // When pausing, optionally release the EGL Context: |
| if (pausing && mHaveEglContext) { |
| GLSurfaceView view = mGLSurfaceViewWeakRef.get(); |
| boolean preserveEglContextOnPause = view == null ? |
| false : view.mPreserveEGLContextOnPause; |
| if (!preserveEglContextOnPause) { |
| stopEglContextLocked(); |
| if (LOG_SURFACE) { |
| Log.i("GLThread", "releasing EGL context because paused tid=" + getId()); |
| } |
| } |
| } |
| |
| // Have we lost the SurfaceView surface? |
| if ((! mHasSurface) && (! mWaitingForSurface)) { |
| if (LOG_SURFACE) { |
| Log.i("GLThread", "noticed surfaceView surface lost tid=" + getId()); |
| } |
| if (mHaveEglSurface) { |
| stopEglSurfaceLocked(); |
| } |
| mWaitingForSurface = true; |
| mSurfaceIsBad = false; |
| sGLThreadManager.notifyAll(); |
| } |
| |
| // Have we acquired the surface view surface? |
| if (mHasSurface && mWaitingForSurface) { |
| if (LOG_SURFACE) { |
| Log.i("GLThread", "noticed surfaceView surface acquired tid=" + getId()); |
| } |
| mWaitingForSurface = false; |
| sGLThreadManager.notifyAll(); |
| } |
| |
| if (doRenderNotification) { |
| if (LOG_SURFACE) { |
| Log.i("GLThread", "sending render notification tid=" + getId()); |
| } |
| mWantRenderNotification = false; |
| doRenderNotification = false; |
| mRenderComplete = true; |
| sGLThreadManager.notifyAll(); |
| } |
| |
| if (mFinishDrawingRunnable != null) { |
| finishDrawingRunnable = mFinishDrawingRunnable; |
| mFinishDrawingRunnable = null; |
| } |
| |
| // Ready to draw? |
| if (readyToDraw()) { |
| |
| // If we don't have an EGL context, try to acquire one. |
| if (! mHaveEglContext) { |
| if (askedToReleaseEglContext) { |
| askedToReleaseEglContext = false; |
| } else { |
| try { |
| mEglHelper.start(); |
| } catch (RuntimeException t) { |
| sGLThreadManager.releaseEglContextLocked(this); |
| throw t; |
| } |
| mHaveEglContext = true; |
| createEglContext = true; |
| |
| sGLThreadManager.notifyAll(); |
| } |
| } |
| |
| if (mHaveEglContext && !mHaveEglSurface) { |
| mHaveEglSurface = true; |
| createEglSurface = true; |
| createGlInterface = true; |
| sizeChanged = true; |
| } |
| |
| if (mHaveEglSurface) { |
| if (mSizeChanged) { |
| sizeChanged = true; |
| w = mWidth; |
| h = mHeight; |
| mWantRenderNotification = true; |
| if (LOG_SURFACE) { |
| Log.i("GLThread", |
| "noticing that we want render notification tid=" |
| + getId()); |
| } |
| |
| // Destroy and recreate the EGL surface. |
| createEglSurface = true; |
| |
| mSizeChanged = false; |
| } |
| mRequestRender = false; |
| sGLThreadManager.notifyAll(); |
| if (mWantRenderNotification) { |
| wantRenderNotification = true; |
| } |
| break; |
| } |
| } else { |
| if (finishDrawingRunnable != null) { |
| Log.w(TAG, "Warning, !readyToDraw() but waiting for " + |
| "draw finished! Early reporting draw finished."); |
| finishDrawingRunnable.run(); |
| finishDrawingRunnable = null; |
| } |
| } |
| // By design, this is the only place in a GLThread thread where we wait(). |
| if (LOG_THREADS) { |
| Log.i("GLThread", "waiting tid=" + getId() |
| + " mHaveEglContext: " + mHaveEglContext |
| + " mHaveEglSurface: " + mHaveEglSurface |
| + " mFinishedCreatingEglSurface: " + mFinishedCreatingEglSurface |
| + " mPaused: " + mPaused |
| + " mHasSurface: " + mHasSurface |
| + " mSurfaceIsBad: " + mSurfaceIsBad |
| + " mWaitingForSurface: " + mWaitingForSurface |
| + " mWidth: " + mWidth |
| + " mHeight: " + mHeight |
| + " mRequestRender: " + mRequestRender |
| + " mRenderMode: " + mRenderMode); |
| } |
| sGLThreadManager.wait(); |
| } |
| } // end of synchronized(sGLThreadManager) |
| |
| if (event != null) { |
| event.run(); |
| event = null; |
| continue; |
| } |
| |
| if (createEglSurface) { |
| if (LOG_SURFACE) { |
| Log.w("GLThread", "egl createSurface"); |
| } |
| if (mEglHelper.createSurface()) { |
| synchronized(sGLThreadManager) { |
| mFinishedCreatingEglSurface = true; |
| sGLThreadManager.notifyAll(); |
| } |
| } else { |
| synchronized(sGLThreadManager) { |
| mFinishedCreatingEglSurface = true; |
| mSurfaceIsBad = true; |
| sGLThreadManager.notifyAll(); |
| } |
| continue; |
| } |
| createEglSurface = false; |
| } |
| |
| if (createGlInterface) { |
| gl = (GL10) mEglHelper.createGL(); |
| |
| createGlInterface = false; |
| } |
| |
| if (createEglContext) { |
| if (LOG_RENDERER) { |
| Log.w("GLThread", "onSurfaceCreated"); |
| } |
| GLSurfaceView view = mGLSurfaceViewWeakRef.get(); |
| if (view != null) { |
| try { |
| Trace.traceBegin(Trace.TRACE_TAG_VIEW, "onSurfaceCreated"); |
| view.mRenderer.onSurfaceCreated(gl, mEglHelper.mEglConfig); |
| } finally { |
| Trace.traceEnd(Trace.TRACE_TAG_VIEW); |
| } |
| } |
| createEglContext = false; |
| } |
| |
| if (sizeChanged) { |
| if (LOG_RENDERER) { |
| Log.w("GLThread", "onSurfaceChanged(" + w + ", " + h + ")"); |
| } |
| GLSurfaceView view = mGLSurfaceViewWeakRef.get(); |
| if (view != null) { |
| try { |
| Trace.traceBegin(Trace.TRACE_TAG_VIEW, "onSurfaceChanged"); |
| view.mRenderer.onSurfaceChanged(gl, w, h); |
| } finally { |
| Trace.traceEnd(Trace.TRACE_TAG_VIEW); |
| } |
| } |
| sizeChanged = false; |
| } |
| |
| if (LOG_RENDERER_DRAW_FRAME) { |
| Log.w("GLThread", "onDrawFrame tid=" + getId()); |
| } |
| { |
| GLSurfaceView view = mGLSurfaceViewWeakRef.get(); |
| if (view != null) { |
| try { |
| Trace.traceBegin(Trace.TRACE_TAG_VIEW, "onDrawFrame"); |
| view.mRenderer.onDrawFrame(gl); |
| if (finishDrawingRunnable != null) { |
| finishDrawingRunnable.run(); |
| finishDrawingRunnable = null; |
| } |
| } finally { |
| Trace.traceEnd(Trace.TRACE_TAG_VIEW); |
| } |
| } |
| } |
| int swapError = mEglHelper.swap(); |
| switch (swapError) { |
| case EGL10.EGL_SUCCESS: |
| break; |
| case EGL11.EGL_CONTEXT_LOST: |
| if (LOG_SURFACE) { |
| Log.i("GLThread", "egl context lost tid=" + getId()); |
| } |
| lostEglContext = true; |
| break; |
| default: |
| // Other errors typically mean that the current surface is bad, |
| // probably because the SurfaceView surface has been destroyed, |
| // but we haven't been notified yet. |
| // Log the error to help developers understand why rendering stopped. |
| EglHelper.logEglErrorAsWarning("GLThread", "eglSwapBuffers", swapError); |
| |
| synchronized(sGLThreadManager) { |
| mSurfaceIsBad = true; |
| sGLThreadManager.notifyAll(); |
| } |
| break; |
| } |
| |
| if (wantRenderNotification) { |
| doRenderNotification = true; |
| wantRenderNotification = false; |
| } |
| } |
| |
| } finally { |
| /* |
| * clean-up everything... |
| */ |
| synchronized (sGLThreadManager) { |
| stopEglSurfaceLocked(); |
| stopEglContextLocked(); |
| } |
| } |
| } |
| |
| public boolean ableToDraw() { |
| return mHaveEglContext && mHaveEglSurface && readyToDraw(); |
| } |
| |
| private boolean readyToDraw() { |
| return (!mPaused) && mHasSurface && (!mSurfaceIsBad) |
| && (mWidth > 0) && (mHeight > 0) |
| && (mRequestRender || (mRenderMode == RENDERMODE_CONTINUOUSLY)); |
| } |
| |
| 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 requestRenderAndNotify(Runnable finishDrawing) { |
| synchronized(sGLThreadManager) { |
| // If we are already on the GL thread, this means a client callback |
| // has caused reentrancy, for example via updating the SurfaceView parameters. |
| // We will return to the client rendering code, so here we don't need to |
| // do anything. |
| if (Thread.currentThread() == this) { |
| return; |
| } |
| |
| mWantRenderNotification = true; |
| mRequestRender = true; |
| mRenderComplete = false; |
| final Runnable oldCallback = mFinishDrawingRunnable; |
| mFinishDrawingRunnable = () -> { |
| if (oldCallback != null) { |
| oldCallback.run(); |
| } |
| if (finishDrawing != null) { |
| finishDrawing.run(); |
| } |
| }; |
| |
| sGLThreadManager.notifyAll(); |
| } |
| } |
| |
| public void surfaceCreated() { |
| synchronized(sGLThreadManager) { |
| if (LOG_THREADS) { |
| Log.i("GLThread", "surfaceCreated tid=" + getId()); |
| } |
| mHasSurface = true; |
| mFinishedCreatingEglSurface = false; |
| sGLThreadManager.notifyAll(); |
| while (mWaitingForSurface |
| && !mFinishedCreatingEglSurface |
| && !mExited) { |
| try { |
| sGLThreadManager.wait(); |
| } catch (InterruptedException e) { |
| Thread.currentThread().interrupt(); |
| } |
| } |
| } |
| } |
| |
| 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) { |
| if (LOG_PAUSE_RESUME) { |
| Log.i("GLThread", "onPause tid=" + getId()); |
| } |
| mRequestPaused = true; |
| sGLThreadManager.notifyAll(); |
| while ((! mExited) && (! mPaused)) { |
| if (LOG_PAUSE_RESUME) { |
| Log.i("Main thread", "onPause waiting for mPaused."); |
| } |
| try { |
| sGLThreadManager.wait(); |
| } catch (InterruptedException ex) { |
| Thread.currentThread().interrupt(); |
| } |
| } |
| } |
| } |
| |
| public void onResume() { |
| synchronized (sGLThreadManager) { |
| if (LOG_PAUSE_RESUME) { |
| Log.i("GLThread", "onResume tid=" + getId()); |
| } |
| mRequestPaused = false; |
| mRequestRender = true; |
| mRenderComplete = false; |
| sGLThreadManager.notifyAll(); |
| while ((! mExited) && mPaused && (!mRenderComplete)) { |
| if (LOG_PAUSE_RESUME) { |
| Log.i("Main thread", "onResume waiting for !mPaused."); |
| } |
| try { |
| sGLThreadManager.wait(); |
| } catch (InterruptedException ex) { |
| Thread.currentThread().interrupt(); |
| } |
| } |
| } |
| } |
| |
| public void onWindowResize(int w, int h) { |
| synchronized (sGLThreadManager) { |
| mWidth = w; |
| mHeight = h; |
| mSizeChanged = true; |
| mRequestRender = true; |
| mRenderComplete = false; |
| |
| // If we are already on the GL thread, this means a client callback |
| // has caused reentrancy, for example via updating the SurfaceView parameters. |
| // We need to process the size change eventually though and update our EGLSurface. |
| // So we set the parameters and return so they can be processed on our |
| // next iteration. |
| if (Thread.currentThread() == this) { |
| return; |
| } |
| |
| sGLThreadManager.notifyAll(); |
| |
| // Wait for thread to react to resize and render a frame |
| while (! mExited && !mPaused && !mRenderComplete |
| && ableToDraw()) { |
| if (LOG_SURFACE) { |
| Log.i("Main thread", "onWindowResize waiting for render complete from tid=" + getId()); |
| } |
| try { |
| sGLThreadManager.wait(); |
| } catch (InterruptedException ex) { |
| Thread.currentThread().interrupt(); |
| } |
| } |
| } |
| } |
| |
| 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(); |
| } |
| } |
| } |
| } |
| |
| public void requestReleaseEglContextLocked() { |
| mShouldReleaseEglContext = true; |
| sGLThreadManager.notifyAll(); |
| } |
| |
| /** |
| * 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 mRequestPaused; |
| private boolean mPaused; |
| private boolean mHasSurface; |
| private boolean mSurfaceIsBad; |
| private boolean mWaitingForSurface; |
| private boolean mHaveEglContext; |
| private boolean mHaveEglSurface; |
| private boolean mFinishedCreatingEglSurface; |
| private boolean mShouldReleaseEglContext; |
| private int mWidth; |
| private int mHeight; |
| private int mRenderMode; |
| private boolean mRequestRender; |
| private boolean mWantRenderNotification; |
| private boolean mRenderComplete; |
| private ArrayList<Runnable> mEventQueue = new ArrayList<Runnable>(); |
| private boolean mSizeChanged = true; |
| private Runnable mFinishDrawingRunnable = null; |
| |
| // End of member variables protected by the sGLThreadManager monitor. |
| |
| @UnsupportedAppUsage |
| private EglHelper mEglHelper; |
| |
| /** |
| * Set once at thread construction time, nulled out when the parent view is garbage |
| * called. This weak reference allows the GLSurfaceView to be garbage collected while |
| * the GLThread is still alive. |
| */ |
| private WeakReference<GLSurfaceView> mGLSurfaceViewWeakRef; |
| |
| } |
| |
| 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 { |
| private static String TAG = "GLThreadManager"; |
| |
| public synchronized void threadExiting(GLThread thread) { |
| if (LOG_THREADS) { |
| Log.i("GLThread", "exiting tid=" + thread.getId()); |
| } |
| thread.mExited = true; |
| notifyAll(); |
| } |
| |
| /* |
| * Releases the EGL context. Requires that we are already in the |
| * sGLThreadManager monitor when this is called. |
| */ |
| public void releaseEglContextLocked(GLThread thread) { |
| notifyAll(); |
| } |
| } |
| |
| private static final GLThreadManager sGLThreadManager = new GLThreadManager(); |
| |
| private final WeakReference<GLSurfaceView> mThisWeakRef = |
| new WeakReference<GLSurfaceView>(this); |
| @UnsupportedAppUsage |
| private GLThread mGLThread; |
| @UnsupportedAppUsage |
| private Renderer mRenderer; |
| private boolean mDetached; |
| private EGLConfigChooser mEGLConfigChooser; |
| private EGLContextFactory mEGLContextFactory; |
| private EGLWindowSurfaceFactory mEGLWindowSurfaceFactory; |
| private GLWrapper mGLWrapper; |
| private int mDebugFlags; |
| private int mEGLContextClientVersion; |
| private boolean mPreserveEGLContextOnPause; |
| } |