Android OpenGL ES - EGL源码解析以及C++实现

时间 2020-12-02

标签 java c++ 缓存 jvm ide 函数 oop this spa 操作系统栏目 Android 繁體版

原文原文链接

PS
咱们在前面的文章中就说过关于EGL的出现缘由以及其做用
OpenGL 是一个跨平台的API,而不一样的操做系统(Windows,Android,IOS)各有本身的屏幕渲染实现。因此OpenGL定义了一个中间接口层EGL（Embedded Graphics Library）标准，具体实现交给各个操做系统自己java

EGL

简单来讲EGL是一个中间接口层，是一个规范，因为OpenGL的跨平台性，因此说这个规范显得尤为重要，无论各个操做系统如何蹦跶，都不能脱离我所定义的规范。c++

EGL的一些基础知识

EGLDisplay

EGL定义的一个抽象的系统显示类，用于操做设备窗口。缓存

EGLConfig

EGL配置，如rgba位数jvm

EGLSurface

渲染缓存，一块内存空间，全部要渲染到屏幕上的图像数据，都要先缓存在EGLSurface上。ide

EGLContext

OpenGL上下文，用于存储OpenGL的绘制状态信息、数据。函数

初始化EGL的过程能够说是对上面几个信息进行配置的过程oop

OpenGL ES绘图完整流程

咱们在使用Java GLSurfaceView的时候其实只是自定义了Render,该Render实现了GLsurfaceView.Renderer接口，而后自定义的Render中的3个方法就会获得回调，Android 系统其实帮我省掉了其中的不少步骤。因此咱们这里来看一下完整流程
(1). 获取显示设备(对应于上面的EGLDisplay)this

/*
 * Get an EGL instance */
 mEgl = (EGL10) EGLContext.getEGL();
 
/*
 * Get to the default display. */
 mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);

(2). 初始化EGLspa

int[] version = new int[2];
//初始化屏幕
if(!mEgl.eglInitialize(mEglDisplay, version)) {
    throw new RuntimeException("eglInitialize failed");
}

(3). 选择Config(用EGLConfig配置参数)操作系统

//这段代码的做用是选择EGL配置， 便可以本身先设定好一个你但愿的EGL配置，好比说RGB三种颜色各占几位，你能够随便配，而EGL可能不能知足你全部的要求，因而它会返回一些与你的要求最接近的配置供你选择。
if (!egl.eglChooseConfig(display, mConfigSpec, configs, numConfigs,
 num_config)) {
    throw new IllegalArgumentException("eglChooseConfig#2 failed");
}

(4). 建立EGLContext

//从上一步EGL返回的配置列表中选择一种配置，用来建立EGL Context。
egl.eglCreateContext(display, config, EGL10.EGL_NO_CONTEXT,
 mEGLContextClientVersion != 0 ? attrib_list : null);

(5). 获取EGLSurface

//建立一个窗口Surface，能够当作屏幕所对应的内存
 egl.eglCreateWindowSurface(display, config, nativeWindow, null)

PS
这里的nativeWindow是GLSurfaceView的surfaceHolder

(6). 绑定渲染环境到当前线程

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

循环绘制

loop:{
    //绘制中....
    //(7).交换缓冲区
    mEglHelper.swap();
}

public int swap() {
    if (! mEgl.eglSwapBuffers(mEglDisplay, mEglSurface)) {
        return mEgl.eglGetError();
    }
    return EGL10.EGL_SUCCESS;
}

Java - GLSurfaceView/GLTextureView

上面咱们介绍了EGL的一些基础知识，接着咱们来看在GLSurfaceView/GLTextureView中EGL的具体实现，咱们来从源码上剖析Android系统EGL及GL线程

GLThread

咱们来看一下GLThread，GLThread也是从普通的Thread类继承而来，理论上就是一个普通的线程，为何它拥有OpenGL绘图能力？继续往下看，里面最重要的部分就是guardedRun()方法

static class GLThread extends Thread {
    ...
    @Override
    public void run() {
      
        try {
                guardedRun();
         } catch (InterruptedException e) {
                // fall thru and exit normally
         } finally {
                sGLThreadManager.threadExiting(this);
         }
    }
}

让咱们来看一下guardedRun()方法里有什么东西，guardedRun()里大体作的事情：

private void guardedRun() throws InterruptedException {
    while(true){
        //if ready to draw
        ...
        mEglHelper.start();//对应于上面完整流程中的(1)(2)(3)(4)
        
        ...
        mEglHelper.createSurface()//对应于上面完整流程中的(5)(6)
        
        ...
        回调GLSurfaceView.Renderer的onSurfaceCreated();
        ...
        回调GLSurfaceView.Renderer的onSurfaceChanged();
        ...
        回调GLSurfaceView.Renderer的onDrawFrame();
        
        ...
         mEglHelper.swap();//对应于上面完整流程中的(5)(7)
    }
}

从上面咱们的分析得知GLSurfaceView 中的GLThread就是一个普通的线程，只不过它按照了OpenGL绘图的完整流程正确地操做了下来，所以它有OpenGL的绘图能力。那么，若是咱们本身建立一个线程，也按这样的操做方法，那咱们也能够在本身建立的线程里绘图吗？答案是确定的(这不正是EGL的接口意义)，下面我会给出EGL在Native C/C++中的实现。

Native - EGL

Android Native环境中并不存在现成的EGL环境，因此咱们在进行OpenGL的NDK开发时就必须本身实现EGL环境，那么如何实现呢，咱们只须要参照GLSurfaceView中的GLThread的写法就能实现Native中的EGL

PS
一下的内容可能须要你对C/C++以及NDK 有必定熟悉

第1步实现相似于Java GLSurfaceView中的GLThread的功能

gl_render.h

class GLRender {
    private:
         const char *TAG = "GLRender";
         //OpenGL渲染状态
         enum STATE {
             NO_SURFACE, //没有有效的surface
             FRESH_SURFACE, //持有一个为初始化的新的surface
             RENDERING, //初始化完毕，能够开始渲染
             SURFACE_DESTROY, //surface销毁
             STOP //中止绘制
         };
         JNIEnv *m_env = NULL;
         //线程依附的jvm环境
         JavaVM *m_jvm_for_thread = NULL;
         //Surface引用，必需要使用引用，不然没法在线程中操做
         jobject m_surface_ref = NULL;
         //本地屏幕
         ANativeWindow *m_native_window = NULL;
         //EGL显示表面
         EglSurface *m_egl_surface = NULL;
         int m_window_width = 0;
         int m_window_height = 0;
         
         // 绘制代理器
         ImageRender *pImageRender;
         
         //OpenGL渲染状态
         STATE m_state = NO_SURFACE;
         // 初始化相关的方法
         void InitRenderThread();
         bool InitEGL();
         void InitDspWindow(JNIEnv *env);
         // 建立/销毁 Surface void CreateSurface();
         void DestroySurface();
         // 渲染方法
         void Render();
         void ReleaseSurface();
         void ReleaseWindow();
         // 渲染线程回调方法
         static void sRenderThread(std::shared_ptr<GLRender> that);
    public:
         GLRender(JNIEnv *env);
         ~GLRender();
         //外部传入Surface
         void SetSurface(jobject surface);
      
         void Stop();
         void SetBitmapRender(ImageRender *bitmapRender);
        // 释放资源相关方法
         void ReleaseRender();
         
         ImageRender *GetImageRender();
};

gl_render.cpp

//构造函数
GLRender::GLRender(JNIEnv *env) {
     this->m_env = env;
     //获取JVM虚拟机，为建立线程做准备
     env->GetJavaVM(&m_jvm_for_thread);
     InitRenderThread();
}
//析构函数
GLRender::~GLRender() {
    delete m_egl_surface;
}

//初始化渲染线程
void GLRender::InitRenderThread() {
    // 使用智能指针，线程结束时，自动删除本类指针
     std::shared_ptr<GLRender> that(this);
     std::thread t(sRenderThread, that);
     t.detach();
}

//线程回调函数
void GLRender::sRenderThread(std::shared_ptr<GLRender> that) {
    JNIEnv *env;
     //(1) 将线程附加到虚拟机，并获取env
     if (that->m_jvm_for_thread->AttachCurrentThread(&env, NULL) != JNI_OK) {
            LOGE(that->TAG, "线程初始化异常");
            return; 
     }
     // (2) 初始化 EGL 
    if (!that->InitEGL()) {
         //解除线程和jvm关联
         that->m_jvm_for_thread->DetachCurrentThread();
         return; 
     }
     
     //进入循环
    while (true) {
            //根据OpenGL渲染状态进入不一样的处理
            switch (that->m_state) {
                //刷新Surface，从外面设置Surface后m_state置为该状态，说明已经从外部(java层)得到Surface的对象了
                case FRESH_SURFACE:
                     LOGI(that->TAG, "Loop Render FRESH_SURFACE")
                     // (3) 初始化Window
                     that->InitDspWindow(env);
                     // (4) 建立EglSurface
                     that->CreateSurface();
                     // m_state置为RENDERING状态进入渲染
                     that->m_state = RENDERING;
                     break; 
                 case RENDERING:
                    LOGI(that->TAG, "Loop Render RENDERING")
                    // (5) 渲染
                    that->Render();
                    break; 
               
                 case STOP:
                    LOGI(that->TAG, "Loop Render STOP")
                    //(6) 解除线程和jvm关联
                     that->ReleaseRender();
                     that->m_jvm_for_thread->DetachCurrentThread();
                     return; 
                case SURFACE_DESTROY:
                    LOGI(that->TAG, "Loop Render SURFACE_DESTROY")
                    //(7) 释放资源
                    that->DestroySurface();
                    that->m_state = NO_SURFACE;
                    break; 
                case NO_SURFACE:
                default:
                    break;
     }
    usleep(20000);
 }
}

咱们定义的GLRender各个流程代码里已经标注了步骤，虽然代码量比较多，可是咱们的c++ class分析也是跟java相似，

PS
上图中的(3)(4)等步骤对应于代码中的步骤注释

小结

本篇文章咱们介绍了EGL，以及分析了Java 中GLSurfaceView中的EGL实现，而后咱们试着参照Java端的代码实现Native中的EGL环境，关于代码以及流程图中的细节，咱们下篇再来分析。