我們在 OpenGL繪制一張圖片的流程--以android-openGL-canvas為例
里看到，要使用opengl進行繪制，要實現的流程相當地繁瑣，那么我們能不能對其進行封裝，使繪制更加簡單呢？
接下來還是以 android-openGL-canvas 為例子進行說明。
在 OpenGL繪制一張圖片的流程--以android-openGL-canvas為例 里面，提到了實現的3個流程，其中第一和第二個流程是初始化的流程，基本上只需要走一遍，所以我們可以考慮將這兩個流程進行封裝。
封裝后的類就是
EglHelper
GLThread
EglHelper
EglHelper封裝了 創建 eglContext 和 創建 surface 的功能，主要的實現代碼是：
public EGLContext start(EGLContext eglContext) {
if (GLThread.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");
}
mEglConfig = eglConfigChooser.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 = eglContextFactory.createContext(mEgl, mEglDisplay, mEglConfig, eglContext);
if (mEglContext == null || mEglContext == EGL10.EGL_NO_CONTEXT) {
mEglContext = null;
throwEglException("createContext");
}
if (GLThread.LOG_EGL) {
Log.w("EglHelper", "createContext " + mEglContext + " tid=" + Thread.currentThread().getId());
}
mEglSurface = null;
return mEglContext;
}
public boolean createSurface(Object surface) {
if (GLThread.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.
*/
mEglSurface = eglWindowSurfaceFactory.createWindowSurface(mEgl,
mEglDisplay, mEglConfig, surface);
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;
}
可以看到兩個方法的參數，說明EGLContext 和 surface 可以從外部傳入。也就是說，可以和其它線程共享一個EGLContext，這樣就可以使用其它線程綁定的texture了。而surface，是繪制的東西的承載者，可以是TextureView的SurfaceTexture，可以是GLSurfaceView的surfaceHolder，可以是MediaCodec的surface(用于錄制視頻）；所以surface的類型是Object。
GLThread
GLThread是一個繼承Thread的類，我們可以不在主線程進行繪制。
主要的運行代碼如下：
while (true) {
synchronized (sGLThreadManager) {
while (true) {
...
mEglContext = mEglHelper.start(mEglContext);
...
sGLThreadManager.wait();
...
}
}
...
mEglHelper.createSurface(mSurface))
...
mRenderer.onSurfaceCreated(gl, mEglHelper.getEglConfig()); // OpenGL第三步流程，繪制流程
...
mRenderer.onSurfaceChanged(gl, w, h); // OpenGL第三步流程，繪制流程
...
mRenderer.onDrawFrame(gl); // OpenGL第三步流程，繪制流程
...
}
- 為了支持持續不斷地刷新界面，也就是RENDERMODE_CONTINUOUSLY的renderMode模式，需要在這個線程里while(true)無限循環地運行
- 為了支持需要時才刷新界面，也就是RENDERMODE_WHEN_DIRTY的renderMode模式，需要sGLThreadManager.wait();
public void requestRender() {
synchronized (sGLThreadManager) {
mRequestRender = true;
sGLThreadManager.notifyAll();
}
}
- 其中synchronized (sGLThreadManager)的部分是用于線程之間通信，外部線程可以停止和恢復這個線程
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 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();
}
}
}
}
- 前文中提及的 EglHelper 和 GLThread 都是由GLSurfaceView里的內部類修改而來的，增加了從外部傳入EGLContext和surface等功能，所以此處使用Builder模式，能夠定制化地create一個GLThread對象。
public static class Builder {
private EGLConfigChooser configChooser;
private EGLContextFactory eglContextFactory;
private EGLWindowSurfaceFactory eglWindowSurfaceFactory;
private GLSurfaceView.Renderer renderer;
private GLWrapper mGLWrapper = null;
private int eglContextClientVersion = 2;
private int debugFlags = 0;
private int renderMode = RENDERMODE_WHEN_DIRTY;
private Object surface;
private EGLContext eglContext = EGL10.EGL_NO_CONTEXT;
public Builder setSurface(Object surface) {
this.surface = surface;
return this;
}
public Builder setEGLConfigChooser(boolean needDepth) {
setEGLConfigChooser(new SimpleEGLConfigChooser(needDepth, eglContextClientVersion));
return this;
}
public Builder setEGLConfigChooser(EGLConfigChooser configChooser) {
this.configChooser = configChooser;
return this;
}
public Builder setEGLConfigChooser(int redSize, int greenSize, int blueSize,
int alphaSize, int depthSize, int stencilSize) {
setEGLConfigChooser(new ComponentSizeChooser(redSize, greenSize,
blueSize, alphaSize, depthSize, stencilSize, eglContextClientVersion));
return this;
}
public Builder setEglContextFactory(EGLContextFactory eglContextFactory) {
this.eglContextFactory = eglContextFactory;
return this;
}
public Builder setEglWindowSurfaceFactory(EGLWindowSurfaceFactory eglWindowSurfaceFactory) {
this.eglWindowSurfaceFactory = eglWindowSurfaceFactory;
return this;
}
public Builder setRenderer(GLSurfaceView.Renderer renderer) {
this.renderer = renderer;
return this;
}
public Builder setmGLWrapper(GLWrapper mGLWrapper) {
this.mGLWrapper = mGLWrapper;
return this;
}
public Builder setEglContextClientVersion(int eglContextClientVersion) {
this.eglContextClientVersion = eglContextClientVersion;
return this;
}
public Builder setDebugFlags(int debugFlags) {
this.debugFlags = debugFlags;
return this;
}
public Builder setRenderMode(int renderMode) {
this.renderMode = renderMode;
return this;
}
public void setSharedEglContext(@NonNull EGLContext sharedEglContext) {
this.eglContext = sharedEglContext;
}
public GLThread createGLThread() {
if (renderer == null) {
throw new NullPointerException("renderer has not been set");
}
if (surface == null && eglWindowSurfaceFactory == null) {
throw new NullPointerException("surface has not been set");
}
if (configChooser == null) {
configChooser = new SimpleEGLConfigChooser(true, eglContextClientVersion);
}
if (eglContextFactory == null) {
eglContextFactory = new DefaultContextFactory(eglContextClientVersion);
}
if (eglWindowSurfaceFactory == null) {
eglWindowSurfaceFactory = new DefaultWindowSurfaceFactory();
}
return new GLThread(configChooser, eglContextFactory, eglWindowSurfaceFactory, renderer, mGLWrapper, debugFlags, renderMode, surface, eglContext);
}
}
主要關注點是configChooser, eglContextFactory, eglWindowSurfaceFactory，這3個變量分別定義了EGLConfig, EGLContext, EGLSurface。
以上就是第一第二步流程地封裝。至于第三步流程，其實在 OpenGL繪制一張圖片的流程--以android-openGL-canvas為例 里也已經引用了相關代碼，總結就是封裝成了GLES20Canvas ，有興趣地可以進去查看。
下一篇文章會講如何使用封裝好的GLThread -- 實現一個代替GLSurfaceView的GLTextureView。
