计算不同面上的平滑法线

Posted 2023-02-22

【中文标题】计算不同面上的平滑法线

【英文标题】：Calculating smooth normals on seperate faces

【发布时间】：2021-04-01 00:57:48

【问题描述】：

我一直在尝试在生成的地形网格（平铺网格样式）上实现平滑法线以发出平滑的光照，但是我只能实现平面阴影光照，我相信这可能与事实有关所有面都是分开的（尽管某些顶点可能具有相同的位置）。

我四处寻找类似的问题，最接近的是：this question 但是我不确定如何实施他的百分比解决方案。

目前我有这段代码，它基于计算平滑法线的典型方法 - 但在我的情况下只能实现平面着色。

    // Reset Normals
    for (int i = 0; i < this->vertexCount; i++) 
        this->vertices[i].normal = glm::vec3(0.0f);
    

    // For each face
    for (int i = 0; i < totalVerts; i += 3) 

        auto index0 = indices ? this->indices[i] : i;
        auto index1 = indices ? this->indices[i + 1] : i + 1;
        auto index2 = indices ? this->indices[i + 2] : i + 2;

        auto vertex0 = this->vertices[index0].position;
        auto vertex1 = this->vertices[index1].position;
        auto vertex2 = this->vertices[index2].position;

        auto normal = glm::cross(vertex1 - vertex0, vertex2 - vertex0);

        this->vertices[index0].normal += normal;
        this->vertices[index1].normal += normal;
        this->vertices[index2].normal += normal;

    

    // Normalize
    for (int i = 0; i < this->vertexCount; i++) 
        this->vertices[i].normal = glm::normalize(this->vertices[i].normal);
    

我将如何改变它以在周围的面之间平滑？ （至于为什么每个人脸都是独立的，是因为有些人可能有特定属性的顶点，不能与其他人脸共享）

【问题讨论】：

提示：this-> 仅在您有可变阴影时才需要，而您可能在这里没有。

这里主要是令人困惑，因为你使用它不一致，这意味着你有可变阴影。

你想要+= normal还是= normal？

参见How to achieve smooth tangent space normals? ...您只需将每个顶点法线计算为共享相同顶点的所有“平面”法线的（加权）平均值。但是看起来您的代码正是这样做的（权重的一部分，但如果您的网格是统一的，则可以），因此错误可能在其他地方...

【参考方案1】：

供您参考，获取面法线、顶点和顶点法线的工作代码是：

void get_vertices_and_normals_from_triangles(vector<triangle> &t, vector<vec3> &fn, vector<vec3> &v, vector<vec3> &vn)


// Face normals
fn.clear();

// Vertices
v.clear();

// Vertex normals
vn.clear();

if(0 == t.size())
    return;

cout << "Triangles: " << t.size() << endl;

cout << "Welding vertices" << endl;

// Insert unique vertices into set.
set<indexed_vertex_3> vertex_set;

for(vector<triangle>::const_iterator i = t.begin(); i != t.end(); i++)

    vertex_set.insert(i->vertex[0]);
    vertex_set.insert(i->vertex[1]);
    vertex_set.insert(i->vertex[2]);


cout << "Vertices: " << vertex_set.size() << endl;

cout << "Generating vertex indices" << endl;

vector<indexed_vertex_3> vv;

// Add indices to the vertices.
for(set<indexed_vertex_3>::const_iterator i = vertex_set.begin(); i != vertex_set.end(); i++)

    size_t index = vv.size();
    vv.push_back(*i);
    vv[index].index = index;


for (size_t i = 0; i < vv.size(); i++)

    vec3 vv_element(vv[i].x, vv[i].y, vv[i].z);
    v.push_back(vv_element);


vertex_set.clear();

// Re-insert modifies vertices into set.
for(vector<indexed_vertex_3>::const_iterator i = vv.begin(); i != vv.end(); i++)
    vertex_set.insert(*i);

cout << "Assigning vertex indices to triangles" << endl;

// Find the three vertices for each triangle, by index.
set<indexed_vertex_3>::iterator find_iter;

for(vector<triangle>::iterator i = t.begin(); i != t.end(); i++)

    find_iter = vertex_set.find(i->vertex[0]);
    i->vertex[0].index = find_iter->index;

    find_iter = vertex_set.find(i->vertex[1]);
    i->vertex[1].index = find_iter->index;

    find_iter = vertex_set.find(i->vertex[2]);
    i->vertex[2].index = find_iter->index;


vertex_set.clear();

cout << "Calculating normals" << endl;
fn.resize(t.size());
vn.resize(v.size());

for(size_t i = 0; i < t.size(); i++)

    vec3 v0;// = t[i].vertex[1] - t[i].vertex[0];
    v0.x = t[i].vertex[1].x - t[i].vertex[0].x;
    v0.y = t[i].vertex[1].y - t[i].vertex[0].y;
    v0.z = t[i].vertex[1].z - t[i].vertex[0].z;

    vec3 v1;// = t[i].vertex[2] - t[i].vertex[0];
    v1.x = t[i].vertex[2].x - t[i].vertex[0].x;
    v1.y = t[i].vertex[2].y - t[i].vertex[0].y;
    v1.z = t[i].vertex[2].z - t[i].vertex[0].z;

    fn[i] = cross(v0, v1);
    fn[i] = normalize(fn[i]);

    vn[t[i].vertex[0].index] = vn[t[i].vertex[0].index] + fn[i];
    vn[t[i].vertex[1].index] = vn[t[i].vertex[1].index] + fn[i];
    vn[t[i].vertex[2].index] = vn[t[i].vertex[2].index] + fn[i];


