OpenGL入门007——摄像机

本节将用opengl实现一个Camera类，学习如何在顶点/片段着色器中应用模型/视图/投影矩阵，以及理解坐标变换和渲染流程。

一些概念

坐标转换

关于坐标转换，模型矩阵，视图矩阵，投影矩阵，可以看这篇的概念说明。

欧拉角

偏航角：

• 概述：Yaw是绕世界坐标系的Y轴旋转的角度
• 作用：控制摄像机左右旋转
• 实现：在摄像机类中，Yaw用于计算摄像机的前向量，从而影响摄像机的视图方向

俯仰角：

• 概述：Pitch是绕摄像机自身的X轴旋转的角度
• 作用：控制摄像机上下旋转
• 实现：在摄像机类中，Pitch同样用于计算摄像机的前向量，从而影响摄像机的视图方向

滚转角：

• 概述：Roll是绕摄像机自身的Z轴的角度
• 作用：控制摄像机的左右倾斜
• 实现：在摄像机类中，滚转角用于计算摄像机的右向量，从而影响摄像机的上向量和右向量

实战

简介

怎么在vscode上使用cmake构建项目，具体可以看这篇Windows上如何使用CMake构建项目 - 凌云行者的博客

目的： 实现Camera类

• 编译工具链：使用msys2安装的mingw-gcc
• 依赖项：glfw3:x64-mingw-static，glad:x64-mingw-static（通过vcpkg安装）

dependencies

shader.fs

// 指定OpenGL着色器语言的版本为3.30
#version 330 core
// 输入变量，表示纹理坐标
in vec2 TexCoord;
// 输出变量，表示片段的最终颜色
out vec4 FragColor;
// uniform变量，表示第一个纹理
uniform sampler2D texture0;
// uniform变量，表示第二个纹理
uniform sampler2D texture1;

void main() {
	// 在两个纹理之间进行线性插值
	FragColor = mix(texture(texture0, TexCoord), texture(texture1, TexCoord), 0.2);
}

shader.vs

#version 330 core
layout (location = 0) in vec2 aPos;
layout (location = 1) in vec2 aTex;

out vec2 TexCoord;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main() {
    
    
    gl_Position = projection * view * model * vec4(aPos, 1.0f);
	TexCoord = aTex;
}

teenager.png

tex.png

扫描二维码关注公众号，回复： 17507038 查看本文章

utils

camera.h

#ifndef CAMERA_H
#define CAMERA_H

#include <glad/glad.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>

#include <vector>

// 定义摄像机移动的几种可能选项
enum Camera_Movement {
    
    
    FORWARD, // 向前
    BACKWARD, // 向后
	LEFT, // 向左
    RIGHT, // 向右
    UP, // 向上
    DOWN, // 向下
    ROLL_LEFT, // 左旋转
    ROLL_RIGHT, // 右旋转
    PITCH_UP, // 向上俯仰
    PITCH_DOWN, // 向下俯仰
    YAW_LEFT, // 向左偏航
    YAW_RIGHT, // 向右偏航
};

// 摄像机默认参数
// 偏航角
const float YAW = -90.0f;
// 俯仰角
const float PITCH = 0.0f;
// 滚转角
const float ROLL = 0.0f;
// 移动速度
const float SPEED = 12.5f;
// 鼠标灵敏度
const float SENSITIVITY = 0.1f;
// 缩放
const float ZOOM = 45.0f;

// 摄像机类
class Camera {
    
    
public:
    // 位置
    glm::vec3 Position;
    // 前向量
    glm::vec3 Front;
    // 上向量
    glm::vec3 Up;
    // 右向量
    glm::vec3 Right;
    // 世界上向量
    glm::vec3 WorldUp;
    
    // 偏航角，控制摄像机左右旋转
    float Yaw;
    // 俯仰角，控制摄像机上下旋转
    float Pitch;
    // 滚转角，控制摄像机的左右倾斜
    float Roll;
    
    // 移动速度
    float MovementSpeed;
    // 鼠标灵敏度
    float MouseSensitivity;
    // 缩放
    float Zoom;
    
