登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›【OpenGL ES】不用GLSurfaceView，如何渲染图像 ...

【OpenGL ES】不用GLSurfaceView，如何渲染图像

坡琨 昨天 14:12
1 前言

​    Android 中，GLSurfaceView 封装了 EGL 环境，使得我们省去了复杂的 EGL 环境搭建。如果我们不用 GLSurfaceView，该如何渲染 OpenGL ES 图像？在回答此问题前，我们先了解下 EGL。
​    EGL 是 Khronos Group 定义的平台无关接口，作为 OpenGL ES 和本地窗口系统之间的桥梁，主要功能如下。

  • 管理图形上下文
  • 创建和管理渲染表面 (surface)
  • 同步渲染与平台显示系统
​    EGL 提供了两种渲染方式，分别是离屏渲染和窗口渲染，分别对应 eglCreatePbufferSurface 和 eglCreateWindowSurface。对于离屏渲染方案，详见 → EGL+FBO离屏渲染。eglCreateWindowSurface 函数的源码如下。
  1. public static EGLSurface eglCreateWindowSurface(EGLDisplay dpy,
  2.     EGLConfig config, Object win, int[] attrib_list, int offset){
  3.     Surface sur = null;
  4.     if (win instanceof SurfaceView) {
  5.         SurfaceView surfaceView = (SurfaceView)win;
  6.         sur = surfaceView.getHolder().getSurface();
  7.     } else if (win instanceof SurfaceHolder) {
  8.         SurfaceHolder holder = (SurfaceHolder)win;
  9.         sur = holder.getSurface();
  10.     } else if (win instanceof Surface) {
  11.         sur = (Surface) win;
  12.     }
  14.     EGLSurface surface;
  15.     if (sur != null) {
  16.         surface = _eglCreateWindowSurface(dpy, config, sur, attrib_list, offset);
  17.     } else if (win instanceof SurfaceTexture) {
  18.         surface = _eglCreateWindowSurfaceTexture(dpy, config,
  19.                 win, attrib_list, offset);
  20.     } else {
  21.         throw new java.lang.UnsupportedOperationException(
  22.             "eglCreateWindowSurface() can only be called with an instance of " +
  23.             "Surface, SurfaceView, SurfaceTexture or SurfaceHolder at the moment, " +
  24.             "this will be fixed later.");
  25.     }
  27.     return surface;
  28. }
复制代码
​    主要留意 win 参数，可以看到它可以是 SurfaceView、SurfaceHolder、Surface，本质都是为了获取 Surface。因此我们提供了以下两种渲染图像的方案。

  • 继承 SurfaceView 方案：自定义一个 View 继承 SurfaceView，并实现 SurfaceHolder.Callback 接口，在 surfaceCreated 方法中将 this 或 getHolder() 传给 eglCreateWindowSurface 函数。
  • 继承 TextureView 方案：自定义一个 View 继承 TextureView，并实现 TextureView.SurfaceTextureListener 接口，在 onSurfaceTextureAvailable 方法中会提供 SurfaceTexture，我们可以创建一个 Surface，并将 SurfaceTexture 传给 Surface，然后将创建的 Surface 传给 eglCreateWindowSurface 函数。
​    本文完整代码详见 → 不用GLSurfaceView，如何渲染图像。
2 继承 SurfaceView 方案

​    自定义一个 View 继承 SurfaceView，并实现 SurfaceHolder.Callback 接口，在 surfaceCreated 方法中将 this 或 getHolder() 传给 eglCreateWindowSurface 函数。
​    由于 GLSurfaceView 继承 SurfaceView，所以该方案很容易想到，只需要将 GLSurfaceView 的核心代码扣出来就行。
​    MainActivity.java
  1. package com.zhyan8.egldemo;
  3. import android.os.Bundle;
  5. import androidx.appcompat.app.AppCompatActivity;
  7. public class MainActivity extends AppCompatActivity {
  8.     private EGLSurfaceView mEglSurfaceView;
  10.     protected void onCreate(Bundle savedInstanceState) {
  11.         super.onCreate(savedInstanceState);
  12.         mEglSurfaceView = new EGLSurfaceView(this);
  13.         setContentView(mEglSurfaceView);
  14.         mEglSurfaceView.setRenderer(new MyRenderer(this));
  15.     }
  17.     @Override
  18.     protected void onResume() {
  19.         super.onResume();
  20.         mEglSurfaceView.requestRender();
  21.         //mEglSurfaceView.startRender();
  22.     }
  24.     @Override
  25.     protected void onPause() {
  26.         super.onPause();
  27.         mEglSurfaceView.stopRender();
  28.     }
  29. }
