如何用C++结合OpenGL基于Z轴排序的2D水平多边形构建3D模型？

嘿，这个需求我之前做类似3D建模项目时刚好碰过，其实核心思路就是把这些按Z轴排序的2D水平轮廓，沿着Z轴方向连接相邻层的顶点生成侧面，再补上上下底面，就能得到完整的闭合3D模型。下面我一步步给你拆解具体实现步骤：

你的输入是按Z轴排序的多层2D闭合多边形点集，相当于3D模型的一系列水平截面。我们要做的就是：

1. 连接相邻Z层的对应顶点，生成侧面的三角面
2. 对最顶层和最底层的多边形进行三角化，生成闭合的上下底面
3. 将所有顶点、索引数据传入OpenGL，完成渲染

1. 数据结构准备 #

首先定义存储顶点的结构体，包含位置、法向量（用于光照）等信息：

#include <vector>
#include <glm/glm.hpp> // 用glm做数学运算，也可以自己实现向量结构体

struct Vertex {
    glm::vec3 position;
    glm::vec3 normal;
    glm::vec2 texCoord; // 可选，用于纹理映射
};

// 存储所有Z层的轮廓：每个元素是一层的2D点集，已按Z轴排序
std::vector<std::vector<glm::vec2>> sorted_layers;
// 存储对应每层的Z值（如果点集里没带Z的话）
std::vector<float> layer_z_values;

2. 生成侧面网格（核心步骤） #

这一步要注意顶点顺序一致性：所有层的多边形顶点必须统一为顺时针或逆时针方向，否则生成的面会因法线反向被OpenGL背面剔除过滤。

遍历每一对相邻Z层，将对应顶点连接成三角面：

std::vector<Vertex> vertices;
std::vector<unsigned int> indices;

for (int i = 0; i < sorted_layers.size() - 1; ++i) {
    const auto& curr_layer = sorted_layers[i];
    const auto& next_layer = sorted_layers[i+1];
    float z_curr = layer_z_values[i];
    float z_next = layer_z_values[i+1];
    int vertex_count = curr_layer.size();

    for (int j = 0; j < vertex_count; ++j) {
        int j_next = (j + 1) % vertex_count; // 闭合循环，处理最后一个顶点到第一个顶点的连接

        // 取四个顶点：当前层j、当前层j+1、下一层j+1、下一层j
        glm::vec2 p_curr = curr_layer[j];
        glm::vec2 p_curr_next = curr_layer[j_next];
        glm::vec2 p_next = next_layer[j];
        glm::vec2 p_next_next = next_layer[j_next];

        // 计算侧面法向量（通过两个边的叉乘）
        glm::vec3 edge1 = glm::vec3(p_curr_next - p_curr, 0.0f);
        glm::vec3 edge2 = glm::vec3(0.0f, 0.0f, z_next - z_curr);
        glm::vec3 normal = glm::normalize(glm::cross(edge1, edge2));

        // 添加四个顶点到数组
        vertices.push_back({glm::vec3(p_curr.x, p_curr.y, z_curr), normal, {0.0f, 0.0f}});
        vertices.push_back({glm::vec3(p_curr_next.x, p_curr_next.y, z_curr), normal, {0.0f, 0.0f}});
        vertices.push_back({glm::vec3(p_next_next.x, p_next_next.y, z_next), normal, {0.0f, 0.0f}});
        vertices.push_back({glm::vec3(p_next.x, p_next.y, z_next), normal, {0.0f, 0.0f}});

        // 添加两个三角面的索引（GL_TRIANGLES模式）
        int base_idx = vertices.size() - 4;
        indices.push_back(base_idx);
        indices.push_back(base_idx + 1);
        indices.push_back(base_idx + 2);

        indices.push_back(base_idx);
        indices.push_back(base_idx + 2);
        indices.push_back(base_idx + 3);
    }
}

小贴士：如果相邻两层的顶点数量不一致，需要先做顶点插值细分（比如用线性插值或贝塞尔曲线过渡），保证每层顶点数相同再进行连接。

3. 生成上下底面 #

对最顶层和最底层的多边形进行三角化（将闭合多边形分解为多个三角面），推荐用耳切法（Ear Clipping），这是处理简单无自交多边形的经典算法。

// 辅助函数：三角化2D多边形，返回三角面的索引
std::vector<unsigned int> triangulate_polygon(const std::vector<glm::vec2>& polygon) {
    std::vector<unsigned int> result;
    // 这里实现耳切法逻辑，或者用成熟的库（比如libtess2）简化开发
    // 示例逻辑（简化版，仅适用于凸多边形）：
    int n = polygon.size();
    for (int i = 1; i < n-1; ++i) {
        result.push_back(0);
        result.push_back(i);
        result.push_back(i+1);
    }
    return result;
}

// 生成底层底面
const auto& bottom_layer = sorted_layers.front();
float z_bottom = layer_z_values.front();
int bottom_base_idx = vertices.size();
for (const auto& p : bottom_layer) {
    vertices.push_back({glm::vec3(p.x, p.y, z_bottom), glm::vec3(0.0f, -1.0f, 0.0f), {0.0f, 0.0f}});
}
auto bottom_indices = triangulate_polygon(bottom_layer);
for (unsigned int idx : bottom_indices) {
    indices.push_back(bottom_base_idx + idx);
}

// 生成顶层底面（注意反转索引顺序，保证法线朝外）
const auto& top_layer = sorted_layers.back();
float z_top = layer_z_values.back();
int top_base_idx = vertices.size();
for (const auto& p : top_layer) {
    vertices.push_back({glm::vec3(p.x, p.y, z_top), glm::vec3(0.0f, 1.0f, 0.0f), {0.0f, 0.0f}});
}
auto top_indices = triangulate_polygon(top_layer);
std::reverse(top_indices.begin(), top_indices.end());
for (unsigned int idx : top_indices) {
    indices.push_back(top_base_idx + idx);
}

4. OpenGL渲染流程 #

将生成的顶点和索引数据上传到GPU，完成渲染：

// 创建VAO、VBO、EBO
unsigned int VAO, VBO, EBO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &EBO);

glBindVertexArray(VAO);

// 绑定VBO并上传顶点数据
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), &vertices[0], GL_STATIC_DRAW);

// 绑定EBO并上传索引数据
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW);

// 设置顶点属性指针（位置、法向量、纹理坐标）
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
glEnableVertexAttribArray(0);

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

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

// 渲染时调用
glBindVertexArray(VAO);
glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);

• 顶点顺序一致性：所有层的多边形顶点必须统一顺时针/逆时针方向，否则面的法线会反向，导致渲染时看不到。
• Z轴排序正确性：确保sorted_layers是严格按Z值从小到大（或从大到小）排序的，否则侧面连接会混乱。
• 三角化兼容性：耳切法仅适用于无自交的简单多边形，如果你的输入有自交多边形，需要先做预处理。
• 性能优化：用EBO（索引缓冲）减少GPU数据传输，复杂模型可以考虑分块渲染或LOD（细节层次）优化。

内容的提问来源于stack exchange，提问作者Mikayel Smbatian