C++ OpenGL4中的逐顶点照明问题

我有一个只有8个顶点的立方体模型，我有逐顶点定向照明的问题。与一次照亮整个模型不同的是，每个立方体看起来像是单独照亮的

这是我的顶点着色器：

layout(location = 0)in vec3 vp;
layout(location = 1)in vec3 color;
layout(location = 2)in vec3 normal;

out vec3 fColor;

uniform mat4 model;
uniform mat3 nm;
uniform mat3 partNM;
uniform mat4 modelPart;
uniform mat4 view;
uniform mat4 projection;

void main () {
    gl_Position = modelPart * vec4(vp, 1.0f);
    gl_Position = model * gl_Position;
    gl_Position = view * gl_Position;
    gl_Position = projection * gl_Position;

    mat3 normalMatrix =  partNM*nm;
    vec3 normalDirection = normalize(normalMatrix*normal);
    vec3 lightDirection = normalize(vec3(-1.0, 1.0, -1.0));

    vec3 diffuseReflection = clamp(dot(normalDirection, lightDirection),0.0,1.0);
    fColor = color+diffuseReflection;
}

和我的片段着色器：

in vec3 fColor;
out vec4 frag_colour;

void main () {
    frag_colour = vec4(fColor.xyz,1.0);
}

这是我用来设置法线矩阵的函数：

void Shader::setNormalMatrix(string name,glm::mat4 matrix) {
    glm::mat3 nm = glm::transpose(glm::inverse(glm::mat3(matrix)));
    unsigned int location = glGetUniformLocation(program, name.c_str());
    glUniformMatrix3fv(location, 1, false, &nm[0][0]);
}

以及为我的立方体生成顶点和法线的函数：

std::vector<float> Cube::createCube(float size,float x,float y,float z,float r, float g, float b) {
    VertexType points[8];

    points[0].x = (x*size)+0.0f;
    points[0].y = (y*size)+0.0f;
    points[0].z = (z*size)+size;
    points[0].nx = 0.577350; 
    points[0].ny = 0.577350;
    points[0].nz = -0.577350;
    points[0].r = r;
    points[0].g = g;
    points[0].b = b;

    points[1].x = (x*size)+size;
    points[1].y = (y*size)+0.0f;
    points[1].z = (z*size)+size;
    points[1].nx = -0.577350; 
    points[1].ny = 0.577350;
    points[1].nz = -0.577350;
    points[1].r = r;
    points[1].g = g;
    points[1].b = b;

    points[2].x = (x*size)+size;
    points[2].y = (y*size)+size;
    points[2].z = (z*size)+size;
    points[2].nx = -0.577350;
    points[2].ny = -0.577350;
    points[2].nz = -0.577350;
    points[2].r = r;
    points[2].g = g;
    points[2].b = b;

    points[3].x = (x*size)+0.0f;
    points[3].y = (y*size)+size;
    points[3].z = (z*size)+size;
    points[3].nx = 0.577350; 
    points[3].ny = -0.577350;
    points[3].nz = -0.577350;
    points[3].r = r;
    points[3].g = g;
    points[3].b = b;

    points[4].x = (x*size)+0.0f;
    points[4].y = (y*size)+0.0f;
    points[4].z = (z*size)+0.0f;
    points[4].nx = 0.577350; 
    points[4].ny = 0.577350;
    points[4].nz = 0.577350;
    points[4].r = r;
    points[4].g = g;
    points[4].b = b;

    points[5].x = (x*size)+size;
    points[5].y = (y*size)+0.0f;
    points[5].z = (z*size)+0.0f;
    points[5].nx = -0.577350; 
    points[5].ny = 0.577350;
    points[5].nz = 0.577350;
    points[5].r = r;
    points[5].g = g;
    points[5].b = b;

    points[6].x = (x*size)+size;
    points[6].y = (y*size)+size;
    points[6].z = (z*size)+0.0f;
    points[6].nx = -0.577350; 
    points[6].ny = -0.577350;
    points[6].nz = 0.577350;
    points[6].r = r;
    points[6].g = g;
    points[6].b = b;

    points[7].x = (x*size)+0.0f;
    points[7].y = (y*size)+size;
    points[7].z = (z*size)+0.0f;
    points[7].nx = 0.577350; 
    points[7].ny = -0.577350;
    points[7].nz = 0.577350;
    points[7].r = r;
    points[7].g = g;
    points[7].b = b;
    std::vector<float> rPoint;
    for(VertexType p:points) {
        rPoint.push_back(p.x);
        rPoint.push_back(p.y);
        rPoint.push_back(p.z);
        rPoint.push_back(p.r);
        rPoint.push_back(p.g);
        rPoint.push_back(p.b);
        rPoint.push_back(p.nx);
        rPoint.push_back(p.ny);
        rPoint.push_back(p.nz);
    }
    return rPoint;
}

