在片段着色器中将世界空间光 position 转换为 model 空间的问题

Question

我正在尝试解决 model 与世界空间坐标的古老问题，当向具有变换模型的场景添加光时。

我有一个房子 model 有两个实例。 一个头骨，我场景中的一个单点光源以及一些地形和一个天空盒。 我注意到当对我的模型应用一些旋转时，点光源提供的照明会随之旋转。 经过一番阅读，很明显我在 model 空间的着色器中进行了所有计算，但我的灯光位置/方向在世界空间中。

所以，我意识到我需要统一我的计算空间，我认为将着色器保留在 model 空间并将灯光组件从世界转换为 model 是有意义的。

当我不进行转换时，它看起来几乎是正确的（尽管我打赌的是不同空间的 b/c 并不完美）。 我在灯光的位置渲染了一个小灯泡 model，房屋顶部和地形都照我预期的相对较好。

当我将灯光 position 转换回 model 空间时，我希望灯光仍会从灯泡 model 照亮。 然而它变得不稳定。

我在模型上没有旋转，但有一些小的平移，所以我很困惑为什么光源似乎围绕 x 轴旋转了 90 度......

  <model name="blackSmith" mesh="black_smith/">
    <transform>
      <position x="2" y="1" z="-2"></position>
      <rotation x="0" y="0" z="0"></rotation>
      <scale x="1" y="1" z="1"></scale>
    </transform>
  </model>
  <model name="blackSmith2" mesh="black_smith/">
    <transform>
      <position x="-2" y="1" z="-2.5"></position>
      <rotation x="0" y="0" z="0"></rotation>
      <scale x="1" y="1" z="1"></scale>
    </transform>
  </model>

我将模型视图矩阵从我的顶点着色器传递到我的片段着色器，然后进行逆转置以将光 position 的世界空间坐标转换为 model 空间。 我想就是这样，但显然我要么错过了什么，要么做错了什么。

这是我的着色器（由标签分隔）。 对于这个例子，它只是一个点光源，所以u_isPointLight = true和u_isSpotLight = false

#type vertex
#version 330 core

layout(location = 0) in vec3 a_Position;
layout(location = 1) in vec3 aNormal;
layout(location = 2) in vec2 aTexCoord;
layout(location = 3) in mat4 aInstanceModelMatrix;

out vec3 outNormal;
out vec2 outTexCoord;
out vec3 outPos;
out mat4 outMat;

uniform mat4 u_Projection;
uniform mat4 u_View;

void main() {
    vec4 worldPosition = aInstanceModelMatrix * vec4(a_Position, 1.0);
    gl_Position = u_Projection * u_View * worldPosition;
    outPos = vec3(aInstanceModelMatrix * vec4(a_Position, 1.0));
    outNormal = aNormal;
    outTexCoord = aTexCoord;
    outMat = u_View * aInstanceModelMatrix;
}

#type fragment
#version 330 core

out vec4 color;

in vec3 outNormal; in vec2 outTexCoord; in vec3 outPos;
in mat4 outMat;

uniform bool u_DiffuseTextureValid;
uniform sampler2D u_DiffuseTexture;
uniform vec3 u_DiffuseColour;

uniform vec3 u_LightPosition;
uniform vec3 u_LightAttenuation;
uniform vec4 u_LightParams;
uniform vec3 u_SpotDirection;
uniform bool u_isSpotLight;
uniform bool u_isPointLight;
uniform float u_SpotInnerAngle;
uniform float u_SpotOuterAngle;

uniform vec4 uAmbientLight;

uniform bool u_AmbientTextureValid;
uniform sampler2D u_AmbientTexture;

uniform bool u_SpecularTextureValid;
uniform sampler2D u_SpecularTexture;
uniform vec4 u_Specular;

uniform sampler2D u_BumpTexture;
uniform bool u_BumpTextureValid;

uniform float u_MaterialAlpha;

void main() {
    const float kGamma = 0.4545454;
    const float kInverseGamma = 2.2;

    // WorldSpace to ModelSpace conversion
    vec3 lightPosition = (transpose(inverse(outMat)) * vec4(u_LightPosition, 1.0)).xyz;

    vec3 norm;
    if (u_BumpTextureValid) {
        norm = normalize(texture(u_BumpTexture, outTexCoord).xyz);
    } else {
        norm = normalize(outNormal);
    }

    vec3 lightDir;
    if (u_isPointLight || u_isSpotLight) {
        lightDir = normalize(lightPosition - outPos);
    } else {
        lightDir = normalize(-u_SpotDirection);
    }

    vec3 viewFragmentDirection = normalize(outPos);
    vec3 viewNormal = normalize(outNormal);

    float lightDistance = length(lightPosition - outPos);
    float attenuation = 1.0;
    if (u_isPointLight) {
        attenuation = 1.0 / (u_LightAttenuation.x + (lightDistance * u_LightAttenuation.y) + (lightDistance * lightDistance * u_LightAttenuation.z));
    }

    vec3 diffuse = u_LightParams.w * u_DiffuseColour * max(dot(norm, lightDir), 0.0) * u_LightParams.xyz;
    vec3 reflectedLightDirection = reflect(-lightDir, viewNormal);

    vec3 specular;
    if (u_SpecularTextureValid) {
        float spec = pow(max(dot(viewNormal, reflectedLightDirection), 0.0), u_Specular.w);
        specular = u_LightParams.xyz * spec * vec3(texture(u_SpecularTexture, outTexCoord));
    } else {
        float specularStrength = max(0.0, dot(viewFragmentDirection, reflectedLightDirection));
        specular = u_LightParams.w * u_Specular.rgb * pow(u_LightParams.w, u_Specular.w);
    }

    float spotFade = 1.0;
    if (u_isSpotLight && u_isPointLight) {
        float spotlightTheta = dot(lightDir, normalize(-u_SpotDirection));
        spotFade = (u_SpotInnerAngle - spotlightTheta) / (u_SpotOuterAngle - u_SpotInnerAngle);
        if (spotlightTheta < u_SpotInnerAngle) {
            specular = vec3(0, 0, 0);
            diffuse = vec3(0, 0, 0);
        }
    }

    vec4 objectColor;
    if (u_DiffuseTextureValid) {
        objectColor = texture(u_DiffuseTexture, outTexCoord);
    } else {
        objectColor = vec4(1.0, 1.0, 1.0, 1.0);
    }
    objectColor.rgb = pow(objectColor.rgb, vec3(kInverseGamma));

    color.a = objectColor.a * u_MaterialAlpha;
    vec3 ambient = uAmbientLight.a * uAmbientLight.rgb;

    ambient *= attenuation;
    diffuse *= attenuation * spotFade;
    specular *= attenuation * spotFade;

    if (u_DiffuseTextureValid) {
        color.rgb = pow(objectColor.rgb + ambient + diffuse + specular, vec3(kGamma));
    } else {
        color.rgb = pow(objectColor.rgb * (ambient + diffuse) + specular, vec3(kGamma));
    }
}

我的问题是：

1. 我是否正确地将光 position 从世界空间转换到 model 空间？
2. 如果我正在做一个纯粹的定向光（即 u_isSpotLight 和 u_isPointLight 都是假的），通过相同的方法将 u_SpotDirection 转换为模型空间应该可以工作......对吗？
3. 假设 1 是正确的，谁能告诉我为什么灯光似乎得到了奇怪的旋转？

Answer 1

model 矩阵将 model 空间转换为世界空间。 因此，您在世界空间中进行光 model 的计算。

 outPos = vec3(aInstanceModelMatrix * vec4(a_Position, 1.0));

但是，您还需要将法线向量从 model 空间转换为世界空间：
（请参阅为什么用模型视图矩阵的逆转置来转换法线？
在哪些情况下逆矩阵等于转置？ )

outNormal = transpose(inverse(mat3(aInstanceModelMatrix))) * aNormal;

outMat可以完全省略。

viewFragmentDirection向量是从片段到相机的向量。 在 Viewscece 中，这很容易计算，因为相机 position 为 (0, 0, 0)。 但在世界空间中，您需要计算从片段到相机 position 的向量：

vec3 viewFragmentDirection = normalize(outPos);

vec3 viewFragmentDirection = normalize(cameraPos - outPos);

您可以为相机的 position 使用制服。 相机position也是逆视图矩阵的平移：

vec3 cameraPos = vec3(inverse(u_View)[3]);