源码分析-GLSurfaceView的内部实现


GLSurfaceView类是继承自SurfaceView的,并且实现了SurfaceHolder.Callback2接口。

GLSurfaceView内部管理着一个surface,专门负责OpenGL渲染。GLSurfaceView内部通过GLThread和EGLHelper

为我们完成了EGL环境渲染和渲染线程的创建及管理,使我们只需要在外部实现渲染器Renderer

即可使用OpenGL ES进行绘图。所以,了解GLSurfaceView的内部逻辑对于我们使用OpenGL ES来绘图还是很有必要的。

GLSurfaceView的初始化

首先,我们在最外使用GLSurfaceView的时候,实例化GLSurfaceView时其会对自身进行初始化:

1
2
3
4
private void init() {
SurfaceHolder holder = getHolder();
holder.addCallback(this);
}

可以看到这里主要对自身的Holder设置了Callback2接口,然后在自身内部实现了Callback2的四个回调方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void surfaceCreated(SurfaceHolder holder) {
mGLThread.surfaceCreated();
}
public void surfaceDestroyed(SurfaceHolder holder) {
mGLThread.surfaceDestroyed();
}
public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
mGLThread.onWindowResize(w,h);
}
public void surfaceRedrawNeeded(SurfaceHolder holder) {
if(mGLThread != null) {
mGLThread.requestRenderAndWait();
}
}

可以看到四个回调方法最终都共同指向了GLThread,其实这里的GLThread是GLSurfaceView内部的绘制线程,

使绘制工作可以独立于主线程(GLThread承担了SurfaceView中大部分的工作,具体的后面再细说)。

至此,GLSurfaceView的初始化工作完成,但到这里渲染环境的初始化工作却还没有开始。

当实例化GLSurfaceView后,接着都会进行两个步骤,那就是设置OpenGL的版本号和渲染器:

1
2
this.setEGLContextClientVersion(2); //设置OpenGL的版本号2.0
setRenderer(new MyRenderer()); //设置OpenGL的渲染器

这里重点要看setRenderer()这个方法,通过这个方法我们不仅为GLSurfaceView设置了renderer,

还会对EGL环境进行初步的设置工作,最后还有调起GLThread,开启绘制线程。所以在GLSurfaceView的整个生命周期中,

setRenderer()只能被调用一次。源码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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();
}

设置渲染器时,首先会对渲染线程的状态进行检查,如果GLThread已经存在即setRenderer已经被调用过,

则抛出异常,这也是为什么setRenderer()只能在GLSurfaceView的整个生命周期中调用一次。

然后会对mEGLConfigChooser、mEGLContextFactory、mEGLWindowSurfaceFactory进行实例化,

再实例化GLThread并执行该渲染线程,其中传入的mThisWeakRef是当前GLSurfaceView的弱引用。

GLThread——GLSurfaceView内部的渲染线程

GLThread是一个继承Thread的类,主要的运行代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
while(true) {
synchronized(sGLThreadManager) {
while(true) {
......
mEglHelper.start();
......
sGLThreadManager.wait();
}
}
......
mEglHelper.createSurface();
......
gl = (GL10) mEglHelper.createGL();
......
mRenderer.onSurfaceCreated(gl, mEglHelper.getEglConfig());
......
mRenderer.onSurfaceChanged(gl, w, h);
......
mRenderer.onDrawFrame(gl);
}

其中被synchronized(sGLThreadManager)同步的代码块是用于线程之间通信的,外部线程可以停止和恢复这个线程。

这部分同步代码块的主要职责是创建EGL环境,GLThread对EGL的所有操作都是通过EglHelper来实现的。

EglHelper——创建EGL环境的帮助类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
private static class EglHelper {
/**
* Initialize EGL for a given configuration spec
*/
public void start() {
......
mEgl = (EGL10) EGLContext.getEGL();
mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
......
mEgl.eglInitialize(mEglDisplay, version);
......
mEglConfig = view.mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
mEglContext = view.mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig);
}
/**
* Create an egl surface for the current SurfaceHolder surface. If a surfce
* already exists, destroy it before creating the new surface.
*/
public boolean createSurface() {
......
/*
* The window size has changed, so we need to create a new surface.
*/
destroySurfaceImp();
......
/*
* Create an EGL surface we can render into.
*/
mEglSurface = view.mEGLWindowSurfaceFactory.createWindowSurface(mEgl, mEglDisplay,
mEglConfig, view.getHolder());
......
/*
* Before we can issue GL commands, we need to make sure the context
* is current and bound to a surface.
*/
mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext);
......
}
/**
* Create a GL object for the current EGL context
*/
GL createGL() {
GL gl = mEglContext.getEGL();
GLSurfaceView view = mGLSurfaceViewWeakRef.get();
......
gl = view.mGLWrapper.wrap(gl);
......
gl = GLDebugHelper.wrap(gl, configFlags, log);
return gl;
}
......
}

