OpenGL 打开绘制窗口 学习笔记

已于 2023-03-16 18:30:36 修改
阅读量527 收藏
点赞数
文章标签： c++ 算法
于 2023-02-17 16:33:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qqQQqsadfj/article/details/129086083
版权 
#include <GLFW/glfw3.h>

int main(void)
{
    GLFWwindow* window;

    /* Initialize the library */
    if (!glfwInit())
        return -1;

    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    /* Make the window's context current */
    glfwMakeContextCurrent(window);

    /* Loop until the user closes the window */
    while (!glfwWindowShouldClose(window))
    {
        /* Render here */
        glClear(GL_COLOR_BUFFER_BIT);


        /* Swap front and back buffers */
        glfwSwapBuffers(window);

        /* Poll for and process events */
        glfwPollEvents();
    }

    glfwTerminate();
    return 0;
}

以上代码是绘制窗口，也是OpenGL最基础的代码

#include <GLFW/glfw3.h>

int main(void)
{
    GLFWwindow* window;

    /* Initialize the library */
    if (!glfwInit())
        return -1;

    //glewInit();

    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    /* Make the window's context current */
    glfwMakeContextCurrent(window);

    /* Loop until the user closes the window */
    while (!glfwWindowShouldClose(window))
    {
        /* Render here */
        glClear(GL_COLOR_BUFFER_BIT);

        glBegin(GL_TRIANGLES);
        glVertex2f(-0.5, -0.5f);
        glVertex2f(0.5, 0.5f);
        glVertex2f(0.5, -0.5f);
        glColor3f(1, 0, 0);
        glEnd();

        
        /* Swap front and back buffers */
        glfwSwapBuffers(window);

        /* Poll for and process events */
        glfwPollEvents();
    }

    glfwTerminate();
    return 0;
}
 glBegin(GL_TRIANGLES);
 glVertex2f(-0.5, -0.5f);
 glVertex2f(0.5, 0.5f);
 glVertex2f(0.5, -0.5f);
 glColor3f(1, 0, 0);
 glEnd();

画三角形，开始画三角，结束画三角，中间就是三角形三个顶点的位置，还有三角形绘制的颜色

缓冲区：


#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include "iostream"

using namespace std;

int main(void)
{
    GLFWwindow* window;

    /* Initialize the library */
    if (!glfwInit())
        return -1;

    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    /* Make the window's context current */
    glfwMakeContextCurrent(window);

    if (glewInit() != GLEW_OK) {
        cout << "ERROR" << endl;
    }

    float Positions[6] = {
        -0.5f, -0.5f,
        0.5f, 0.5f,
        0.5, -0.5f
    };

    unsigned int a;
    glGenBuffers(1, &a);//第一个参数代表生成缓冲区的数量，第二个为指定对象来生成缓冲区
    //当生成多个缓冲区时: 
    //unsigned int b[3];
    //glGenBuffers(3, b);
    //cout << a << endl;
    //for (int i = 0; i < 3; i++) {
    //    cout << b[i] << endl;
    //}
    glBindBuffer(GL_ARRAY_BUFFER, a);//定义缓冲区类型
    glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(float), Positions, GL_STATIC_DRAW);//绑定完毕就要开始存放顶点数据了
    glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);//设置顶点属性，第一个参数为从第几个属性开始取值，很明显从第一个数组0号位
    //第二个参数时代表一个顶点需要几个值，比如二维需要两个float才能组成一个顶点的位置，当然顶点不只是位置信息，第三个参数为描述顶点位置的属性
    //第四个参数代表是否将属性进行归一化，这里我们不需要，第五个参数代表一个顶点所占的字节数，第六个参数代表字节偏移量


    /* Loop until the user closes the window */
    while (!glfwWindowShouldClose(window))
    {
        /* Render here */
        glClear(GL_COLOR_BUFFER_BIT);

        /*glBegin(GL_TRIANGLES);
        glVertex2f(-0.5, -0.5f);
        glVertex2f(0.5, 0.5f);
        glVertex2f(0.5, -0.5f);
        glColor3f(1, 0, 0);
        glEnd();*/

        glDrawArrays(GL_TRIANGLES, 0, 3);//画好了三角形，但是苦于没有shader，所以不显示

        
        /* Swap front and back buffers */
        glfwSwapBuffers(window);

        /* Poll for and process events */
        glfwPollEvents();
    }

    glfwTerminate();
    return 0;
}

shader是只运行在GPU上的程序


#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include "iostream"

using namespace std;

static unsigned int CompileShader(const string& source, unsigned int type) {
    unsigned int id = glCreateShader(type);
    const char* src = source.c_str(); 
    glShaderSource(id, 1, &src, nullptr);
    glCompileShader(id);

    int result;
    glGetShaderiv(id, GL_COMPILE_STATUS, &result);
    if (result == GL_FALSE) {
        int length;
        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length);
        char* message = (char*)alloca(length * sizeof(char));//alloca是在栈上分配空间，malloc是在堆上分配空间，当遇到char message[length]，而这个length却不是常量的时候可以使用该方法
        glGetShaderInfoLog(id, length, &length, message);
        cout << "FAILED TO COMPILE SHADER !" << endl;
        cout << message << endl;
        glDeleteShader(id);

        return 0;
    }

    return id;
}

static unsigned int CreateShader(const string& vertexShader, const string& fragmentShader) {
//总结：1、创建program 2、编译shader（1、创建shader 2、编译shader 3、获取着色器资源 4、判断shader是否创建成功） 3、将着色器附着在program对象上 4、与program建立链接 5、验证program 6、删除shader
    unsigned int program = glCreateProgram();
    unsigned int program = glCreateProgram();//创建program
    unsigned int vs = CompileShader(vertexShader, GL_VERTEX_SHADER);
    unsigned int fs = CompileShader(fragmentShader, GL_FRAGMENT_SHADER);

    glAttachShader(program, vs);
    glAttachShader(program, fs);
    glLinkProgram(program);
    glValidateProgram(program);

    glDeleteShader(vs);
    glDeleteShader(fs);

    return program;
}

int main(void)
{
    GLFWwindow* window;

    /* Initialize the library */
    if (!glfwInit())
        return -1;

    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    /* Make the window's context current */
    glfwMakeContextCurrent(window);

    if (glewInit() != GLEW_OK) {
        cout << "ERROR" << endl;
    }

    float Positions[6] = {
        -0.5f, -0.5f,
        0.5f, 0.5f,
        0.5, -0.5f
    };

    unsigned int a;
    glGenBuffers(1, &a);//第一个参数代表生成缓冲区的数量，第二个为指定对象来生成缓冲区
    //当生成多个缓冲区时: 
    //unsigned int b[3];
    //glGenBuffers(3, b);
    //cout << a << endl;
    //for (int i = 0; i < 3; i++) {
    //    cout << b[i] << endl;
    //}
    glBindBuffer(GL_ARRAY_BUFFER, a);//定义缓冲区类型
    glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(float), Positions, GL_STATIC_DRAW);//绑定完毕就要开始存放顶点数据了
    glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);//设置顶点属性，第一个参数为从第几个属性开始取值，很明显从第一个数组0号位
    //第二个参数时代表一个顶点需要几个值，比如二维需要两个float才能组成一个顶点的位置，当然顶点不只是位置信息，第三个参数为描述顶点位置的属性
    //第四个参数代表是否将属性进行归一化，这里我们不需要，第五个参数代表一个顶点所占的字节数，第六个参数代表字节偏移量
    string vertexShader = "#version 330 core\n"//在这里定义顶点着色器的着色信息
        "\n"
        "layout(location = 0) in vec4 position;\n"
        "void main(){\n"
        "   gl_Position = position;\n"
        "}\n";
    string fragmentShader = "#version 330 core\n"//在这里定义片段着色器的着色信息
        "\n"
        "layout(location = 0) out vec4 color;\n"
        "void main(){\n"
        "   color = vec4(1.0, 0.0, 0.0, 1.0);\n"
        "}\n";

    unsigned int shader = CreateShader(vertexShader, fragmentShader);//通过创建好的着色器创建program
    glUseProgram(shader);//使用刚创建的program

    /* Loop until the user closes the window */
    while (!glfwWindowShouldClose(window))
    {
        /* Render here */
        glClear(GL_COLOR_BUFFER_BIT);

        /*glBegin(GL_TRIANGLES);
        glVertex2f(-0.5, -0.5f);
        glVertex2f(0.5, 0.5f);
        glVertex2f(0.5, -0.5f);
        glColor3f(1, 0, 0);
        glEnd();*/

        glDrawArrays(GL_TRIANGLES, 0, 3);//画好了三角形，但是苦于没有shader，所以不显示
        //glColor3f(1.f, 0, 0);

        
        /* Swap front and back buffers */
        glfwSwapBuffers(window);

        /* Poll for and process events */
        glfwPollEvents();
    }

    glDeleteProgram(shader);
    glfwTerminate();
    return 0;
}

将shader写进文件


#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include "iostream"
#include "fstream"
#include "string"
#include "sstream"

using namespace std;

struct ShaderProgramSource {
    string VertexSource;
    string FragmentSource;
};

static ShaderProgramSource ParseShader(const string& filepath) {
    ifstream stream(filepath);

    enum class ShaderType {
        NONE = -1, VERTEX = 0, FRAGMENT = 1
    };

    string line;
    stringstream ss[2];
    ShaderType type = ShaderType::NONE;
    while (getline(stream, line)) {
        if (line.find("#shader") != string::npos) {
            if (line.find("vertex") != string::npos) {
                type = ShaderType::VERTEX;
            }
            else if(line.find("fragment") != string::npos) {
                type = ShaderType::FRAGMENT;
            }
        }
        else {
            ss[(int)type] << line << "\n";
        }
    }

    return ShaderProgramSource{ ss[0].str(), ss[1].str() };
}

static unsigned int CompileShader(const string& source, unsigned int type) {
    unsigned int id = glCreateShader(type);
    const char* src = source.c_str();
    glShaderSource(id, 1, &src, nullptr);
    glCompileShader(id);

int result;
    glGetShaderiv(id, GL_COMPILE_STATUS, &result);
    if (result == GL_FALSE) {
        int length;
        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length);
        char* message = (char*)alloca(length * sizeof(char));//alloca是在栈上分配空间，malloc是在堆上分配空间，当遇到char message[length]，而这个length却不是常量的时候可以使用该方法
        glGetShaderInfoLog(id, length, &length, message);
        cout << "FAILED TO COMPILE SHADER !" << endl;
        cout << message << endl;
        glDeleteShader(id);
 
        return 0;
    }
    
    return id;
}

static unsigned int CreateShader(const string& vertexShader, const string& fragmentShader) {
//总结：1、创建program 2、编译shader（1、创建shader 2、编译shader 3、获取着色器资源 4、判断shader是否创建成功） 3、将着色器附着在program对象上 
    //4、与program建立链接 5、验证program 6、删除shader
    unsigned int program = glCreateProgram();
    unsigned int vs = CompileShader(vertexShader, GL_VERTEX_SHADER);
    unsigned int fs = CompileShader(fragmentShader, GL_FRAGMENT_SHADER);

    glAttachShader(program, vs);
    glAttachShader(program, fs);
    glLinkProgram(program);
    glValidateProgram(program);

    glDeleteShader(vs);
    glDeleteShader(fs);

    return program;
}

