Android GLSurfaceView详解

其他 2018-06-03 06:07:15 阅读次数: 1
学习在Android中使用OpenGL ES，就不得不提到一个控件：GLSurfaceView

GLSurfaceView从Android 1.5(API level 3)开始加入，继承自SurfaceView，实现了SurfaceHolder.Callback2接口，拥有SurfaceView的全部特性，也有view所有的功能和属性，特别是处理事件的能力，它主要是在SurfaceView的基础上它加入了EGL的管理，并自带了一个GLThread绘制线程（EGLContext创建GL环境所在线程即为GL线程），绘制的工作直接通过OpenGL在绘制线程进行，不会阻塞主线程，绘制的结果输出到SurfaceView所提供的Surface上，这使得GLSurfaceView也拥有了OpenGlES所提供的图形处理能力，通过它定义的Render接口，使更改具体的Render的行为非常灵活性，只需要将实现了渲染函数的Renderer的实现类设置给GLSurfaceView即可。

GLSurfaceView提供了下列特性：
    1>  提供并且管理一个独立的Surface。
    2>  提供并且管理一个EGL display，它能让opengl把内容渲染到上述的Surface上。
    3>  支持用户自定义渲染器(Render)，通过setRenderer设置一个自定义的Renderer。
    4>  让渲染器在独立的GLThread线程里运作，和UI线程分离。
    5>  支持按需渲染(on-demand)和连续渲染(continuous)两种模式。
    6>  GPU加速：GLSurfaceView的效率是SurfaceView的30倍以上，SurfaceView使用画布进行绘制，GLSurfaceView利用GPU加速提高了绘制效率。
    7>  View的绘制onDraw(Canvas canvas)使用Skia渲染引擎渲染，而GLSurfaceView的渲染器Renderer的onDrawFrame(GL10 gl)使用opengl绘制引擎进行渲染。


2.GLSurfaceView的使用步骤

开发基于GLSurfaceView的程序，通常需要继承GLSurfaceView，并重载一些和用户输入事件有关的方法，如果你不需监听事件，也可以直接使用GLSurfaceView， 你可以使用set方法来修改默认的属性，例如setRenderer(Renderer)设置渲染器，主要的工作就是设置Renderer，其他过程，例如EGL的创建，Surface的分配以及OpenGLES的调用都被隐藏起来了，GLSurfaceView会启动一个工作线程来完成渲染，避免阻塞UI主线程，这个工作线程就是mGLThread，这个线程在应用程序setRederer的时候启动，然后不停地等待和处理事件，同时还负责开展Render工作。

第一步：创建GLSurfaceView

GLSurfaceView也是View，可以通过布局文件的方式将它加入整棵view树中，或者在java代码中创建并且添加。
在布局中,摆布好GLSurfaceView的位置.如下:
<android.opengl.GLSurfaceView
        android:id="@+id/glv_main"
        android:layout_width="match_parent"
        android:layout_height= "200dp"  />

在Activity中实例化,如下:
@Override
protected  void  onCreate (Bundle savedInstanceState){
    GLSurfaceView glv  = (GLSurfaceView)findViewById(R.id.glv_main);
}

第二步：初始化OpenGLES环境

GLSurfaceView默认情况下已经初始化好了OpenGLES的运行环境，不需要做额外的工作就可以使用，当然也可以更改一些默认的设置。

第三步：设置Renderer
渲染是OpenGLES的核心工作，setRenderer可以将用户自定义的一个 Renderer 加入实际的渲染流程中。
public class GLRender implements GLSurfaceView.Renderer{

    //控制旋转的角度
    private float rotate;

    @Override
    public void onSurfaceCreated(GL10 gl,  EGLConfig config) {
        //关闭抗抖动
        gl.glDisable(GL10.GL_DITHER);
        //设置系统对透视进行修正
        gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_FASTEST);
        gl .glClearColor ( 0 ,  0 ,  0 ,  0 ) ;
        //设置阴影平滑模式
        gl.glShadeModel(GL10.GL_SMOOTH);
        //启动深度测试
        gl.glEnable(GL10.GL_DEPTH_TEST);
        //设置深度测试的类型
        gl.glDepthFunc(GL10.GL_LEQUAL);

    }

    @Override
    public void onSurfaceChanged(GL10 gl, int width, int height) {
        //设置3D视窗的大小及位置
        gl .glViewport ( 0 ,  0 , width, height) ;
        //将当前矩阵模式设为投影矩形
        gl.glMatrixMode(GL10.GL_PROJECTION);
        //初始化单位矩阵
        gl.glLoadIdentity();
        //计算透视窗口的宽度高度比
        float ratio = (float) width / height;
        //调用此方法设置透视窗口的空间大小
        gl .glFrustumf (-ratio, ratio, - 1 ,  1 ,  1 ,  10 ) ;
    }

    @Override
    public void onDrawFrame(GL10 gl) {
        //清除屏幕缓存和深度缓存
        gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
        //启用顶点坐标数据
        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
        //启用顶点颜色数据
        gl.glEnableClientState(GL10.GL_COLOR_ARRAY);
        //设置当前矩阵堆栈为模型堆栈
        gl.glMatrixMode(GL10.GL_MODELVIEW);
        //------绘制第一个图形-----
        //重置当前的模型视图矩阵
        gl.glLoadIdentity();
        gl.glTranslatef(0.95f, -0.8f, -1.5f); //1⃣
        //设置顶点位置数据
        gl .glVertexPointer ( 3 , GL10 .GL _FLOAT,  0 , PointData .floatBufferUtil (PointData .triangleData )) ;
        //设置顶点颜色数据
        gl .glColorPointer ( 4 , GL10 .GL _FIXED,  0 , PointData .intBufferUtil (PointData .triangleColor )) ;
        //根据顶点数据绘制平面图形
        gl .glDrawArrays (GL10 .GL _TRIANGLES,  0 ,  3 ) ;

        //-----绘制第二个图形-----
        //重置当前的模型视图矩阵
        gl.glLoadIdentity();
        gl .glTranslatef ( 0.95 f,  0.8 f, - 1.5 f) ;
        //设置顶点位置数据
        gl .glVertexPointer ( 3 , GL10 .GL _FLOAT,  0 , PointData .floatBufferUtil (PointData .rectData )) ;
        //设置顶点颜色数据
        gl .glColorPointer ( 4 , GL10 .GL _FIXED,  0 , PointData .intBufferUtil (PointData .rectColor )) ;
        //更具顶点数据绘制平面图形
        gl .glDrawArrays (GL10 .GL _TRIANGLE_STRIP,  0 ,  4 ) ;

        //-----绘制第三个图形----
        //重置当前的模型视图矩阵
        gl.glLoadIdentity();
        gl .glTranslatef (- 0.95 f,  0.8 f, - 1.5 f) ;
        //设置顶点位置数据
        gl .glVertexPointer ( 3 , GL10 .GL _FLOAT,  0 , PointData .floatBufferUtil (PointData .rectData 2)) ;
        //根据顶点数据绘制平面图形
        gl .glDrawArrays (GL10 .GL _TRIANGLE_STRIP,  0 ,  4 ) ;

        //-----绘制第四个图形-----
        //重置当前的模型视图矩阵
        gl.glLoadIdentity();
        gl.glTranslatef(-0.95f, -0.8f, -1.5f);
        //设置使用纯色填充 **需要注意: 使用纯色填充需要禁用顶点颜色数组
        gl .glColor 4f( 1.0 f,  0.2 f,  0.2 f,  0.0 f) ;
        gl.glDisableClientState(GL10.GL_COLOR_ARRAY);
        //设置顶点位置数据
        gl .glVertexPointer ( 3 , GL10 .GL _FLOAT,  0 , PointData .floatBufferUtil (PointData .pentacle )) ;
        //根据顶点数据绘制图形
        gl .glDrawArrays (GL10 .GL _TRIANGLE_STRIP,  0 ,  5 ) ;

        //----绘制第五个图形---
        //重置当前的模型视图矩阵
        gl.glLoadIdentity();
        gl .glTranslatef ( 0 f,  0 f, - 1.5 f) ;
        gl .glRotatef (rotate,  0 f,  0.2 f,  0 f) ;
        //设置顶点位置数据
        gl .glVertexPointer ( 3 , GL10 .GL _FLOAT,  0 , PointData .floatBufferUtil (TDPointData .taperVertices )) ;
        //启用顶点颜色组
        gl.glEnableClientState(GL10.GL_COLOR_ARRAY);
        //设置顶点颜色数据
        gl .glColorPointer ( 4 , GL10 .GL _FIXED,  0 , PointData .intBufferUtil (TDPointData .taperColors )) ;
        //按taperFacetsBuffer指定的面绘制三角形
        ByteBuffer byteBuffer = PointData.byteBufferUtil(TDPointData.taperFacets);
        gl.glDrawElements(GL10.GL_TRIANGLE_STRIP, byteBuffer.remaining(), GL10.GL_UNSIGNED_BYTE, byteBuffer);


        //绘制结束
        gl.glFinish();
        gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
        //旋转角度+1
        rotate +=  1 ;
    }
}

@Override
protected  void  onCreate (Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_glsurface);
    glv = (GLSurfaceView)findViewById(R.id.glv_opengl);
    GLRender render =  new  GLRender();
    glv.setRenderer(render);
}

第四步：设置RenderingMode

GLSurfaceView 在onAttachedToWindow后就启动了一个无线循环的 GLThread 线程， GLSurfaceView默认采用的是 RENDERMODE_CONTINUOUSLY 连续渲染的方式， 刷新的帧率是60FPS，16ms就重绘一次， 可以通过 mGLView.setRenderMode()更改其渲染方式为 RENDERMODE_WHEN_DIRTY，表示被动渲染，在 surfaceCreate的时候会绘制一次，之后 只有在调用requestRender或者onResume等方法 主动请求重绘 时才会进行渲染， 如果你的界面不需要频繁的刷新最好使用 RENDERMODE_WHEN_DIRTY ，这样可以降低CPU和GPU的活动 。

第五步：状态处理

使用GLSurfaceView需要注意程序的生命周期， Activity及Fragment 会有暂停和恢复等状态，GLSurfaceView也需根据这些状态来做相应的处理， GLSurfaceView具有onResume和onPause两个同Activity及Fragment中的生命周期同名的方法，在Activity或者Fragment中的onResume和onPause方法中，需要主动调用GLSurfaceView的实例的这两个方法 ，这样能使OpenGLES的内部线程做出正确的判断，从而保证应用程序的稳定性。

第六部：事件处理
为了处理事件，一般都是继承GLSurfaceView类并重载它的事件方法，但是由于GLSurfaceView是多线程的，渲染器在独立的渲染线程里，你应该使用Java的跨线程机制跟渲染器通讯，GLSurfaceView提供的queueEvent(Runnable)方法就是一种相对简单的操作，queueEvent()方法被安全地用于在UI线程和渲染线程之间进行交流通信：
public void queueEvent(Runnable r) {
    mGLThread.queueEvent(r);
}

这里直接调用 GLThread的 queueEvent(Runnable r)方法 给 GLThread的 mEventQueue 队列中添加 Runnable 
     public void queueEvent(Runnable r) {  
      
         synchronized(sGLThreadManager) {  
             mEventQueue.add(r);  
             sGLThreadManager.notifyAll();  
         }  
       
     }  

在GLThread的guardenRun()方法中有如下代码：
  1. if (! mEventQueue.isEmpty()) {  
  2.     event = mEventQueue.remove(0);  
  3.     break;  
  4. }  
  5.                   
  6. ...  
  7.                   
  8. if (event != null) {  
  9.     event.run();  
  10.     event = null;  
  11.     continue;  
  12. }  
