Question

我目前正在尝试实施Phong着色＆amp;使用HLSL和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

首先：

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

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

第二

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

添加不正确，你应该用凸起法线替换法线。

第三：

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

如果您只想测试镜面反射，则可以使用原始法线。

为什么我的着色器会产生不正确的镜面效果？ [DX11]

1 个答案: