TextureView展示OpenGL内容(Demo)
上图的实现，如果是用GLSurfaceView实现，那会相对比较简单，直接在设置的Renderer实现类中实现gl展示即可，但是使用TextureView就没那么方便了，一般TextureView与OpenGL和结合就是相机预览和视频播放了，那如果是一般的gles展示呢？ 这就需要重新创建一个GL线程了（相比之下，这种方式是真真不好的，通过实践发现：这种实现方式CPU占用率比GLSurfaceView的CPU占用率还高。再者GLSurfaceView本就对渲染同步、状态控制等做了优化封装），但既然已经做了，就写下来mark一下！
那这个demo主要有3个类，主要看代码，代码中有注释。
1.GLESTextureView，这个类继承自TextureView，主要是添加了setRenderer和setRenderMode方法，使其用起来像GLSurfaceView一样。
2.GLESTVThread，这是一个线程类，在GLESTextureView的SurfaceTexture准备好之后开启该线程作为一个GL线程（GL的一些操作都要在该线程中去实现）。
3.IGLESRenderer，该类是GL线程流程的接口，该接口的实现可用于GLESTextureView的setRenderer,也可以用于GLSurfaceView中的renderer的方法体实现。
package com.dandy.helper.gles;
/**
*
* GLES里用到的用于渲染的一个接口。
* 如果是GLSurfaceView要用到，则其对应的GLSurfaceView.Renderer可以来调用IGLESRenderer的实现类来实现逻辑
* 如果是TextureView要用到，则使用自定义的一个线程里调用IGLESRenderer的实现类来做一个类似于GLSurfaceView.Renderer的操作
* 所以IGLESRenderer中的方法都要在GL线程里运行（TextureView创建一个线程，把它当做一个GL线程）
*
*
* @author flycatdeng
*
*/
public interface IGLESRenderer {
/**
*
* Surface创建好之后
*
*/
public void onSurfaceCreated();
/**
*
* 界面大小有更改
*
*
* @param width
* @param height
*/
public void onSurfaceChanged(int width, int height);
/**
*
* 绘制每一帧
*
*/
public void onDrawFrame();
/**
*
* Activity的onResume时的操作
*
*/
public void onResume();
/**
*
* Activity的onPause时的操作
*
*/
public void onPause();
/**
*
* Activity的onDestroy时的操作
*
*/
public void onDestroy();
}
package com.dandy.module.gles.textureview;
import android.content.Context;
import android.graphics.SurfaceTexture;
import android.util.AttributeSet;
import android.view.TextureView;
import com.dandy.helper.gles.IGLESRenderer;
/**
*
* 一个类似于GLSurfaceView的TextureView，用于显示opengl
* {@link #setRenderer(IGLESRenderer)}类似于GLSurfaceView的setRenderer（Renderer）
* {{@link #setRenderMode(int)}类似于GLSurfaceView的setRenderMode(int)
* 详细调用可模仿com.dandy.gldemo.glestextureview.DemoGlesTextureView
* 没事可看参照1或者参照2
*
*
* @author flycatdeng
*
*/
public class GLESTextureView extends TextureView implements TextureView.SurfaceTextureListener {
public final static int RENDERMODE_WHEN_DIRTY = 0;
public final static int RENDERMODE_CONTINUOUSLY = 1;
private GLESTVThread mGLThread;
private IGLESRenderer mRenderer;
private int mRendererMode = RENDERMODE_CONTINUOUSLY;
public GLESTextureView(Context context) {
super(context);
init(context);
}
public GLESTextureView(Context context, AttributeSet attrs) {
super(context, attrs);
init(context);
}
/**
*
* 类似于GLSurfaceView的setRenderer
*
*/
public void setRenderer(IGLESRenderer renderer) {
mRenderer = renderer;
}
/**
*
* 类似于GLSurfaceView的setRenderMode
* 渲染模式，是循环刷新，还是请求的时候刷新
*
*/
public void setRenderMode(int mode) {
mRendererMode = mode;
}
/**
* 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() {
if (mRendererMode != RENDERMODE_WHEN_DIRTY) {
return;
}
mGLThread.requestRender();
}
private void init(Context context) {
setSurfaceTextureListener(this);
}
@Override
public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
mGLThread = new GLESTVThread(surface, mRenderer);// 创建一个线程，作为GL线程
mGLThread.setRenderMode(mRendererMode);
mGLThread.start();
mGLThread.onSurfaceChanged(width, height);
}
@Override
public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
return false;
}
@Override
public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
mGLThread.onSurfaceChanged(width, height);
}
@Override
public void onSurfaceTextureUpdated(SurfaceTexture surface) {
}
public void onResume() {
if (mGLThread != null) {
mGLThread.onResume();
}
}
public void onPause() {
if (mGLThread != null) {
mGLThread.onPause();
}
}
public void onDestroy() {
if (mGLThread != null) {
mGLThread.onDestroy();
}
}
}
package com.dandy.module.gles.textureview;
import javax.microedition.khronos.egl.EGL10;
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 android.graphics.SurfaceTexture;
import android.opengl.GLUtils;
import com.dandy.helper.android.LogHelper;
import com.dandy.helper.gles.IGLESRenderer;
import com.dandy.helper.java.PendingThreadAider;
/**
*
* TextureView中要用的GLThread
* 一个很好的EGL相关学习参考
* 一般在Android中使用OpenGL ES，总是会从GLSurfaceView和Renderer开始，只需要提供一个合适的SurfaceHolder，就可以完成整个环境初始化，并进行绘制。
* GLSurfaceView和Renderer事实上只是在本文描述的基础上封装了一些便利的功能，便于开发者开发，比如渲染同步、状态控制、主（渲染）循环等
*
*
* @author flycatdeng
*/
class GLESTVThread extends Thread {
private static final String TAG = "GLESTVThread";
private SurfaceTexture mSurfaceTexture;
private EGL10 mEgl;
private EGLDisplay mEglDisplay = EGL10.EGL_NO_DISPLAY;// 显示设备
private EGLSurface mEglSurface = EGL10.EGL_NO_SURFACE;
private EGLContext mEglContext = EGL10.EGL_NO_CONTEXT;
// private GL mGL;
private static final int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
private static final int EGL_OPENGL_ES2_BIT = 4;
private IGLESRenderer mRenderer;
private PendingThreadAider mPendingThreadAider = new PendingThreadAider();
private boolean mNeedRenderring = true;
private Object LOCK = new Object();
private boolean mIsPaused = false;
public GLESTVThread(SurfaceTexture surface, IGLESRenderer renderer) {
mSurfaceTexture = surface;
mRenderer = renderer;
}
@Override
public void run() {
LogHelper.d(TAG, LogHelper.getThreadName());
initGLESContext();
mRenderer.onSurfaceCreated();
while (mNeedRenderring) {
mPendingThreadAider.runPendings();// 执行未执行的，或要执行的事件。（后期可以开放以便模仿GLSurfaceView的queueEvent(Runnable r)）
mRenderer.onDrawFrame();// 绘制
// 一帧完成之后，调用eglSwapBuffers(EGLDisplay dpy, EGLContext ctx)来显示
mEgl.eglSwapBuffers(mEglDisplay, mEglSurface);// 这一句不能少啊，少了就GG了，一片空白
// 1.凡是onPause都要停止，2.如果是onResume的状态，如果是循环刷新则会继续下一次循环，否则会暂停等待调用requestRender()
if (mIsPaused) {
pauseWhile();
} else if (mRendererMode == GLESTextureView.RENDERMODE_WHEN_DIRTY) {
pauseWhile();
}
}
destoryGLESContext();
}
private void initGLESContext() {
LogHelper.d(TAG, LogHelper.getThreadName());
mEgl = (EGL10) EGLContext.getEGL();
mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);// 获取显示设备
if (mEglDisplay == EGL10.EGL_NO_DISPLAY) {
throw new RuntimeException("eglGetdisplay failed : " + GLUtils.getEGLErrorString(mEgl.eglGetError()));
}
int[] version = new int[2];
if (!mEgl.eglInitialize(mEglDisplay, version)) {// //version中存放EGL 版本号，int[0]为主版本号，int[1]为子版本号
throw new RuntimeException("eglInitialize failed : " + GLUtils.getEGLErrorString(mEgl.eglGetError()));
}
// 构造需要的特性列表
int[] configAttribs = { //
EGL10.EGL_BUFFER_SIZE, 32,//
EGL10.EGL_ALPHA_SIZE, 8, // 指定Alpha大小，以下四项实际上指定了像素格式
EGL10.EGL_BLUE_SIZE, 8, // 指定B大小
EGL10.EGL_GREEN_SIZE, 8,// 指定G大小
EGL10.EGL_RED_SIZE, 8,// 指定RGB中的R大小（bits）
EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,// 指定渲染api类别,这里或者是硬编码的4，或者是EGL14.EGL_OPENGL_ES2_BIT
EGL10.EGL_SURFACE_TYPE, EGL10.EGL_WINDOW_BIT, EGL10.EGL_NONE// 总是以EGL10.EGL_NONE结尾
};
int[] numConfigs = new int[1];
EGLConfig[] configs = new EGLConfig[1];
// eglChooseConfig(display, attributes, configs, num, configNum);
// 用于获取满足attributes的所有config，参数1、2其意明显，参数3用于存放输出的configs，参数4指定最多输出多少个config，参数5由EGL系统写入，表明满足attributes的config一共有多少个
if (!mEgl.eglChooseConfig(mEglDisplay, configAttribs, configs, 1, numConfigs)) {// 获取所有满足attributes的configs,并选择一个
throw new RuntimeException("eglChooseConfig failed : " + GLUtils.getEGLErrorString(mEgl.eglGetError()));
}
int[] contextAttribs = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE};// attrib_list,目前可用属性只有EGL_CONTEXT_CLIENT_VERSION, 1代表OpenGL ES 1.x,
// 2代表2.0。同样在Android4.2之前，没有EGL_CONTEXT_CLIENT_VERSION这个属性，只能使用硬编码0x3098代替
mEglContext = mEgl.eglCreateContext(mEglDisplay, configs[0], EGL10.EGL_NO_CONTEXT, // share_context,是否有context共享，共享的contxt之间亦共享所有数据。EGL_NO_CONTEXT代表不共享
contextAttribs);// 创建context
mEglSurface = mEgl.eglCreateWindowSurface(mEglDisplay, configs[0], mSurfaceTexture,// 负责对Android Surface的管理
null// Surface属性
);// 获取显存，create a new EGL window surface
if (mEglSurface == EGL10.EGL_NO_SURFACE || mEglContext == EGL10.EGL_NO_CONTEXT) {
int error = mEgl.eglGetError();
if (error == EGL10.EGL_BAD_NATIVE_WINDOW) {
throw new RuntimeException("eglCreateWindowSurface returned EGL_BAD_NATIVE_WINDOW. ");
}
throw new RuntimeException("eglCreateWindowSurface failed : " + GLUtils.getEGLErrorString(mEgl.eglGetError()));
}
if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {// 设置为当前的渲染环境
throw new RuntimeException("eglMakeCurrent failed : " + GLUtils.getEGLErrorString(mEgl.eglGetError()));
}
// mGL = mEglContext.getGL();
}
private void pauseWhile() {
synchronized (LOCK) {
try {
LOCK.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private void destoryGLESContext() {
LogHelper.d(TAG, LogHelper.getThreadName());
mEgl.eglDestroyContext(mEglDisplay, mEglContext);
mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
mEglContext = EGL10.EGL_NO_CONTEXT;
mEglSurface = EGL10.EGL_NO_SURFACE;
}
public void onPause() {
mRenderer.onPause();
mIsPaused = true;
}
public void onResume() {
mRenderer.onResume();
mIsPaused = false;
requestRender();
}
public void onSurfaceChanged(final int width, final int height) {
mPendingThreadAider.addToPending(new Runnable() {// 在GL线程中执行
@Override
public void run() {
mRenderer.onSurfaceChanged(width, height);
}
});
}
private int mRendererMode = GLESTextureView.RENDERMODE_CONTINUOUSLY;
public void setRenderMode(int mode) {
mRendererMode = mode;
}
public void requestRender() {
synchronized (LOCK) {
LOCK.notifyAll();
}
}
public void onDestroy() {
mNeedRenderring = false;
mRenderer.onDestroy();
destoryGLESContext();
}
}
demo:https://github.com/flycatdeng/GLTextureViewDemo
一个Activity里两个GLSurfaceView无法同时渲染，所以如果要分多个区渲染的话，这个TextureView倒也可以去用用
http://stackoverflow.com/questions/4991095/how-can-i-use-multiple-glsurfaceview-components-in-the-same-layout