一般事件的使用如下：
  1. class MyGLSurfaceView extends GLSurfaceView {    
  2.     private MyRenderer mMyRenderer;    
  3.     
  4.     public boolean onKeyDown(int keyCode, KeyEvent event) {    
  5.     
  6.        if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {    
  7.            queueEvent(new Runnable() {    
  8.               // 这个方法会在渲染线程里被调用    
  9.               public void run() {    
  10.                     mMyRenderer.handleDpadCenter();    
  11.            }});    
  12.            return true;    
  13.        }    
  14.     
  15.        return super.onKeyDown(keyCode, event);    
  16.    }    

  18.    public boolean onTouchEvent(final MotionEvent event) {
  19.             queueEvent(new Runnable(){
  20.                public void run() {
  21.                 mRenderer.setColor(event.getX() / getWidth(),
  22.                         event.getY() / getHeight(), 1.0f);
  23.             }});
  24.             return true;
  25.          }    
  26. }    
如果在UI线程里调用渲染器的方法，因为UI事件和渲染绘制是在不同的线程里，会收到“call to OpenGL ES API with no current context”的警告，典型的案例就是在键盘或触摸事件方法里直接调用opengl es的API。

GLSurfaceView源码分析
GLSurfaceView中对于GL环境的操作，除queueEvent是将事件放入队列中然后到GL线程中执行外， 其他方法基本都是在主线程中修改某个状态值（某个属性属性），然后调用 sGLThreadManager.notifyAll() 取消GL线程的等待， 在GL线程中根据属性的状态值作不同的操作，并在操作后反馈给主线程，当然有的方法也不需要反馈。
相关类图如下，GLSurfaceView中的EglHelper和GLThread分别实现了上面提到的管理EGL环境和渲染线程的工作，GLSurfaceView的使用者需要实现Renderer接口。

渲染的整体步骤如下：

  • 获取EGLDisplay对象，初始化与EGLDisplay 之间的连接
  • 获取EGLConfig对象
  • 创建EGLContext 实例
  • 创建EGLSurface实例
  • 连接EGLContext和EGLSurface.
  • 是否需要重新申请EGLSurface，如果尺寸发生了变化，此时createEGLSurface为true
  • 是否需要申请GLObject，此时createGLinterface为true
  • 是否需要生成EGLContext，此时createEGLContext为true
  • 尺寸是否变化，sizeChanged为true，此时需要通知观察者
  • 一切准备好之后，使用GL指令绘制图形，调用view.mRenderer.onDrawFrame进行真正的渲染
  • 最后通过swap把渲染结果显示到屏幕
  • 断开并释放与EGLSurface关联的EGLContext对象
  • 删除EGLSurface对象
  • 删除EGLContext对象
  • 终止与EGLDisplay之间的连接

public  class  GLSurfaceView  extends  SurfaceView  implements  SurfaceHolder . Callback2  {

     public  final  static  int  RENDERMODE_WHEN_DIRTY =  0 ;//按需渲染模式
     public  final  static  int  RENDERMODE_CONTINUOUSLY =  1 ;//连续渲染模式

    private static final   GLThreadManager   sGLThreadManager   =   new   GLThreadManager() ;

    private final   WeakReference<GLSurfaceView>   mThisWeakRef   =  new   WeakReference<GLSurfaceView>( this ) ;
    private   GLThread   mGLThread ;
    private   Renderer   mRenderer ;
    private boolean   mDetached ;
    private   EGLConfigChooser   mEGLConfigChooser ;
    private   EGLContextFactory   mEGLContextFactory ;
    private   EGLWindowSurfaceFactory   mEGLWindowSurfaceFactory ;
    private int   mDebugFlags ;
    private int   mEGLContextClientVersion ;
    private boolean   mPreserveEGLContextOnPause ;

     public  GLSurfaceView (Context context) {
         super (context);
        init();
    }

     public  GLSurfaceView (Context context, AttributeSet attrs) {
         super (context, attrs);
        init();
    }

     //调试用的
     public  void  setDebugFlags ( int  debugFlags);
     public  int  getDebugFlags ();

     //设置暂停的时候是否保持EglContext
     public  void  setPreserveEGLContextOnPause ( boolean  preserveOnPause);
     public  boolean  getPreserveEGLContextOnPause ();

     //设置渲染器，这个非常重要，渲染工作就依靠渲染器了
     //调用此方法会开启一个新的线程，即GL线程
     public  void  setRenderer (Renderer renderer) {
        checkRenderThreadState();//检查渲染线程是否已经创建了，如果已经创建了就抛出异常
         if  (mEGLConfigChooser ==  null ) {
            mEGLConfigChooser =  new  SimpleEGLConfigChooser( true );//默认的设置EglConfig的方法
        }
         if  (mEGLContextFactory ==  null ) {
            mEGLContextFactory =  new  DefaultContextFactory();//默认的EGLContext工厂
        }
         if  (mEGLWindowSurfaceFactory ==  null ) {
            mEGLWindowSurfaceFactory =  new  DefaultWindowSurfaceFactory();//默认的EGLSurface工厂
        }
        mRenderer = renderer;
        mGLThread =  new  GLThread(mThisWeakRef);
        mGLThread.start();
    }

     //设置EGLContext工厂，不设置就用默认的
     public  void  setEGLContextFactory (EGLContextFactory factory){
    checkRenderThreadState() ;
     mEGLContextFactory   = factory ;
    }

     //设置EGLSurface工厂，不设置就用默认的
     public  void  setEGLWindowSurfaceFactory (EGLWindowSurfaceFactory factory){
    checkRenderThreadState() ;
       mEGLWindowSurfaceFactory   = factory ;
    }
     //设置EglConfig，一般颜色深度等等，利用此方法设置。不设置就用默认的
     public  void  setEGLConfigChooser (EGLConfigChooser configChooser){
    checkRenderThreadState() ;
     mEGLConfigChooser   = configChooser ;
    }