for (size_t i = 0; i < vn.size(); i++)
    vn[i] = normalize(vn[i]);

将顶点数据填充到向量中的代码如下。请注意，三角形的未焊接顶点在以下对 vertex_data.push_back(v0.x); 等的调用中被重建。

void draw_mesh(void)

glUseProgram(render.get_program());


glUniformMatrix4fv(uniforms.render.proj_matrix, 1, GL_FALSE, &main_camera.projection_mat[0][0]);
glUniformMatrix4fv(uniforms.render.mv_matrix, 1, GL_FALSE, &main_camera.view_mat[0][0]);
glUniform1f(uniforms.render.shading_level, 1.0f);

vector<float> vertex_data;

for (size_t i = 0; i < triangles.size(); i++)

    vec3 colour(0.0f, 0.8f, 1.0f);

    size_t v0_index = triangles[i].vertex[0].index;
    size_t v1_index = triangles[i].vertex[1].index;
    size_t v2_index = triangles[i].vertex[2].index;

    vec3 v0_fn(vertex_normals[v0_index].x, vertex_normals[v0_index].y, vertex_normals[v0_index].z);
    vec3 v1_fn(vertex_normals[v1_index].x, vertex_normals[v1_index].y, vertex_normals[v1_index].z);
    vec3 v2_fn(vertex_normals[v2_index].x, vertex_normals[v2_index].y, vertex_normals[v2_index].z);

    vec3 v0(triangles[i].vertex[0].x, triangles[i].vertex[0].y, triangles[i].vertex[0].z);
    vec3 v1(triangles[i].vertex[1].x, triangles[i].vertex[1].y, triangles[i].vertex[1].z);
    vec3 v2(triangles[i].vertex[2].x, triangles[i].vertex[2].y, triangles[i].vertex[2].z);

    vertex_data.push_back(v0.x);
    vertex_data.push_back(v0.y);
    vertex_data.push_back(v0.z);
    vertex_data.push_back(v0_fn.x);
    vertex_data.push_back(v0_fn.y);
    vertex_data.push_back(v0_fn.z);
    vertex_data.push_back(colour.x);
    vertex_data.push_back(colour.y);
    vertex_data.push_back(colour.z);

    vertex_data.push_back(v1.x);
    vertex_data.push_back(v1.y);
    vertex_data.push_back(v1.z);
    vertex_data.push_back(v1_fn.x);
    vertex_data.push_back(v1_fn.y);
    vertex_data.push_back(v1_fn.z);
    vertex_data.push_back(colour.x);
    vertex_data.push_back(colour.y);
    vertex_data.push_back(colour.z);

    vertex_data.push_back(v2.x);
    vertex_data.push_back(v2.y);
    vertex_data.push_back(v2.z);
    vertex_data.push_back(v2_fn.x);
    vertex_data.push_back(v2_fn.y);
    vertex_data.push_back(v2_fn.z);
    vertex_data.push_back(colour.x);
    vertex_data.push_back(colour.y);
    vertex_data.push_back(colour.z);



GLuint components_per_vertex = 9;
const GLuint components_per_normal = 3;
GLuint components_per_position = 3;
const GLuint components_per_colour = 3;

GLuint triangle_buffer;

glGenBuffers(1, &triangle_buffer);

GLuint num_vertices = static_cast<GLuint>(vertex_data.size()) / components_per_vertex;

glBindBuffer(GL_ARRAY_BUFFER, triangle_buffer);
glBufferData(GL_ARRAY_BUFFER, vertex_data.size() * sizeof(GLfloat), &vertex_data[0], GL_DYNAMIC_DRAW);

glEnableVertexAttribArray(glGetAttribLocation(render.get_program(), "position"));
glVertexAttribPointer(glGetAttribLocation(render.get_program(), "position"),
    components_per_position,
    GL_FLOAT,
    GL_FALSE,
    components_per_vertex * sizeof(GLfloat),
    NULL);

glEnableVertexAttribArray(glGetAttribLocation(render.get_program(), "normal"));
glVertexAttribPointer(glGetAttribLocation(render.get_program(), "normal"),
    components_per_normal,
    GL_FLOAT,
    GL_TRUE,
    components_per_vertex * sizeof(GLfloat),
    (const GLvoid*)(components_per_position * sizeof(GLfloat)));

glEnableVertexAttribArray(glGetAttribLocation(render.get_program(), "colour"));
glVertexAttribPointer(glGetAttribLocation(render.get_program(), "colour"),
    components_per_colour,
    GL_FLOAT,
    GL_TRUE,
    components_per_vertex * sizeof(GLfloat),
    (const GLvoid*)(components_per_normal * sizeof(GLfloat) + components_per_position * sizeof(GLfloat)));

glDrawArrays(GL_TRIANGLES, 0, num_vertices);

glDeleteBuffers(1, &triangle_buffer);

我不确定你是否收到我的编辑通知。

【讨论】：

嘿，这看起来不错，我会试试看。我注意到焊接了，它仍然输出未焊接的顶点法线吗？

好吧，好消息！这几乎可以工作，除了它似乎每隔这么多行就会产生一条相反的法线......就像这样：imgur.com/JMRPkKo

@Nork 是您的地形始终蜿蜒曲折吗？如果不是，那么一些法线将抵消导致结果的严重破坏..类似于您的屏幕截图显示的内容。尝试启用GL_CULL_FACE 看看是否正确

@Spektre 面部剔除已启用，据我所知，我的缠绕是正确的。我有一个想法，这可能与我的分块系统有关，因为问题似乎与我的块大小一致，所以我目前正在调查。

@Nork 未焊接的顶点在 draw_mesh 函数中重建。希望对您有所帮助。