int main(void)
{
    GLFWwindow* window;

    /* Initialize the library */
    if (!glfwInit())
        return -1;

    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    /* Make the window's context current */
    glfwMakeContextCurrent(window);

    if (glewInit() != GLEW_OK) {
        cout << "ERROR" << endl;
    }

    float Positions[6] = {
        -0.5f, -0.5f,
        0.5f, 0.5f,
        0.5, -0.5f
    };

    unsigned int a;
    glGenBuffers(1, &a);//第一个参数代表生成缓冲区的数量，第二个为指定对象来生成缓冲区
    //当生成多个缓冲区时: 
    //unsigned int b[3];
    //glGenBuffers(3, b);
    //cout << a << endl;
    //for (int i = 0; i < 3; i++) {
    //    cout << b[i] << endl;
    //}
    glBindBuffer(GL_ARRAY_BUFFER, a);//定义缓冲区类型
    glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(float), Positions, GL_STATIC_DRAW);//绑定完毕就要开始存放顶点数据了
    glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);//设置顶点属性，第一个参数为从第几个属性开始取值，很明显从第一个数组0号位
    //第二个参数时代表一个顶点需要几个值，比如二维需要两个float才能组成一个顶点的位置，当然顶点不只是位置信息，第三个参数为描述顶点位置的属性
    //第四个参数代表是否将属性进行归一化，这里我们不需要，第五个参数代表一个顶点所占的字节数，第六个参数代表字节偏移量

    ShaderProgramSource source = ParseShader("Shader.shader");
    cout << "Fragment: " << endl;
    cout << source.FragmentSource << endl;
    cout << "Vertex: " << endl;
    cout << source.VertexSource << endl;

    string vertexShader = source.VertexSource;//在这里定义顶点着色器的着色信息
    string fragmentShader = source.FragmentSource;//在这里定义片段着色器的着色信息

    unsigned int shader = CreateShader(vertexShader, fragmentShader);//通过创建好的着色器创建program
    glUseProgram(shader);//使用刚创建的program

    /* Loop until the user closes the window */
    while (!glfwWindowShouldClose(window))
    {
        /* Render here */
        glClear(GL_COLOR_BUFFER_BIT);

        /*glBegin(GL_TRIANGLES);
        glVertex2f(-0.5, -0.5f);
        glVertex2f(0.5, 0.5f);
        glVertex2f(0.5, -0.5f);
        glColor3f(1, 0, 0);
        glEnd();*/

        glDrawArrays(GL_TRIANGLES, 0, 3);//画好了三角形，但是苦于没有shader，所以不显示
        //glColor3f(1.f, 0, 0);

        
        /* Swap front and back buffers */
        glfwSwapBuffers(window);

        /* Poll for and process events */
        glfwPollEvents();
    }

    glDeleteProgram(shader);
    glfwTerminate();
    return 0;
}
#shader vertex
#version 330 core

layout(location = 0) in vec4 position;
void main(){
   gl_Position = position;
}

#shader fragment
#version 330 core

layout(location = 0) out vec4 color;
void main(){
   color = vec4(1.0, 0.0, 0.0, 1.0);
}

绘制长方形：用两个三角形拼接，所有几何体，都可以用三角形来拼接


#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include "iostream"
#include "fstream"
#include "string"
#include "sstream"

using namespace std;

struct ShaderProgramSource {
    string VertexSource;
    string FragmentSource;
};

static ShaderProgramSource ParseShader(const string& filepath) {
    ifstream stream(filepath);

    enum class ShaderType {
        NONE = -1, VERTEX = 0, FRAGMENT = 1
    };

    string line;
    stringstream ss[2];
    ShaderType type = ShaderType::NONE;
    while (getline(stream, line)) {
        if (line.find("#shader") != string::npos) {
            if (line.find("vertex") != string::npos) {
                type = ShaderType::VERTEX;
            }
            else if(line.find("fragment") != string::npos) {
                type = ShaderType::FRAGMENT;
            }
        }
        else {
            ss[(int)type] << line << "\n";
        }
    }

    return ShaderProgramSource{ ss[0].str(), ss[1].str() };
}

static unsigned int CompileShader(const string& source, unsigned int type) {
    unsigned int id = glCreateShader(type);
    const char* src = source.c_str();
    glShaderSource(id, 1, &src, nullptr);
    glCompileShader(id);

    int result;
    glGetShaderiv(id, GL_COMPILE_STATUS, &result);
    if (result == GL_FALSE) {
        int length;
        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length);
        char* message = (char*)alloca(length * sizeof(char));//alloca是在栈上分配空间，malloc是在堆上分配空间，当遇到char message[length]，而这个length却不是常量的时候可以使用该方法
        glGetShaderInfoLog(id, length, &length, message);
        cout << "FAILED TO COMPILE SHADER !" << endl;
        cout << message << endl;
        glDeleteShader(id);
 
        return 0;
    }
    
    return id;
}

static unsigned int CreateShader(const string& vertexShader, const string& fragmentShader) {
//总结：1、创建program 2、编译shader（1、创建shader 2、编译shader 3、获取着色器资源 4、判断shader是否创建成功） 3、将着色器附着在program对象上 
    //4、与program建立链接 5、验证program 6、删除shader
    unsigned int program = glCreateProgram();
    unsigned int vs = CompileShader(vertexShader, GL_VERTEX_SHADER);
    unsigned int fs = CompileShader(fragmentShader, GL_FRAGMENT_SHADER);

    glAttachShader(program, vs);
    glAttachShader(program, fs);
    glLinkProgram(program);
    glValidateProgram(program);

    glDeleteShader(vs);
    glDeleteShader(fs);

    return program;
}

int main(void)
{
    GLFWwindow* window;

    /* Initialize the library */
    if (!glfwInit())
        return -1;

    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    /* Make the window's context current */
    glfwMakeContextCurrent(window);

    if (glewInit() != GLEW_OK) {
        cout << "ERROR" << endl;
    }

    float Positions[12] = {
        -0.5f, -0.5f,
        0.5f, 0.5f,
        0.5, -0.5f,

        -0.5, -0.5,
        -0.5, 0.5,
        0.5, 0.5
    };

    unsigned int a;
    glGenBuffers(1, &a);//第一个参数代表生成缓冲区的数量，第二个为指定对象来生成缓冲区
    //当生成多个缓冲区时: 
    //unsigned int b[3];
    //glGenBuffers(3, b);
    //cout << a << endl;
    //for (int i = 0; i < 3; i++) {
    //    cout << b[i] << endl;
    //}
    glBindBuffer(GL_ARRAY_BUFFER, a);//定义缓冲区类型
    glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(float), Positions, GL_STATIC_DRAW);//绑定完毕就要开始存放顶点数据了
    glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);//设置顶点属性，第一个参数为从第几个属性开始取值，很明显从第一个数组0号位
    //第二个参数时代表一个顶点需要几个值，比如二维需要两个float才能组成一个顶点的位置，当然顶点不只是位置信息，第三个参数为描述顶点位置的属性
    //第四个参数代表是否将属性进行归一化，这里我们不需要，第五个参数代表一个顶点所占的字节数，第六个参数代表字节偏移量

    ShaderProgramSource source = ParseShader("Shader.shader");
    cout << "Fragment: " << endl;
    cout << source.FragmentSource << endl;
    cout << "Vertex: " << endl;
    cout << source.VertexSource << endl;

    string vertexShader = source.VertexSource;//在这里定义顶点着色器的着色信息
    string fragmentShader = source.FragmentSource;//在这里定义片段着色器的着色信息

    unsigned int shader = CreateShader(vertexShader, fragmentShader);//通过创建好的着色器创建program
    glUseProgram(shader);//使用刚创建的program

    /* Loop until the user closes the window */
    while (!glfwWindowShouldClose(window))
    {
        /* Render here */
        glClear(GL_COLOR_BUFFER_BIT);

        /*glBegin(GL_TRIANGLES);
        glVertex2f(-0.5, -0.5f);
        glVertex2f(0.5, 0.5f);
        glVertex2f(0.5, -0.5f);
        glColor3f(1, 0, 0);
        glEnd();*/

        glDrawArrays(GL_TRIANGLES, 0, 6);//画好了三角形，但是苦于没有shader，所以不显示
        //glColor3f(1.f, 0, 0);

        
        /* Swap front and back buffers */
        glfwSwapBuffers(window);

        /* Poll for and process events */
        glfwPollEvents();
    }

    glDeleteProgram(shader);
    glfwTerminate();
    return 0;
}

 改动1：

改动2：

改动3：

但是在改动1的情况下，我们重复记录了相同的顶点，这造成了内存浪费，所以也要在Slate编程一样的去记录引用缓冲

   float Positions[12] = {
        -0.5f, -0.5f,
        0.5f, 0.5f,
        0.5, -0.5f,
        -0.5, 0.5,
    };

    unsigned int Indices[] = {
        0, 1, 2,
        0, 1, 3
    };

    unsigned int ibo;
    glGenBuffers(1, &ibo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);//定义缓冲区类型
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6 * sizeof(unsigned int), Indices, GL_STATIC_DRAW);//绑定完毕就要开始存放顶点数据了
    glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);

存放顶点然后用引用缓冲进行绘制


#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include "iostream"
#include "fstream"
#include "string"
#include "sstream"

using namespace std;

struct ShaderProgramSource {
    string VertexSource;
    string FragmentSource;
};

static ShaderProgramSource ParseShader(const string& filepath) {
    ifstream stream(filepath);

    enum class ShaderType {
        NONE = -1, VERTEX = 0, FRAGMENT = 1
    };

    string line;
    stringstream ss[2];
    ShaderType type = ShaderType::NONE;
    while (getline(stream, line)) {
        if (line.find("#shader") != string::npos) {
            if (line.find("vertex") != string::npos) {
                type = ShaderType::VERTEX;
            }
            else if(line.find("fragment") != string::npos) {
                type = ShaderType::FRAGMENT;
            }
        }
        else {
            ss[(int)type] << line << "\n";
        }
    }

    return ShaderProgramSource{ ss[0].str(), ss[1].str() };
}

static unsigned int CompileShader(const string& source, unsigned int type) {
    unsigned int id = glCreateShader(type);
    const char* src = source.c_str();
    glShaderSource(id, 1, &src, nullptr);
    glCompileShader(id);

    int result;
    glGetShaderiv(id, GL_COMPILE_STATUS, &result);
    if (result == GL_FALSE) {
        int length;
        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length);
        char* message = (char*)alloca(length * sizeof(char));//alloca是在栈上分配空间，malloc是在堆上分配空间，当遇到char message[length]，而这个length却不是常量的时候可以使用该方法
        glGetShaderInfoLog(id, length, &length, message);
        cout << "FAILED TO COMPILE SHADER !" << endl;
        cout << message << endl;
        glDeleteShader(id);
 
        return 0;
    }
    
    return id;
}

static unsigned int CreateShader(const string& vertexShader, const string& fragmentShader) {
//总结：1、创建program 2、编译shader（1、创建shader 2、编译shader 3、获取着色器资源 4、判断shader是否创建成功） 3、将着色器附着在program对象上 
    //4、与program建立链接 5、验证program 6、删除shader
    unsigned int program = glCreateProgram();
    unsigned int vs = CompileShader(vertexShader, GL_VERTEX_SHADER);
    unsigned int fs = CompileShader(fragmentShader, GL_FRAGMENT_SHADER);

    glAttachShader(program, vs);
    glAttachShader(program, fs);
    glLinkProgram(program);
    glValidateProgram(program);

    glDeleteShader(vs);
    glDeleteShader(fs);

    return program;
}

