OpenGL VAO/VBO/EBO 与顶点管理：高效顶点数据传输

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <vector>

// 顶点数据：32位浮点数，每个顶点包含位置和颜色
// layout: position(x,y,z) + color(r,g,b)
float vertices[] = {
    // position          // color
    -0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f,  // 左下 红
     0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f,  // 右下 绿
     0.0f,  0.5f, 0.0f, 0.0f, 0.0f, 1.0f   // 顶部 蓝
};

GLuint vbo;
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

// 验证数据是否成功上传
GLint bufferSize = 0;
glGetBufferParameteriv(GL_ARRAY_BUFFER, GL_BUFFER_SIZE, &bufferSize);
// bufferSize 应等于 sizeof(vertices)，即 72 字节

// shader 属性位置
const GLuint ATTR_POSITION = 0;
const GLuint ATTR_COLOR    = 1;

GLuint vao, vbo;

// 生成并绑定 VAO（必须在 VBO 配置之前）
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);

// 配置 VBO
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

// 配置 position 属性（layout = 0，3 个 float，偏移 0）
glEnableVertexAttribArray(ATTR_POSITION);
glVertexAttribPointer(
    ATTR_POSITION,   // 属性索引
    3,               // 分量数（vec3）
    GL_FLOAT,        // 数据类型
    GL_FALSE,        // 是否归一化整数
    6 * sizeof(float), // 步长（stride）：每个顶点 6 个 float
    (void*)0         // 偏移量（offset）
);

// 配置 color 属性（layout = 1，3 个 float，偏移 3*sizeof(float)）
glEnableVertexAttribArray(ATTR_COLOR);
glVertexAttribPointer(
    ATTR_COLOR,
    3,
    GL_FLOAT,
    GL_FALSE,
    6 * sizeof(float),
    (void*)(3 * sizeof(float))  // 从第 4 个 float 开始
);

// 解绑 VAO（好习惯，防止后续意外修改）
glBindVertexArray(0);

// 渲染时只需一句即可恢复所有状态
glBindVertexArray(vao);
glDrawArrays(GL_TRIANGLES, 0, 3);

// 顶点：4 个点构成一个四边形
float quadVertices[] = {
    // position         // texCoord
     0.5f,  0.5f, 0.0f, 1.0f, 1.0f,  // 右上
     0.5f, -0.5f, 0.0f, 1.0f, 0.0f,  // 右下
    -0.5f, -0.5f, 0.0f, 0.0f, 0.0f,  // 左下
    -0.5f,  0.5f, 0.0f, 0.0f, 1.0f   // 左上
};

// 索引：2 个三角形
unsigned int indices[] = {
    0, 1, 3,   // 第一个三角形
    1, 2, 3    // 第二个三角形
};

GLuint vao, vbo, ebo;

glGenVertexArrays(1, &vao);
glBindVertexArray(vao);

// VBO
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), quadVertices, GL_STATIC_DRAW);

// EBO：注意绑定目标必须是 GL_ELEMENT_ARRAY_BUFFER，且在 VAO 绑定状态下
glGenBuffers(1, &ebo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

// 配置顶点属性
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);

glBindVertexArray(0);

// 渲染
glBindVertexArray(vao);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

void glVertexAttribPointer(
    GLuint index,      // 着色器中 layout(location = index)
    GLint size,        // 分量数：1, 2, 3, 4（如 vec3 -> 3，vec4 -> 4）
    GLenum type,       // 数据类型：GL_FLOAT, GL_INT, GL_UNSIGNED_SHORT, 等
    GLboolean normalized, // 整数类型是否映射到 [-1,1] 或 [0,1]
    GLsizei stride,    // 顶点结构体大小（字节）
    const void* pointer // 该属性在顶点结构体中的偏移
);

// 顶点结构
struct Vertex {
    float position[3];
    float normal[3];
    unsigned int boneIDs[4];   // 整数索引
    float weights[4];
};

// 在 VAO 配置中
glVertexAttribIPointer(2, 4, GL_UNSIGNED_INT, sizeof(Vertex), 
                       (void*)offsetof(Vertex, boneIDs));
glEnableVertexAttribArray(2);

layout(location = 2) in uvec4 aBoneIDs;