    // 使用向量的构造函数
    Camera(glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f), float yaw = YAW, float pitch = PITCH, float roll = ROLL) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM) {
    
    
        Position = position;
        WorldUp = up;
        Yaw = yaw;
        Pitch = pitch;
        Roll = roll;
        updateCameraVectors();
    }
    // 使用标量的构造函数
    Camera(float posX, float posY, float posZ, float upX, float upY, float upZ, float yaw, float pitch, float roll = ROLL) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM) {
    
    
        Position = glm::vec3(posX, posY, posZ);
        WorldUp = glm::vec3(upX, upY, upZ);
        Yaw = yaw;
        Pitch = pitch;
        Roll = roll;
        updateCameraVectors();
    }
    
    // 返回使用前向量和上向量以计算的视图矩阵
    glm::mat4 GetViewMatrix() {
    
    
        return glm::lookAt(this->Position, this->Position + this->Front, this->Up);
    }
    
    // 处理键盘输入
    void ProcessKeyboard(Camera_Movement direction, float deltaTime) {
    
    
        float velocity = MovementSpeed * deltaTime;
        if (direction == FORWARD) 
            this->Position += this->Front * velocity;
        if (direction == BACKWARD) 
            this->Position -= this->Front * velocity;
        if (direction == LEFT)
            this->Position -= this->Right * velocity;
        if (direction == RIGHT) 
            this->Position += this->Right * velocity;
        if (direction == UP)
            this->Position += this->Up * velocity;
        if (direction == DOWN)
            this->Position -= this->Up * velocity;
        if (direction == ROLL_LEFT)
            this->Roll -= velocity;
        if (direction == ROLL_RIGHT)
            this->Roll += velocity;
        if (direction == PITCH_UP)
            this->Pitch += velocity;
        if (direction == PITCH_DOWN)
            this->Pitch -= velocity;
        if (direction == YAW_LEFT)
            this->Yaw -= velocity;
        if (direction == YAW_RIGHT)
            this->Yaw += velocity;
        
        updateAngles();
        updateCameraVectors();
    }
    
    // 处理鼠标的移动
    void ProcessMouseMovement(float xoffset, float yoffset, GLboolean constrainPitch = true) {
    
    
        xoffset *= MouseSensitivity;
        yoffset *= MouseSensitivity;

        this->Yaw += xoffset;
        this->Pitch += yoffset;

        // 确保当前俯仰角超出范围时，屏幕不会翻转
        if (constrainPitch) {
    
    
            if (this->Pitch > 89.0f)
                this->Pitch = 89.0f;
            if (this->Pitch < -89.0f)
                this->Pitch = -89.0f;
        }

        // 使用更新的欧拉角更新前向量、右向量和上向量
        updateCameraVectors();
    }

    // 处理鼠标滚轮事件，只处理在垂直滚轮轴上的输入
    void ProcessMouseScroll(float yoffset) {
    
    
        this->Zoom -= (float)yoffset;
        if (this->Zoom < 1.0f) 
            this->Zoom = 1.0f;
        if (this->Zoom > 45.0f)
            this->Zoom = 45.0f;
    }
    
private:
    // 更新角度，确保俯仰角在合理范围内
    void updateAngles() {
    
    
        if (this->Pitch > 89.9f)
            this->Pitch = 89.9f;
        if (this->Pitch < -89.9f) 
            this->Pitch = -89.9f;
    }
    // 更新前向量，上向量和右向量
    void updateCameraVectors() {
    
    
        // 计算新的前向量
        glm::vec3 front;
        front.x = cos(glm::radians(Yaw)) * cos(glm::radians(Pitch));
        front.y = sin(glm::radians(Pitch));
        front.z = sin(glm::radians(Yaw)) * cos(glm::radians(Pitch));
        this->Front = glm::normalize(front);
        
        // 计算新的右向量
        this->Right = glm::normalize(glm::cross(Front, WorldUp));
        glm::mat4 rollMatrix = glm::rotate(glm::mat4(1.0f), glm::radians(this->Roll), this->Front);
        this-> Right = glm::vec3(rollMatrix * glm::vec4(this->Right, 0.0f));
        
        // 计算新的上向量
        Up = glm::normalize(glm::cross(this->Right, this->Front));
    }
};
#endif

windowFactory.h

这个文件有改动！！！

#pragma once
#include "camera.h"
#include <glad/glad.h> // gald前面不能包含任何opengl头文件
#include <GLFW/glfw3.h>
#include <functional>
#include <iostream>

using std::cout;
using std::endl;

class GLFWWindowFactory {
    
    
public:
    // 默认构造函数
    GLFWWindowFactory() {
    
    }
    // 构造函数，初始化窗口
    GLFWWindowFactory(int width, int height, const char* title) {
    
    
        // 初始化glfw
        glfwInit();
        // 设置opengl版本
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
        // 使用核心模式：确保不使用任何被弃用的功能
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

        // 创建glfw窗口
        this->window = glfwCreateWindow(width, height, title, NULL, NULL);
        if (this->window == NULL) {
    
    
            cout << "Failed to create GLFW window" << endl;
            glfwTerminate();
            exit(-1);
        }
        // 设置当前窗口的上下文
        glfwMakeContextCurrent(this->window);
        // 设置窗口大小改变的回调函数
        glfwSetFramebufferSizeCallback(this->window, framebuffer_size_callback);
        // 加载所有opengl函数指针
        if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
    
    
            cout << "Failed to initialize GLAD" << endl;
        }
        // 再次设置当前窗口的上下文，确保当前上下文仍然是刚刚创建的窗口，是一个安全措施
        glfwMakeContextCurrent(this->window);
        // 设置窗口大小改变的回调函数
        glfwSetFramebufferSizeCallback(this->window, framebuffer_size_callback);
        // 设置鼠标移动的回调函数
        glfwSetCursorPosCallback(this->window, mouse_callback);
        // 设置鼠标滚轮滚动的回调函数
        glfwSetScrollCallback(this->window, scroll_callback);
        // 告诉GLFW捕获鼠标
        glfwSetInputMode(this->window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
    }

    // 获取窗口对象
    GLFWwindow* getWindow() {
    
    
        return this->window;
    }