     //内部调用setEGLConfigChooser
     public  void  setEGLConfigChooser ( boolean  needDepth){
    setEGLConfigChooser( new   SimpleEGLConfigChooser(needDepth)) ;
    }

     //内部调用setEGLConfigChooser
     public  void  setEGLConfigChooser ( int  redSize,  int  greenSize,  int  blueSize,
             int  alphaSize,  int  depthSize,  int  stencilSize){
    setEGLConfigChooser( new   ComponentSizeChooser(redSize ,   greenSize ,
blueSize ,   alphaSize ,   depthSize ,   stencilSize)) ;
    }

     //设置EGLContextVersion，比如2，即OpenGLES2.0
     public  void  setEGLContextClientVersion ( int  version){
     checkRenderThreadState() ;
       mEGLContextClientVersion   = version ;
    }

     //设置渲染方式，有RENDERMODE_CONTINUOUSLY表示不断渲染
     //以及RENDERMODE_WHEN_DIRTY表示在需要的时候才会渲染
     //渲染的时候调用requestRender必须在setRenderer后
     public  void  setRenderMode ( int  renderMode){
     mGLThread .setRenderMode(renderMode) ;
    }

     public  int  getRenderMode (){
     return   mGLThread .getRenderMode() ;
    }

     //主动请求渲染
     public  void  requestRender (){
       mGLThread .requestRender() ;
    }


     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) ;
    }

     @Override
     public  void  surfaceRedrawNeeded (SurfaceHolder holder) {
         if  (mGLThread !=  null ) {
            mGLThread.requestRenderAndWait();
        }
    }

     //生命周期，一般在Activity、Fragment的onPause中调用
     public  void  onPause (){
       mGLThread .onPause() ;
    }

     //生命周期，一般在Activity、Fragment的onResume中调用
     public  void  onResume (){
       mGLThread .onResume() ;
    }

     //向GL线程发送一个任务
     public  void  queueEvent (Runnable r){
     mGLThread .queueEvent(r) ;
    }

     //附加到Window上时被调用，外部不可调用
     protected  void  onAttachedToWindow (){
     super .onAttachedToWindow() ;
     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;
    }

      //从Window上被移除时调用，外部不可调用
     protected  void  onDetachedFromWindow (){
     if   ( mGLThread   !=   null ) {
     mGLThread .requestExitAndWait() ;
     }
     mDetached   =   true;
    super .onDetachedFromWindow() ;
    }

     //渲染器接口
     public  interface  Renderer  {

         //Surface被创建时被调用，通常在此进行渲染的初始化
         void  onSurfaceCreated(GL10 gl, EGLConfig config);

         //Surface大小被改变时被调用
         void  onSurfaceChanged(GL10 gl,  int  width,  int  height);

         //执行渲染时被调用，以完成用户渲染工作
         void  onDrawFrame(GL10 gl);

    }

     //非常重要的一个EGL帮助类，GL环境的建立依靠此类
     private  static  class  EglHelper  {
         public  EglHelper (WeakReference<GLSurfaceView> glSurfaceViewWeakRef) {
            mGLSurfaceViewWeakRef = glSurfaceViewWeakRef;
        }

         //EGL的初始化，可以参考此方法
         public  void  start () {
           
             /*
             * 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" );
            }
            GLSurfaceView view = mGLSurfaceViewWeakRef.get();
             if  (view ==  null ) {
                mEglConfig =  null ;
                mEglContext =  null ;
            }  else  {
                mEglConfig = view.mEGLConfigChooser.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 = view.mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig);
            }
             if  (mEglContext ==  null  || mEglContext == EGL10.EGL_NO_CONTEXT) {
                mEglContext =  null ;
                throwEglException("createContext");
            }
             if  (LOG_EGL) {
                Log.w( "EglHelper" ,  "createContext "  + mEglContext +  " tid="  + Thread.currentThread().getId());
            }

            mEglSurface =  null ;
        }

         //创建EGLSurface，使GL的渲染，能够渲染到用户指定的Surface
         //默认的Surface就是SurfaceHolder的Surface
         public  boolean  createSurface () {
             
             /*
             * 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.
             */
            GLSurfaceView view = mGLSurfaceViewWeakRef.get();
             if  (view !=  null ) {
                mEglSurface = view.mEGLWindowSurfaceFactory.createWindowSurface(mEgl,
                        mEglDisplay, mEglConfig, view.getHolder());
            }  else  {
                mEglSurface =  null ;
            }

             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 ;
        }

         //通过EGL得到GL，然后用户设置了Wrapper的话会给得到的GL做个包装
         //同时也会解析一下用户的Debug意图，看看要不要debug
        GL createGL(){

        GL gl = mEglContext.getGL();
         GLSurfaceView view =   mGLSurfaceViewWeakRef .get() ;
        if   (view !=   null ) {
         if   (view.mGLWrapper !=   null ) {
        gl = view.mGLWrapper.wrap(gl) ;
         }

         if   ((view.mDebugFlags & ( DEBUG_CHECK_GL_ERROR   |   DEBUG_LOG_GL_CALLS )) !=   0 ) {
         int   configFlags =   0 ;
          Writer log =   null;
        if   ((view.mDebugFlags &   DEBUG_CHECK_GL_ERROR ) !=   0 ) {
        configFlags |= GLDebugHelper. CONFIG_CHECK_GL_ERROR ;
         }
         if   ((view.mDebugFlags &   DEBUG_LOG_GL_CALLS ) !=   0 ) {
        log =   new   LogWriter() ;
         }
        gl = GLDebugHelper. wrap (gl ,   configFlags ,   log) ;
         }
        }
          return   gl ;
        }

         //绘制完成之后，调用此方法，将绘制的内容输出到前台，让用户可以看到
         public  int  swap (){
         if   (!   mEgl .eglSwapBuffers( mEglDisplay ,   mEglSurface )) {
         return   mEgl .eglGetError() ;
         }
         return   EGL10. EGL_SUCCESS ;
        }

         //销毁Surface的方法，具体实现在destroySurfaceImp方法中       
        public void destroySurface() {  
            destroySurfaceImp() ;
        }

        private void   destroySurfaceImp () {
            if   ( mEglSurface   !=   null   &&   mEglSurface   != EGL10. EGL_NO_SURFACE ) {
                mEgl .eglMakeCurrent( mEglDisplay ,   EGL10. EGL_NO_SURFACE ,
                EGL10. EGL_NO_SURFACE ,
                EGL10. EGL_NO_CONTEXT ) ;
                GLSurfaceView view =   mGLSurfaceViewWeakRef .get() ;
                if   (view !=   null ) {
                    view.mEGLWindowSurfaceFactory.destroySurface( mEgl ,   mEglDisplay ,   mEglSurface ) ;
                }
                mEglSurface   =   null;
            }
        }
        //销毁GL环境
        public void   finish () {
            if   ( mEglContext   !=   null ) {
                GLSurfaceView view =   mGLSurfaceViewWeakRef .get() ;
                if   (view !=   null ) {
                    view.mEGLContextFactory.destroyContext( mEgl ,   mEglDisplay ,   mEglContext ) ;
                }
                mEglContext   =   null;
            }
            if   ( mEglDisplay   !=   null ) {
                mEgl .eglTerminate( mEglDisplay ) ;
                mEglDisplay   =   null;
            }
        }
    }
----------------------------------------------------------------------------------------------
     //GL线程，此类中存在的方法在GLSurfaceView中都有同名的， 都是提供给GLSurfaceView作为真正的实现调用
     static  class GLThread extends Thread {

    GLSurfaceView中对于GL环境的操作，除queueEvent是将事件放入队列中然后到GL线程中执行外，
    其他方法基本都是在主线程中修改某个状态值（下面的某个属性属性），然后调用sGLThreadManager.notifyAll()取消GL线程的等待，
    在GL线程中根据属性的状态值作不同的操作，并在操作后反馈给主线程，当然有的方法也不需要反馈。
         
        private boolean mShouldExit;
        private boolean   mExited ;
        private boolean   mRequestPaused ;
        private boolean   mPaused ;
        private boolean   mHasSurface ;
        private boolean   mSurfaceIsBad ;
        private boolean   mWaitingForSurface ;
        private boolean   mHaveEglContext ;
        private boolean   mHaveEglSurface ;
        private boolean   mFinishedCreatingEglSurface ;
        private boolean   mShouldReleaseEglContext ;
        private int   mWidth ;
        private int   mHeight ;
        private int   mRenderMode ;
        private boolean   mRequestRender ;
        private boolean   mWantRenderNotification ;
        private boolean   mRenderComplete ;
        private   ArrayList<Runnable>   mEventQueue   =   new   ArrayList<Runnable>() ;
        private boolean   mSizeChanged   =   true;

        // End of member variables protected by the sGLThreadManager monitor.
        private   EglHelper   mEglHelper ;

        private   WeakReference<GLSurfaceView>   mGLSurfaceViewWeakRef ;

        GLThread (WeakReference<GLSurfaceView> glSurfaceViewWeakRef) {
         super () ;
           mWidth   =   0 ;
         mHeight   =   0 ;
         mRequestRender   =   true;//开始需要刷新一次
         mRenderMode   =   RENDERMODE_CONTINUOUSLY ;//默认的渲染模式
         mWantRenderNotification   =   false;
         mGLSurfaceViewWeakRef   = glSurfaceViewWeakRef ;
        }

        
        @Override
        public void   run () {
        setName( "GLThread "   + getId()) ;
         try   {
        guardedRun() ;//处理所有渲染逻辑

         }   catch   (InterruptedException e) {
      
         }   finally   {
         sGLThreadManager .threadExiting( this ) ;
         }
        }

        

         //销毁EglSurface
         private  void  stopEglSurfaceLocked (){
         if   ( mHaveEglSurface ) {
         mHaveEglSurface   =   false;
         mEglHelper .destroySurface() ;
         }
        }

         //销毁EglContext
         private  void  stopEglContextLocked (){
         if   ( mHaveEglContext ) {
         mEglHelper .finish() ;
         mHaveEglContext   =   false;
         sGLThreadManager .releaseEglContextLocked( this ) ;
         }
        }

         // GLSurfaceView的核心就在这个方法里面, GL线程 渲染的主要逻辑 都在这个方法里面，这个方法比较复杂     
        第一步：判断事件队列是否为空，如果有事件需要处理，则直接跳出内循环去处理事件，否则依然在内循环运行
        第二步：1.判断是否需要释放EGLSurface，
                        2.判断是否丢失了Surface，mHasSurface表示当前有没有可用的Surface，mWaitingForSurface表示是否在申请Surface的过程中，
                        3.是否需要放弃EGLContext
        第三步：经过以上的判断之后，程序进入图形渲染前的准备工作，也就是readyToDraw之间的代码
        第四步：一旦程序执行到这里也就是跳出了内循环，有两种可能，第一是EventQueue中有需要处理的事件，第二是需要执行渲染工作
       private  void  guardedRun ()  throws  InterruptedException {
            mEglHelper =  new  EglHelper(mGLSurfaceViewWeakRef);//初始化EglHelper
            mHaveEglContext =  false ;
            mHaveEglSurface =  false ;
            mWantRenderNotification =  false ;

                     try  {
                GL10 gl =  null ;
                 boolean  createEglContext =  false ;
                         boolean  createEglSurface =  false ;
                         boolean  createGlInterface =  false ;
                 boolean  lostEglContext =  false ;
                         boolean  sizeChanged =  false ;
                         boolean  wantRenderNotification =  false ;
                 boolean  doRenderNotification =  false ;
                 boolean  askedToReleaseEglContext =  false ;
                         int  w =  0 ;
                         int  h =  0 ;
               Runnable event =  null ;

                 while  ( true ) {
                         synchronized  (sGLThreadManager) {
                         while  ( true ) {//死循环，除非主动跳出
                                 //外部请求退出GL线程
                             if  (mShouldExit) {
                                 return ;
                            }

                             /*外部请求在GL线程中处理的事件没有处理完时，就优先处理这些事件*/
                                     if  (! mEventQueue.isEmpty()) {
                                event = mEventQueue.remove( 0 );
                                          break ;
                            }

                                     //暂停和恢复状态变化时，onResume和onPause状态变化
                                     boolean  pausing =  false ;
                                     if  (mPaused != mRequestPaused) {
                                pausing = mRequestPaused;
                                mPaused = mRequestPaused;
                                         /*GLSurfaceView的onPause和onResume都会用wait方法等待GL线程的响应，这时候主线程阻塞。
                                    此处调用notifyAll通知onPause和onResume，放弃主线程的阻塞。
                                    GLSurfaceView中其他很多方法也存在wait方法，基本与此类似
                                */
                                sGLThreadManager.notifyAll();
                            }

                                     // 需要释放EglContext时候执行的工作
                                     if  (mShouldReleaseEglContext) {
                        
                                stopEglSurfaceLocked();
                                stopEglContextLocked();
                                mShouldReleaseEglContext =  false ;
                                askedToReleaseEglContext =  true ;
                            }

                                     // EglContext丢失时，销毁EglSurface和EglContext
                                     if  (lostEglContext) {
                                stopEglSurfaceLocked();
                                stopEglContextLocked();
                                lostEglContext =  false ;
                            }

                                     // 如果 acitivity 已经暂停， 接收了暂停信号，而且当前EglSurface存在时，销毁EglSurface
                                     if  (pausing && mHaveEglSurface) {
                                stopEglSurfaceLocked();
                            }

                                 /*接收了暂停信号，而且当前EglContext存在时，根据用户设置，来决定是否销毁EglContext*/
                                 if  (pausing && mHaveEglContext) {
                                GLSurfaceView view = mGLSurfaceViewWeakRef.get();
                                 boolean  preserveEglContextOnPause = view ==  null  ?  false  : view.mPreserveEGLContextOnPause;
                                         if  (!preserveEglContextOnPause) {
                                    stopEglContextLocked();
                                }
                          }

                                 /*Surface不存在而且当前并没有在等待Surface*/
                                 if  ((! mHasSurface) && (! mWaitingForSurface)) {
                                 if  (mHaveEglSurface) {
                                stopEglSurfaceLocked();
                            }
                            mWaitingForSurface =  true ;
                            mSurfaceIsBad =  false ;
                            sGLThreadManager.notifyAll();
                        }

                         // Surface存在，而且在等待Surface
                             if  (mHasSurface && mWaitingForSurface) {
                        
                            mWaitingForSurface =  false ;
                            sGLThreadManager.notifyAll();
                        }

                             if  (doRenderNotification) {
                       
                            mWantRenderNotification =  false ;
                            doRenderNotification =  false ;
                            mRenderComplete =  true ;
                            sGLThreadManager.notifyAll();
                        }

                        // 判断当前环境准备好了渲染执行，否则进入下一轮等待及判断
                            判断两个关键因素：EGLContext和EGLSurface是否存在并有效，如果没有EGLContext，就需要获取一个，
                            如果当前有EGLSurface但尺寸发生了变化，那么就需要销毁他并重新申请Surface。
                            可以渲染图形的条件是：
                            1.程序当前不处于pause状态， 2.已经成功获得Surface， 3.有合适的尺寸， 4.处于自动持续渲染状态或用户发起了渲染请求
                         if  (readyToDraw()) {

                             // 没有EglContext就需要借助EglHelper来创建EglContext
                             if  (! mHaveEglContext) {
                             if  (askedToReleaseEglContext) {
                                askedToReleaseEglContext =  false ;
                            }  else  {
                                 try  {
                                    mEglHelper.start();
                                }  catch  (RuntimeException t) {
                                    sGLThreadManager.releaseEglContextLocked( this );
                                     throw  t;
                                }
                                mHaveEglContext =  true ;
                                createEglContext =  true ;

                                sGLThreadManager.notifyAll();
                            }
                        }

                         /*有了EglContext,但是没有EglSurface，就需要设置一些状态，以便后续操作*/
                         if  (mHaveEglContext && !mHaveEglSurface) {
                            mHaveEglSurface =  true ;
                            createEglSurface =  true ;
                            createGlInterface =  true ;
                            sizeChanged =  true ;
                        }

                         /*有eglSurface时，需要判断是否需要执行surface sizechange*/
                         if  (mHaveEglSurface) {
                             if  (mSizeChanged) {
                                sizeChanged =  true ;
                                w = mWidth;
                                h = mHeight;
                                mWantRenderNotification =  true ;
                               
                                 // Destroy and recreate the EGL surface.
                                createEglSurface =  true ;

                                mSizeChanged =  false ;
                            }
                            mRequestRender =  false ;
                            sGLThreadManager.notifyAll();
                             if  (mWantRenderNotification) {
                                wantRenderNotification =  true ;
                            }
                             //注意此处break，跳出等待的循环
                             break ;
                        }
                    }

                     // By design, this is the only place in a GLThread thread where we wait().
                    sGLThreadManager.wait();
                }
            }

             /*外部请求在GL线程中处理的事件没有处理完时，就优先处理这些事件*/
             if  (event !=  null ) {
                event.run();
                event =  null ;
                 continue ;
            }

             //后续就是根据上面的判断设置，来执行相应的操作
             if  (createEglSurface) {//EglSurface需要被创建
                 //创建EglSurface
                 if  (mEglHelper.createSurface()) {      
                     synchronized (sGLThreadManager) {
                        mFinishedCreatingEglSurface =  true ;
                        sGLThreadManager.notifyAll();
                    }
                }  else  {
                     synchronized (sGLThreadManager) {
                        mFinishedCreatingEglSurface =  true ;
                        mSurfaceIsBad =  true ;
                        sGLThreadManager.notifyAll();
                    }
                     continue ;
                }
                createEglSurface =  false ;
            }

             if  (createGlInterface) {
                gl = (GL10) mEglHelper.createGL();

                createGlInterface =  false ;
            }

             if  (createEglContext) {

                GLSurfaceView view = mGLSurfaceViewWeakRef.get();
                 if  (view !=  null ) {
                     try  {
                        Trace.traceBegin(Trace.TRACE_TAG_VIEW,  "onSurfaceCreated" );
                         //调用GLSurfaceView设置的renderer的onSurfceCreated方法
                        view.mRenderer.onSurfaceCreated(gl, mEglHelper.mEglConfig);
                    }  finally  {
                        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
                    }
                }
                createEglContext =  false ;
            }

             //surface大小被改变
             if  (sizeChanged) {
                GLSurfaceView view = mGLSurfaceViewWeakRef.get();
                 if  (view !=  null ) {
                     try  {
                        Trace.traceBegin(Trace.TRACE_TAG_VIEW,  "onSurfaceChanged" );
                        view.mRenderer.onSurfaceChanged(gl, w, h);//通知应用程序尺寸发生了变化
                    }  finally  {
                        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
                    }
                }
                sizeChanged =  false ;
            }

             //每帧绘制
            {
                GLSurfaceView view = mGLSurfaceViewWeakRef.get();
                 if  (view !=  null ) {
                     try  {
                        Trace.traceBegin(Trace.TRACE_TAG_VIEW,  "onDrawFrame" );
                        view.mRenderer.onDrawFrame(gl);//调用应用程序的Renderer渲染
                    }  finally  {
                        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
                    }
                }
            }
            //提交绘制结果，通过swap把渲染结果显示到屏幕上
             int  swapError = mEglHelper.swap();
             switch  (swapError) {
                 case  EGL10.EGL_SUCCESS:
                     break ;
                 case  EGL11.EGL_CONTEXT_LOST:
                    lostEglContext =  true ;
                     break ;
                 default :
                    EglHelper.logEglErrorAsWarning( "GLThread" ,  "eglSwapBuffers" , swapError);

                     synchronized (sGLThreadManager) {
                        mSurfaceIsBad =  true ;
                        sGLThreadManager.notifyAll();
                    }
                     break ;
            }

             if  (wantRenderNotification) {
                doRenderNotification =  true ;
                wantRenderNotification =  false ;
            }
        }

    }  finally  {
             /*
             * clean-up everything...
             */
         synchronized  (sGLThreadManager) {
            stopEglSurfaceLocked();
            stopEglContextLocked();
        }
    }

}

         public  boolean  ableToDraw () {
             return  mHaveEglContext && mHaveEglSurface && readyToDraw();
        }

         private  boolean  readyToDraw () {
             return  (!mPaused) && mHasSurface && (!mSurfaceIsBad)
                && (mWidth >  0 ) && (mHeight >  0 )
                && (mRequestRender || (mRenderMode == RENDERMODE_CONTINUOUSLY));
        }

         //设置渲染方法，见GLSurfaceView的setRenderMode
         public  void  setRenderMode ( int  renderMode){
         if   ( !(( RENDERMODE_WHEN_DIRTY   <= renderMode) && (renderMode <=   RENDERMODE_CONTINUOUSLY )) ) {
         throw new   IllegalArgumentException( "renderMode" ) ;
         }
         synchronized ( sGLThreadManager ) {
         mRenderMode   = renderMode ;
         sGLThreadManager .notifyAll() ;
         }
        }

         public  int  getRenderMode (){
         synchronized ( sGLThreadManager ) {
         return   mRenderMode ;
         }
        }

         //请求一次渲染
         public  void  requestRender (){
         synchronized ( sGLThreadManager ) {
         mRequestRender   =   true;
         sGLThreadManager .notifyAll() ;
         }
        }

         //请求一次渲染，并等待渲染完成
         public  void  requestRenderAndWait (){
         synchronized ( sGLThreadManager ) {
         if   (Thread. currentThread () ==   this ) {
           return;
         }

           mWantRenderNotification   =   true;
         mRequestRender   =   true;
         mRenderComplete   =   false;

         sGLThreadManager .notifyAll() ;

        while   (! mExited   && ! mPaused   && ! mRenderComplete   && ableToDraw()) {
         try   {
         sGLThreadManager .wait() ;
         }   catch   (InterruptedException ex) {
        Thread. currentThread ().interrupt() ;
         }
        }

         }
        }
         //创建Surface
         public  void  surfaceCreated (){
         synchronized ( sGLThreadManager ) {
         mHasSurface   =   true;
         mFinishedCreatingEglSurface   =   false;
         sGLThreadManager .notifyAll() ;
        while   ( mWaitingForSurface
     && ! mFinishedCreatingEglSurface
       && ! mExited ) {
         try   {
     sGLThreadManager .wait() ;
         }   catch   (InterruptedException e) {
        Thread. currentThread ().interrupt() ;
         }
         }
        }
        }

         //销毁Surface
         public  void  surfaceDestroyed (){
         synchronized ( sGLThreadManager ) {
         mHasSurface   =   false;
         sGLThreadManager .notifyAll() ;
         while ((! mWaitingForSurface ) && (! mExited )) {
         try   {
         sGLThreadManager .wait() ;
         }   catch   (InterruptedException e) {
        Thread. currentThread ().interrupt() ;
         }
        }
        }
        }

         public  void  onPause (){
         synchronized   ( sGLThreadManager ) {
         mRequestPaused   =   true;
         sGLThreadManager .notifyAll() ;
        while   ((!   mExited ) && (!   mPaused )) {
         try   {
         sGLThreadManager .wait() ;
         }   catch   (InterruptedException ex) {
        Thread. currentThread ().interrupt() ;
         }
        }
        }
        }
         public  void  onResume (){
         synchronized   ( sGLThreadManager ) {
         mRequestPaused   =   false;
         mRequestRender   =   true;
         mRenderComplete   =   false;
         sGLThreadManager .notifyAll() ;
        while   ((!   mExited ) &&   mPaused   && (! mRenderComplete )) {
         try   {
         sGLThreadManager .wait() ;
         }   catch   (InterruptedException ex) {
        Thread. currentThread ().interrupt() ;
         }
        }
        }
        }

         //Surface的大小被改变时调用
         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 ex) {
        Thread. currentThread ().interrupt() ;
         }
        }
         }
        }

         //请求退出渲染线程，并等待退出
         public  void  requestExitAndWait (){
         synchronized ( sGLThreadManager ) {
         mShouldExit   =   true;
         sGLThreadManager .notifyAll() ;
        while   (!   mExited ) {
         try   {
         sGLThreadManager .wait() ;
         }   catch   (InterruptedException ex) {
        Thread. currentThread ().interrupt() ;
         }
        }
        }
        }

         //请求回收EglContext
         public  void  requestReleaseEglContextLocked (){
         mShouldReleaseEglContext   =   true;
         sGLThreadManager .notifyAll() ;
        }

         //向GL线程发送一个任务
         public  void  queueEvent (Runnable r){
         if   (r ==   null ) {
         throw new   IllegalArgumentException( "r must not be null" ) ;
         }
         synchronized ( sGLThreadManager ) {
         mEventQueue .add(r) ;
         sGLThreadManager .notifyAll() ;
         }
        }

    }


     //很多方法都会调用此方法，会检查mGLThread不为null， 即保证调用此方法的方法，必须在setRenderer之前调用
     private  void  checkRenderThreadState (){
     if   ( mGLThread   !=   null ) {
     throw new   IllegalStateException(
"setRenderer has already been called for this instance." ) ;
     }
    }

     //主要就是用来做同步用的，利用Object的wait和notifyAll
     private  static  class  GLThreadManager  {

            public synchronized void  threadExiting(GLThread thread) {
                thread. mExited =  true;
                notifyAll() ;
            }

            public void  releaseEglContextLocked(GLThread thread) {
                notifyAll() ;
            }
    }

}




EGLHelper
readyToDraw后调用了 EGLHelper. start方法初始化，然后跳出readyToDraw后调用了 EGLHelper. createSurface方法创建一个 EglSurface，
最后绘制完成以后 通过 EGLHelper. swap把渲染结果显示到屏幕上。

第一步： EGLHelper. start()方法初始化EGLHelper的内容
public void start() {
　   mEgl = (EGL10) EGLContext.getEGL();//获取一个EGL实例
        //获取一个EGLDisplay
    mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);

       //初始化EGL并返回版本号
    if(!mEgl.eglInitialize(mEglDisplay, version)) {
    }
    GLSurfaceView view = mGLSurfaceViewWeakRef.get();
        //选取一个配置
    mEglConfig = view.mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
        //创建EGLContext
    mEglContext = view.mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig);
    mEglSurface = null;
}

第二步：如果需要创建 EglSurface，调用 mEglHelper.createSurface()方法
public boolean createSurface() {
    if (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");
    }
    GLSurfaceView view = mGLSurfaceViewWeakRef.get();
   
    mEglSurface = view.mEGLWindowSurfaceFactory.createWindowSurface(mEgl,
                mEglDisplay, mEglConfig, view.getHolder());

    return true;
}

private static class DefaultWindowSurfaceFactory implements EGLWindowSurfaceFactory {