// 实例偏移量：每个实例一个 vec3，所有实例共享同一个 VBO
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
// 设为 1：该属性每 1 个实例推进一次，而非每顶点
glVertexAttribDivisor(3, 1);

struct InterleavedVertex {
    float position[3];
    float normal[3];
    float texCoord[2];
    unsigned int color;
};

// 内存布局：[px,py,pz,nx,ny,nz,u,v,color] [px,py,pz,...] ...

float positions[]  = { /* ... */ };
float normals[]    = { /* ... */ };
float texCoords[]  = { /* ... */ };

// 三个独立的 VBO
GLuint posVBO, normalVBO, texVBO;

struct Vertex {
    glm::vec3 position;
    glm::vec3 normal;
    glm::vec2 texCoord;
};

std::vector<Vertex> vertices = /* ... */;

GLuint vao, vbo;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);

glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), 
             vertices.data(), GL_STATIC_DRAW);

glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), 
                      (void*)offsetof(Vertex, position));

glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), 
                      (void*)offsetof(Vertex, normal));

glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), 
                      (void*)offsetof(Vertex, texCoord));

glBindVertexArray(0);

GLuint vao, posVBO, normalVBO, texVBO;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);

// Position VBO
glGenBuffers(1, &posVBO);
glBindBuffer(GL_ARRAY_BUFFER, posVBO);
glBufferData(GL_ARRAY_BUFFER, positions.size() * sizeof(float),
             positions.data(), GL_DYNAMIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);

// Normal VBO
glGenBuffers(1, &normalVBO);
glBindBuffer(GL_ARRAY_BUFFER, normalVBO);
glBufferData(GL_ARRAY_BUFFER, normals.size() * sizeof(float),
             normals.data(), GL_STATIC_DRAW);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);

// TexCoord VBO
glGenBuffers(1, &texVBO);
glBindBuffer(GL_ARRAY_BUFFER, texVBO);
glBufferData(GL_ARRAY_BUFFER, texCoords.size() * sizeof(float),
             texCoords.data(), GL_STATIC_DRAW);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);

glBindVertexArray(0);

// 假设粒子位置 VBO 已创建，usage 为 GL_DYNAMIC_DRAW
GLuint particlePosVBO;
std::vector<glm::vec3> updatedPositions(particleCount);

// 在模拟循环中更新
UpdateParticlesCPU(updatedPositions);  // CPU 端粒子模拟

glBindBuffer(GL_ARRAY_BUFFER, particlePosVBO);
glBufferSubData(GL_ARRAY_BUFFER, 0, 
                updatedPositions.size() * sizeof(glm::vec3), 
                updatedPositions.data());

glBindBuffer(GL_ARRAY_BUFFER, particlePosVBO);

// 映射整个缓冲区用于写入
// GL_MAP_WRITE_BIT       ：映射用于写入
// GL_MAP_INVALIDATE_RANGE_BIT ：表示我们将覆盖之前的整个映射范围内容，驱动可优化
void* ptr = glMapBufferRange(GL_ARRAY_BUFFER, 0, 
                              particleCount * sizeof(glm::vec3),
                              GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT);

if (ptr) {
    glm::vec3* mappedPositions = static_cast<glm::vec3*>(ptr);
    for (int i = 0; i < particleCount; ++i) {
        mappedPositions[i] = ComputeParticlePosition(i);
    }
    glUnmapBuffer(GL_ARRAY_BUFFER);  // 必须取消映射
}

glBindBuffer(GL_ARRAY_BUFFER, particlePosVBO);

// 核心技巧：先 orphan（弃用）旧缓冲区，再映射
// 分配标志的完整含义：
// GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT | GL_MAP_UNSYNCHRONIZED_BIT
glBufferData(GL_ARRAY_BUFFER, particleCount * sizeof(glm::vec3), 
             nullptr, GL_DYNAMIC_DRAW);  // orphan! 旧数据被丢弃