复制代码
​    EGLSurfaceView.java
  1. package com.zhyan8.egldemo;
  3. import android.content.Context;
  4. import android.opengl.EGL14;
  5. import android.opengl.EGLConfig;
  6. import android.opengl.EGLContext;
  7. import android.opengl.EGLDisplay;
  8. import android.opengl.EGLExt;
  9. import android.opengl.EGLSurface;
  10. import android.util.Log;
  11. import android.view.Choreographer;
  12. import android.view.SurfaceHolder;
  13. import android.view.SurfaceView;
  15. import androidx.annotation.NonNull;
  17. /**
  18. * @author little fat sheep
  19. * 承载EGL环境的View, 类比GLSurfaceView
  20. */
  21. public class EGLSurfaceView extends SurfaceView implements SurfaceHolder.Callback {
  22.     private static final String TAG = "EGLSurfaceView";
  24.     protected EGLDisplay mEGLDisplay;
  25.     protected EGLConfig mEGLConfig;
  26.     protected EGLContext mEGLContext;
  27.     protected EGLSurface mEGLSurface;
  28.     protected Context mContext;
  29.     protected Renderer mRenderer;
  30.     protected boolean mFirstCreateSurface = true;
  31.     private Choreographer mChoreographer = Choreographer.getInstance();
  33.     public EGLSurfaceView(Context context) {
  34.         super(context);
  35.         mContext = context;
  36.         getHolder().addCallback(this);
  37.     }
  39.     // 设置渲染器
  40.     public void setRenderer(Renderer renderer) {
  41.         mRenderer = renderer;
  42.     }
  44.     // 开始持续渲染
  45.     public void startRender() {
  46.         Log.i(TAG, "startRender");
  47.         mChoreographer.removeFrameCallback(mFrameCallback);
  48.         mChoreographer.postFrameCallback(mFrameCallback);
  49.     }
  51.     // 暂停持续渲染
  52.     public void stopRender() {
  53.         Log.i(TAG, "stopRender");
  54.         mChoreographer.removeFrameCallback(mFrameCallback);
  55.     }
  57.     // 请求渲染一帧
  58.     public void requestRender() {
  59.         mFrameCallback.doFrame(System.nanoTime());
  60.     }
  62.     @Override
  63.     protected void onAttachedToWindow() {
  64.         super.onAttachedToWindow();
  65.         createDisplay();
  66.         createConfig();
  67.         createContext();
  68.     }
  70.     @Override
  71.     public void surfaceCreated(@NonNull SurfaceHolder holder) { // 每次activity resume都会调用一次
  72.         Log.i(TAG, "surfaceCreated, surface=" + holder.getSurface());
  73.         createSurface();
  74.         makeCurrent();
  75.         if (mFirstCreateSurface) {
  76.             mRenderer.onSurfaceCreated();
  77.             mFirstCreateSurface = false;
  78.         }
  79.     }
  81.     @Override
  82.     public void surfaceChanged(@NonNull SurfaceHolder holder, int format, int width, int height) {
  83.         Log.i(TAG, "surfaceChanged, width=" + width + ", height=" + height);
  84.         mRenderer.onSurfaceChanged(width, height);
  85.     }
  87.     @Override
  88.     public void surfaceDestroyed(@NonNull SurfaceHolder holder) { // 每次activity pause都会调用一次
  89.         Log.i(TAG, "surfaceDestroyed");
  90.         if (mEGLDisplay != null && mEGLDisplay != EGL14.EGL_NO_DISPLAY) {
  91.             // 与显示设备解绑
  92.             EGL14.eglMakeCurrent(mEGLDisplay, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_CONTEXT);
  93.             // 销毁 EGLSurface
  94.             if (mEGLSurface != null && mEGLSurface != EGL14.EGL_NO_SURFACE) {
  95.                 EGL14.eglDestroySurface(mEGLDisplay, mEGLSurface);
  96.                 checkoutConfig("eglDestroySurface");
  97.                 mEGLSurface = null;
  98.             }
  99.         }
  100.     }
  102.     @Override
  103.     public void onDetachedFromWindow() {
  104.         super.onDetachedFromWindow();
  105.         Log.i(TAG, "onDetachedFromWindow");
  106.         stopRender();
  107.         getHolder().removeCallback(this);
  108.         if (mEGLDisplay != null && mEGLDisplay != EGL14.EGL_NO_DISPLAY) {
  109.             // 与显示设备解绑
  110.             EGL14.eglMakeCurrent(mEGLDisplay, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_CONTEXT);
  111.             // 销毁 EGLSurface
  112.             if (mEGLSurface != null && mEGLSurface != EGL14.EGL_NO_SURFACE) {
  113.                 EGL14.eglDestroySurface(mEGLDisplay, mEGLSurface);
  114.                 checkoutConfig("eglDestroySurface");
  115.                 mEGLSurface = null;
  116.             }
  117.             // 销毁 EGLContext
  118.             if (mEGLContext != null && mEGLContext != EGL14.EGL_NO_CONTEXT) {
  119.                 EGL14.eglDestroyContext(mEGLDisplay, mEGLContext);
  120.                 checkoutConfig("eglDestroyContext");
  121.                 mEGLContext = null;
  122.             }
  123.             // 销毁 EGLDisplay (显示设备)
  124.             EGL14.eglTerminate(mEGLDisplay);
  125.             checkoutConfig("eglTerminate");
  126.             mEGLDisplay = null;
  127.         }
  128.     }
  130.     // 1.创建EGLDisplay
  131.     private void createDisplay() {
  132.         mEGLDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
  133.         int[] versions = new int[2];
  134.         EGL14.eglInitialize(mEGLDisplay, versions,0, versions, 1);
  135.         checkoutConfig("eglInitialize");
  136.     }
  138.     // 2.创建EGLConfig
  139.     private void createConfig() {
  140.         if (mEGLDisplay != null && mEGLDisplay != EGL14.EGL_NO_DISPLAY) {
  141.             EGLConfig[] configs = new EGLConfig[1];
  142.             int[] configNum = new int[1];
  143.             EGL14.eglChooseConfig(mEGLDisplay, mEGLConfigAttrs, 0, configs, 0,1,  configNum, 0);
  144.             if (configNum[0] > 0) {
  145.                 mEGLConfig = configs[0];
  146.             }
  147.             checkoutConfig("eglChooseConfig");
  148.         }
  149.     }
  151.     // 3.创建EGLContext
  152.     private void createContext() {
  153.         if (mEGLConfig != null) {
  154.             mEGLContext = EGL14.eglCreateContext(mEGLDisplay, mEGLConfig, EGL14.EGL_NO_CONTEXT, mEGLContextAttrs, 0);
  155.             checkoutConfig("eglCreateContext");
  156.         }
  157.     }
  159.     // 4.创建EGLSurface
  160.     private void createSurface() {
  161.         if (mEGLContext != null && mEGLContext != EGL14.EGL_NO_CONTEXT) {
  162.             int[] eglSurfaceAttrs = { EGL14.EGL_NONE };
  163.             //mEGLSurface = EGL14.eglCreateWindowSurface(mEGLDisplay, mEGLConfig, getHolder(), eglSurfaceAttrs, 0);
  164.             mEGLSurface = EGL14.eglCreateWindowSurface(mEGLDisplay, mEGLConfig, this, eglSurfaceAttrs, 0);
  165.             checkoutConfig("eglCreateWindowSurface");
  166.         }
  167.     }
  169.     // 5.绑定EGLSurface和EGLContext到显示设备（EGLDisplay）
  170.     private void makeCurrent() {
  171.         if (mEGLSurface != null && mEGLSurface != EGL14.EGL_NO_SURFACE) {
  172.             EGL14.eglMakeCurrent(mEGLDisplay, mEGLSurface, mEGLSurface, mEGLContext);
  173.             checkoutConfig("eglMakeCurrent");
  174.         }
  175.     }
  177.     private void checkoutConfig(String tag) {
  178.         int error = EGL14.eglGetError();
  179.         if (error != EGL14.EGL_SUCCESS) {
  180.             Log.e(TAG, tag + " error=0x" + Integer.toHexString(error));
  181.         }
  182.     }
  184.     // EGLConfig参数
  185.     private int[] mEGLConfigAttrs = {
  186.             EGL14.EGL_RED_SIZE, 8,
  187.             EGL14.EGL_GREEN_SIZE, 8,
  188.             EGL14.EGL_BLUE_SIZE, 8,
  189.             EGL14.EGL_ALPHA_SIZE, 8,
  190.             EGL14.EGL_DEPTH_SIZE, 8,
  191.             //EGL14.EGL_RENDERABLE_TYPE, EGL14.EGL_OPENGL_ES2_BIT,
  192.             EGL14.EGL_RENDERABLE_TYPE, EGLExt.EGL_OPENGL_ES3_BIT_KHR,
  193.             EGL14.EGL_NONE
  194.     };
  196.     // EGLContext参数
  197.     private int[] mEGLContextAttrs = {
  198.             EGL14.EGL_CONTEXT_CLIENT_VERSION, 3,
  199.             EGL14.EGL_NONE
  200.     };
  202.     Choreographer.FrameCallback mFrameCallback = new Choreographer.FrameCallback() {
  203.         @Override
  204.         public void doFrame(long frameTimeNanos) {
  205.             mChoreographer.postFrameCallback(mFrameCallback);
  206.             if (mEGLSurface != null) {
  207.                 mRenderer.onDrawFrame();
  208.                 EGL14.eglSwapBuffers(mEGLDisplay, mEGLSurface);
  209.                 checkoutConfig("eglSwapBuffers");
  210.             }
  211.         }
  212.     };
  214.     /**
  215.      * @author little fat sheep
  216.      * 渲染器接口, 类比GLSurfaceView.Renderer
  217.      */
  218.     interface Renderer {
  219.         void onSurfaceCreated();
  220.         void onSurfaceChanged(int width, int height);
  221.         void onDrawFrame();
  222.     }
  223. }