所以整体看来,就是GLThread在其同步代码块中通过mEglHelper.start()对EGL环境进行初始化,

而后在同步块外部先调用mEglHelper.createSurface()为当前的Surface创建一个EGL的surface,

再通过mEglHelper.createGL()创建一个GL对象,最后就将GL对象传递给renderer的三个回调方法

onSurfaceCreated()、onSurfaceChanged()、onDrawFrame()。所以我们在最外面只需要在这三个

回调方法中实现我们真正要绘制的东西即可。

再说GLThread

我们再来看看GLThread内部其他的一些方法,在最开始的时候我们说到给holder传入一个回调接口,

而这个回调接口的四个方法的实现最终都指向了GLThread的内部方法,那么我们先来看看这四个方法

在GLThread内部的实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
// GLThread的内部方法
public void surfaceCreated() {
synchronized(sGLThreadManager) {
mHasSurface = true;
mFinishedCreatingEglSurface = false;
sGLThreadManager.notifyAll();
while(mWaitingForSurface && !mFinishedCreatingEglSurface && !mExited) {
try {
sGLThreadManager.wait();
} catch (InterruptedException e) {
Thread.currentThread().interrput();
}
}
}
}
public void surfaceDestroyed() {
synchronized(sGLThreadManager) {
mHasSurface = true;
sGLThreadManager.notifyAll();
while(!mWaitingForSurface && !mExited) {
try {
sGLThreadManager.wait();
} catch (InterruptedException e) {
Thread.currentThread().interrput();
}
}
}
}
public void onWindowResize(int w, int h) {
synchronized(sGLThreadManager) {
mWidth = w;
mHeight = h;
mSizeChanged = true;
mRequestRender = true;
mRenderComplete = false;
if(Thread.currentThread() == this) {
return;
}
sGLThreadManager.notifyAll();
while(!mExited && !mPaused && !mRenderComplete && ableToDraw) {
try {
sGLThreadManager.wait();
} catch (InterruptedException e) {
Thread.currentThread().interrput();
}
}
}
}
public void requestRenderAndWait() {
synchronized(sGLThreadManager) {
if(Thread.currentThread() == this) {
return;
}
mWantRenderNotification = true;
mRequestRender = true;
mRenderComplete = false;
sGLThreadManager.notifyAll();
while(!mExited && !mPaused && !RenderComplete && ableToDraw()) {
try {
sGLThreadManager.wait();
} catch (InterruptedException e) {
Thread.currentThread().interrput();
}
}
}
}

这些供外部调用的方法其最终都只是改变GLThread的一些内部标志,然后通过sGLThreadManager.notifyAll

唤醒渲染线程,GLThread内部即通过判断这些标志位去执行对应的参数设置操作,这些参数设置操作都在

synchronized(sGLTHreadManager)同步的循环体中进行,当最后已经准备好绘制工作,则跳出内循环体,

在外循环体中调用renderer的回调方法onDrawFrame去真正实现绘制,核心代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
while(true) {
synchronized(sGLThreadManager) {
while(true) {
......
mEglHelper.start();
......
// 如果已经准备好绘制环境
if(readyToDraw()) {
// 再一次检查EglContext和EglSurface的状态,满足则跳出同步代码块的循环体
// If we don't have an EGL context, try to acquire one
if(!mHaveEglContext) {
......
if(sGLThreadManager.tryAcquireEglContextLocked(this)) {
mEglHelper.start();
}
}
if(mHaveEglSurface) {
......
break; // 跳出同步代码块的循环体
}
}
......
sGLThreadManager.wait();
}
}
......
// 调用Renderer进行绘制
mEglHelper.createSurface();
gl = (GL10) mEglHelper.createGL();
mRenderer.onSurfaceCreated(gl, mEglHelper.getEglConfig());
mRenderer.onSurfaceChanged(gl, w, h);
mRenderer.onDrawFrame(gl);
}

最后终于回到了我们的渲染器Renderer,然后,我们只需要在外部实现Renderer的三个回调方法便

可使用OpenGL ES来绘图了。当然,在我们弄懂了GLSurfaceView的原理后自己动手封装一个也是没有

问题的。不过这里其实没有说得很明白的还有EGL这部分,后面有时间将补上。


展开阅读全文

没有更多推荐了,返回首页