    public EGLSurface createWindowSurface(EGL10 egl, EGLDisplay display,
            EGLConfig config, Object nativeWindow) {
        EGLSurface result = null;
        result = egl.eglCreateWindowSurface(display, config, nativeWindow, null);
        return result;
}

}

第三步：提交绘制结果，通过mEglHelper.swap()把渲染结果显示到屏幕上
public int swap() {
     if (! mEgl.eglSwapBuffers(mEglDisplay, mEglSurface)) {
          return mEgl.eglGetError();
     }
     return EGL10.EGL_SUCCESS;
}

总结GLSurfaceView使用EGL的流程如下：
1.生成一个EGL实例
mEgl = (EGL10) EGLContext.getEGL();
2.获取一个EGL Display  
mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
3.初始化EGL并返回版本号
if(!mEgl.eglInitialize(mEglDisplay, version)) {}
4.选取一个配置
mEglConfig = view.mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
5.创建一个EGLContext
mEglContext = view.mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig);
6.创建EGLSurface
egl.eglCreateWindowSurface(display, config, nativeWindow, null);
7.通过swap将渲染内容显示到屏幕
mEgl.eglSwapBuffers(mEglDisplay, mEglSurface)

猜你喜欢

转载自blog.csdn.net/tugele/article/details/79199161
今日推荐
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
周排行
laravle中orm简单的增删改查
文本分类 特征选取之CHI开方检验
Spark核心编程-WordCount
大数据开发实战系列之电信客服(1)
读书笔记 - 把时间当作朋友 by 李笑来
python 笔记--if else
SpringBoot/Mybatis/Druid, 多数据源MultiDataSource配置思路
排序三个整数
redis集群搭建【2】-Windows中Redis集群搭建
STM32F030驱动TM1650点亮4联数码管
每日归档
更多
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022