int main(void)
{
    GLFWwindow* window;

    /* Initialize the library */
    if (!glfwInit())
        return -1;

    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    /* Make the window's context current */
    glfwMakeContextCurrent(window);

    if (glewInit() != GLEW_OK) {
        cout << "ERROR" << endl;
    }

    float Positions[12] = {
        -0.5f, -0.5f,
        0.5f, 0.5f,
        0.5, -0.5f,
        -0.5, 0.5,
    };

    unsigned int Indices[] = {
        0, 1, 2,
        0, 1, 3
    };

    unsigned int a;
    glGenBuffers(1, &a);//第一个参数代表生成缓冲区的数量，第二个为指定对象来生成缓冲区
    //当生成多个缓冲区时: 
    //unsigned int b[3];
    //glGenBuffers(3, b);
    //cout << a << endl;
    //for (int i = 0; i < 3; i++) {
    //    cout << b[i] << endl;
    //}
    glBindBuffer(GL_ARRAY_BUFFER, a);//定义缓冲区类型
    glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(float), Positions, GL_STATIC_DRAW);//绑定完毕就要开始存放顶点数据了
    glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);//设置顶点属性，第一个参数为从第几个属性开始取值，很明显从第一个数组0号位
    //第二个参数时代表一个顶点需要几个值，比如二维需要两个float才能组成一个顶点的位置，当然顶点不只是位置信息，第三个参数为描述顶点位置的属性
    //第四个参数代表是否将属性进行归一化，这里我们不需要，第五个参数代表一个顶点所占的字节数，第六个参数代表字节偏移量

    unsigned int ibo;
    glGenBuffers(1, &ibo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);//定义缓冲区类型
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6 * sizeof(unsigned int), Indices, GL_STATIC_DRAW);//绑定完毕就要开始存放顶点数据了
    glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);

    ShaderProgramSource source = ParseShader("Shader.shader");
    cout << "Fragment: " << endl;
    cout << source.FragmentSource << endl;
    cout << "Vertex: " << endl;
    cout << source.VertexSource << endl;

    string vertexShader = source.VertexSource;//在这里定义顶点着色器的着色信息
    string fragmentShader = source.FragmentSource;//在这里定义片段着色器的着色信息

    unsigned int shader = CreateShader(vertexShader, fragmentShader);//通过创建好的着色器创建program
    glUseProgram(shader);//使用刚创建的program

    /* Loop until the user closes the window */
    while (!glfwWindowShouldClose(window))
    {
        /* Render here */
        glClear(GL_COLOR_BUFFER_BIT);

        /*glBegin(GL_TRIANGLES);
        glVertex2f(-0.5, -0.5f);
        glVertex2f(0.5, 0.5f);
        glVertex2f(0.5, -0.5f);
        glColor3f(1, 0, 0);
        glEnd();*/

        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);
        /*glDrawArrays(GL_TRIANGLES, 0, 6);*///画好了三角形，但是苦于没有shader，所以不显示
        //glColor3f(1.f, 0, 0);

        
        /* Swap front and back buffers */
        glfwSwapBuffers(window);

        /* Poll for and process events */
        glfwPollEvents();
    }

    glDeleteProgram(shader);
    glfwTerminate();
    return 0;
}

差错：

static void GLClearError() {
    while (glGetError() != GL_NO_ERROR);
}

static void GLCheckError() {
    while (GLenum Enum = glGetError()) {
        cout << "OpenGL Error: ( " << Enum << " )" << endl;
    }
}
    GLClearError();
    glDrawElements(GL_TRIANGLES, 6, GL_INT, nullptr);//这里故意将GL_UNSIGNED_INT改成了GL_INT用于检查错误
    GLCheckError();

报错编号为1280，转为16进制就为500，500对应的枚举值为无效枚举

#define ASSERT(x) if(!x) __debugbreak();

static bool GLLogCall() {
    while (GLenum Enum = glGetError()) {
        cout << "OpenGL Error: ( " << Enum << " )" << endl;
        return false;
    }

    return true;
}

ASSERT(GLLogCall());

将GLCheckError改成GLLogCall，调用改成ASSERT(GLLogCall());

    GLClearError();
    glDrawElements(GL_TRIANGLES, 6, GL_INT, nullptr);
    ASSERT(GLLogCall());

再整体封装一遍：

#define ASSERT(x) if(!x) __debugbreak();
#define GLCALL(x) GLClearError();\
x;\
ASSERT(GLLogCall())

static void GLClearError() {
    while (glGetError() != GL_NO_ERROR);
}

static bool GLLogCall() {
    while (GLenum Enum = glGetError()) {
        cout << "OpenGL Error: ( " << Enum << " )" << endl;
        return false;
    }

    return true;
}

GLCALL(glDrawElements(GL_TRIANGLES, 6, GL_INT, nullptr));

 ​​​​

再进行一次优化：

#define ASSERT(x) if(!x) __debugbreak();
#define GLCALL(x) GLClearError();\
x;\
ASSERT(GLLogCall(#x, __FILE__, __LINE__))

static void GLClearError() {
    while (glGetError() != GL_NO_ERROR);
}

static bool GLLogCall(const char* function, const char* file, int line) {
    while (GLenum Enum = glGetError()) {
        cout << "OpenGL Error: ( " << Enum << " )" << " Function Name : " << function << " File : " << file << " Line : " << line << endl;
        return false;
    }

    return true;
}

当前所有代码：


#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include "iostream"
#include "fstream"
#include "string"
#include "sstream"

#define ASSERT(x) if(!x) __debugbreak();
#define GLCALL(x) GLClearError();\
x;\
ASSERT(GLLogCall(#x, __FILE__, __LINE__))

using namespace std;

struct ShaderProgramSource {
    string VertexSource;
    string FragmentSource;
};

static void GLClearError() {
    while (glGetError() != GL_NO_ERROR);
}

static bool GLLogCall(const char* function, const char* file, int line) {
    while (GLenum Enum = glGetError()) {
        cout << "OpenGL Error: ( " << Enum << " )" << " Function Name : " << function << " File : " << file << " Line : " << line << endl;
        return false;
    }

    return true;
}

static ShaderProgramSource ParseShader(const string& filepath) {
    ifstream stream(filepath);

    enum class ShaderType {
        NONE = -1, VERTEX = 0, FRAGMENT = 1
    };

    string line;
    stringstream ss[2];
    ShaderType type = ShaderType::NONE;
    while (getline(stream, line)) {
        if (line.find("#shader") != string::npos) {
            if (line.find("vertex") != string::npos) {
                type = ShaderType::VERTEX;
            }
            else if(line.find("fragment") != string::npos) {
                type = ShaderType::FRAGMENT;
            }
        }
        else {
            ss[(int)type] << line << "\n";
        }
    }

    return ShaderProgramSource{ ss[0].str(), ss[1].str() };
}

static unsigned int CompileShader(const string& source, unsigned int type) {
    unsigned int id = glCreateShader(type);
    const char* src = source.c_str();
    glShaderSource(id, 1, &src, nullptr);
    glCompileShader(id);

    int result;
    glGetShaderiv(id, GL_COMPILE_STATUS, &result);
    if (result == GL_FALSE) {
        int length;
        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length);
        char* message = (char*)alloca(length * sizeof(char));//alloca是在栈上分配空间，malloc是在堆上分配空间，当遇到char message[length]，而这个length却不是常量的时候可以使用该方法
        glGetShaderInfoLog(id, length, &length, message);
        cout << "FAILED TO COMPILE SHADER !" << endl;
        cout << message << endl;
        glDeleteShader(id);
 
        return 0;
    }

    return id;
}

static unsigned int CreateShader(const string& vertexShader, const string& fragmentShader) {
//总结：1、创建program 2、编译shader（1、创建shader 2、编译shader 3、获取着色器资源 4、判断shader是否创建成功） 3、将着色器附着在program对象上 
    //4、与program建立链接 5、验证program 6、删除shader
    unsigned int program = glCreateProgram();
    unsigned int vs = CompileShader(vertexShader, GL_VERTEX_SHADER);
    unsigned int fs = CompileShader(fragmentShader, GL_FRAGMENT_SHADER);

    glAttachShader(program, vs);
    glAttachShader(program, fs);
    glLinkProgram(program);
    glValidateProgram(program);

    glDeleteShader(vs);
    glDeleteShader(fs);

    return program;
}

int main(void)
{
    GLFWwindow* window;

    /* Initialize the library */
    if (!glfwInit())
        return -1;

    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    /* Make the window's context current */
    glfwMakeContextCurrent(window);

    if (glewInit() != GLEW_OK) {
        cout << "ERROR" << endl;
    }

    float Positions[12] = {
        -0.5f, -0.5f,
        0.5f, 0.5f,
        0.5, -0.5f,
        -0.5, 0.5,
    };

    unsigned int Indices[] = {
        0, 1, 2,
        0, 1, 3
    };

    unsigned int a;
    glGenBuffers(1, &a);//第一个参数代表生成缓冲区的数量，第二个为指定对象来生成缓冲区
    //当生成多个缓冲区时: 
    //unsigned int b[3];
    //glGenBuffers(3, b);
    //cout << a << endl;
    //for (int i = 0; i < 3; i++) {
    //    cout << b[i] << endl;
    //}
    glBindBuffer(GL_ARRAY_BUFFER, a);//定义缓冲区类型
    glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(float), Positions, GL_STATIC_DRAW);//绑定完毕就要开始存放顶点数据了
    glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);//设置顶点属性，第一个参数为从第几个属性开始取值，很明显从第一个数组0号位
    //第二个参数时代表一个顶点需要几个值，比如二维需要两个float才能组成一个顶点的位置，当然顶点不只是位置信息，第三个参数为描述顶点位置的属性
    //第四个参数代表是否将属性进行归一化，这里我们不需要，第五个参数代表一个顶点所占的字节数，第六个参数代表字节偏移量

    unsigned int ibo;
    glGenBuffers(1, &ibo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);//定义缓冲区类型
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6 * sizeof(unsigned int), Indices, GL_STATIC_DRAW);//绑定完毕就要开始存放顶点数据了
    glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);

    ShaderProgramSource source = ParseShader("Shader.shader");
    cout << "Fragment: " << endl;
    cout << source.FragmentSource << endl;
    cout << "Vertex: " << endl;
    cout << source.VertexSource << endl;

    string vertexShader = source.VertexSource;//在这里定义顶点着色器的着色信息
    string fragmentShader = source.FragmentSource;//在这里定义片段着色器的着色信息

    unsigned int shader = CreateShader(vertexShader, fragmentShader);//通过创建好的着色器创建program
    glUseProgram(shader);//使用刚创建的program

    /* Loop until the user closes the window */
    while (!glfwWindowShouldClose(window))
    {
        /* Render here */
        glClear(GL_COLOR_BUFFER_BIT);

        /*glBegin(GL_TRIANGLES);
        glVertex2f(-0.5, -0.5f);
        glVertex2f(0.5, 0.5f);
        glVertex2f(0.5, -0.5f);
        glColor3f(1, 0, 0);
        glEnd();*/

        GLCALL(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr));
        /*glDrawArrays(GL_TRIANGLES, 0, 6);*///画好了三角形，但是苦于没有shader，所以不显示
        //glColor3f(1.f, 0, 0);X

        
        /* Swap front and back buffers */
        glfwSwapBuffers(window);

        /* Poll for and process events */
        glfwPollEvents();
    }

    glDeleteProgram(shader);
    glfwTerminate();
    return 0;
}

