Question

最近我在我的引擎中添加了延迟着色支持;但是我遇到了一些衰减问题：

正如您所看到的，当我渲染光量（球体）时，它并不能很好地与图像的环境部分混合！

以下是我宣布点光的方法：

PointLight pointlight;
pointlight.SetPosition(glm::vec3(0.0, 6.0, 0.0));
pointlight.SetIntensity(glm::vec3(1.0f, 1.0f, 1.0f));

以下是我计算光球半径的方法：

Attenuation attenuation = pointLights[i].GetAttenuation();
    float lightMax = std::fmaxf(std::fmax(pointLights[i].GetIntensity().r, pointLights[i].GetIntensity().g),
        pointLights[i].GetIntensity().b);

    float pointLightRadius = (-attenuation.linear +
        std::sqrtf(std::pow(attenuation.linear, 2.0f) - 4.0f * attenuation.exponential *
            (attenuation.constant - (256.0f / 5.0f) * lightMax))) / (2.0f * attenuation.exponential);

最后，这是我的PointLightPass片段着色器：

#version 450 core

struct BaseLight
{
    vec3 intensities;//a.k.a color of light
    float ambientCoeff;
};

struct Attenuation
{
    float constant;
    float linear;
    float exponential;
};

struct PointLight
{
    BaseLight base;
    Attenuation attenuation;
    vec3 position;
};

struct Material
{
    float shininess;
    vec3  specularColor;
    float ambientCoeff;
};


layout (std140) uniform Viewport
{
    uniform mat4 Projection;
    uniform mat4 View;
    uniform mat4 ViewProjection;
    uniform vec2 scrResolution;
};

layout(binding = 0) uniform sampler2D gPositionMap;
layout(binding = 1) uniform sampler2D gAlbedoMap;
layout(binding = 2) uniform sampler2D gNormalMap;
layout(binding = 3) uniform sampler2D gSpecularMap;

uniform vec3 cameraPosition;
uniform PointLight pointLight;

out vec4 fragmentColor;

vec2 FetchTexCoord()
{
      return gl_FragCoord.xy / scrResolution;
}

void main()
{
      vec2 texCoord = FetchTexCoord();
      vec3 gPosition =      texture(gPositionMap, texCoord).xyz;
      vec3 gSurfaceColor =  texture(gAlbedoMap, texCoord).xyz;
      vec3 gNormal =        texture(gNormalMap, texCoord).xyz;
    vec3 gSpecColor =   texture(gSpecularMap, texCoord).xyz;
    float gSpecPower =  texture(gSpecularMap, texCoord).a;

    vec3 totalLight = gSurfaceColor * 0.1; //TODO remove hardcoded ambient light
    vec3 viewDir = normalize(cameraPosition - gPosition);

    vec3 lightDir = normalize(pointLight.position - gPosition);
    vec3 diffuse = max(dot(gNormal, lightDir), 0.0f) * gSurfaceColor *
                    pointLight.base.intensities;

    vec3 halfWayDir = normalize(lightDir + viewDir);
    float spec = pow(max(dot(gNormal, halfWayDir), 0.0f), 1.0f);
    vec3 specular = pointLight.base.intensities * spec /** gSpecColor*/;

    float distance = length(pointLight.position - gPosition);
    float attenuation = 1.0f / (1.0f + pointLight.attenuation.linear * distance
                    + pointLight.attenuation.exponential * distance * distance +
                     pointLight.attenuation.constant);



    diffuse *= attenuation;
    specular *= attenuation;
    totalLight += diffuse + specular;

    fragmentColor = vec4(totalLight, 1.0f);
}

那么您有什么建议来处理这个问题？

编辑：以下是更多详情：

对于延迟着色，

我填充了我的GBuffer;

我在环境光线照射下渲染全屏四边形环境颜色：

#version 420核心

layout (std140) uniform Viewport
{
    uniform mat4 Projection;
    uniform mat4 View;
    uniform mat4 ViewProjection;
    uniform vec2 scrResolution;
};

layout(binding = 1) uniform sampler2D gAlbedoMap;
out vec4 fragmentColor;

vec2 FetchTexCoord()
{
      return gl_FragCoord.xy / scrResolution;
}

void main()
{
    vec2 texCoord = FetchTexCoord();
    vec3 gSurfaceColor =    texture(gAlbedoMap, texCoord).xyz;

    vec3 totalLight = gSurfaceColor * 1.2; //TODO remove hardcoded ambient light
    fragmentColor = vec4(totalLight, 1.0f);
}

然后我传递我的点光源（见上面的代码）;

Answer 1

你遇到这个问题的原因是你使用的是“轻量级”（事实是你在这个问题上没有完全清楚，但是在your other question中提到了这个问题。） / p>

您正在使用正常的光衰减方程。好吧，你会注意到这个等式并没有神奇地停在任意半径。它定义为从0到无穷大的所有距离。

光量的目的是防止光线超过一定距离。那么，如果你的光衰减在那个距离没有变为零，那么你将会看到光量边缘的不连续性。

如果您打算使用光量，则需要使用光衰减方程，该方程实际上保证在体积边缘达到零。或者如果不这样做，你应该为你的体积选择一个半径，使光的衰减强度几乎为零。你的半径太小了。

继续使你的半径更大，直到你无法分辨它为止。

延迟着色和衰减

1 个答案: