最新八、EGL实践_egl egl(1)，不吃透都对不起自己

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

OpenGL ES 的平台无关性正是借助 EGL 实现的，EGL 屏蔽了不同平台的差异（Apple 提供了自己的 EGL API 的 iOS 实现，自称 EAGL）。

本地窗口相关的 API 提供了访问本地窗口系统的接口，而 EGL 可以创建渲染表面 EGLSurface ，同时提供了图形渲染上下文 EGLContext，用来进行状态管理，接下来 OpenGL ES 就可以在这个渲染表面上绘制。

从图片可以看出EGL其实包含实际的显示设备，SurFace也就是对应帧缓冲一样的，存储图像的内存空间，还有一个自我管理的上下文存储一些OpenGL ES 绘图的状态信息。

3）渲染的步骤

1、获取 EGLDisplay 对象，建立与本地窗口系统的连接

eglGetDisplay 为原生窗口系统 displayId 获取一个 EGL display 连接，在 OpenGL ES 与本地窗口系统之间架起了一座沟通的桥梁

/* 描述：获取 EGLDisplay 对象 显示设备
 * 参数：
 *   displayId：系统显示类型
 *
 * 返回值：成功返回 EGLDisplay 对象，失败返回 EGL_NO_DISPLAY
 * EGLDisplay eglGetDisplay(EGLNativeDisplayType displayId);
 */
EGLDisplay m_eglDisplay;
m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);

2、初始化 EGL 方法

EGLint eglMajVers, eglMinVers;//返回 EGL 主次版本号
eglInitialize(m_eglDisplay, &eglMajVers, &eglMinVers)

3、获取 EGLConfig 对象，确定渲染表面的配置信息

确定可用的 Surface 的配置

一旦初始化了EGL，就可以确定可用渲染表面的类型和配置了。有两种方法：两种方法均得到 EGLConfig 对象。EGLConfig 包含了渲染表面的所有信息，包括可用颜色、缓冲区等其他特性。

【1】先使用 eglGetConfigs 查询每个配置，再使用 eglGetConfigAttrib 找出最好的选择

【2】指定一组需求，使用 eglChooseChofig 让 EGL 推荐最佳配置

EGLConfig  m_eglConf;
EGLint numConfigs;
// EGL config attributes
const EGLint confAttr[] =
{
    EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT_KHR,
    EGL_SURFACE_TYPE,EGL_PBUFFER_BIT,//EGL_WINDOW_BIT EGL_PBUFFER_BIT we will create a pixelbuffer surface
    EGL_RED_SIZE,   8,
    EGL_GREEN_SIZE, 8,
    EGL_BLUE_SIZE,  8,
    EGL_ALPHA_SIZE, 8,// if you need the alpha channel
    EGL_DEPTH_SIZE, 16,// if you need the depth buffer
    EGL_STENCIL_SIZE,8,
    EGL_NONE
};
eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, 1, &numConfigs)

4、创建渲染表面 EGLSurface

通过 EGLDisplay 和 EGLConfig ，调用 eglCreateWindowSurface 或eglCreatePbufferSurface 方法创建渲染表面，得到 EGLSurface，其中eglCreateWindowSurface 用于创建屏幕上渲染区域，eglCreatePbufferSurface 用于创建屏幕外渲染区域。

const EGLint surfaceAttr[] = {
    EGL_WIDTH, 1,
    EGL_HEIGHT,1,
    EGL_NONE
};
m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);

5、创建渲染上下文 EGLContext

const EGLint ctxAttr[] = {
    EGL_CONTEXT_CLIENT_VERSION, 2,
    EGL_NONE
};
m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);

6、绑定上下文

通过 eglMakeCurrent 方法将 EGLSurface、EGLContext、EGLDisplay 三者绑定，绑定成功之后 OpenGLES 环境就创建好了，接下来便可以进行渲染。

eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglCtx)

系统通常还支持另外两种Surface：PixmapSurface和PBufferSurface，这两种都不是可显示的Surface，PixmapSurface是保存在系统内存中的位图，PBuffer则是保存在显存中的帧。

7、交换缓冲

OpenGLES 绘制结束后，使用 eglSwapBuffers 方法交换前后缓冲，将绘制内容显示到屏幕上，而屏幕外的渲染不需要调用此方法。

8、释放 EGL 环境

if (m_eglDisplay != EGL_NO_DISPLAY) {
   eglMakeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
   eglDestroyContext(m_eglDisplay, m_eglCtx);
   eglDestroySurface(m_eglDisplay, m_eglSurface);
   eglReleaseThread();
   eglTerminate(m_eglDisplay);
}