    // 运行窗口，传入一个自定义的更新函数
    void run(std::function<void()> updateFunc) {
    
    
        // 启用深度测试，opengl将在绘制每个像素之前比较其深度值，以确定该像素是否应该被绘制
        glEnable(GL_DEPTH_TEST);

        // 循环渲染
        while (!glfwWindowShouldClose(this->window)) {
    
     // 检查是否应该关闭窗口
            // 清空屏幕所用的颜色
            glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
            // 清空颜色缓冲，主要目的是为每一帧的渲染准备一个干净的画布
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

            float currentFrame = glfwGetTime();
            this->deltaTime = currentFrame - this->lastFrame;
            this->lastFrame = currentFrame;
            this->timeElapsed += this->deltaTime;
            this->frameCount++;

            // 处理输入
            GLFWWindowFactory::process_input(this->window);

            // 初始化投影矩阵和视图矩阵
            this->projection =
                glm::perspective(glm::radians(camera.Zoom),
                    (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
            this->view = this->camera.GetViewMatrix();

            // 执行更新函数
            updateFunc();

            // 交换缓冲区
            glfwSwapBuffers(this->window);
            // 处理所有待处理事件，去poll所有事件，看看哪个没处理的
            glfwPollEvents();
        }

        // 终止GLFW，清理GLFW分配的资源
        glfwTerminate();
    }

    // 窗口大小改变的回调函数
    static void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
    
    
        // 确保视口与新窗口尺寸匹配，注意在视网膜显示器上，宽度和高度会显著大于指定值
        glViewport(0, 0, width, height);
    }

    // 鼠标移动的回调函数
    static void mouse_callback(GLFWwindow* window, double xposIn, double yposIn) {
    
    
        float xpos = static_cast<float>(xposIn);
        float ypos = static_cast<float>(yposIn);

        if (firstMouse) {
    
    
            lastX = xpos;
            lastY = ypos;
            firstMouse = false;
        }

        float xoffset = xpos - lastX;
        // 反转y坐标，因为y坐标的范围是从上到下，我们需要从下到上
        float yoffset = lastY - ypos;

        lastX = xpos;
        lastY = ypos;

        camera.ProcessMouseMovement(xoffset, yoffset);
    }

    // 鼠标滚轮的回调函数
    static void scroll_callback(GLFWwindow* window, double xoffset, double yoffset) {
    
    
        camera.ProcessMouseScroll(static_cast<float>(yoffset));
    }

    // 处理输入
    static void process_input(GLFWwindow* window) {
    
    
        // 按下ESC键时进入if块
        if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
            // 关闭窗口
            glfwSetWindowShouldClose(window, true);

        if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
            camera.ProcessKeyboard(FORWARD, deltaTime);
        if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
            camera.ProcessKeyboard(BACKWARD, deltaTime);
        if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
            camera.ProcessKeyboard(LEFT, deltaTime);
        if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
            camera.ProcessKeyboard(RIGHT, deltaTime);
        if (glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS)
            camera.ProcessKeyboard(UP, deltaTime);
        if (glfwGetKey(window, GLFW_KEY_E) == GLFW_PRESS)
            camera.ProcessKeyboard(DOWN, deltaTime);
        if (glfwGetKey(window, GLFW_KEY_I) == GLFW_PRESS)
            camera.ProcessKeyboard(PITCH_UP, deltaTime);
        if (glfwGetKey(window, GLFW_KEY_K) == GLFW_PRESS)
            camera.ProcessKeyboard(PITCH_DOWN, deltaTime);
        if (glfwGetKey(window, GLFW_KEY_J) == GLFW_PRESS)
            camera.ProcessKeyboard(YAW_LEFT, deltaTime);
        if (glfwGetKey(window, GLFW_KEY_L) == GLFW_PRESS)
            camera.ProcessKeyboard(YAW_RIGHT, deltaTime);
        if (glfwGetKey(window, GLFW_KEY_U) == GLFW_PRESS)
            camera.ProcessKeyboard(ROLL_LEFT, deltaTime);
        if (glfwGetKey(window, GLFW_KEY_O) == GLFW_PRESS)
            camera.ProcessKeyboard(ROLL_RIGHT, deltaTime);
    }

    // 获取投影矩阵
    const glm::mat4 getProjectionMatrix() {
    
    
        return this->projection;
    }

    // 获取视图矩阵
    glm::mat4 getViewMatrix() {
    
    
        return this->view;
    }

public:
    // 投影矩阵
    glm::mat4 projection;
    // 视图矩阵
    glm::mat4 view;
    // 摄像机
    static Camera camera;
    // 屏幕宽度
    static const unsigned int SCR_WIDTH = 800;
    // 屏幕高度
    static const unsigned int SCR_HEIGHT = 600;

private:
    // 窗口对象
    GLFWwindow* window;

    // 经过的时间
    float timeElapsed;
    // 帧计数
    int frameCount;

    // 上一次鼠标的X坐标
    static float lastX;
    // 上一次鼠标的Y坐标
    static float lastY;
    // 是否第一次鼠标移动
    static bool firstMouse;

    // 时间间隔
    static float deltaTime;
    // 上一帧的时间
    static float lastFrame;
};

windowFactory.cpp

#include "windowFactory.h"

Camera GLFWWindowFactory::camera = Camera(glm::vec3(0.0f, 0.0f, 3.0f));

// 初始化鼠标的最后X位置为屏幕宽度的一半
float GLFWWindowFactory::lastX = GLFWWindowFactory::SCR_WIDTH / 2.0f;
// 初始化鼠标的最后Y位置为屏幕高度的一半
float GLFWWindowFactory::lastY = GLFWWindowFactory::SCR_HEIGHT / 2.0f;
// 标记是否为第一次鼠标输入
bool GLFWWindowFactory::firstMouse = true;
// 初始化帧间隔时间
float GLFWWindowFactory::deltaTime = 0.0f;
// 初始化上一帧的时间
float GLFWWindowFactory::lastFrame = 0.0f;

shader.h

#ifndef SHADER_H
#define SHADER_H

#include <glad/glad.h>
#include <glm/glm.hpp>

#include <string>
#include <fstream>
#include <sstream>
#include <iostream>

using std::string;
using std::ifstream;
using std::stringstream;
using std::cout;
using std::endl;

class Shader {
    
    
public:
    // 默认构造函数
    Shader() {
    
    }
    // 着色器程序ID
    unsigned int ID;

    // 构造函数
    Shader(const char* vertexPath, const char* fragmentPath) {
    
    
        string vertexCode;
        string fragmentCode;
        ifstream vShaderFile;
        ifstream fShaderFile;

        // 确保ifstream对象可以抛出异常
        vShaderFile.exceptions(ifstream::failbit | ifstream::badbit);
        fShaderFile.exceptions(ifstream::failbit | ifstream::badbit);
        try {
    
    
            // 打开文件
            vShaderFile.open(vertexPath);
            fShaderFile.open(fragmentPath);
            // 读取文件缓冲区内容到stream中
            stringstream vShaderStream, fShaderStream;
            vShaderStream << vShaderFile.rdbuf();
            fShaderStream << fShaderFile.rdbuf();
            // 关闭文件处理器
            vShaderFile.close();
            fShaderFile.close();
            // 将stream转换为字符串
            vertexCode = vShaderStream.str();
            fragmentCode = fShaderStream.str();
        } catch (ifstream::failure& e) {
    
    
            cout << "ERROR::SHADER::FILE_NOT_SUCCESSFULLY_READ: " << e.what() << endl;
        }
        const char* vShaderCode = vertexCode.c_str();
        const char* fShaderCode = fragmentCode.c_str();
        // 编译着色器
        unsigned int vertex, fragment;
        // 顶点着色器
        vertex = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(vertex, 1, &vShaderCode, NULL);
        glCompileShader(vertex);
        checkCompileErrors(vertex, "VERTEX");
        // 片段着色器
        fragment = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fragment, 1, &fShaderCode, NULL);
        glCompileShader(fragment);
        checkCompileErrors(fragment, "FRAGMENT");
        // 着色器程序
        ID = glCreateProgram();
        glAttachShader(ID, vertex);
        glAttachShader(ID, fragment);
        glLinkProgram(ID);
        checkCompileErrors(ID, "PROGRAM");
        // 删除着色器
        glDeleteShader(vertex);
        glDeleteShader(fragment);
    }

    // 激活着色器
    void use() {
    
    
        glUseProgram(ID);
    }

    // 实用的uniform工具函数
    // 用于在着色器程序中设置uniform值
    // 设置一个布尔类型的uniform变量
    void setBool(const std::string& name, bool value) const {
    
    
        glUniform1i(glGetUniformLocation(ID, name.c_str()), (int)value);
    }

    // 设置一个整型的uniform变量
    void setInt(const std::string& name, int value) const {
    
    
        glUniform1i(glGetUniformLocation(ID, name.c_str()), value);
    }

    // 设置一个浮点类型的uniform变量
    void setFloat(const std::string& name, float value) const {
    
    
        glUniform1f(glGetUniformLocation(ID, name.c_str()), value);
    }

    // 设置一个vec2类型的uniform变量
    void setVec2(const std::string& name, const glm::vec2& value) const {
    
    
        glUniform2fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
    }
    // 设置一个vec2类型的uniform变量
    void setVec2(const std::string& name, float x, float y) const {
    
    
        glUniform2f(glGetUniformLocation(ID, name.c_str()), x, y);
    }

    // 设置一个vec3类型的uniform变量
    void setVec3(const std::string& name, const glm::vec3& value) const {
    
    
        glUniform3fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
    }
    // 设置一个vec3类型的uniform变量
    void setVec3(const std::string& name, float x, float y, float z) const {
    
    
        glUniform3f(glGetUniformLocation(ID, name.c_str()), x, y, z);
    }

    // 设置一个vec4类型的uniform变量
    void setVec4(const std::string& name, const glm::vec4& value) const {
    
    
        glUniform4fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
    }
    // 设置一个vec4类型的uniform变量
    void setVec4(const std::string& name, float x, float y, float z, float w) {
    
    
        glUniform4f(glGetUniformLocation(ID, name.c_str()), x, y, z, w);
    }

    // 设置一个mat2类型的uniform变量
    void setMat2(const std::string& name, const glm::mat2& mat) const {
    
    
        glUniformMatrix2fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
    }

    //  设置一个mat3类型的uniform变量
    void setMat3(const std::string& name, const glm::mat3& mat) const {
    
    
        glUniformMatrix3fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
    }