使用uniform去修改shader内值

#shader vertex
#version 330 core

layout(location = 0) in vec4 position;

void main(){
   gl_Position = position;
}

#shader fragment
#version 330 core

layout(location = 0) out vec4 color;

uniform vec4 u_Color;

void main(){
   color = u_Color;
}
    unsigned int shader = CreateShader(vertexShader, fragmentShader);//通过创建好的着色器创建program
    glUseProgram(shader);//使用刚创建的program

    int location = glGetUniformLocation(shader, "u_Color");
    glUniform4f(location, 0.2, 0.4, 0.3, 1);

拿到shader内的u_Color变量，然后去设置vec4 u_Color的值

制作矩形颜色闪烁效果：

    float r = 0.2;
    float increment = 0.01;
    /* Loop until the user closes the window */
    while (!glfwWindowShouldClose(window))
    {   
        /* Render here */   
        glClear(GL_COLOR_BUFFER_BIT);

        glUniform4f(location, r, 0.4, 0.3, 1);

        if (r < 0)   increment = 0.01;
        else if (r > 1)  increment = -0.01;
        r += increment;
        /*glBegin(GL_TRIANGLES);
        glVertex2f(-0.5, -0.5f);
        glVertex2f(0.5, 0.5f);
        glVertex2f(0.5, -0.5f);
        glColor3f(1, 0, 0);
        glEnd();*/

        GLCALL(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr));
        /*glDrawArrays(GL_TRIANGLES, 0, 6);*///画好了三角形，但是苦于没有shader，所以不显示
        //glColor3f(1.f, 0, 0);X

        
        /* Swap front and back buffers */
        glfwSwapBuffers(window);

        /* Poll for and process events */
        glfwPollEvents();
    }

让矩形旋转，将四个位置乘以旋转矩阵，然后再将位置与引用进行重新绑定


#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include "iostream"
#include "math.h"
#include "fstream"
#include "string"
#include "sstream"

#define ASSERT(x) if(!x) __debugbreak();
#define GLCALL(x) GLClearError();\
x;\
ASSERT(GLLogCall(#x, __FILE__, __LINE__))

using namespace std;

struct ShaderProgramSource {
    string VertexSource;
    string FragmentSource;
};

static void GLClearError() {
    while (glGetError() != GL_NO_ERROR);
}

static bool GLLogCall(const char* function, const char* file, int line) {
    while (GLenum Enum = glGetError()) {
        cout << "OpenGL Error: ( " << Enum << " )" << " Function Name : " << function << " File : " << file << " Line : " << line << endl;
        return false;
    }

    return true;
}

static ShaderProgramSource ParseShader(const string& filepath) {
    ifstream stream(filepath);

    enum class ShaderType {
        NONE = -1, VERTEX = 0, FRAGMENT = 1
    };

    string line;
    stringstream ss[2];
    ShaderType type = ShaderType::NONE;
    while (getline(stream, line)) {
        if (line.find("#shader") != string::npos) {
            if (line.find("vertex") != string::npos) {
                type = ShaderType::VERTEX;
            }
            else if(line.find("fragment") != string::npos) {
                type = ShaderType::FRAGMENT;
            }
        }
        else {
            ss[(int)type] << line << "\n";
        }
    }

    return ShaderProgramSource{ ss[0].str(), ss[1].str() };
}

static unsigned int CompileShader(const string& source, unsigned int type) {
    unsigned int id = glCreateShader(type);
    const char* src = source.c_str();
    glShaderSource(id, 1, &src, nullptr);
    glCompileShader(id);

    int result;
    glGetShaderiv(id, GL_COMPILE_STATUS, &result);
    if (result == GL_FALSE) {
        int length;
        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length);
        char* message = (char*)alloca(length * sizeof(char));//alloca是在栈上分配空间，malloc是在堆上分配空间，当遇到char message[length]，而这个length却不是常量的时候可以使用该方法
        glGetShaderInfoLog(id, length, &length, message);
        cout << "FAILED TO COMPILE SHADER !" << endl;
        cout << message << endl;
        glDeleteShader(id);
 
        return 0;
    }

    return id;
}

#define PI 3.1415   

struct Pos {
    float x;
    float y;
};

Pos RotateMatrix(int Angle, float x, float y) {
    float newX = x * cos(Angle * PI / 180) - y * sin(Angle * PI / 180);
    float newY = x * sin(Angle * PI / 180) + y * cos(Angle * PI / 180);

    Pos pos = Pos{ newX, newY };

    return pos;
}

void UpdateValue(float Positions[], int& Angle, unsigned int id, unsigned int Indices[], unsigned int dataId) {
    for (int i = 0; i < 8; i += 2) {
        float tempX = Positions[i];
        float tempY = Positions[i + 1];
        Positions[i] = RotateMatrix(Angle, tempX, tempY).x;
        Positions[i + 1] = RotateMatrix(Angle, tempX, tempY).y;
        //cout << tempX << " / " << tempY << endl;
    }
    glGenBuffers(1, &dataId);
    glBindBuffer(GL_ARRAY_BUFFER, dataId);//定义缓冲区类型
    glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(float), Positions, GL_STATIC_DRAW);//绑定完毕就要开始存放顶点数据了
    glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);

    glGenBuffers(1, &id);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id);//定义缓冲区类型
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6 * sizeof(unsigned int), Indices, GL_STATIC_DRAW);//绑定完毕就要开始存放顶点数据了
    glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);
    Angle++;
}

static unsigned int CreateShader(const string& vertexShader, const string& fragmentShader) {
//总结：1、创建program 2、编译shader（1、创建shader 2、编译shader 3、获取着色器资源 4、判断shader是否创建成功） 3、将着色器附着在program对象上 
    //4、与program建立链接 5、验证program 6、删除shader
    unsigned int program = glCreateProgram();
    unsigned int vs = CompileShader(vertexShader, GL_VERTEX_SHADER);
    unsigned int fs = CompileShader(fragmentShader, GL_FRAGMENT_SHADER);

    glAttachShader(program, vs);
    glAttachShader(program, fs);
    glLinkProgram(program);
    glValidateProgram(program);

    glDeleteShader(vs);
    glDeleteShader(fs);

    return program;
}

void outputVertex(float Positions[]) {
    for (int i = 0; i < sizeof(Positions) / sizeof(float); i += 2) {
        cout << Positions[i] << " \ " << Positions[i + 1] << endl;
    }
}

int main(void)
{
    GLFWwindow* window;

    /* Initialize the library */
    if (!glfwInit())
        return -1;

    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    /* Make the window's context current */
    glfwMakeContextCurrent(window);

    glfwSwapInterval(1);//屏幕刷新频率，此时为一帧刷新一次

    if (glewInit() != GLEW_OK) {
        cout << "ERROR" << endl;
    }

    float Positions[12] = {
        -0.5f, -0.5f,
        0.5f, 0.5f,
        0.5, -0.5f,
        -0.5, 0.5,
    };

    unsigned int Indices[] = {
        0, 1, 2,
        0, 1, 3
    };

    unsigned int a;
    glGenBuffers(1, &a);//第一个参数代表生成缓冲区的数量，第二个为指定对象来生成缓冲区
    //当生成多个缓冲区时: 
    //unsigned int b[3];
    //glGenBuffers(3, b);
    //cout << a << endl;
    //for (int i = 0; i < 3; i++) {
    //    cout << b[i] << endl;
    //}
    glBindBuffer(GL_ARRAY_BUFFER, a);//定义缓冲区类型
    glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(float), Positions, GL_STATIC_DRAW);//绑定完毕就要开始存放顶点数据了
    glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);//设置顶点属性，第一个参数为从第几个属性开始取值，很明显从第一个数组0号位
    //第二个参数时代表一个顶点需要几个值，比如二维需要两个float才能组成一个顶点的位置，当然顶点不只是位置信息，第三个参数为描述顶点位置的属性
    //第四个参数代表是否将属性进行归一化，这里我们不需要，第五个参数代表一个顶点所占的字节数，第六个参数代表字节偏移量

    unsigned int ibo;
    glGenBuffers(1, &ibo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);//定义缓冲区类型
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6 * sizeof(unsigned int), Indices, GL_STATIC_DRAW);//绑定完毕就要开始存放顶点数据了
    glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);

    ShaderProgramSource source = ParseShader("Shader.shader");
    cout << "Fragment: " << endl;
    cout << source.FragmentSource << endl;
    cout << "Vertex: " << endl;
    cout << source.VertexSource << endl;

    string vertexShader = source.VertexSource;//在这里定义顶点着色器的着色信息
    string fragmentShader = source.FragmentSource;//在这里定义片段着色器的着色信息

    unsigned int shader = CreateShader(vertexShader, fragmentShader);//通过创建好的着色器创建program
    glUseProgram(shader);//使用刚创建的program

    int location = glGetUniformLocation(shader, "u_Color");
    glUniform4f(location, 0.2, 0.4, 0.3, 1);

    float r = 0.2;
    float increment = 0.01;
    int Angle = 0;
    /* Loop until the user closes the window */
    while (!glfwWindowShouldClose(window))
    {   
        /* Render here */   
        glClear(GL_COLOR_BUFFER_BIT);

        glUniform4f(location, r, 0.4, 0.3, 1);

        if (r < 0)   increment = 0.01;
        else if (r > 1)  increment = -0.01;
        r += increment;

        UpdateValue(Positions, Angle, ibo, Indices, a);

        outputVertex(Positions);
        /*glBegin(GL_TRIANGLES);
        glVertex2f(-0.5, -0.5f);
        glVertex2f(0.5, 0.5f);
        glVertex2f(0.5, -0.5f);
        glColor3f(1, 0, 0);
        glEnd();*/

        GLCALL(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr));
        /*glDrawArrays(GL_TRIANGLES, 0, 6);*///画好了三角形，但是苦于没有shader，所以不显示
        //glColor3f(1.f, 0, 0);X

        
        /* Swap front and back buffers */
        glfwSwapBuffers(window);

        /* Poll for and process events */
        glfwPollEvents();
    }

    glDeleteProgram(shader);
    glfwTerminate();
    return 0;
}

vao比vbo理论上速度要快，官方推荐用vao，之前上面实现方法为vbo

第一步：

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);//改变OPENGL的版本为3.3

加上以上代码使用vao

第二步：

    unsigned int vao;
    glGenVertexArrays(1, &vao);//第一个参数是要生成顶点数组的数量，第二个参数为生成的顶点数组
    glBindVertexArray(vao);

第三步：

glBindVertexArray(vao);

在while循环内进行绑定


#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include "iostream"
#include "math.h"
#include "fstream"
#include "string"
#include "sstream"