std:：vector Cube:：createCube（浮点大小、浮点x、浮点y、浮点z、浮点r、浮点g、浮点b）{
顶点类型点[8]；
点[0]。x=（x*大小）+0.0f；
点[0]。y=（y*大小）+0.0f；
点[0]。z=（z*大小）+大小；
点[0]，nx=0.577350；
点[0]，ny=0.577350；
点[0].nz=-0.577350；
点[0]，r=r；
点[0]，g=g；
点[0].b=b；
点[1]。x=（x*大小）+大小；
点[1]。y=（y*大小）+0.0f；
点[1]。z=（z*大小）+大小；
点[1]，nx=-0.577350；
点[1]，ny=0.577350；
点[1]，nz=-0.577350；
点[1]，r=r；
点[1]，g=g；
点[1]，b=b；
点[2]。x=（x*大小）+大小；
点[2]。y=（y*大小）+大小；
点[2]。z=（z*大小）+大小；
点[2]，nx=-0.577350；
点[2]。ny=-0.577350；
点[2]，nz=-0.577350；
点[2]，r=r；
点[2]，g=g；
点[2].b=b；
点[3]。x=（x*大小）+0.0f；
点[3]。y=（y*大小）+大小；
点[3]。z=（z*大小）+大小；
点[3]，nx=0.577350；
点[3]。ny=-0.577350；
点[3]，nz=-0.577350；
点[3]，r=r；
点[3]，g=g；
第[3]点，b=b；
点[4]。x=（x*大小）+0.0f；
点[4]。y=（y*大小）+0.0f；
点[4]。z=（z*大小）+0.0f；
点[4]，nx=0.577350；
点[4]，ny=0.577350；
点[4]，nz=0.577350；
点[4]，r=r；
点[4]，g=g；
点[4]，b=b；
点[5]。x=（x*大小）+大小；
点[5]。y=（y*大小）+0.0f；
点[5]。z=（z*大小）+0.0f；
点[5]，nx=-0.577350；
点[5]，ny=0.577350；
点[5]，nz=0.577350；
点[5]，r=r；
点[5]，g=g；
点[5]，b=b；
点[6]。x=（x*大小）+大小；
点[6]。y=（y*大小）+大小；
点[6]。z=（z*大小）+0.0f；
点[6]，nx=-0.577350；
点[6]，ny=-0.577350；
点[6]，nz=0.577350；
点[6]，r=r；
点[6]，g=g；
点[6]，b=b；
点[7]。x=（x*大小）+0.0f；
点[7]。y=（y*大小）+大小；
点[7]。z=（z*大小）+0.0f；
点[7]，nx=0.577350；
点[7]。ny=-0.577350；
点[7]，nz=0.577350；
点[7]，r=r；
点[7]，g=g；
点[7]，b=b；
std：：向量rPoint；
对于（顶点类型p:点）{
rPoint.push_back（p.x）；
rPoint.push_back（每年）；
rPoint.push_back（p.z）；
r点。推回（p.r）；
rPoint.推回（p.g）；
rPoint.push_back（p.b.）；
rPoint.push_back（p.nx）；
rPoint.push_back（纽约）；
rPoint.推回（p.nz）；
}
返回rPoint；
}

---

模型被分成几个部分，这就是为什么我有两个标准矩阵和模型矩阵；一个用于整个模型，一个用于模型的单个部分。我的代码是否有问题，或者我是否需要使用逐片段照明来修复此错误？

原因是您将每个多维数据集渲染为单独的模型。因此，着色器将为每个模型运行一次，在您的情况下，为每个立方体运行一次。要解决此问题，您需要将整个模型（您的机器人）渲染为一个具有一组顶点的模型，而不是一组立方体。

原因是您将每个立方体渲染为单独的模型。因此，着色器将为每个模型运行一次，在您的情况下，为每个立方体运行一次。要解决此问题，您需要将整个模型（机器人）渲染为一个模型，带有一组顶点，而不是一组立方体。

您的问题是网格的拓扑结构。在立方体的拐角处，三个面相交。每个面都有不同的法线。这会在法线的拓扑中创建不连续性。或者更简单地说。每个角点必须使用3个顶点，每个面一个，且面法线指向正确的方向

---

当你这样做的时候，你可以移除那些不可见的立方体面。

你的问题是网格的拓扑结构。在立方体的拐角处，三个面相交。每个面都有不同的法线。这会在法线的拓扑中创建不连续性。或者更简单地说。每个角点必须使用3个顶点，每个面一个，且面法线指向正确的方向

---

同时，您可以删除那些无论如何都不可见的立方体面。

即使将机器人渲染为一组立方体，也不会改变结果。我将其渲染为一组顶点。立方体创建函数输出顶点，然后将其与其他立方体的顶点连接起来。即使机器人渲染为一组立方体，也不会改变结果。我将其渲染为一组顶点。立方体创建函数输出顶点，然后将其与其他立方体的顶点连接起来。我已经在索引级别删除了不可见的面，我希望避免使用重复的顶点。@jbills:它们不是重复的顶点。顶点等于位置是一种常见的误解。但顶点是位置、法线、颜色、纹理坐标等的完整集合。如果更改顶点的一个属性，则会有一个完全不同的顶点。对于不同的法线，你有不同的顶点，因此没有重复。谢谢你的澄清，我会记住这一点！我已经在索引级别删除了不可见的面，我希望避免使用重复的顶点。@jbills:它们不是重复的顶点。顶点等于位置是一种常见的误解。但顶点是位置、法线、颜色、纹理坐标等的完整集合。如果更改顶点的一个属性，则会有一个完全不同的顶点。因此，我们有不同的看法