三、opengles画三角形

第一部分Java端

1）界面

<?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">

    <android.opengl.GLSurfaceView
        android:id="@+id/gl_surface"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        />

</androidx.constraintlayout.widget.ConstraintLayout>

2）自定义MyGLSurfaceView

MyGLSurfaceView集成GLSurfaceView实现父类方法，并加载opengl相关参数和设置

自定义MyGLRender类实现GLSurfaceView.Renderer接口，并在其中引入jni相关的类方法

package com.example.onedrawtri2;

import android.content.Context;
import android.opengl.GLSurfaceView;

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

public class MyGLSurfaceView extends GLSurfaceView {
    private MyRenderer renderer;

    public MyGLSurfaceView(Context context) {
        super(context);
        setEGLContextClientVersion(3);
        renderer = new MyRenderer();
        setRenderer(renderer);
        setRenderMode(GLSurfaceView.RENDERMODE_CONTINUOUSLY);
    }
    private class MyRenderer implements GLSurfaceView.Renderer {
        @Override
        public void onSurfaceCreated(GL10 gl10, EGLConfig eglConfig) {
            NativeImpl.NativeImpl_init();
        }

        @Override
        public void onSurfaceChanged(GL10 gl10, int width, int height) {
            NativeImpl.NativeImpl_OnSurfaceChanged(width, height);
        }

        @Override
        public void onDrawFrame(GL10 gl10) {
            NativeImpl.NativeImpl_draw();
        }
    }
}

3）jni方法

package com.example.onedrawtri2;

public class NativeImpl {
    static {
        System.loadLibrary("native-lib");
    }

    public static native void NativeImpl_init();
    public static native void NativeImpl_OnSurfaceChanged(int width,int height);
    public static native void NativeImpl_draw();
}

4）MainActivity引入加载MyGLSurfaceView

package com.example.onedrawtri2;

import androidx.appcompat.app.AppCompatActivity;

import android.opengl.GLSurfaceView;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {
    private GLSurfaceView gLView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        gLView = new MyGLSurfaceView(this);

        setContentView(gLView);
    }
}

第二部分C++端

1）native动态加载jni方法

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

#include "jni.h"
#include <android/log.h>
#include <GLES2/gl2.h>
#include "Util.h"
#include "DrawTriangle.h"
#define NATIVE_RENDER_CLASS_NAME "com/example/onedrawtri2/NativeImpl"
#define TAG "GLTRIANGLE"
#ifdef __cplusplus
extern "C" {
#endif

/*
 * Class:     com_example_onedrawtri2_NativeImpl
 * Method:    init
 * Signature: ()V
 */
JNIEXPORT void JNICALL NativeImpl_init(JNIEnv *env, jobject instance)
{
    DrawTriangle::GetInstance();
    DrawTriangle::GetInstance()->CreateProgram();
}

/*
 * Class:     com_example_onedrawtri2_NativeImpl
 * Method:    OnSurfaceChanged
 * Signature: (II)V
 */
JNIEXPORT void JNICALL NativeImpl_OnSurfaceChanged(JNIEnv *env, jobject instance, jint width, jint height)
{
    glViewport(0, 0, width, height);
}

/*
 * Class:     com_example_onedrawtri2_NativeImpl
 * Method:    draw
 * Signature: ()V
 */
JNIEXPORT void JNICALL NativeImpl_draw(JNIEnv *env, jobject instance)
{
    DrawTriangle::GetInstance()->Draw();
}


#ifdef __cplusplus
}
#endif

static JNINativeMethod g_RenderMethods[] = {
		{"NativeImpl_init",             "()V",       (void *)(NativeImpl_init)},
		{"NativeImpl_OnSurfaceChanged",   "(II)V",     (void *)(NativeImpl_OnSurfaceChanged)},
		{"NativeImpl_draw",        "()V",       (void *)(NativeImpl_draw)},
};

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

2）opengles画三角形类

在里面实现了编写shader着色器，附加编译链接绑定着色器等相关操作。

DrawTriangle.h文件

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

#ifndef ONEDRAWTRIANGLE_DRAWTRIANGLE_H
#define ONEDRAWTRIANGLE_DRAWTRIANGLE_H