    // 设置一个mat4类型的uniform变量
    void setMat4(const std::string& name, const glm::mat4& mat) const {
    
    
        glUniformMatrix4fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
    }

private:
    // 检查着色器编译/链接错误
    void checkCompileErrors(GLuint shader, string type) {
    
    
        GLint success;
        GLchar infoLog[1024];
        if (type != "PROGRAM") {
    
    
            glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
            if (!success) {
    
    
                glGetShaderInfoLog(shader, 1024, NULL, infoLog);
                cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << endl;
            }
        }
        else {
    
    
            glGetProgramiv(shader, GL_LINK_STATUS, &success);
            if (!success) {
    
    
                glGetProgramInfoLog(shader, 1024, NULL, infoLog);
                cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << endl;
            }
        }
    }
};
#endif

RectangleModel.h

#pragma once
#include <glad/glad.h>
#include "shader.h"

#include <vector>
#include <chrono>
#include <cmath>

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

class RectangleModel {
    
    
public:
    // 构造函数
    RectangleModel(const Shader& shader);
    // 析构函数
    ~RectangleModel();
    
    // 绘制矩形
    void draw();

private:
    unsigned int VAO;
    unsigned int VBO;
    unsigned int EBO;
    Shader shader;
    
    // 纹理
    std::vector<unsigned int>texture;
    
    
    // 编译着色器
    void compileShaders();
    // 设置缓冲区
    void setElements();
    // 加载纹理
    void loadTexture();
    // 绑定纹理
    void bindTexture(GLuint& textured, const char* path);
};

RectangleModel.cpp

#include "RectangleModel.h"
#include <iostream>
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

using std::cout;
using std::endl;

// 构造函数
RectangleModel::RectangleModel(const Shader& shader) : shader(shader) {
    
    
    // 加载纹理
    loadTexture();
    // 设置缓冲区
    setElements();
}

// 析构函数
RectangleModel::~RectangleModel() {
    
    
    // 删除VAO
    glDeleteVertexArrays(1, &this->VAO);
    // 删除VBO
    glDeleteBuffers(1, &this->VBO);
    // 删除EBO
    glDeleteBuffers(1, &this->EBO);
}

/// public
// 绘制矩形
void RectangleModel::draw() {
    
    
    // 使用着色器程序
    this->shader.use();
    // 绑定VAO
    glBindVertexArray(VAO);

    // 获取当前时间
    auto now = std::chrono::system_clock::now();
    // 计算毫秒数
    auto duration = now.time_since_epoch();
    double milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();

    // 设置模型矩阵
    glm::mat4 model = glm::mat4(1.0f);
    shader.setMat4("model", model);

    // 绘制矩形，即绘制两个三角形，GL_UNSIGNED_INT表示索引数组中的每个元素都是一个无符号整数
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
}

/// private
void RectangleModel::setElements() {
    
    
    //顶点数据
    float vertices[] = {
    
    
        -0.75f, -0.75f,0.0f, 0.0f, 0.0f,
        -0.1f, -0.75f,0.0f, 1.0f, 0.0f,
        -0.75f, -0.1f,0.0f, 0.0f, 1.0f,
        -0.1f, -0.1f,0.0f, 1.0f, 1.0f,
    };
    // 索引数据
    int indices[] = {
    
    
        0, 1, 2,
        1, 2, 3,

    };

    // 生成一个VAO
    glGenVertexArrays(1, &this->VAO);
    // 绑定VAO，使其成为当前操作的VAO
    glBindVertexArray(this->VAO);
    // 生成一个VBO
    glGenBuffers(1, &this->VBO);
    // 绑定VBO, 使其成为当前操作的VBO，GL_ARRAY_BUFFER表示顶点缓冲区
    glBindBuffer(GL_ARRAY_BUFFER, this->VBO);
    // 为当前绑定的VBO创建并初始化数据存储，GL_STATIC_DRAW表示数据将一次性提供给缓冲区，并且在之后的绘制过程中不会频繁更改
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    // 生成一个EBO
    glGenBuffers(1, &this->EBO);
    // 绑定EBO，使其成为当前操作的EBO
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    // 传递索引数据
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

    // 定义顶点属性的布局
    // - index：顶点属性的索引
    // - size：每个顶点属性的数量
    // - type：数据类型
    // - normalized：是否将非浮点数值归一化
    // - stride：连续顶点属性之间的间隔
    // - pointer：数据在缓冲区中的偏移量
    // 设置顶点属性指针，位置属性
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
    // 启用顶点属性
    glEnableVertexAttribArray(0);
    // 设置顶点属性指针，颜色属性
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
    // 启用顶点属性
    glEnableVertexAttribArray(1);
}

