C++ 图形编程：亲手点亮第一个三角形

vcpkg install glfw3 glad
# Ubuntu 下也可以直接用系统包
sudo apt install libglfw3-dev

cmake_minimum_required(VERSION 3.20)
project(FirstTriangle)

find_package(glfw3 CONFIG REQUIRED)
find_package(glad CONFIG REQUIRED)

add_executable(tri main.cpp)
target_link_libraries(tri PRIVATE glfw glad::glad)

// main.cpp —— 第一版：窗口 + 清屏
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>

int main() {
    glfwInit();
    // 明确告诉驱动：我们要 OpenGL 3.3 核心 Profile（现代写法，废弃了旧即时模式）
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    GLFWwindow* window = glfwCreateWindow(800, 600, "first triangle", nullptr, nullptr);
    if (!window) {
        std::cerr << "create window failed\n";
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);

    // 窗口建好后才能向驱动要函数指针
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
        std::cerr << "load glad failed\n";
        return -1;
    }
    glViewport(0, 0, 800, 600);

    // 渲染循环：只要窗口没被关闭，就不停地 画 -> 交换 -> 处理事件
    while (!glfwWindowShouldClose(window)) {
        glClearColor(0.1f, 0.2f, 0.4f, 1.0f);  // 设定清屏色：深蓝
        glClear(GL_COLOR_BUFFER_BIT);          // 用清屏色涂满整个画布

        glfwSwapBuffers(window);  // 把后台画好的帧翻到前台（双缓冲）
        glfwPollEvents();         // 收键盘鼠标消息，否则窗口会「未响应」
    }
    glfwTerminate();
    return 0;
}

// 顶点着色器：每个顶点执行一次，决定它落在屏幕哪个位置
const char* vertexShaderSource = R"(
    #version 330 core
    layout (location = 0) in vec3 aPos;   // 从第 0 号槽位读入顶点坐标
    void main() {
        gl_Position = vec4(aPos, 1.0);
    }
)";

// 片段着色器：每个可能被画出的像素执行一次，决定它的颜色
const char* fragmentShaderSource = R"(
    #version 330 core
    out vec4 FragColor;                   // 输出 RGBA 颜色
    void main() {
        FragColor = vec4(1.0, 0.5, 0.2, 1.0);  // 橙色
    }
)";

#include <string>

GLuint compileShader(GLenum type, const char* source) {
    GLuint shader = glCreateShader(type);
    glShaderSource(shader, 1, &source, nullptr);
    glCompileShader(shader);

    GLint success = 0;
    glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
    if (!success) {
        char infoLog[512];
        glGetShaderInfoLog(shader, 512, nullptr, infoLog);
        std::cerr << "shader compile failed: " << infoLog << "\n";
    }
    return shader;
}

GLuint createShaderProgram() {
    GLuint vs = compileShader(GL_VERTEX_SHADER, vertexShaderSource);
    GLuint fs = compileShader(GL_FRAGMENT_SHADER, fragmentShaderSource);
    GLuint program = glCreateProgram();
    glAttachShader(program, vs);
    glAttachShader(program, fs);
    glLinkProgram(program);
    glDeleteShader(vs);  // 已链入程序，单独的着色器对象可以删了
    glDeleteShader(fs);
    return program;
}

float vertices[] = {
    -0.5f, -0.5f, 0.0f,   // 左下
     0.5f, -0.5f, 0.0f,   // 右下
     0.0f,  0.5f, 0.0f    // 顶部
};

GLuint VAO, VBO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);

glBindVertexArray(VAO);                       // VAO 开始「录音」
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);  // 数据上传显存

// 告诉 OpenGL：每 3 个 float 为一个顶点，从缓冲区第 0 字节开始，对应 location = 0
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);

glBindVertexArray(0);                         // 停止「录音」

GLuint shaderProgram = createShaderProgram();  // 循环外做一次

while (!glfwWindowShouldClose(window)) {
    glClearColor(0.1f, 0.2f, 0.4f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);

    glUseProgram(shaderProgram);   // 启用着色器
    glBindVertexArray(VAO);        // 递上「快递单」
    glDrawArrays(GL_TRIANGLES, 0, 3);  // 从第 0 个顶点起，画 3 个

    glfwSwapBuffers(window);
    glfwPollEvents();
}

顶点数据(VBO/VAO) -> 顶点着色器 -> 图元装配(连成三角形) -> 光栅化(切成像素)
      -> 片段着色器(算颜色) -> 逐片段测试(深度/模板) -> 帧缓冲(屏幕)

float quad[] = {
    // 位置(x,y,z)        UV(u,v)
    -0.5f, -0.5f, 0.0f,   0.0f, 0.0f,   // 左下
     0.5f, -0.5f, 0.0f,   1.0f, 0.0f,   // 右下
     0.5f,  0.5f, 0.0f,   1.0f, 1.0f,   // 右上
    -0.5f,  0.5f, 0.0f,   0.0f, 1.0f    // 左上
};
unsigned int indices[] = { 0, 1, 2,  2, 3, 0 };  // 两个三角形
// 用 glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0) 配合 EBO 索引缓冲绘制

GLuint loadTexture(const char* path) {
    GLuint tex;
    glGenTextures(1, &tex);
    glBindTexture(GL_TEXTURE_2D, tex);

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

    int w, h, channels;
    unsigned char* data = stbi_load(path, &w, &h, &channels, 0);
    if (data) {
        GLenum format = (channels == 4) ? GL_RGBA : GL_RGB;
        glTexImage2D(GL_TEXTURE_2D, 0, format, w, h, 0, format, GL_UNSIGNED_BYTE, data);
        glGenerateMipmap(GL_TEXTURE_2D);   // 生成缩小版链条，远处采样用
    } else {
        std::cerr << "texture load failed: " << path << "\n";
    }
    stbi_image_free(data);   // CPU 侧数据上传完即释放，显存里的才长期持有
    return tex;
}

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

glm::mat4 model      = glm::rotate(glm::mat4(1.0f), (float)glfwGetTime(),
                                   glm::vec3(0.0f, 0.0f, 1.0f));   // 物体随时间自转
glm::mat4 view       = glm::translate(glm::mat4(1.0f), glm::vec3(0, 0, -3.0f)); // 相机后退 3 米
glm::mat4 projection = glm::perspective(glm::radians(45.0f), 800.0f / 600.0f,
                                        0.1f, 100.0f);             // 透视：近大远小

GLuint loc = glGetUniformLocation(shaderProgram, "uMVP");
glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(projection * view * model));

glEnable(GL_DEPTH_TEST);                       // 初始化时开一次
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  // 每帧同时清颜色与深度

// bgfx：同一份代码在 Windows 用 D3D11、Linux 用 Vulkan 渲染
bgfx::Init init;
init.type = bgfx::RendererType::Count;   // 自动选后端
init.resolution.width  = 800;
init.resolution.height = 600;
init.resolution.reset  = BGFX_RESET_VSYNC;
bgfx::init(init);