为什么我的着色器产生不正确的镜面结果?[DX11]

Question

我目前正在尝试实现Phong着色& &;使用hsl和DirectX 11在纹理立方体上照明。我相信我的环境照明和漫射照明计算是正确的，它们在视觉上产生了预期的结果。然而，当我应用镜面照明，我得到奇怪的结果(见链接)

漫反射，环境&镜面:https://i.gyazo.com/f7700d758e05227e27be91ab0cfdf64e.png

仅限镜面:https://i.gyazo.com/27bbfa0efce5c60748f61f54365cc042.png

我的。fx文件:

//Texture Variables
Texture2D txDiffuse[2] : register(t0);
SamplerState anisoSampler : register(s0);
//--------------------------------------------------------------------------------------
// Constant Buffer Variables
//--------------------------------------------------------------------------------------
cbuffer ConstantBuffer : register(b0)
{
    matrix World;
    matrix View;
    matrix Projection;
    float4 DiffuseMtrl;
    float4 DiffuseLight;
    float3 LightPosition;
    float4 AmbientMaterial;
    float4 AmbientLight;
    float4 specularMaterial;
    float4 specularLight;
    float  specularPower;
    float3 eyePosW;
}
//--------------------------------------------------------------------------------------
struct VS_INPUT
{
    float4 Pos : POSITION;
    float3 Normal : NORMAL;
    float2 Tex : TEXCOORD0;
};
//--------------------------------------------------------------------------------------
struct VS_OUTPUT
{
    float4 Pos : SV_POSITION;
    float3 Norm : NORMAL;
    float3 PosW : POSITION; //Eye Vector
    float3 LPos : LIGHTPOS; //Position of light
    float2 Tex : TEXCOORD0;
};
//--------------------------------------------------------------------------------------
// Vertex Shader
//--------------------------------------------------------------------------------------
VS_OUTPUT VS(VS_INPUT vIn)
{
    VS_OUTPUT output = (VS_OUTPUT)0;
    float4 worldPosition;
    output.Tex = vIn.Tex;
    vIn.Pos.w = 1.0f;
    output.Pos = mul(vIn.Pos, World);

    output.Pos = mul(output.Pos, View);
    output.Pos = mul(output.Pos, Projection);
    worldPosition = mul(vIn.Pos, World);
    output.LPos = normalize(worldPosition - LightPosition);
    output.PosW = normalize(eyePosW.xyz - worldPosition.xyz);
    float3 normalW = mul(float4(vIn.Normal, 0.0f), World).xyz;
    normalW = normalize(normalW);

    output.Norm = normalW;
    return output;
}

//--------------------------------------------------------------------------------------
// Pixel Shader
//--------------------------------------------------------------------------------------
float4 PS(VS_OUTPUT input) : SV_Target
{
    float4 textureColor = txDiffuse[0].Sample(anisoSampler, input.Tex);
    float4 bumpNormal = txDiffuse[1].Sample(anisoSampler, input.Tex);
    float4 output;
    float lightIntensity;
    float specularAmount;
    input.Norm = normalize(input.Norm);
    bumpNormal = normalize(bumpNormal);
    //Invert LDir for calculations
    float3 LDir = -input.LPos;
    lightIntensity = saturate(dot((input.Norm + bumpNormal.rgb), LDir));
    float3 r = reflect(LDir, (input.Norm + bumpNormal.rgb));
    specularAmount = pow(max(dot(r, input.PosW), 0.0f), specularPower);

    // Compute Colour using Diffuse ambient and texture
    float diffuseAmount = max(dot(LDir, (input.Norm + bumpNormal.rgb)), 0.0f);
    float3 diffuse = (diffuseAmount * (DiffuseMtrl * DiffuseLight).rgb) * lightIntensity;
    float3 ambient = AmbientLight * AmbientMaterial;
    float3 specular = specularAmount * (specularMaterial * specularLight).rgb * lightIntensity;
    output.rgb = ((ambient + diffuse) * textureColor) + specular;
    output.a = textureColor.a;
    return output;
}

请原谅任何混乱的代码或变量名，我已经尝试使用各种教程和教科书，每个都有自己的命名约定，所以我的现在有点混乱。

编辑:使用答案和其他一些信息来源，我重新工作了我的着色器，并得到了它的工作。我的一个问题是不正确的填充在恒定的缓冲区。我还添加了切线空间计算，并正确地将我的凹凸法线转换为-1到+1范围

//--------------------------------------------------------------------------------------
// Constant Buffer Variables
//--------------------------------------------------------------------------------------
cbuffer ConstantBuffer
{
    matrix World;
    matrix View;
    matrix Projection;
}
struct PointLight
{
    float4 ambient;
    float4 diffuse;
    float4 specular;
    float3 pos;
    float range;
    float3 att;
    float pad;
};
cbuffer CbPerFrame
{
    PointLight light;
    float3 eyePosW;
    float pad;
    float4 SpecularMaterial;
    float SpecularPower;
    float3 pad2;
};
Texture2D ObjTexture[2];
SamplerState ObjSamplerState;
//--------------------------------------------------------------------------------------
struct VS_OUTPUT
{
    float4 Pos : SV_POSITION;
    float4 worldPos : POSITION;
    float2 TexCoord : TEXCOORD;
    float3 normal : NORMAL;
    float3 tangent : TANGENT;
    float3 biTangent : BITANGENT;
};
void CalcTanBiTan(float3 norm, out float3 tan, out float3 biTan)
{
    float3 c1 = cross(norm, float3(0.0f, 0.0f, 1.0f));
    float3 c2 = cross(norm, float3(0.0f, 1.0f, 0.0f));
    if (length(c1) > length(c2))
    {
        tan = c1;
    }
    else
    {
        tan = c2;
    }
    tan = normalize(tan);
    biTan = cross(norm, tan);
    biTan = normalize(biTan);
}
//--------------------------------------------------------------------------------------
// Vertex Shader
//--------------------------------------------------------------------------------------
VS_OUTPUT VS(float4 inPos : POSITION, float2 inTexCoord : TEXCOORD, float3 normal : NORMAL)
{
    VS_OUTPUT output = (VS_OUTPUT)0;
    output.Pos = mul(inPos, World);
    output.worldPos = mul(inPos, World);
    output.Pos = mul(output.Pos, View);
    output.Pos = mul(output.Pos, Projection);
    output.normal = mul(normal, World);
    output.TexCoord = inTexCoord;
    float3 tangent, biTangent;
    CalcTanBiTan(normal, tangent, biTangent);
    output.tangent = mul(tangent, (float3x3)World);
    output.tangent = normalize(output.tangent);
    output.biTangent = mul(biTangent, (float3x3)World);
    output.biTangent = normalize(output.biTangent);
    return output;
}

//--------------------------------------------------------------------------------------
// Pixel Shader
//--------------------------------------------------------------------------------------
float4 PS(VS_OUTPUT input) : SV_Target
{
    input.normal = normalize(input.normal);
    float4 diffuse = ObjTexture[0].Sample(ObjSamplerState, input.TexCoord);
    float4 bumpMap = ObjTexture[1].Sample(ObjSamplerState, input.TexCoord);
    bumpMap = (bumpMap * 2.0f) - 1.0f;
    float3 bumpNormal = (bumpMap.x * input.tangent) + (bumpMap.y * input.biTangent) + (bumpMap.z * input.normal);
    bumpNormal = normalize(bumpNormal);
    float3 finalColor = float3(0.0f, 0.0f, 0.0f);
    //Create vector between light and pixel
    float3 lightToPixelVec = light.pos - input.worldPos;
    //find distance between light pos and pixel pos
    float d = length(lightToPixelVec);
    float3 finalAmbient = diffuse * light.ambient;
    if (d > light.range)
        return float4(finalAmbient, diffuse.a);
    //Turn lightToPixelVec into a unit vector describing pixel direction from the light position
    lightToPixelVec /= d;
    float howMuchLight = dot(lightToPixelVec, bumpNormal);
    float3 toEye = normalize(eyePosW - input.worldPos);
    float3 spec;
    [flatten]
    if (howMuchLight > 0.0f)
    {
        float3 v = reflect(-lightToPixelVec, bumpNormal);
        float specFactor = pow(max(dot(v, toEye), 0.0f), SpecularPower);
        spec = specFactor * SpecularMaterial * light.specular;
        finalColor += howMuchLight * diffuse * light.diffuse;
        finalColor /= light.att[0] + (light.att[1] * d) + light.att[2] * (d*d);
    }
    finalColor = saturate(finalColor + finalAmbient + spec);
    return float4(finalColor, diffuse.a);
}

Answer 1

First:

 float4 bumpNormal = txDiffuse[1].Sample(anisoSampler, input.Tex);
 bumpNormal = normalize(bumpNormal);

纹理中的数据存储通常是RGBA格式，每个通道8位。除非你是从一个浮动纹理读取。当纹理存储每个通道8位时。你需要在shader中将值从0~1映射到-1~1。

第二:

 input.Norm = normalize(input.Norm);
 bumpNormal = normalize(bumpNormal);
 (input.Norm + bumpNormal.rgb)

add是不正确的，你应该用bump法线代替法线。

第三:

我不确定你的法线存储在什么空间，通常法线将存储在切线空间，这意味着你也应该从顶点着色器传递切线或双法线。

如果你只想测试镜面，你可以使用原来的法线。