void* ptr = glMapBufferRange(GL_ARRAY_BUFFER, 0,
                              particleCount * sizeof(glm::vec3),
                              GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
if (ptr) {
    // 直接写入映射内存...
    glUnmapBuffer(GL_ARRAY_BUFFER);
}

// 1. 创建单位立方体的 VAO/VBO（与常规相同）
GLuint cubeVAO, cubeVBO;
// ... 初始化一个 1x1x1 的立方体

// 2. 创建实例数据 VBO（每个实例一个 mat4）
const int INSTANCE_COUNT = 10000;
glm::mat4 instanceMatrices[INSTANCE_COUNT];

// 在 CPU 上生成变换矩阵（可以是随机分布、网格排列等）
for (int i = 0; i < INSTANCE_COUNT; ++i) {
    instanceMatrices[i] = GenerateTransform(i);
}

GLuint instanceVBO;
glGenBuffers(1, &instanceVBO);
glBindBuffer(GL_ARRAY_BUFFER, instanceVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(instanceMatrices), 
             instanceMatrices, GL_STATIC_DRAW);

// 3. 在 VAO 绑定状态下，配置实例矩阵为 4 个 vec4 属性
// 因为 mat4 在着色器中占 4 个连续的 layout 位置
glBindVertexArray(cubeVAO);
glBindBuffer(GL_ARRAY_BUFFER, instanceVBO);

for (unsigned int i = 0; i < 4; ++i) {
    glEnableVertexAttribArray(3 + i);  // 用 location 3,4,5,6
    glVertexAttribPointer(3 + i, 4, GL_FLOAT, GL_FALSE, 
                          sizeof(glm::mat4),
                          (void*)(i * sizeof(glm::vec4)));
    glVertexAttribDivisor(3 + i, 1);   // 每个实例更新一次
}

glBindVertexArray(0);

// 4. 渲染
shader.use();
glBindVertexArray(cubeVAO);
glDrawArraysInstanced(GL_TRIANGLES, 0, 36, INSTANCE_COUNT);

#version 330 core
layout(location = 0) in vec3 aPos;
layout(location = 1) in vec3 aNormal;
layout(location = 2) in vec2 aTexCoord;
layout(location = 3) in mat4 aInstanceMatrix;  // 占 3,4,5,6

uniform mat4 view;
uniform mat4 projection;

out vec2 TexCoord;

void main() {
    gl_Position = projection * view * aInstanceMatrix * vec4(aPos, 1.0);
    TexCoord = aTexCoord;
}

// CPU 端：将顶点数据放入 SSBO
struct CompressedVertex {
    uint32_t pos;       // 10-10-10-2 或量化整数位置
    uint32_t normal;    // Octahedral 编码
    uint32_t texCoord;  // half-float 打包
};

std::vector<CompressedVertex> compressedVertices;
// ... 压缩填充 ...

GLuint ssbo;
glGenBuffers(1, &ssbo);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo);
glBufferData(GL_SHADER_STORAGE_BUFFER, 
             compressedVertices.size() * sizeof(CompressedVertex),
             compressedVertices.data(), GL_STATIC_DRAW);
// 绑定到绑定点 0
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, ssbo);

#version 430 core

layout(std430, binding = 0) readonly buffer VertexBuffer {
    uint data[];  // 顶点数据扁平存储
} vertexBuffer;

// 仍然是 gl_VertexID 驱动顶点着色器执行
layout(location = 0) in uint aVertexID;  // 或直接用 gl_VertexID

uniform mat4 mvp;

out vec3 vNormal;
out vec2 vTexCoord;

// 解码辅助函数
vec3 UnpackPosition(uint packed) {
    int x = int((packed >>  0) & 0x3FF);
    int y = int((packed >> 10) & 0x3FF);
    int z = int((packed >> 20) & 0x3FF);
    // 从 [0, 1023] 解压到 [-1, 1]
    return vec3(x, y, z) / 511.5 - 1.0;
}

vec3 OctahedralDecode(uint packed) {
    vec2 e = unpackSnorm2x16(packed);
    vec3 v = vec3(e.xy, 1.0 - abs(e.x) - abs(e.y));
    // 拆解 octahedral 映射...
    // 此处示意
    return normalize(v);
}

vec2 UnpackTexCoord(uint packed) {
    return unpackHalf2x16(packed);
}