#define ASSERT(x) if(!x) __debugbreak();
#define GLCALL(x) GLClearError();\
x;\
ASSERT(GLLogCall(#x, __FILE__, __LINE__))

using namespace std;

struct ShaderProgramSource {
    string VertexSource;
    string FragmentSource;
};

static void GLClearError() {
    while (glGetError() != GL_NO_ERROR);
}

static bool GLLogCall(const char* function, const char* file, int line) {
    while (GLenum Enum = glGetError()) {
        cout << "OpenGL Error: ( " << Enum << " )" << " Function Name : " << function << " File : " << file << " Line : " << line << endl;
        return false;
    }

    return true;
}

static ShaderProgramSource ParseShader(const string& filepath) {
    ifstream stream(filepath);

    enum class ShaderType {
        NONE = -1, VERTEX = 0, FRAGMENT = 1
    };

    string line;
    stringstream ss[2];
    ShaderType type = ShaderType::NONE;
    while (getline(stream, line)) {
        if (line.find("#shader") != string::npos) {
            if (line.find("vertex") != string::npos) {
                type = ShaderType::VERTEX;
            }
            else if(line.find("fragment") != string::npos) {
                type = ShaderType::FRAGMENT;
            }
        }
        else {
            ss[(int)type] << line << "\n";
        }
    }

    return ShaderProgramSource{ ss[0].str(), ss[1].str() };
}

static unsigned int CompileShader(const string& source, unsigned int type) {
    unsigned int id = glCreateShader(type);
    const char* src = source.c_str();
    glShaderSource(id, 1, &src, nullptr);
    glCompileShader(id);

    int result;
    glGetShaderiv(id, GL_COMPILE_STATUS, &result);
    if (result == GL_FALSE) {
        int length;
        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length);
        char* message = (char*)alloca(length * sizeof(char));//alloca是在栈上分配空间，malloc是在堆上分配空间，当遇到char message[length]，而这个length却不是常量的时候可以使用该方法
        glGetShaderInfoLog(id, length, &length, message);
        cout << "FAILED TO COMPILE SHADER !" << endl;
        cout << message << endl;
        glDeleteShader(id);
 
        return 0;
    }

    return id;
}

#define PI 3.1415   

struct Pos {
    float x;
    float y;
};

Pos RotateMatrix(int Angle, float x, float y) {
    float newX = x * cos(Angle * PI / 180) - y * sin(Angle * PI / 180);
    float newY = x * sin(Angle * PI / 180) + y * cos(Angle * PI / 180);

    Pos pos = Pos{ newX, newY };

    return pos;
}

void UpdateValue(float Positions[], int& Angle, unsigned int id, unsigned int Indices[], unsigned int dataId) {
    for (int i = 0; i < 8; i += 2) {
        float tempX = Positions[i];
        float tempY = Positions[i + 1];
        Positions[i] = RotateMatrix(Angle, tempX, tempY).x;
        Positions[i + 1] = RotateMatrix(Angle, tempX, tempY).y;
        //cout << tempX << " / " << tempY << endl;
    }
   
    Angle++;
}

static unsigned int CreateShader(const string& vertexShader, const string& fragmentShader) {
//总结：1、创建program 2、编译shader（1、创建shader 2、编译shader 3、获取着色器资源 4、判断shader是否创建成功） 3、将着色器附着在program对象上 
    //4、与program建立链接 5、验证program 6、删除shader
    unsigned int program = glCreateProgram();
    unsigned int vs = CompileShader(vertexShader, GL_VERTEX_SHADER);
    unsigned int fs = CompileShader(fragmentShader, GL_FRAGMENT_SHADER);

    glAttachShader(program, vs);
    glAttachShader(program, fs);
    glLinkProgram(program);
    glValidateProgram(program);

    glDeleteShader(vs);
    glDeleteShader(fs);

    return program;
}

void outputVertex(float Positions[]) {
    for (int i = 0; i < sizeof(Positions) / sizeof(float); i += 2) {
        cout << Positions[i] << " \ " << Positions[i + 1] << endl;
    }
}

int main(void)
{
    GLFWwindow* window;

    /* Initialize the library */
    if (!glfwInit())
        return -1;

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);//改变OPENGL的版本为3.3

    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    /* Make the window's context current */
    glfwMakeContextCurrent(window);

    glfwSwapInterval(0.5);//屏幕刷新频率，此时为一帧刷新一次

    if (glewInit() != GLEW_OK) {
        cout << "ERROR" << endl;
    }

    float Positions[12] = {
        -0.5f, -0.5f,
        0.5f, 0.5f,
        0.5, -0.5f,
        -0.5, 0.5,
    };

    unsigned int Indices[] = {
        0, 1, 2,
        0, 1, 3
    };

    unsigned int vao;
    glGenVertexArrays(1, &vao);//第一个参数是要生成顶点数组的数量，第二个参数为生成的顶点数组
    glBindVertexArray(vao);

    unsigned int a;
    glGenBuffers(1, &a);//第一个参数代表生成缓冲区的数量，第二个为指定对象来生成缓冲区
    //当生成多个缓冲区时: 
    //unsigned int b[3];
    //glGenBuffers(3, b);
    //cout << a << endl;
    //for (int i = 0; i < 3; i++) {
    //    cout << b[i] << endl;
    //}
    glBindBuffer(GL_ARRAY_BUFFER, a);//定义缓冲区类型
    glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(float), Positions, GL_STATIC_DRAW);//绑定完毕就要开始存放顶点数据了
    glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);//设置顶点属性，第一个参数为从第几个属性开始取值，很明显从第一个数组0号位
    //第二个参数时代表一个顶点需要几个值，比如二维需要两个float才能组成一个顶点的位置，当然顶点不只是位置信息，第三个参数为描述顶点位置的属性
    //第四个参数代表是否将属性进行归一化，这里我们不需要，第五个参数代表一个顶点所占的字节数，第六个参数代表字节偏移量

    unsigned int ibo;
    glGenBuffers(1, &ibo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);//定义缓冲区类型
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6 * sizeof(unsigned int), Indices, GL_STATIC_DRAW);//绑定完毕就要开始存放顶点数据了
    glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);

    ShaderProgramSource source = ParseShader("Shader.shader");
    cout << "Fragment: " << endl;
    cout << source.FragmentSource << endl;
    cout << "Vertex: " << endl;
    cout << source.VertexSource << endl;

    string vertexShader = source.VertexSource;//在这里定义顶点着色器的着色信息
    string fragmentShader = source.FragmentSource;//在这里定义片段着色器的着色信息

    unsigned int shader = CreateShader(vertexShader, fragmentShader);//通过创建好的着色器创建program
    glUseProgram(shader);//使用刚创建的program

    int location = glGetUniformLocation(shader, "u_Color");
    glUniform4f(location, 0.2, 0.4, 0.3, 1);

    glBindVertexArray(0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);//定义缓冲区类型
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glUseProgram(0);//使用刚创建的program

    float r = 0.2;
    float increment = 0.01;
    int Angle = 0;
    /* Loop until the user closes the window */
    while (!glfwWindowShouldClose(window))
    {   
        /* Render here */   
        glClear(GL_COLOR_BUFFER_BIT);

        glUniform4f(location, 0.2, 0.4, 0.3, 1);
        //glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);//定义缓冲区类型
        glBindVertexArray(vao);
        glBindBuffer(GL_ARRAY_BUFFER, a);
        glBufferData(GL_ARRAY_BUFFER, 8 * sizeof(float), Positions, GL_STATIC_DRAW);//绑定完毕就要开始存放顶点数据了
        glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
        glUseProgram(shader);//使用刚创建的program
        glUniform4f(location, r, 0.4, 0.3, 1);

        if (r < 0)   increment = 0.01;
        else if (r > 1)  increment = -0.01;
        r += increment;

        UpdateValue(Positions, Angle, ibo, Indices, a);

        outputVertex(Positions);
        /*glBegin(GL_TRIANGLES);
        glVertex2f(-0.5, -0.5f);
        glVertex2f(0.5, 0.5f);
        glVertex2f(0.5, -0.5f);
        glColor3f(1, 0, 0);
        glEnd();*/

        GLCALL(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr));
        /*glDrawArrays(GL_TRIANGLES, 0, 6);*///画好了三角形，但是苦于没有shader，所以不显示
        //glColor3f(1.f, 0, 0);X

        
        /* Swap front and back buffers */
        glfwSwapBuffers(window);

        /* Poll for and process events */
        glfwPollEvents();
    }

    glDeleteProgram(shader);
    glfwTerminate();
    return 0;
}

分类管理：

IndexBuffer: 

#pragma once

class IndexBuffer {
private:
	unsigned int m_RendererID;
	unsigned int m_Count;

public:
	IndexBuffer(const unsigned int* data, unsigned int count);
	~IndexBuffer();

	void Bind() const;
	void UnBind() const;

	inline unsigned int GetCount() const { return m_Count; }
};
#include "IndexBuffer.h"
#include "Renderer.h"

IndexBuffer::IndexBuffer(const unsigned int* data, unsigned int count) : m_Count(count) {
	glGenBuffers(1, &m_RendererID);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_RendererID);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, count * sizeof(unsigned int), data, GL_STATIC_DRAW);
}

IndexBuffer::~IndexBuffer() {
	glDeleteBuffers(1, &m_RendererID);
}

void IndexBuffer::Bind() const {
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_RendererID);
}

void IndexBuffer::UnBind() const {
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}

VertexBuffer:

#pragma once

class VertexBuffer {
private:
	unsigned int m_RendererID;

public: 
	VertexBuffer(const void* data, unsigned int size);
	~VertexBuffer();

	void Bind();
	void UnBind();
};
#include "VertexBuffer.h"
#include "Renderer.h"

VertexBuffer::VertexBuffer(const void* data, unsigned int size) {
	glGenBuffers(1, &m_RendererID);
	glBindBuffer(GL_ARRAY_BUFFER, m_RendererID);
	glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW);
}

VertexBuffer::~VertexBuffer() {
	glDeleteBuffers(1, &m_RendererID);
}

void VertexBuffer::Bind() {
	glBindBuffer(GL_ARRAY_BUFFER, m_RendererID);
}

void VertexBuffer::UnBind() {
	glBindBuffer(GL_ARRAY_BUFFER, 0);
}

Renderer:

#pragma once

#include <GL/glew.h>
#include <GLFW/glfw3.h>