复制代码
​    MyRenderer.java
  1. package com.zhyan8.egldemo;
  3. import android.content.Context;
  4. import android.opengl.GLES30;
  6. import java.nio.FloatBuffer;
  8. public class MyRenderer implements EGLSurfaceView.Renderer {
  9.     private FloatBuffer vertexBuffer;
  10.     private FloatBuffer textureBuffer;
  11.     private MyGLUtils mGLUtils;
  12.     private int mTextureId;
  14.     public MyRenderer(Context context) {
  15.         mGLUtils = new MyGLUtils(context);
  16.         getFloatBuffer();
  17.     }
  19.     @Override
  20.     public void onSurfaceCreated() {
  21.         //设置背景颜色
  22.         GLES30.glClearColor(0.1f, 0.2f, 0.3f, 0.4f);
  23.         //编译着色器
  24.         final int vertexShaderId = mGLUtils.compileShader(GLES30.GL_VERTEX_SHADER, R.raw.vertex_shader);
  25.         final int fragmentShaderId = mGLUtils.compileShader(GLES30.GL_FRAGMENT_SHADER, R.raw.fragment_shader);
  26.         //链接程序片段
  27.         int programId = mGLUtils.linkProgram(vertexShaderId, fragmentShaderId);
  28.         GLES30.glUseProgram(programId);
  29.         mTextureId = mGLUtils.loadTexture(R.raw.girl);
  30.     }
  32.     @Override
  33.     public void onSurfaceChanged(int width, int height) {
  34.         //设置视图窗口
  35.         GLES30.glViewport(0, 0, width, height);
  36.     }
  38.     @Override
  39.     public void onDrawFrame() {
  40.         //将颜色缓冲区设置为预设的颜色
  41.         GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
  42.         //启用顶点的数组句柄
  43.         GLES30.glEnableVertexAttribArray(0);
  44.         GLES30.glEnableVertexAttribArray(1);
  45.         //准备顶点坐标和纹理坐标
  46.         GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 0, vertexBuffer);
  47.         GLES30.glVertexAttribPointer(1, 2, GLES30.GL_FLOAT, false, 0, textureBuffer);
  48.         //激活纹理
  49.         GLES30.glActiveTexture(GLES30.GL_TEXTURE);
  50.         //绑定纹理
  51.         GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, mTextureId);
  52.         //绘制贴图
  53.         GLES30.glDrawArrays(GLES30.GL_TRIANGLE_FAN, 0, 4);
  54.         //禁止顶点数组句柄
  55.         GLES30.glDisableVertexAttribArray(0);
  56.         GLES30.glDisableVertexAttribArray(1);
  57.     }
  59.     private void getFloatBuffer() {
  60.         float[] vertex = new float[] {
  61.                 1f, 1f, 0f,     //V0
  62.                 -1f, 1f, 0f,    //V1
  63.                 -1f, -1f, 0f,   //V2
  64.                 1f, -1f, 0f     //V3
  65.         };
  66.         float[] texture = {
  67.                 1f, 0f,     //V0
  68.                 0f, 0f,     //V1
  69.                 0f, 1.0f,   //V2
  70.                 1f, 1.0f    //V3
  71.         };
  72.         vertexBuffer = mGLUtils.getFloatBuffer(vertex);
  73.         textureBuffer = mGLUtils.getFloatBuffer(texture);
  74.     }
  75. }