#include <GLES3/gl3.h>
class DrawTriangle {
public:
    DrawTriangle(){};
    ~DrawTriangle(){};
    void CreateProgram();
    void Draw();
    static DrawTriangle* GetInstance();
    static void DestroyInstance();
private:
    GLuint program;
    GLuint vertexShaderHandle;
    GLuint fragShaderHandle;
    GLuint VBO, VAO;
};


#endif //ONEDRAWTRIANGLE_DRAWTRIANGLE_H

DrawTriangle.cpp文件

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

#include "DrawTriangle.h"
#include <android/log.h>

#include "Util.h"
#define TAG "DRAWTRINGLE"
DrawTriangle* m_pContext = nullptr;
//编写顶点着色器代码
char vShaderStr[] =
        "#version 300 es                          \n"
        "layout(location = 0) in vec4 vPosition;  \n"
        "void main()                              \n"
        "{                                        \n"
        "   gl_Position = vPosition;\n"
        "}                                        \n";
//编写顶点着色器代码
char fShaderStr[] =
        "#version 300 es                              \n"
        "precision mediump float;                     \n"
        "out vec4 fragColor;                          \n"
        "void main()                                  \n"
        "{                                            \n"
        "   fragColor = vec4 ( 1.0f, 0.2f, 0.2f, 1.0f );  \n"
        "}                                            \n";
float vertices[] = {
        -0.5f, -0.5f, 0.0f,
        0.5f, -0.5f, 0.0f,
        0.0f, 0.5f, 0.0f
};
void DrawTriangle::CreateProgram()
{
    LOGD("CreateProgram Enter");
    //程序中加载编译链接顶点着色器
    vertexShaderHandle = glCreateShader(GL_VERTEX_SHADER);//创建顶点着色器
    const char * s = vShaderStr;
    glShaderSource(vertexShaderHandle, 1, &s, NULL);//绑定源码
    glCompileShader(vertexShaderHandle);//编译
    GLint compiled = 0;
    glGetShaderiv(vertexShaderHandle, GL_COMPILE_STATUS, &compiled);//检查编译是否成功
    if (!compiled)
    {
        LOGD("CreateProgram vertexShaderHandle error");
        return;
    }

    //程序中加载编译链接片段着色器
    fragShaderHandle = glCreateShader(GL_FRAGMENT_SHADER);//创建顶片段着色器
    const char *s1 = fShaderStr;
    glShaderSource(fragShaderHandle, 1, &s1, NULL);//绑定源码
    glCompileShader(fragShaderHandle);//编译
    glGetShaderiv(fragShaderHandle, GL_COMPILE_STATUS, &compiled);//检查编译是否成功
    if (!compiled)
    {
        LOGD("CreateProgram fragShaderHandle error");
        return;
    }

    //创建程序
    program = glCreateProgram();
    if (program)
    {
        GLint AttachStatus = GL_FALSE;
        glAttachShader(program, vertexShaderHandle);//添加顶点着色器
        glGetProgramiv(program, GL_ATTACHED_SHADERS, &AttachStatus);//检查链接是否成功GL_ATTACHED_SHADERS
        if (AttachStatus != 1)
        {
            LOGD("AttachStatus vertexShaderHandle error");
            return;
        }
        GLint AttachStatus1 = GL_FALSE;
        glAttachShader(program, fragShaderHandle);//添加片段着色器
        glGetProgramiv(program, GL_ATTACHED_SHADERS, &AttachStatus1);//检查链接是否成功
        if (AttachStatus1 != 2)
        {
            LOGD("AttachStatus fragShaderHandle error glError (0x%x)  %d",glGetError(),AttachStatus1);
            return;
        }
        glLinkProgram(program);//链接
        GLint linkStatus = GL_FALSE;
        glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);//检查链接是否成功
        if (linkStatus != GL_TRUE)
        {
            LOGD("CreateProgram glLinkProgram error");
            return;
        }
        //成功之后可以解绑着色器并删除调，使用完则删除内存
        glDetachShader(program, vertexShaderHandle);
        glDeleteShader(vertexShaderHandle);
        vertexShaderHandle = 0;
       glDetachShader(program, fragShaderHandle);
        glDeleteShader(fragShaderHandle);
        fragShaderHandle = 0;
    }

    glUseProgram(program);//使用着色器程序
    glGenVertexArrays(1, &VAO);//创建一个顶点数组 与顶点属性相绑定
    glGenBuffers(1, &VBO);//创建顶点缓冲对象
    glBindVertexArray(VAO);//绑定顶点数组

    glBindBuffer(GL_ARRAY_BUFFER, VBO);//将GL_ARRAY_BUFFER类型的缓存与VBO绑定
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);//之前定义的顶点数据复制到缓冲的内存

    /*
        0;指定我们要配置的顶点属性 就是顶点着色器里面location那个
    */
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(float), (void *)0);
    glEnableVertexAttribArray(0);//以顶点属性位置值0作为参数，启用顶点属性

    //glBindBuffer(GL_ARRAY_BUFFER, 0);//VBO 已经与顶点属性数组VAO进行绑定了 那么GL_ARRAY_BUFFER就可以解除绑定
    //glBindVertexArray(0);//您可以在之后解除绑定VAO，这样其他VAO调用就不会意外地修改这个VAO*/
    LOGD("CreateProgram End");
    return;
}
void DrawTriangle::Draw()
{
    LOGD("Draw Enter");
    glClear(GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//使用状态函数
    glClearColor(0.2f, 0.9f, 0.3f, 1.0f); //设置状态函数



    glUseProgram(program);//使用着色器程序
    glBindVertexArray(VAO);//绑定顶点数组  就是使用顶点属性
    /*
    我们希望绘制的是一个三角形，这里传递GL_TRIANGLES给它。
    第二个参数指定了顶点数组的起始索引，我们这里填0。
    最后一个参数指定我们打算绘制多少个顶点，这里是3
    （我们只从我们的数据中渲染一个三角形，它只有3个顶点长）
    */
    glDrawArrays(GL_TRIANGLES, 0, 3);
    glBindVertexArray(0);
    LOGD("Draw end");
}

DrawTriangle *DrawTriangle::GetInstance() {
    if (m_pContext == nullptr)
    {
        m_pContext = new DrawTriangle();
    }
    return m_pContext;
}

void DrawTriangle::DestroyInstance() {
    if (m_pContext)
    {
        delete m_pContext;
        m_pContext = nullptr;
    }
}

第三部分安卓配置文件配置

1）bulid.gradle(app)引入cmake

defaultConfig {
    ...
    externalNativeBuild {
        cmake {
            cppFlags ''
            abiFilters "arm64-v8a"
            //arguments "-DANDROID_STL=c++_shared"
        }
    }
}
externalNativeBuild {
    cmake {
        path file('src/main/cpp/CMakeLists.txt')
        version '3.10.2'
    }
}

2)settings.gradle文件配置链接

