* A GLTextureView provides the following features: *
*
* For more information about how to use OpenGL, read the OpenGL developer guide. *
** Typically you use GLTextureView 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 GLTextureView can be used as-is. For the most * part GLTextureView 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 GLTextureView * using the {@link #setRenderer(Renderer)} call. *
*
*
*
* By default GLTextureView chooses a EGLConfig that has an RGB_888 pixel * format, with at least a 16-bit depth buffer and no stencil. *
* If you would prefer a different EGLConfig you can override the default * behavior by calling one of the setEGLConfigChooser methods. *
*
*
*
*
*
* To handle an event you will typically subclass GLTextureView 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: * *
* class MyGLTextureView extends GLTextureView {
*
* 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);
* }
* }
*
*
*/
public class GLTextureView extends TextureView implements SurfaceTextureListener {
private final static String TAG = "GLTextureView";
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
* "GLTextureView".
*
* @see #getDebugFlags
* @see #setDebugFlags
*/
public final static int DEBUG_LOG_GL_CALLS = 2;
private static int sGLESVersion;
/**
* Standard View constructor. In order to render something, you must call
* {@link #setRenderer} to register a renderer.
*/
public GLTextureView(Context context) {
super(context);
init();
}
/**
* Standard View constructor. In order to render something, you must call
* {@link #setRenderer} to register a renderer.
*/
public GLTextureView(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() {
sGLESVersion = getInt(getContext(), "ro.opengles.version", ConfigurationInfo.GL_ES_VERSION_UNDEFINED);
// Install a SurfaceTexture.Callback so we get notified when the
// underlying surface is created and destroyed
//SurfaceTexture 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(SurfaceTexture.SURFACE_TYPE_GPU);
setSurfaceTextureListener(this);
this.addOnLayoutChangeListener(new OnLayoutChangeListener() {
@Override
public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
surfaceChanged(getSurfaceTexture(), 0, right - left, bottom - top);
}
});
}
@SuppressLint("UseValueOf")
@SuppressWarnings("unchecked")
public static Integer getInt(Context context, String key, int def) throws IllegalArgumentException {
Integer ret = def;
try {
ClassLoader cl = context.getClassLoader();
@SuppressWarnings("rawtypes")
Class SystemProperties = cl.loadClass("android.os.SystemProperties");
//Parameters Types
@SuppressWarnings("rawtypes")
Class[] paramTypes = new Class[2];
paramTypes[0] = String.class;
paramTypes[1] = int.class;
Method getInt = SystemProperties.getMethod("getInt", paramTypes);
//Parameters
Object[] params = new Object[2];
params[0] = new String(key);
params[1] = new Integer(def);
ret = (Integer) getInt.invoke(SystemProperties, params);
} catch (IllegalArgumentException iAE) {
throw iAE;
} catch (Exception e) {
ret = def;
}
return ret;
}
/**
* 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.
* * Wrapping is typically used for debugging purposes. *
* 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 GLTextureView is * paused and resumed. *
* If set to true, then the EGL context may be preserved when the * GLTextureView is paused. Whether the EGL context is actually preserved or * not depends upon whether the Android device that the program is running * on 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. *
* If set to false, the EGL context will be released when the GLTextureView * is paused, and recreated when the GLTextureView is resumed. *
* * 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. *
* This method should be called once and only once in the life-cycle of a * GLTextureView. *
* The following GLTextureView methods can only be called before * setRenderer is called: *
* The following GLTextureView methods can only be called after * setRenderer is called: *
* If this method is called, it must be called before * {@link #setRenderer(Renderer)} is called. *
* 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. *
* If this method is called, it must be called before * {@link #setRenderer(Renderer)} is called. *
* 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. *
* If this method is called, it must be called before * {@link #setRenderer(Renderer)} is called. *
* 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. *
* If this method is called, it must be called before * {@link #setRenderer(Renderer)} is called. *
* 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. *
* If this method is called, it must be called before * {@link #setRenderer(Renderer)} is called. *
* 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. *
* Use this method to create an OpenGL ES 2.0-compatible context. Example: * *
*
*
*
*
* public MyView(Context context) {
* super(context);
* setEGLContextClientVersion(2); // Pick an OpenGL ES 2.0 context.
* setRenderer(new MyRenderer());
* }
*
* * 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. *
* If this method is called, it must be called before * {@link #setRenderer(Renderer)} is called. *
* 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. *
* 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. *
* 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 SurfaceTexture.Callback interface, and is not * normally called or subclassed by clients of GLTextureView. */ public void surfaceCreated(SurfaceTexture holder) { mGLThread.surfaceCreated(); } /** * This method is part of the SurfaceTexture.Callback interface, and is not * normally called or subclassed by clients of GLTextureView. */ public void surfaceDestroyed(SurfaceTexture holder) { // Surface will be destroyed when we return mGLThread.surfaceDestroyed(); } /** * This method is part of the SurfaceTexture.Callback interface, and is not * normally called or subclassed by clients of GLTextureView. */ public void surfaceChanged(SurfaceTexture 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 GLTextureView. */ @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 public void setBackgroundColor(int color) { // Do nothing since TextureView does not support displaying background drawables } @Override public void setBackground(Drawable background) { // Do nothing since TextureView does not support displaying background drawables } @Override public void setBackgroundDrawable(Drawable background) { // Do nothing since TextureView does not support displaying background drawables } @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. *
* 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: * *
* class MyGLWrapper implements GLWrapper {
* GL wrap(GL gl) {
* return new MyGLImplementation(gl);
* }
* static class MyGLImplementation implements GL,GL10,GL11,... {
* ...
* }
* }
*
*
* @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.
* * The renderer is responsible for making OpenGL calls to render a frame. *
* GLTextureView clients typically create their own classes that implement * this interface, and then call {@link GLTextureView#setRenderer} to * register the renderer with the GLTextureView. *
* *
* For more information about how to use OpenGL, read the OpenGL developer * guide. *
**
* 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. *
* 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. *
* 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. *
*
* @param gl
* the GL interface. Use instanceof 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.
*
* Called after the surface is created and whenever the OpenGL ES * surface size changes. *
* Typically you will set your viewport here. If your camera is fixed * then you could also set your projection matrix here: * *
*
*
*
*
* 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);
* }
*
*
* @param gl
* the GL interface. Use instanceof 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.
* * This method is responsible for drawing the current frame. *
* The implementation of this method typically looks like this: * *
*
*
*
*
* void onDrawFrame(GL10 gl) {
* gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
* //... other gl calls to render the scene ...
* }
*
*
* @param gl
* the GL interface. Use instanceof to test if
* the interface supports GL11 or higher interfaces.
*/
void onDrawFrame(GL10 gl);
}
/**
* An interface for customizing the eglCreateContext and eglDestroyContext
* calls.
* * This interface must be implemented by clients wishing to call * {@link GLTextureView#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. *
* This interface must be implemented by clients wishing to call * {@link GLTextureView#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 SurfaceTexture.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. *
* This interface must be implemented by clients wishing to call
* {@link GLTextureView#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