复制代码
​    MyGLUtils.java
  1. package com.zhyan8.egldemo;
  3. import android.content.Context;
  4. import android.graphics.Bitmap;
  5. import android.graphics.BitmapFactory;
  6. import android.opengl.GLES30;
  7. import android.opengl.GLUtils;
  8. import java.io.BufferedReader;
  9. import java.io.InputStream;
  10. import java.io.InputStreamReader;
  11. import java.nio.ByteBuffer;
  12. import java.nio.ByteOrder;
  13. import java.nio.FloatBuffer;
  15. public class MyGLUtils {
  16.     private Context mContext;
  17.     private Bitmap mBitmap;
  19.     public MyGLUtils(Context context) {
  20.         mContext = context;
  21.     }
  23.     public FloatBuffer getFloatBuffer(float[] floatArr) {
  24.         FloatBuffer fb = ByteBuffer.allocateDirect(floatArr.length * Float.BYTES)
  25.                 .order(ByteOrder.nativeOrder())
  26.                 .asFloatBuffer();
  27.         fb.put(floatArr);
  28.         fb.position(0);
  29.         return fb;
  30.     }
  32.     //通过代码片段编译着色器
  33.     public int compileShader(int type, String shaderCode){
  34.         int shader = GLES30.glCreateShader(type);
  35.         GLES30.glShaderSource(shader, shaderCode);
  36.         GLES30.glCompileShader(shader);
  37.         return shader;
  38.     }
  40.     //通过外部资源编译着色器
  41.     public int compileShader(int type, int shaderId){
  42.         String shaderCode = readShaderFromResource(shaderId);
  43.         return compileShader(type, shaderCode);
  44.     }
  46.     //链接到着色器
  47.     public int linkProgram(int vertexShaderId, int fragmentShaderId) {
  48.         final int programId = GLES30.glCreateProgram();
  49.         //将顶点着色器加入到程序
  50.         GLES30.glAttachShader(programId, vertexShaderId);
  51.         //将片元着色器加入到程序
  52.         GLES30.glAttachShader(programId, fragmentShaderId);
  53.         //链接着色器程序
  54.         GLES30.glLinkProgram(programId);
  55.         return programId;
  56.     }
  58.     //从shader文件读出字符串
  59.     private String readShaderFromResource(int shaderId) {
  60.         InputStream is = mContext.getResources().openRawResource(shaderId);
  61.         BufferedReader br = new BufferedReader(new InputStreamReader(is));
  62.         String line;
  63.         StringBuilder sb = new StringBuilder();
  64.         try {
  65.             while ((line = br.readLine()) != null) {
  66.                 sb.append(line);
  67.                 sb.append("\n");
  68.             }
  69.             br.close();
  70.         } catch (Exception e) {
  71.             e.printStackTrace();
  72.         }
  73.         return sb.toString();
  74.     }
  76.     //加载纹理贴图
  77.     public int loadTexture(int resourceId) {
  78.         BitmapFactory.Options options = new BitmapFactory.Options();
  79.         options.inScaled = false;
  80.         mBitmap = BitmapFactory.decodeResource(mContext.getResources(), resourceId, options);
  81.         final int[] textureIds = new int[1];
  82.         // 生成纹理id
  83.         GLES30.glGenTextures(1, textureIds, 0);
  84.         // 绑定纹理到OpenGL
  85.         GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureIds[0]);
  86.         GLES30.glTexParameteri(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_MIN_FILTER, GLES30.GL_LINEAR_MIPMAP_LINEAR);
  87.         GLES30.glTexParameteri(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_MAG_FILTER, GLES30.GL_LINEAR);
  88.         // 加载bitmap到纹理中
  89.         GLUtils.texImage2D(GLES30.GL_TEXTURE_2D, 0, mBitmap, 0);
  90.         // 生成MIP贴图
  91.         GLES30.glGenerateMipmap(GLES30.GL_TEXTURE_2D);
  92.         // 取消绑定纹理
  93.         GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, 0);
  94.         return textureIds[0];
  95.     }
  96. }
复制代码
​    vertex_shader.glsl
  1. attribute vec4 a_position;
  2. attribute vec2 a_texCoord;
  3. varying vec2 v_texCoord;
  4. void main() {
  5.      gl_Position = a_position;
  6.      v_texCoord = a_texCoord;
  7. }
复制代码
​    fragment_shader.glsl
  1. precision mediump float;
  2. uniform sampler2D u_texture;
  3. varying vec2 v_texCoord;
  4. void main() {
  5.      gl_FragColor = texture2D(u_texture, v_texCoord);
  6. }
复制代码
​    运行效果如下。
1.png

3 继承 TextureView 方案

​    自定义一个 View 继承 TextureView，并实现 TextureView.SurfaceTextureListener 接口，在 onSurfaceTextureAvailable 方法中会提供 SurfaceTexture，我们可以创建一个 Surface，并将 SurfaceTexture 传给 Surface，然后将创建的 Surface 传给 eglCreateWindowSurface 函数。
​    前段时间在看 Rive 的源码，详见 → rive-android源码分析，了解到 Rive 底层是通过 OpenGL ES 渲染图像，并且也没有使用 GLSurfaceView，由此借鉴而来。该方案主要参考 Rive 中 RiveTextureView 的实现，eglCreateWindowSurface 参考 thread_state_egl.cpp。
​    与第二节相比，只有 EGLSurfaceView 类有差异，因此本节仅展示 EGLSurfaceView 的代码。
​    EGLSurfaceView.java
  1. package com.zhyan8.egldemo;
  3. import android.content.Context;
  4. import android.graphics.SurfaceTexture;
  5. import android.opengl.EGL14;
  6. import android.opengl.EGLConfig;
  7. import android.opengl.EGLContext;
  8. import android.opengl.EGLDisplay;
  9. import android.opengl.EGLExt;
  10. import android.opengl.EGLSurface;
  11. import android.util.Log;
  12. import android.view.Choreographer;
  13. import android.view.Surface;
  14. import android.view.TextureView;
  16. import androidx.annotation.NonNull;
  18. /**
  19. * @author little fat sheep
  20. * 承载EGL环境的View, 类比GLSurfaceView
  21. */
  22. public class EGLSurfaceView extends TextureView implements TextureView.SurfaceTextureListener {
  23.     private static final String TAG = "EGLSurfaceView";
  25.     protected EGLDisplay mEGLDisplay;
  26.     protected EGLConfig mEGLConfig;
  27.     protected EGLContext mEGLContext;
  28.     protected EGLSurface mEGLSurface;
  29.     protected Context mContext;
  30.     protected Surface mSurface;
  31.     protected Renderer mRenderer;
  32.     private Choreographer mChoreographer = Choreographer.getInstance();
  34.     public EGLSurfaceView(Context context) {
  35.         super(context);
  36.         mContext = context;
  37.         setSurfaceTextureListener(this);
  38.     }
  40.     // 设置渲染器
  41.     public void setRenderer(Renderer renderer) {
  42.         mRenderer = renderer;
  43.     }
  45.     // 开始持续渲染
  46.     public void startRender() {
  47.         Log.i(TAG, "startRender");
  48.         mChoreographer.removeFrameCallback(mFrameCallback);
  49.         mChoreographer.postFrameCallback(mFrameCallback);
  50.     }
  52.     // 暂停持续渲染
  53.     public void stopRender() {
  54.         Log.i(TAG, "stopRender");
  55.         mChoreographer.removeFrameCallback(mFrameCallback);
  56.     }
  58.     // 请求渲染一帧
  59.     public void requestRender() {
  60.         mFrameCallback.doFrame(System.nanoTime());
  61.     }
  63.     @Override
  64.     protected void onAttachedToWindow() {
  65.         super.onAttachedToWindow();
  66.         Log.i(TAG, "onAttachedToWindow");
  67.         createDisplay();
  68.         createConfig();
  69.         createContext();
  70.     }
  72.     @Override
  73.     public void onSurfaceTextureAvailable(@NonNull SurfaceTexture surface, int width, int height) {
  74.         Log.i(TAG, "onSurfaceTextureAvailable");
  75.         mSurface = new Surface(surface);
  76.         createSurface();
  77.         makeCurrent();
  78.         mRenderer.onSurfaceCreated();
  79.         mRenderer.onSurfaceChanged(width, height);
  80.     }
  82.     @Override
  83.     public void onSurfaceTextureSizeChanged(@NonNull SurfaceTexture surface, int width, int height) {
  84.         Log.i(TAG, "onSurfaceTextureSizeChanged, width=" + width + ", height=" + height);
  85.         mRenderer.onSurfaceChanged(width, height);
  86.     }
  88.     @Override
  89.     public boolean onSurfaceTextureDestroyed(@NonNull SurfaceTexture surface) {
  90.         Log.i(TAG, "onSurfaceTextureDestroyed");
  91.         return false;
  92.     }
  94.     @Override
  95.     public void onSurfaceTextureUpdated(@NonNull SurfaceTexture surface) {
  96.     }
  98.     @Override
  99.     protected void onDetachedFromWindow() {
  100.         super.onDetachedFromWindow();
  101.         Log.i(TAG, "onDetachedFromWindow");
  102.         stopRender();
  103.         setSurfaceTextureListener(null);
  104.         mSurface.release();
  105.         if (mEGLDisplay != null && mEGLDisplay != EGL14.EGL_NO_DISPLAY) {
  106.             // 与显示设备解绑
  107.             EGL14.eglMakeCurrent(mEGLDisplay, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_CONTEXT);
  108.             // 销毁 EGLSurface
  109.             if (mEGLSurface != null && mEGLSurface != EGL14.EGL_NO_SURFACE) {
  110.                 EGL14.eglDestroySurface(mEGLDisplay, mEGLSurface);
  111.                 checkoutConfig("eglDestroySurface");
  112.                 mEGLSurface = null;
  113.             }
  114.             // 销毁 EGLContext
  115.             if (mEGLContext != null && mEGLContext != EGL14.EGL_NO_CONTEXT) {
  116.                 EGL14.eglDestroyContext(mEGLDisplay, mEGLContext);
  117.                 checkoutConfig("eglDestroyContext");
  118.                 mEGLContext = null;
  119.             }
  120.             // 销毁 EGLDisplay (显示设备)
  121.             EGL14.eglTerminate(mEGLDisplay);
  122.             checkoutConfig("eglTerminate");
  123.             mEGLDisplay = null;
  124.         }
  125.     }
  127.     // 1.创建EGLDisplay
  128.     private void createDisplay() {
  129.         mEGLDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
  130.         int[] versions = new int[2];
  131.         EGL14.eglInitialize(mEGLDisplay, versions,0, versions, 1);
  132.         checkoutConfig("eglInitialize");
  133.     }
  135.     // 2.创建EGLConfig
  136.     private void createConfig() {
  137.         if (mEGLDisplay != null && mEGLDisplay != EGL14.EGL_NO_DISPLAY) {
  138.             EGLConfig[] configs = new EGLConfig[1];
  139.             int[] configNum = new int[1];
  140.             EGL14.eglChooseConfig(mEGLDisplay, mEGLConfigAttrs, 0, configs, 0,1,  configNum, 0);
  141.             if (configNum[0] > 0) {
  142.                 mEGLConfig = configs[0];
  143.             }
  144.             checkoutConfig("eglChooseConfig");
  145.         }
  146.     }
  148.     // 3.创建EGLContext
  149.     private void createContext() {
  150.         if (mEGLConfig != null) {
  151.             mEGLContext = EGL14.eglCreateContext(mEGLDisplay, mEGLConfig, EGL14.EGL_NO_CONTEXT, mEGLContextAttrs, 0);
  152.             checkoutConfig("eglCreateContext");
  153.         }
  154.     }
  156.     // 4.创建EGLSurface
  157.     private void createSurface() {
  158.         if (mEGLContext != null && mEGLContext != EGL14.EGL_NO_CONTEXT) {
  159.             int[] eglSurfaceAttrs = { EGL14.EGL_NONE };
  160.             mEGLSurface = EGL14.eglCreateWindowSurface(mEGLDisplay, mEGLConfig, mSurface, eglSurfaceAttrs, 0);
  161.             checkoutConfig("eglCreateWindowSurface");
  162.         }
  163.     }
  165.     // 5.绑定EGLSurface和EGLContext到显示设备（EGLDisplay）
  166.     private void makeCurrent() {
  167.         if (mEGLSurface != null && mEGLSurface != EGL14.EGL_NO_SURFACE) {
  168.             EGL14.eglMakeCurrent(mEGLDisplay, mEGLSurface, mEGLSurface, mEGLContext);
  169.             checkoutConfig("eglMakeCurrent");
  170.         }
  171.     }
  173.     private void checkoutConfig(String tag) {
  174.         int error = EGL14.eglGetError();
  175.         if (error != EGL14.EGL_SUCCESS) {
  176.             Log.e(TAG, tag + " error=0x" + Integer.toHexString(error));
  177.         }
  178.     }
  180.     // EGLConfig参数
  181.     private int[] mEGLConfigAttrs = {
  182.             EGL14.EGL_RED_SIZE, 8,
  183.             EGL14.EGL_GREEN_SIZE, 8,
  184.             EGL14.EGL_BLUE_SIZE, 8,
  185.             EGL14.EGL_ALPHA_SIZE, 8,
  186.             EGL14.EGL_DEPTH_SIZE, 8,
  187.             //EGL14.EGL_RENDERABLE_TYPE, EGL14.EGL_OPENGL_ES2_BIT,
  188.             EGL14.EGL_RENDERABLE_TYPE, EGLExt.EGL_OPENGL_ES3_BIT_KHR,
  189.             EGL14.EGL_NONE
  190.     };
  192.     // EGLContext参数
  193.     private int[] mEGLContextAttrs = {
  194.             EGL14.EGL_CONTEXT_CLIENT_VERSION, 3,
  195.             EGL14.EGL_NONE
  196.     };
  198.     Choreographer.FrameCallback mFrameCallback = new Choreographer.FrameCallback() {
  199.         @Override
  200.         public void doFrame(long frameTimeNanos) {
  201.             mChoreographer.postFrameCallback(mFrameCallback);
  202.             if (mEGLSurface != null) {
  203.                 mRenderer.onDrawFrame();
  204.                 EGL14.eglSwapBuffers(mEGLDisplay, mEGLSurface);
  205.                 checkoutConfig("eglSwapBuffers");
  206.             }
  207.         }
  208.     };
  210.     /**
  211.      * @author little fat sheep
  212.      * 渲染器接口, 类比GLSurfaceView.Renderer
  213.      */
  214.     interface Renderer {
  215.         void onSurfaceCreated();
  216.         void onSurfaceChanged(int width, int height);
  217.         void onDrawFrame();
  218.     }
  219. }
复制代码
​    运行效果如下。
2.png

​    声明：本文转自【OpenGL ES】不用GLSurfaceView，如何渲染图像。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
坡琨
昨天 14:12

0

粉丝关注

13

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