jcenter()

3）cmake文件

# For more information about using CMake with Android Studio, read the
# documentation: https://d.android.com/studio/projects/add-native-code.html

# Sets the minimum version of CMake required to build the native library.

cmake_minimum_required(VERSION 3.10.2)

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++11")

# Declares and names the project.
set(jnilibs ${CMAKE_SOURCE_DIR}/../jniLibs)
set(libname native-lib)

include_directories(
        include
        ${CMAKE_SOURCE_DIR}
)

link_directories(
        ${jnilibs}/${ANDROID_ABI})

file(GLOB src-files
        ${CMAKE_SOURCE_DIR}/*.cpp
        ${CMAKE_SOURCE_DIR}/drawTriangle.cpp
        )
# Creates and names a library, sets it as either STATIC
# or SHARED, and provides the relative paths to its source code.
# You can define multiple libraries, and CMake builds them for you.
# Gradle automatically packages shared libraries with your APK.

add_library( # Sets the name of the library.
        ${libname}

        # Sets the library as a shared library.
        SHARED

        # Provides a relative path to your source file(s).
        ${src-files}
        )

# Searches for a specified prebuilt library and stores the path as a
# variable. Because CMake includes system libraries in the search path by
# default, you only need to specify the name of the public NDK library
# you want to add. CMake verifies that the library exists before
# completing its build.

#set(third-party-libs
#        GLES
#        )
set(native-libs
        android
        log
        m
        z
        )
target_link_libraries( # Specifies the target library.
        ${libname}

        # Links the target library to the log library
        # included in the NDK.
        ${log-lib}
        ${native-libs}
        EGL
        GLESv3
        )

第四部分将着色器代码放到assets中引入

1)新建assets文件夹添加文件

在main文件夹上新建directory选择assets。

新建vertex.vs顶点着色器文件编写顶点着色器代码

#version 300 es
layout(location = 0) in vec4 vPosition;
void main()
{
    gl_Position = vPosition;
}

新建fragment.fs片段着色器文件编写片段着色器代码

#version 300 es
precision mediump float;
out vec4 fragColor;
void main()
{
    fragColor = vec4 ( 1.0f, 0.2f, 0.2f, 1.0f );
}

2）Java部分

private AssetManager mrg;
mrg = getResources().getAssets();
再调用native函数将mrg句柄传到native层次
NativeImpl.NativeImpl_InitScene(mrg);
JNI定义接口
public static native void NativeImpl_InitScene(Object mrg);

3)C++部分

创建一个读取assets资源的文件的接口

#ifndef C_NDKTEST_READFILEUTIL_H
#define C_NDKTEST_READFILEUTIL_H
#include <android/asset_manager.h>
#include <android/asset_manager_jni.h>
#include "Util.h"
#define TAG "READFILEUTIL"
const char *LoadFileContent(const char *filepath);
AAssetManager *g_mrg;

const char *LoadFileContent(const char *filepath) {
    // read shader code form asset
    char *fileContent = nullptr;
    AAsset *asset = AAssetManager_open(g_mrg, filepath, AASSET_MODE_UNKNOWN);
    if (asset == nullptr) {
        // LOGE("LoadFileContent asset is null, load shader error ");
        LOGD("LoadFileContent asset is null, load shader error ");
    }
    int filesSize_v = AAsset_getLength(asset);
    fileContent = new char[filesSize_v];
    AAsset_read(asset, fileContent, filesSize_v);
    fileContent[filesSize_v] = '\0';
    AAsset_close(asset);
    LOGD("LoadFileContent asset is %s", fileContent);
    return fileContent;
}

#endif //C_NDKTEST_READFILEUTIL_H

在jni中使用

JNI函数native接口是实现
/*
 * Class:     com_example_onedrawtri2_NativeImpl
 * Method:    NativeImpl_InitScene
 * Signature: (Ljava/lang/Object;)V
 */
JNIEXPORT void JNICALL NativeImpl_InitScene(JNIEnv *env, jobject instance, jobject msg)
{
   g_mrg = AAssetManager_fromJava(env, msg);
}

//使用读取内容
/*
 * Class:     com_example_onedrawtri2_NativeImpl
 * Method:    init
 * Signature: ()V
 */
JNIEXPORT void JNICALL NativeImpl_init(JNIEnv *env, jobject instance)
{
    DrawTriangle::GetInstance();
    DrawTriangle::GetInstance()->CreateProgram(LoadFileContent("vertex.vs"), LoadFileContent("fragment.fs"));
}

第五部分多种颜色的三角形

添加 vColor属性

1)顶点着色器