#define ASSERT(x) if(!x) __debugbreak();
#define GLCALL(x) GLClearError();\
x;\
ASSERT(GLLogCall(#x, __FILE__, __LINE__))

using namespace std;

void GLClearError();

bool GLLogCall(const char* function, const char* file, int line);
#include "Renderer.h"

#include "iostream"

using namespace std;

void GLClearError() {
    while (glGetError() != GL_NO_ERROR);
}

bool GLLogCall(const char* function, const char* file, int line) {
    while (GLenum Enum = glGetError()) {
        cout << "OpenGL Error: ( " << Enum << " )" << " Function Name : " << function << " File : " << file << " Line : " << line << endl;
        return false;
    }

    return true;
}

使用：很清晰能够看清使用更加舒服简化了

VertexBuffer vb(Positions, 8 * sizeof(float));
IndexBuffer ib(Indices, 8 * sizeof(unsigned int));
while (!glfwWindowShouldClose(window))
        {
            /* Render here */
            glClear(GL_COLOR_BUFFER_BIT);

            glUniform4f(location, 0.2, 0.4, 0.3, 1);
            //glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);//定义缓冲区类型
            glBindVertexArray(vao);
            ib.Bind();
            glBufferData(GL_ARRAY_BUFFER, 8 * sizeof(float), Positions,吧GL_STATIC_DRAW);//绑定完毕就要开始存放顶点数据了
            glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
            glUseProgram(shader);//使用刚创建的program
            glUniform4f(location, r, 0.4, 0.3, 1);

            if (r < 0)   increment = 0.01;
            else if (r > 1)  increment = -0.01;
            r += increment;

            //UpdateValue(Positions, Angle, ibo, Indices, a);

            outputVertex(Positions);
            /*glBegin(GL_TRIANGLES);
            glVertex2f(-0.5, -0.5f);
            glVertex2f(0.5, 0.5f);
            glVertex2f(0.5, -0.5f);
            glColor3f(1, 0, 0);
            glEnd();*/

            GLCALL(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr));
            /*glDrawArrays(GL_TRIANGLES, 0, 6);*///画好了三角形，但是苦于没有shader，所以不显示
            //glColor3f(1.f, 0, 0);X


            /* Swap front and back buffers */
            glfwSwapBuffers(window);

            /* Poll for and process events */
            glfwPollEvents();
        }

所有代码：

#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include "iostream"
#include "math.h"
#include "fstream"
#include "string"
#include "sstream"

#include "Renderer.h"

#include "VertexBuffer.h"
#include "IndexBuffer.h"

#include "iostream"

using namespace std;

struct ShaderProgramSource {
    string VertexSource;
    string FragmentSource;
};

static ShaderProgramSource ParseShader(const string& filepath) {
    ifstream stream(filepath);

    enum class ShaderType {
        NONE = -1, VERTEX = 0, FRAGMENT = 1
    };

    string line;
    stringstream ss[2];
    ShaderType type = ShaderType::NONE;
    while (getline(stream, line)) {
        if (line.find("#shader") != string::npos) {
            if (line.find("vertex") != string::npos) {
                type = ShaderType::VERTEX;
            }
            else if(line.find("fragment") != string::npos) {
                type = ShaderType::FRAGMENT;
            }
        }
        else {
            ss[(int)type] << line << "\n";
        }
    }

    return ShaderProgramSource{ ss[0].str(), ss[1].str() };
}

static unsigned int CompileShader(const string& source, unsigned int type) {
    unsigned int id = glCreateShader(type);
    const char* src = source.c_str();
    glShaderSource(id, 1, &src, nullptr);
    glCompileShader(id);

    int result;
    glGetShaderiv(id, GL_COMPILE_STATUS, &result);
    if (result == GL_FALSE) {
        int length;
        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length);
        char* message = (char*)alloca(length * sizeof(char));//alloca是在栈上分配空间，malloc是在堆上分配空间，当遇到char message[length]，而这个length却不是常量的时候可以使用该方法
        glGetShaderInfoLog(id, length, &length, message);
        cout << "FAILED TO COMPILE SHADER !" << endl;
        cout << message << endl;
        glDeleteShader(id);
 
        return 0;
    }

    return id;
}

#define PI 3.1415   

struct Pos {
    float x;
    float y;
};

Pos RotateMatrix(int Angle, float x, float y) {
    float newX = x * cos(Angle * PI / 180) - y * sin(Angle * PI / 180);
    float newY = x * sin(Angle * PI / 180) + y * cos(Angle * PI / 180);

    Pos pos = Pos{ newX, newY };

    return pos;
}

void UpdateValue(float Positions[], int& Angle, unsigned int id, unsigned int Indices[], unsigned int dataId) {
    for (int i = 0; i < 8; i += 2) {
        float tempX = Positions[i];
        float tempY = Positions[i + 1];
        Positions[i] = RotateMatrix(Angle, tempX, tempY).x;
        Positions[i + 1] = RotateMatrix(Angle, tempX, tempY).y;
        //cout << tempX << " / " << tempY << endl;
    }
   
    Angle++;
}

static unsigned int CreateShader(const string& vertexShader, const string& fragmentShader) {
//总结：1、创建program 2、编译shader（1、创建shader 2、编译shader 3、获取着色器资源 4、判断shader是否创建成功） 3、将着色器附着在program对象上 
    //4、与program建立链接 5、验证program 6、删除shader
    unsigned int program = glCreateProgram();
    unsigned int vs = CompileShader(vertexShader, GL_VERTEX_SHADER);
    unsigned int fs = CompileShader(fragmentShader, GL_FRAGMENT_SHADER);

    glAttachShader(program, vs);
    glAttachShader(program, fs);
    glLinkProgram(program);
    glValidateProgram(program);

    glDeleteShader(vs);
    glDeleteShader(fs);

    return program;
}

void outputVertex(float Positions[]) {
    for (int i = 0; i < sizeof(Positions) / sizeof(float); i += 2) {
        cout << Positions[i] << " \ " << Positions[i + 1] << endl;
    }
}

int main(void)
{
    GLFWwindow* window;

    /* Initialize the library */
    if (!glfwInit())
        return -1;

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);//改变OPENGL的版本为3.3

    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    /* Make the window's context current */
    glfwMakeContextCurrent(window);

    glfwSwapInterval(0.5);//屏幕刷新频率，此时为一帧刷新一次

    if (glewInit() != GLEW_OK) {
        cout << "ERROR" << endl;
    }

    {
        float Positions[12] = {
            -0.5f, -0.5f,
            0.5f, 0.5f,
            0.5, -0.5f,
            -0.5, 0.5,
        };

        unsigned int Indices[] = {
            0, 1, 2,
            0, 1, 3
        };

        unsigned int vao;
        glGenVertexArrays(1, &vao);//第一个参数是要生成顶点数组的数量，第二个参数为生成的顶点数组
        glBindVertexArray(vao);

        VertexBuffer vb(Positions, 8 * sizeof(float));
        glEnableVertexAttribArray(0);//启用第一组顶点属性数组，0代表数组下标为0
        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);//设置顶点属性，第一个参数为从第几个属性开始取值，很明显从第一个数组0号位
 

        IndexBuffer ib(Indices, 8 * sizeof(unsigned int));

        ShaderProgramSource source = ParseShader("Shader.shader");
        cout << "Fragment: " << endl;
        cout << source.FragmentSource << endl;
        cout << "Vertex: " << endl;
        cout << source.VertexSource << endl;

        string vertexShader = source.VertexSource;//在这里定义顶点着色器的着色信息
        string fragmentShader = source.FragmentSource;//在这里定义片段着色器的着色信息

        unsigned int shader = CreateShader(vertexShader, fragmentShader);//通过创建好的着色器创建program
        //glUseProgram(shader);//使用刚创建的program

        int location = glGetUniformLocation(shader, "u_Color");
        glUniform4f(location, 0.2, 0.4, 0.3, 1);

        glBindVertexArray(0);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);//定义缓冲区类型
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glUseProgram(0);//使用刚创建的program

        float r = 0.2;
        float increment = 0.01;
        int Angle = 0;
        /* Loop until the user closes the window */
        while (!glfwWindowShouldClose(window))
        {
            /* Render here */
            glClear(GL_COLOR_BUFFER_BIT);

            glUniform4f(location, 0.2, 0.4, 0.3, 1);
            glBindVertexArray(vao);
            ib.Bind();
            glUseProgram(shader);//使用刚创建的program
            glUniform4f(location, r, 0.4, 0.3, 1);

            if (r < 0)   increment = 0.01;
            else if (r > 1)  increment = -0.01;
            r += increment;

            //UpdateValue(Positions, Angle, ibo, Indices, a);

            outputVertex(Positions);

            GLCALL(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr));

            /* Swap front and back buffers */
            glfwSwapBuffers(window);

            /* Poll for and process events */
            glfwPollEvents();
        }

        glDeleteProgram(shader);
    }
    glfwTerminate();
    return 0;
}

因为自己也是初学者，我刚开始看视频没太理解vao与vbo，看了这篇文章讲的比较通透：

(73条消息) 详解Opengl中VBO和VAO_代码乐的博客-CSDN博客_vbo vao

将VertexArray封装成类：

IndexBuffer:

#pragma once

class IndexBuffer {
private:
	unsigned int m_RendererID;
	unsigned int m_Count;

public:
	IndexBuffer(const unsigned int* data, unsigned int count);
	~IndexBuffer();

	void Bind() const;
	void UnBind() const;

	inline unsigned int GetCount() const { return m_Count; }
};
#include "IndexBuffer.h"
#include "Renderer.h"

IndexBuffer::IndexBuffer(const unsigned int* data, unsigned int count) : m_Count(count) {
	glGenBuffers(1, &m_RendererID);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_RendererID);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, count * sizeof(unsigned int), data, GL_STATIC_DRAW);
}

IndexBuffer::~IndexBuffer() {
	glDeleteBuffers(1, &m_RendererID);
}

void IndexBuffer::Bind() const {
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_RendererID);
}

void IndexBuffer::UnBind() const {
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}

Renderer：

#pragma once

#include <GL/glew.h>
#include <GLFW/glfw3.h>