m_eglDisplay = EGL_NO_DISPLAY;
m_eglSurface = EGL_NO_SURFACE;
m_eglCtx = EGL_NO_CONTEXT;

9、GLES30.glReadPixels()

读取一些像素。当前可以简单理解为“把已经绘制好的像素（它可能已经被保存到显卡的显存中）读取到内存

void glReadPixels（GLint x,
    GLint y,
    GLsizei width,
    GLsizei height,
    GLenum format,
    GLenum type,
    GLvoid * data）;
前四个参数可以得到一个矩形，该矩形所包括的像素都会被读取出来。
X Y指定从帧缓冲区读取的第一个像素的窗口坐标。 此位置是矩形像素块的左下角。
width height指定像素矩形的尺寸。 一个宽度和高度对应于单个像素。
format 指定像素数据的格式。 接受以下符号值：GL_ALPHA，GL_RGB和GL_RGBA。
type 指定像素数据的数据类型。 必须是GL_UNSIGNED_BYTE，GL_UNSIGNED_SHORT_5_6_5，GL_UNSIGNED_SHORT_4_4_4_4或GL_UNSIGNED_SHORT_5_5_5_1之一
data 返回像素数据。
注意：glReadPixels实际上是从缓冲区中读取数据，如果使用了双缓冲区，则默认是从正在显示的缓冲（即前缓冲）中读取，而绘制工作是默认绘制到后缓冲区的。因此，如果需要读取已经绘制好的像素，往往需要先交换前后缓冲。

第二部分编写代码

1）java部分

界面部分：使用ImageView显示图片

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <ImageView
        android:id="@+id/imageView"
        android:layout_width="466dp"
        android:layout_height="700dp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:srcCompat="@drawable/awesomeface" />

</androidx.constraintlayout.widget.ConstraintLayout>

MainActivity.java代码

package com.example.fiveegldraw;

import androidx.appcompat.app.AppCompatActivity;

import android.content.res.AssetManager;
import android.opengl.GLES30;
import android.opengl.GLException;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.widget.ImageView;

import java.nio.IntBuffer;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "EGLActivity";
    private ImageView mImageView;
    private NativeEglRender mBgRender;
    private AssetManager mrg;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mImageView = (ImageView) findViewById(R.id.imageView);
        mrg = getResources().getAssets();

        mBgRender = new NativeEglRender();
        mBgRender.native_InitScene(mrg);//将AssetManager对象传下去
        mBgRender.native_EglRenderInit();//调到Native里面的EGL初始化去
        mBgRender.native_EglRenderDraw();//调用底层OPENGL的离屏渲染
        mImageView.setImageBitmap(createBitmapFromGLSurface(0, 0, 512, 512));//读取显存图片到内存进行显示
    }
    @Override
    protected void onResume() {
        super.onResume();
    }

    @Override
    protected void onPause() {
        super.onPause();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mBgRender.native_EglRenderUnInit();
    }

    private Bitmap createBitmapFromGLSurface(int x, int y, int w, int h) {
        int bitmapBuffer[] = new int[w * h];
        int bitmapSource[] = new int[w * h];
        IntBuffer intBuffer = IntBuffer.wrap(bitmapBuffer);
        intBuffer.position(0);
        try {
            //glReadPixels从显存读取数据到内存中
            GLES30.glReadPixels(x, y, w, h, GLES30.GL_RGBA, GLES30.GL_UNSIGNED_BYTE,intBuffer);
            int offset1, offset2;
            for (int i = 0; i < h; i++) {
                offset1 = i * w;
                offset2 = (h - i - 1) * w;
                for (int j = 0; j < w; j++) {
                    int texturePixel = bitmapBuffer[offset1 + j];
                    int blue = (texturePixel >> 16) & 0xff;
                    int red = (texturePixel << 16) & 0x00ff0000;
                    int pixel = (texturePixel & 0xff00ff00) | red | blue;
                    bitmapSource[offset2 + j] = pixel;
                }
            }
        } catch (GLException e) {
            return null;
        }
        return Bitmap.createBitmap(bitmapSource, w, h, Bitmap.Config.ARGB_8888);
    }
}

NativeEglRender类

package com.example.fiveegldraw;

public class NativeEglRender {
    static {
        System.loadLibrary("native-lib");
    }
    public static native void native_InitScene(Object mrg);
    public native void native_EglRenderInit();
    public native void native_EglRenderDraw();
    public native void native_EglRenderUnInit();
}

