Android游戏引擎andengine

// ############################################################ // ############################################################ // // This class is a replacement for the original GLSurfaceView, due to issue: // http://code.google.com/p/android/issues/detail?id=2828 // // Reason: Two sequential Activities using a GLSurfaceView leads to a deadlock in the GLThread! // // ############################################################ // ############################################################ package org.anddev.andengine.opengl.view; import java.util.ArrayList; import java.util.concurrent.Semaphore; import javax.microedition.khronos.egl.EGL10; import javax.microedition.khronos.egl.EGL11; import javax.microedition.khronos.egl.EGLConfig; import javax.microedition.khronos.egl.EGLContext; import javax.microedition.khronos.egl.EGLDisplay; import javax.microedition.khronos.egl.EGLSurface; import javax.microedition.khronos.opengles.GL; import javax.microedition.khronos.opengles.GL10; import android.content.Context; import android.util.AttributeSet; import android.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 { // =========================================================== // Constants // =========================================================== /** * 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; private static final Semaphore sEglSemaphore = new Semaphore(1); // =========================================================== // Fields // =========================================================== private GLThread mGLThread; private EGLConfigChooser mEGLConfigChooser; private GLWrapper mGLWrapper; private int mDebugFlags; private int mRenderMode; private Renderer mRenderer; private int mSurfaceWidth; private int mSurfaceHeight; private boolean mHasSurface; // =========================================================== // Constructors // =========================================================== /** * Standard View constructor. In order to render something, you must call * {@link #setRenderer} to register a renderer. */ public GLSurfaceView(final Context context) { super(contex