#define ASSERT(x) if(!x) __debugbreak();
#define GLCALL(x) GLClearError();\
x;\
ASSERT(GLLogCall(#x, __FILE__, __LINE__))

using namespace std;

void GLClearError();

bool GLLogCall(const char* function, const char* file, int line);
#include "Renderer.h"

#include "iostream"

using namespace std;

void GLClearError() {
    while (glGetError() != GL_NO_ERROR);
}

bool GLLogCall(const char* function, const char* file, int line) {
    while (GLenum Enum = glGetError()) {
        cout << "OpenGL Error: ( " << Enum << " )" << " Function Name : " << function << " File : " << file << " Line : " << line << endl;
        return false;
    }

    return true;
}

VertexArray:

#pragma once

#include "VertexBuffer.h"
#include "VertexBufferLayout.h"

class VertexArray {
private:
	unsigned int m_RendererID;
public:
	VertexArray();
	~VertexArray();

	void Bind() const;
	void UnBind() const;

	void AddBuffer(const VertexBuffer& vb, const VertexBufferLayout& layout);
};
#include "VertexArray.h"
#include "VertexBufferLayout.h"

VertexArray::VertexArray() {
	glGenVertexArrays(1, &m_RendererID);//第一个参数是要生成顶点数组的数量，第二个参数为生成的顶点数组
	glBindVertexArray(m_RendererID);
}

VertexArray::~VertexArray() {
	glDeleteVertexArrays(1, &m_RendererID);
}

void VertexArray::AddBuffer(const VertexBuffer& vb, const VertexBufferLayout& layout) {
	vb.Bind();
	const auto& elements = layout.GetElement();
	unsigned int offset = 0;
	for (unsigned int i = 0; i < elements.size(); i++) {
		const auto& element = elements[i];
		glEnableVertexAttribArray(i);//启用第一组顶点属性数组，0代表数组下标为0
		glVertexAttribPointer(i, element.count, element.type, element.normalized, layout.GetStride(), (const void*)offset);//设置顶点属性，第一个参数为从第几个属性开始取值，很明显从第一个数组0号位
		offset += element.count * VertexBufferElements::GetSizeOfType(element.type);
	}
	  
}

void VertexArray::Bind() const {
	glBindVertexArray(m_RendererID);
}

void VertexArray::UnBind() const {
	glBindVertexArray(0);
}

VertexBuffer:

#pragma once

class VertexBuffer {
private:
	unsigned int m_RendererID;
public: 
	VertexBuffer(const void* data, unsigned int size);
	~VertexBuffer();

	void Bind() const;
	void UnBind();
};
#include "VertexBuffer.h"
#include "Renderer.h"

VertexBuffer::VertexBuffer(const void* data, unsigned int size) {
	glGenBuffers(1, &m_RendererID);
	glBindBuffer(GL_ARRAY_BUFFER, m_RendererID);
	glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW);
}

VertexBuffer::~VertexBuffer() {
	glDeleteBuffers(1, &m_RendererID);
}

void VertexBuffer::Bind() const {
	glBindBuffer(GL_ARRAY_BUFFER, m_RendererID);
}

void VertexBuffer::UnBind() {
	glBindBuffer(GL_ARRAY_BUFFER, 0);
}

VertexBufferLayout:

#pragma once

#include "vector"
#include "Renderer.h"
#include "GL/glew.h"

struct VertexBufferElements {
	unsigned int type;
	unsigned int count;
	unsigned char normalized;

	static unsigned int GetSizeOfType(unsigned int type) {
		switch (type) {
			case GL_FLOAT:	return 4;
			case GL_UNSIGNED_INT: return 4;
			case GL_UNSIGNED_BYTE: return 1;
		}
		ASSERT(false);
		return 0;
	}
};

class VertexBufferLayout {
private:

	std::vector<VertexBufferElements> m_Elements;
	unsigned int m_Stride;

public:

	VertexBufferLayout() : m_Stride(0) {};

	template<typename T>
	void Push(unsigned int count) {
		static_assert(false);
	}

	template<>
	void Push<float>(unsigned int count) {
		m_Elements.push_back(VertexBufferElements{ GL_FLOAT, count, GL_FALSE });
		m_Stride += count * VertexBufferElements::GetSizeOfType(GL_FLOAT);
	}

	template<>
	void Push<unsigned int>(unsigned int count) {
		m_Elements.push_back(VertexBufferElements{ GL_UNSIGNED_INT, count, GL_FALSE });
		m_Stride += count * VertexBufferElements::GetSizeOfType(GL_UNSIGNED_INT);
	}

	template<>
	void Push<unsigned char>(unsigned int count) {
		m_Elements.push_back(VertexBufferElements{ GL_UNSIGNED_BYTE, count, GL_TRUE });
		m_Stride += count * VertexBufferElements::GetSizeOfType(GL_UNSIGNED_BYTE);
	}

	inline std::vector<VertexBufferElements> GetElement() const { return m_Elements; }
	inline unsigned int GetStride() const { return m_Stride; }
};

Application:

#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include "iostream"
#include "math.h"
#include "fstream"
#include "string"
#include "sstream"

#include "Renderer.h"

#include "VertexBuffer.h"
#include "IndexBuffer.h"
#include "VertexArray.h"

#include "iostream"

using namespace std;

struct ShaderProgramSource {
    string VertexSource;
    string FragmentSource;
};

static ShaderProgramSource ParseShader(const string& filepath) {
    ifstream stream(filepath);

    enum class ShaderType {
        NONE = -1, VERTEX = 0, FRAGMENT = 1
    };

    string line;
    stringstream ss[2];
    ShaderType type = ShaderType::NONE;
    while (getline(stream, line)) {
        if (line.find("#shader") != string::npos) {
            if (line.find("vertex") != string::npos) {
                type = ShaderType::VERTEX;
            }
            else if(line.find("fragment") != string::npos) {
                type = ShaderType::FRAGMENT;
            }
        }
        else {
            ss[(int)type] << line << "\n";
        }
    }

    return ShaderProgramSource{ ss[0].str(), ss[1].str() };
}

static unsigned int CompileShader(const string& source, unsigned int type) {
    unsigned int id = glCreateShader(type);
    const char* src = source.c_str();
    glShaderSource(id, 1, &src, nullptr);
    glCompileShader(id);

    int result;
    glGetShaderiv(id, GL_COMPILE_STATUS, &result);
    if (result == GL_FALSE) {
        int length;
        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length);
        char* message = (char*)alloca(length * sizeof(char));//alloca是在栈上分配空间，malloc是在堆上分配空间，当遇到char message[length]，而这个length却不是常量的时候可以使用该方法
        glGetShaderInfoLog(id, length, &length, message);
        cout << "FAILED TO COMPILE SHADER !" << endl;
        cout << message << endl;
        glDeleteShader(id);
 
        return 0;
    }

    return id;
}

#define PI 3.1415   

struct Pos {
    float x;
    float y;
};

Pos RotateMatrix(int Angle, float x, float y) {
    float newX = x * cos(Angle * PI / 180) - y * sin(Angle * PI / 180);
    float newY = x * sin(Angle * PI / 180) + y * cos(Angle * PI / 180);

    Pos pos = Pos{ newX, newY };

    return pos;
}

void UpdateValue(float Positions[], int& Angle, unsigned int id, unsigned int Indices[], unsigned int dataId) {
    for (int i = 0; i < 8; i += 2) {
        float tempX = Positions[i];
        float tempY = Positions[i + 1];
        Positions[i] = RotateMatrix(Angle, tempX, tempY).x;
        Positions[i + 1] = RotateMatrix(Angle, tempX, tempY).y;
        //cout << tempX << " / " << tempY << endl;
    }
   
    Angle++;
}

static unsigned int CreateShader(const string& vertexShader, const string& fragmentShader) {
//总结：1、创建program 2、编译shader（1、创建shader 2、编译shader 3、获取着色器资源 4、判断shader是否创建成功） 3、将着色器附着在program对象上 
    //4、与program建立链接 5、验证program 6、删除shader
    unsigned int program = glCreateProgram();
    unsigned int vs = CompileShader(vertexShader, GL_VERTEX_SHADER);
    unsigned int fs = CompileShader(fragmentShader, GL_FRAGMENT_SHADER);

    glAttachShader(program, vs);
    glAttachShader(program, fs);
    glLinkProgram(program);
    glValidateProgram(program);

    glDeleteShader(vs);
    glDeleteShader(fs);

    return program;
}

void outputVertex(float Positions[]) {
    for (int i = 0; i < sizeof(Positions) / sizeof(float); i += 2) {
        cout << Positions[i] << " \ " << Positions[i + 1] << endl;
    }
}

int main(void)
{
    GLFWwindow* window;

    /* Initialize the library */
    if (!glfwInit())
        return -1;

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);//改变OPENGL的版本为3.3

    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    /* Make the window's context current */
    glfwMakeContextCurrent(window);

    glfwSwapInterval(0.5);//屏幕刷新频率，此时为一帧刷新一次

    if (glewInit() != GLEW_OK) {
        cout << "ERROR" << endl;
    }

    {
        float Positions[12] = {
            -0.5f, -0.5f,
            0.5f, 0.5f,
            0.5, -0.5f,
            -0.5, 0.5,
        };

        unsigned int Indices[] = {
            0, 1, 2,
            0, 1, 3
        };

        VertexArray va;//这里把vao给声明好，并绑定好
        VertexBuffer vb(Positions, 8 * sizeof(float));//这里把顶点缓冲的数据也准备好了
        VertexBufferLayout layout;//声明顶点样式
        layout.Push<float>(2);//定义顶点样式，例如一个值组成一个顶点，从第几个顶点开始读，这里传进去的是2，证明两个浮点值组成一个顶点
        va.AddBuffer(vb, layout);//将layout数据进行处理并将vb进行绑定

        IndexBuffer ib(Indices, 8 * sizeof(unsigned int));

        ShaderProgramSource source = ParseShader("Shader.shader");
        cout << "Fragment: " << endl;
        cout << source.FragmentSource << endl;
        cout << "Vertex: " << endl;
        cout << source.VertexSource << endl;

        string vertexShader = source.VertexSource;//在这里定义顶点着色器的着色信息
        string fragmentShader = source.FragmentSource;//在这里定义片段着色器的着色信息

        unsigned int shader = CreateShader(vertexShader, fragmentShader);//通过创建好的着色器创建program
        glUseProgram(shader);//使用刚创建的program

        int location = glGetUniformLocation(shader, "u_Color");
        glUniform4f(location, 0.2, 0.4, 0.3, 1);

        glBindVertexArray(0);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);//定义缓冲区类型
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glUseProgram(0);//使用刚创建的program

        float r = 0.2;
        float increment = 0.01;
        int Angle = 0;
        /* Loop until the user closes the window */
        while (!glfwWindowShouldClose(window))
        {
            /* Render here */
            glClear(GL_COLOR_BUFFER_BIT);

            glUseProgram(shader);//使用刚创建的program
            glUniform4f(location, 0.2, 0.4, r, 1);

            va.Bind();
            ib.Bind();

            if (r < 0)   increment = 0.01;
            else if (r > 1)  increment = -0.01;
            r += increment;

            //UpdateValue(Positions, Angle, ibo, Indices, a);

            //outputVertex(Positions);

            GLCALL(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr));

            /* Swap front and back buffers */
            glfwSwapBuffers(window);

            /* Poll for and process events */
            glfwPollEvents();
        }

        glDeleteProgram(shader);
    }
    glfwTerminate();
    return 0;
}

将shader再一次进行封装处理：

#pragma once
#include "string"
#include "unordered_map"

using namespace std;

struct ShaderProgramSource {
	string VertexSource;
	string FragmentSource;
};

class Shader {

public:
	Shader(const string& filepath);
	~Shader();

	void Bind() const;
	void UnBind() const;

	//Set Uniforms
	void SetUniform4f(const string& name, float v0, float v1, float v2, float v3);

private:
	unsigned int m_RendererID;
	string m_FilePath;
	unordered_map<string, int> m_UniformLocationCache;

private:
	unsigned int CompileShader(const string& source, unsigned int type);
	int CreateShader(const string& vertexShader, const string& fragmentShader);
	ShaderProgramSource ParseShader(const string& filepath);
	int GetUniformLocation(const string& name);

};
#include "Shader.h"
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include "iostream"
#include "sstream"
#include "fstream"


Shader::Shader(const string& filepath) : m_FilePath(filepath), m_RendererID(0) {
	//CompileShader();
    ShaderProgramSource source = ParseShader(m_FilePath);
    m_RendererID = CreateShader(source.VertexSource, source.FragmentSource);//通过创建好的着色器创建program
}

Shader::~Shader() {
    glDeleteProgram(m_RendererID);
}

void Shader::Bind() const{
    glUseProgram(m_RendererID);
}

void Shader::UnBind() const {
    glUseProgram(0);
}

void Shader::SetUniform4f(const string& name, float v0, float v1, float v2, float v3) {
    glUniform4f(GetUniformLocation(name), v0, v1, v2, v3);
}

int Shader::GetUniformLocation(const string& name) {
    if (m_UniformLocationCache.find(name) != m_UniformLocationCache.end())   return m_UniformLocationCache[name];
    int location = glGetUniformLocation(m_RendererID, name.c_str());
    if (location == -1)  cout << "Warning: uniform '" << name << "' doesn't exist!" << endl;
    return location;
}

int Shader::CreateShader(const string& vertexShader, const string& fragmentShader) {
    //总结：1、创建program 2、编译shader（1、创建shader 2、编译shader 3、获取着色器资源 4、判断shader是否创建成功） 3、将着色器附着在program对象上 
        //4、与program建立链接 5、验证program 6、删除shader
    unsigned int program = glCreateProgram();
    unsigned int vs = CompileShader(vertexShader, GL_VERTEX_SHADER);
    unsigned int fs = CompileShader(fragmentShader, GL_FRAGMENT_SHADER);

    glAttachShader(program, vs);
    glAttachShader(program, fs);
    glLinkProgram(program);
    glValidateProgram(program);

    glDeleteShader(vs);
    glDeleteShader(fs);

    return program;
}