#version 300 es
layout(location = 0) in vec4 vPosition;
layout(location = 1) in vec3 vColor;
out vec3 ourColor;
void main()
{
    gl_Position = vPosition;
    ourColor = vColor;
}

片段着色器

#version 300 es
precision mediump float;
out vec4 fragColor;
in vec3 ourColor;
void main()
{
    fragColor = vec4 ( ourColor.rgb, 1.0 );
}

顶点坐标添加颜色属性

float verticesCor[] = {
        // positions         // colors
        0.5f, -0.5f, 0.0f,  1.0f, 0.0f, 0.0f,   // bottom right
        -0.5f, -0.5f, 0.0f,  0.0f, 1.0f, 0.0f,   // bottom left
        0.0f,  0.5f, 0.0f,  0.0f, 0.0f, 1.0f    // top
};

2）添加颜色属性绑定顶点坐标

/*
    0;指定我们要配置的顶点属性 就是顶点着色器里面location那个
*/
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6*sizeof(float), (void *)0);
glEnableVertexAttribArray(0);//以顶点属性位置值0作为参数，启用顶点属性

/*
 * 1、配置颜色属性
 */
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6*sizeof(float), (void *)(3*sizeof(float)));
glEnableVertexAttribArray(1);//以顶点属性位置值0作为参数，启用顶点属性

参考链接：

https://blog.csdn.net/one_chow_chow/article/details/125888904 NDK OpenGL ES 3.0 ：画个三角形

在这里插入图片描述