// 加载纹理
void RectangleModel::loadTexture() {
    
    
    std::vector<std::string> path = {
    
     "teenager.png", "tex.png" };
    texture.resize(path.size());
    for (int i = 0; i < path.size(); i++) {
    
    
        bindTexture(texture[i], path[i].c_str());
    }
    // 参数传入指定要激活的纹理单元，例如GL_TEXTURE0/1/*
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, texture[0]);
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, texture[1]);

    // 使用着色器程序
    shader.use();
    // 设置uniform变量
    shader.setInt("texture0", 0);
    shader.setInt("texture1", 1);
}

// 绑定纹理
void RectangleModel::bindTexture(GLuint& textureId, const char* path) {
    
    
    glGenTextures(1, &textureId);
    glBindTexture(GL_TEXTURE_2D, textureId);
    // 设置纹理环绕和过滤方式
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    // 加载并生成纹理
    stbi_set_flip_vertically_on_load(true);
    int width, height, nrChannels;
    unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
    if (data) {
    
    
        GLenum format;
        if (nrChannels == 4)
            format = GL_RGBA;
        else if (nrChannels == 3)
            format = GL_RGB;
        else
            format = GL_RED;

        glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
        glGenerateMipmap(GL_TEXTURE_2D);
    }
    else {
    
    
        std::cout << "Failed to load texture" << std::endl;
    }
    stbi_image_free(data);
}

main.cpp

#include "utils/RectangleModel.h"
#include "utils/windowFactory.h"

int main() {
    
    
    // 创建一个窗口Factory对象
    GLFWWindowFactory myWindow(800, 600, "This is Title");
    // 创建一个着色器对象
    Shader shader("shader.vs", "shader.fs");
    // 创建一个矩形模型对象
    RectangleModel rectangle(shader);
    
    // 运行窗口，传入一个lambda表达式，用于自定义渲染逻辑
    myWindow.run([&]() {
    
    
        // 设置投影矩阵
        shader.setMat4("projection", myWindow.getProjectionMatrix());
        // 设置视图矩阵
        shader.setMat4("view", myWindow.getViewMatrix());
        // 绘制矩形
        rectangle.draw();
    });
    
    return 0;
}

CMakeLists.txt

# 设置CMake的最低版本要求
cmake_minimum_required(VERSION 3.10)
# 设置项目名称
project(Camera)

# vcpkg集成, 这里要换成你自己的vcpkg工具链文件和共享库路径
set(VCPKG_ROOT D:/software6/vcpkg/)
set(CMAKE_TOOLCHAIN_FILE ${VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake)
set(CMAKE_PREFIX_PATH ${VCPKG_ROOT}/installed/x64-mingw-static/share)

# 查找所需的包
find_package(glad CONFIG REQUIRED)
find_package(glfw3 CONFIG REQUIRED)
find_package(glm CONFIG REQUIRED)
find_package(assimp CONFIG REQUIRED)
find_package(yaml-cpp CONFIG REQUIRED)

# 搜索并收集utils文件夹下的所有源文件
file(GLOB UTILS "utils/*.cpp", "utils/*.h")

# 添加可执行文件（还要加入utils文件夹下的源文件）
add_executable(Camera main.cpp ${UTILS})

# 链接所需的库
target_link_libraries(Camera PRIVATE glad::glad glfw glm::glm assimp::assimp yaml-cpp::yaml-cpp)

# 检查项目是否有dependeicies目录，如果存在，则在使用add_custom_command命令在构建后将dependencies目录中的文件复制到项目的输出目录
set(SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies")
if(EXISTS ${SOURCE_DIR})
    add_custom_command(TARGET Camera POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E copy_directory
        ${SOURCE_DIR} $<TARGET_FILE_DIR:Camera>)
endif()

最终效果