ShaderProgramSource Shader::ParseShader(const string& filepath) {
    ifstream stream(filepath);

    enum class ShaderType {
        NONE = -1, VERTEX = 0, FRAGMENT = 1
    };

    string line;
    stringstream ss[2];
    ShaderType type = ShaderType::NONE;
    while (getline(stream, line)) {
        if (line.find("#shader") != string::npos) {
            if (line.find("vertex") != string::npos) {
                type = ShaderType::VERTEX;
            }
            else if (line.find("fragment") != string::npos) {
                type = ShaderType::FRAGMENT;
            }
        }
        else {
            ss[(int)type] << line << "\n";
        }
    }

    return ShaderProgramSource{ ss[0].str(), ss[1].str() };
}

unsigned int Shader::CompileShader(const string& source, unsigned int type) {
    unsigned int id = glCreateShader(type);
    const char* src = source.c_str();
    glShaderSource(id, 1, &src, nullptr);
    glCompileShader(id);

    int result;
    glGetShaderiv(id, GL_COMPILE_STATUS, &result);
    if (result == GL_FALSE) {
        int length;
        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length);
        char* message = (char*)alloca(length * sizeof(char));//alloca是在栈上分配空间，malloc是在堆上分配空间，当遇到char message[length]，而这个length却不是常量的时候可以使用该方法
        glGetShaderInfoLog(id, length, &length, message);
        cout << "FAILED TO COMPILE SHADER !" << endl;
        cout << message << endl;
        glDeleteShader(id);

        return 0;
    }

    return id;
}

将绘制进行封装：

#pragma once

#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include "VertexArray.h"
#include "VertexBuffer.h"
#include "IndexBuffer.h"
#include "Shader.h"

#define ASSERT(x) if(!x) __debugbreak();
#define GLCALL(x) GLClearError();\
x;\
ASSERT(GLLogCall(#x, __FILE__, __LINE__))

using namespace std;

void GLClearError();

bool GLLogCall(const char* function, const char* file, int line);

class Renderer {
public:
	void GLDrawCall(const VertexArray& va, const IndexBuffer& ib, const Shader& shader) const;

	void GLClear() const;
};
#include "Renderer.h"

#include "iostream"

using namespace std;

void GLClearError() {
    while (glGetError() != GL_NO_ERROR);
}

bool GLLogCall(const char* function, const char* file, int line) {
    while (GLenum Enum = glGetError()) {
        cout << "OpenGL Error: ( " << Enum << " )" << " Function Name : " << function << " File : " << file << " Line : " << line << endl;
        return false;
    }

    return true;
}

void Renderer::GLDrawCall(const VertexArray& va, const IndexBuffer& ib, const Shader& shader) const {
    va.Bind();
    ib.Bind();
    shader.Bind();
    GLCALL(glDrawElements(GL_TRIANGLES, ib.GetCount(), GL_UNSIGNED_INT, nullptr));
}

void Renderer::GLClear() const {
    glClear(GL_COLOR_BUFFER_BIT);
}
 Renderer renderer;
        float r = 0.2;
        float increment = 0.01;
        int Angle = 0;
        /* Loop until the user closes the window */
        while (!glfwWindowShouldClose(window))
        {
            /* Render here */
            renderer.GLClear();
            
           //shader.Bind();//使用刚创建的program
            renderer.GLDrawCall(va, ib, shader);
            shader.SetUniform4f("u_Color", 0.2, 0.4, r, 1);

            //va.Bind();
           // ib.Bind();

            if (r < 0)   increment = 0.01;
            else if (r > 1)  increment = -0.01;
            r += increment;

            //UpdateValue(Positions, Angle, ibo, Indices, a);

            //outputVertex(Positions);

            GLCALL(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr));

            /* Swap front and back buffers */
            glfwSwapBuffers(window);

            /* Poll for and process events */
            glfwPollEvents();
        }

远离UE4
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【OpenGL手册】GLFW窗口指南
gongdiwudu的专栏
05-13 1462
​ 指南介绍GLFW的窗口相关功能。有关此类别中特定功能的详细信息，请参阅窗口参考。还有 GLFW 其他领域的指南。
OpenGL学习笔记：2、OpenGL简介
weixin_44546625的博客
11-02 1649
OpenGL（全称：Open Graphics Library，译名：开放图形库或者“开放式图形库”）是用于渲染2D、3D矢量图形的跨语言、跨平台的一种应用程序编程接口（API）。一种可以对图形硬件设备特性进行访问的软件库，也就是一种是个专业的图形程序接口，是一个功能强大，调用方便的底层图形库。包含了超过500个不同函数调用，可以用于设置所需对象、图像、操作。总的来说，OpenGL就是一个开放的图形应用编程接口，有一堆函数组成，以实现对于图形应用程序的开发。
Qt+OpenGL学习笔记-绘制三角形
zaomengze的博客
07-16 974
OpenGL中任何事物都在3D空间中（即X，Y，Z轴），但是屏幕和窗口都是2D像素数组，导致OpenGL大部分工作是将3D坐标转变为适应你屏幕的2D像素，3D坐标转为2D坐标的处理过程是由OpenGL的图形渲染管线（Graphics Pipeline，大多译为管线，实际上指的是一堆原始图形数据途经一个输送管道，期间经过各种变化处理最终出现在屏幕的过程）管理的。图形渲染管线可以被划分为两个主要部分：第一部分把你的，第二部分是把。
OpenGL/C++_学习笔记（三）绘制第一个图形
CJL_asLong72的博客
01-22 1117
汇总页 上一篇: OpenGL/C++_学习笔记（二） 引入图形渲染相关概念复习第一节的gl在代码中的初始化流程 窗口空间/标准化设备坐标 标准化设备坐标是一个x、y和z值在-1.0到1.0的一小段空间。任何落在范围外的坐标都会被丢弃/裁剪，不会显示在你的屏幕上。下面你会看到我们定义的在标准化设备坐标中的三角形(忽略z轴)： 显存不能直接被 OpenGL 应用程序在 cpu 通过内存地址进行访问, 因此衍生出各种以gl库为中间人, 借由gl库函数(api/程序接口)对进行发令控制和交付数据, 间接管理存储对
OpenGL学习笔记 —— 绘制大体流程
qq_43924934的博客
10-17 89
什么是GLFW？GLFW是一款轻量级、开源的c语言库，它提供了跨平台的窗口管理和输入处理功能，支持多个OpenGL版本和扩展。首先我们使用glfwInit 函数初始化GLFW在初始化时我们需要设置OpenGL上下文的主版本号：使用glfwInitHint(GLFW_CONTEXT_VERSION_MAJOR, 4)函数：这里参数的意思是希望使用主版本为4的OpenGL上下文使用glfwWindowHint函数来配置glfw：这个函数的作用是用于设置窗口创建时的各种题实参数，以便GLFW在创建窗口是可以进行适
OpenGl学习笔记一：创建窗口&绘制三角形
Duoteng Xu
08-19 451
在OpenGL中，任何事物都在3D空间中，而屏幕和窗口却是2D像素数组，3D坐标转为2D坐标的处理过程是由OpenGL的图形渲染管线（一堆原始图形数据途经一个输送管道，期间经过各种变化处理最终出现在屏幕的过程）管理的。几何着色器的输出会被传入光栅化阶段(Rasterization Stage)，这里它会把图元映射为最终屏幕上相应的像素，生成供片段着色器(Fragment Shader)使用的片段(Fragment)。片段着色器的主要目的是计算一个像素的最终颜色，这也是所有OpenGL高级效果产生的地方。
OpenGL学习笔记【4】——创建窗口，给窗口添加渲染颜色
奋斗的菇凉的博客
03-21 962
章节一讲述了OpenGL在渲染的时候需要一个Context来记录了OpenGL渲染需要的所有信息和状态，可以把上下文理解成一个大的结构体，它里面记录了当前绘制使用的颜色、是否有光照计算以及开启的光源等。不同的操作系统，都有各自的上下文创建方法，最简单的上下文可以通过创建。章节二讲述了一个一个轻量级的图形界面框架，GLFW 的是提供了处理手柄、键盘、鼠标输入章节二还创建了一个空项目章节三讲述了GLAD库是用来管理OpenGL的函数指针的，所以在调用任何OpenGL的函数之前我们需要，从而让我们。
OpenGL学习笔记【1】——简介
奋斗的菇凉的博客
03-19 1187
OpenGL (Open Graphics Library，译名：开放式图形库) 是一种用于渲染 2D 和 3D 图形的跨语言、跨平台的编程接口(API)。OpenGL 是一个 C 语言库，因此理解 C 语言（或 C++）的基本知识是非常有用的。然而，许多其他语言也有 OpenGL 的绑定，值得一提的包括：所以你可以选择你最熟悉的语言来学习。
【OpenGL 学习笔记】第 5 篇：绘制球
有朋自远方来，不亦乐乎。
07-07 3327
封装后，在应对存在对个着色器程序的渲染流程时，可以更方便使用不同的着色器程序，同时也可以降低代码冗余。 如下，传入参数分别为顶点着色器和片元着色器的路径，在封装了Shader类之后，我们就可以通过一行代码去创建一个新的着色器对象： 假如我们在绘制时需要切换到某个着色器并使用它，我们仅需要一行代码： 假如我们需要向着色器传入一种类型的值，我们也仅需要一行代码去解决它（name是着色器中的名称，value为你希望设置的值）： 2、绘制球模型
OpenGL学习笔记二 开启窗口
weixin_45730255的博客
11-12 564
#include <glad/glad> #include <GLFW/glfw3.h> int main(){ glfwInit();//初始化函数库 glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); //提示使用主版本号为3. glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE,GLFW_OPENGL_CORE_PROFILE
OpenGL学习笔记
10-31
### OpenGL学习笔记知识点详解 #### 一、OpenGL简介与安装准备 OpenGL（Open Graphics Library）是一种用于渲染2D、3D矢量图形的跨语言、跨平台的应用程序编程接口（API）。它被广泛应用于游戏开发、图形软件以及...
code__opengl学习笔记2-绘制矩形
09-24
本学习笔记主要关注如何使用OpenGL绘制矩形，这是一个基础但至关重要的概念，因为几乎所有的图形绘制都可以通过组合基本形状如矩形来实现。 在OpenGL中，没有内置的“绘制矩形”函数。相反，我们通常使用四条直线...
Opengl学习笔记
08-14
### OpenGL学习笔记关键知识点 #### 一、OpenGL坐标系与绘图函数 - **坐标系定义**：在OpenGL中，坐标系定义了三维空间中物体的位置。X坐标轴从左至右，Y坐标轴从下至上，Z坐标轴从观察者的视角由近及远（即从里至...
NeHe OpenGL教程 学习笔记1
04-06
总的来说，NeHe OpenGL教程的学习笔记1主要涵盖了OpenGL环境的初始化、基本几何形状的绘制、颜色设定、视口与投影以及渲染流程的基础概念。通过理解和实践这些基本操作，开发者可以逐步构建更复杂的3D场景。
opengl学习笔记
08-23
本学习笔记旨在帮助初学者掌握OpenGL编程的基础知识，尤其针对坐标变换和图形管线有深入的探讨。 首先，OpenGL图形管线是其核心概念之一，它是从几何形状到屏幕像素的处理流程。管线可以分为几个阶段：顶点着色器、...
C语言——函数
attitude_lu的博客
08-01 755
函数的主要思想是：函数其实是从上到下逐步求解的过程，把一个大的问题拆成多个小的子问题或者说把一个大的功能拆成小的功能模块，通过实现小的功能最终实现大的功能的过程。
【C++】输入输出
2401_83948390的博客
08-02 298
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
【C++】类和对象（中）
最新发布
2302_81149370的博客
08-02 573
✨✨欢迎大家来到Celia的博客✨✨。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值