2）着色器代码

顶点着色器

#version 300 es
layout (location = 0) in vec4 a_position;
layout (location = 1) in vec2 a_texCoord;

out vec2 v_texCoord;

void main()
{
    gl_Position = a_position;
    v_texCoord = a_texCoord;
}

片段着色器

#version 300 es
precision highp float;
layout(location = 0) out vec4 outColor;
in vec2 v_texCoord;
uniform sampler2D s_TextureMap;
uniform vec2 u_texSize;
void main() {
    float size = u_texSize.x / 75.0;
    float radius = size * 0.5;
    vec2 fragCoord = v_texCoord * u_texSize.xy;
    vec2 quadPos = floor(fragCoord.xy / size) * size;
    vec2 quad = quadPos/u_texSize.xy;
    vec2 quadCenter = (quadPos + size/2.0);
    float dist = length(quadCenter - fragCoord.xy);

    if (dist > radius) {
        outColor = vec4(0.25);
    } else {
        outColor = texture(s_TextureMap, v_texCoord);
    }
}

3）C++部分

NativeGL.cpp，jni中实现java接口

//
// Created by CreatWall_zhouwen on 2023/4/11.
//

#include "jni.h"
#include <android/log.h>
#include <GLES3/gl3.h>
#include "EGLDraw.h"
#include "Util.h"
#include "ReadFileUtil.h"
#define NATIVE_RENDER_CLASS_NAME "com/example/fiveegldraw/NativeEglRender"
#define TAG "GLTRIANGLE"
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_example_fiveegldraw_NativeEglRender
 * Method:    native_InitScene
 * Signature: (Ljava/lang/Object;)V
 */
JNIEXPORT void JNICALL native_InitScene(JNIEnv *env, jobject instance, jobject msg)
{
   g_mrg = AAssetManager_fromJava(env, msg);
}

/*
 * Class:     com_example_fiveegldraw_NativeEglRender
 * Method:    native_EglRenderInit
 * Signature: ()V
 */
JNIEXPORT void JNICALL native_EglRenderInit(JNIEnv *env, jobject instance)
{
   EGLDraw::GetInstance();
   int width = 0, height = 0;
   unsigned char *img = ReadBMP("awesomeface.bmp", width, height);
   EGLDraw::GetInstance()->CreateGlesEnv();//创建EGL环境
   EGLDraw::GetInstance()->getTexturedata(img, width, height);//加载图片数据
   EGLDraw::GetInstance()->CreateProgram(
         reinterpret_cast<const char *>(LoadFileContent("vertex.vs")),
         reinterpret_cast<const char *>(LoadFileContent("fFboShader.fs")));//创建openngl工程
}
/*
 * Class:     com_example_fiveegldraw_NativeEglRender
 * Method:    native_EglRenderDraw
 * Signature: ()V
 */
JNIEXPORT void JNICALL native_EglRenderDraw(JNIEnv *env, jobject instance)
{
   EGLDraw::GetInstance()->Draw();//opengl绘画
}
/*
 * Class:     com_example_fiveegldraw_NativeEglRender
 * Method:    native_EglRenderUnInit
 * Signature: ()V
 */
JNIEXPORT void JNICALL native_EglRenderUnInit(JNIEnv *env, jobject instance)
{
   EGLDraw::GetInstance()->UnInit();
}

#ifdef __cplusplus
}
#endif

static JNINativeMethod g_RenderMethods[] = {
      {"native_InitScene",             "(Ljava/lang/Object;)V",       (void *)(native_InitScene)},
      {"native_EglRenderInit",             "()V",       (void *)(native_EglRenderInit)},
      {"native_EglRenderDraw",        "()V",       (void *)(native_EglRenderDraw)},
      {"native_EglRenderUnInit",        "()V",       (void *)(native_EglRenderUnInit)},
};

static int RegisterNativeMethods(JNIEnv *env, const char *className, JNINativeMethod *methods, int methodNum)
{
   LOGD("RegisterNativeMethods");
   jclass clazz = env->FindClass(className);
   if (clazz == NULL)
   {
      LOGD("RegisterNativeMethods fail. clazz == NULL");
      return JNI_FALSE;
   }
   if (env->RegisterNatives(clazz, methods, methodNum) < 0)
   {
      LOGD("RegisterNativeMethods fail");
      return JNI_FALSE;
   }
   return JNI_TRUE;
}