void main() {
    uint baseIndex = uint(gl_VertexID) * 3u;
    
    uint packedPos  = vertexBuffer.data[baseIndex + 0];
    uint packedNorm = vertexBuffer.data[baseIndex + 1];
    uint packedTex  = vertexBuffer.data[baseIndex + 2];
    
    vec3 position = UnpackPosition(packedPos);
    vec3 normal   = OctahedralDecode(packedNorm);
    vec2 texCoord = UnpackTexCoord(packedTex);
    
    gl_Position = mvp * vec4(position, 1.0);
    vNormal = normal;
    vTexCoord = texCoord;
}

// 在 GLSL 中声明
// layout(std140, binding = 0) uniform Matrices {
//     mat4 projection;
//     mat4 view;
//     mat4 model[100];
// };

// C++ 端对齐结构体
glm::mat4 projection = glm::perspective(...);
glm::mat4 view       = glm::lookAt(...);

// std140 布局规则要求 mat4 按列对齐到 vec4（16 字节）边界
// 所以 Matrices 结构大小为 2 * 64 = 128 字节（不含 model 数组时）

GLuint ubo;
glGenBuffers(1, &ubo);
glBindBuffer(GL_UNIFORM_BUFFER, ubo);
glBufferData(GL_UNIFORM_BUFFER, 2 * sizeof(glm::mat4), nullptr, GL_STATIC_DRAW);

// 上传数据
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), glm::value_ptr(projection));
glBufferSubData(GL_UNIFORM_BUFFER, sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(view));

// 绑定到 binding point 0
glBindBufferBase(GL_UNIFORM_BUFFER, 0, ubo);

// 在 shader 中使用 layout(std140, binding = 0) uniform Matrices { ... }
// 无需手动设置 uniform location

// OpenGL 4.3+ 的多绘制间接命令结构
struct DrawArraysIndirectCommand {
    uint32_t count;         // glDrawArrays 的 vertex count
    uint32_t instanceCount; // 实例数量
    uint32_t first;         // 起始顶点偏移
    uint32_t baseInstance;  // 实例偏移基数
};

struct DrawElementsIndirectCommand {
    uint32_t count;         // 索引数量
    uint32_t instanceCount;
    uint32_t firstIndex;    // 第一个索引在 EBO 中的偏移
    uint32_t baseVertex;    // 顶点索引的基值（加到每个索引上）
    uint32_t baseInstance;
};

// 假设场景中有 N 个独立的 mesh，存储在同一个大的 VBO/EBO 中
// 每个 mesh 的 draw command 已经提前按 view frustum culling 筛好

std::vector<DrawElementsIndirectCommand> commands;
// 填充 commands ...

GLuint indirectBuffer;
glGenBuffers(1, &indirectBuffer);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, indirectBuffer);
glBufferData(GL_DRAW_INDIRECT_BUFFER,
             commands.size() * sizeof(DrawElementsIndirectCommand),
             commands.data(), GL_STATIC_DRAW);

// 提交所有绘制命令（CPU 端只需一次 API 调用！）
glBindVertexArray(mergedSceneVAO);  // 包含合并后的 VBO/EBO
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, indirectBuffer);
glMultiDrawElementsIndirect(
    GL_TRIANGLES,                  // mode
    GL_UNSIGNED_INT,               // EBO 索引类型
    nullptr,                       // offset（从 buffer 起始位置开始）
    commands.size(),               // drawcount：命令数量
    sizeof(DrawElementsIndirectCommand)  // stride：命令之间的字节间距
);

// Compute Shader 输出可见对象的 draw commands
layout(local_size_x = 256, local_size_y = 1, local_size_z = 1) in;

layout(std430, binding = 0) readonly buffer MeshData { ... };
layout(std430, binding = 1) writeonly buffer CommandBuffer {
    DrawElementsIndirectCommand commands[];
};
layout(std430, binding = 2) buffer AtomicCounter {
    uint commandCount;
};

void main() {
    uint meshID = gl_GlobalInvocationID.x;
    if (meshID >= totalMeshCount) return;
    
    if (FrustumCull(meshID)) {
        uint idx = atomicAdd(commandCount, 1);
        commands[idx] = BuildDrawCommand(meshID);
    }
}

// 提交时 commandCount 是原子操作的累积结果
uint commandCount;
glGetNamedBufferSubData(counterBuffer, 0, sizeof(uint), &commandCount);

glBindBuffer(GL_DRAW_INDIRECT_BUFFER, indirectBuffer);
glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 
                            nullptr, commandCount, 0);