static void UnregisterNativeMethods(JNIEnv *env, const char *className)
{
   LOGD("UnregisterNativeMethods");
   jclass clazz = env->FindClass(className);
   if (clazz == NULL)
   {
      LOGD("UnregisterNativeMethods fail. clazz == NULL");
      return;
   }
   if (env != NULL)
   {
      env->UnregisterNatives(clazz);
   }
}

// call this func when loading lib
extern "C" jint JNI_OnLoad(JavaVM *jvm, void *p)
{
   LOGD("===== JNI_OnLoad =====");
   jint jniRet = JNI_ERR;
   JNIEnv *env = NULL;
   if (jvm->GetEnv((void **) (&env), JNI_VERSION_1_6) != JNI_OK)
   {
      return jniRet;
   }

   jint regRet = RegisterNativeMethods(env, NATIVE_RENDER_CLASS_NAME, g_RenderMethods,
                              sizeof(g_RenderMethods) /
                              sizeof(g_RenderMethods[0]));
   if (regRet != JNI_TRUE)
   {
      return JNI_ERR;
   }

   return JNI_VERSION_1_6;
}

extern "C" void JNI_OnUnload(JavaVM *jvm, void *p)
{
   JNIEnv *env = NULL;
   if (jvm->GetEnv((void **) (&env), JNI_VERSION_1_6) != JNI_OK)
   {
      return;
   }

   UnregisterNativeMethods(env, NATIVE_RENDER_CLASS_NAME);
}

EGLDraw类

//
// Created by CreatWall_zhouwen on 2023/4/24.
//

#ifndef FIVEEGLDRAW_EGLDRAW_H
#define FIVEEGLDRAW_EGLDRAW_H


#include <GLES3/gl3.h>
#include <EGL/egl.h>
#include <EGL/eglext.h>

class EGLDraw {
public:
    EGLDraw();
    ~EGLDraw();
    int CreateGlesEnv();
    void CreateProgram(const char *ver, const char * fragfbo);//创建工程并初始化
    void getTexturedata(unsigned char *data, int width, int height);//从NDK那边获取图片数据传过来
    static EGLDraw* GetInstance();
    static void DestroyInstance();
    void Draw();//绘画 就是执行离屏渲染再将离屏渲染的结果显示
    void UnInit();
private:
    GLuint m_FboVertexShader;//FBO的顶点着色器和片段着色器
    GLuint m_FboFragmentShader;
    GLuint m_FboProgramObj;//FBO工程ID
    GLuint m_ImageTextureId;//图片数据的纹理ID
    GLuint m_FboTextureId;//FBO绑定的空数据纹理ID
    GLint m_FboSamplerLoc;//FBO片段着色器中的采样器值的位置
    GLint m_TexSizeLoc;
    GLuint m_FboId;//FBO的ID
    unsigned char *texturedata;
    int texturewidth, textureheight;
    GLuint m_VaoId;//存放顶点数据
    GLuint m_VboIds[3];//0表示顶点坐标缓冲区，1表示离屏渲染纹理坐标缓冲区，2表示纹理索引坐标缓冲区

    EGLConfig  m_eglConf;
    EGLSurface m_eglSurface;
    EGLContext m_eglCtx;
    EGLDisplay m_eglDisplay;
};



#endif //FIVEEGLDRAW_EGLDRAW_H

cpp代码

//
// Created by CreatWall_zhouwen on 2023/4/24.
//

#include "EGLDraw.h"
#include "Util.h"
#include "GLUtil.h"
EGLDraw* m_pContext = nullptr;
#define TAG "DRAWTEXTURE"
//顶点坐标
GLfloat vVertices[] = {
        -1.0f, -1.0f, 0.0f,
        1.0f, -1.0f, 0.0f,
        -1.0f,  1.0f, 0.0f,


![img](https://img-blog.csdnimg.cn/img_convert/c3f279f0d59d770563e47e4dd1b9c055.png)
![img](https://img-blog.csdnimg.cn/img_convert/f8449169872dd2fb74cbe4ebd72829f0.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

atWall_zhouwen on 2023/4/24.
//

#include "EGLDraw.h"
#include "Util.h"
#include "GLUtil.h"
EGLDraw* m_pContext = nullptr;
#define TAG "DRAWTEXTURE"
//顶点坐标
GLfloat vVertices[] = {
        -1.0f, -1.0f, 0.0f,
        1.0f, -1.0f, 0.0f,
        -1.0f,  1.0f, 0.0f,


[外链图片转存中...(img-PvqPtJIK-1715876656040)]
[外链图片转存中...(img-vrXkH1QR-1715876656040)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**