Shadow Mapping (DirectX12) : Shadow map does not render properly

Question

Sorry for auto translation.

The part that's stuck right now is shadow mapping. The position of the player is exactly 2000, 0, 2000; there is a light source that is the origin of the shadow mapping camera directly over the sky (it is a directory light).

Question 1

You need a shadow map to apply shadow mapping, don't you?

The shadow map isn't working right now, but let's move on.

As long as the viewport of the shadow mapping camera is in the cover space itself, the render is not working properly on the shadow map.

Even if it's initialized to 1.0f, it's all supposed to be outside the shadows.

Although the current shadow map camera position is 2000, 100, 2000, and the focus position is 0, 0, 0.

It's not a red square area that's supposed to be determined to be outside the shadow.

The green square area is determined to be out of the shadow.

For your information, there's nothing blocking the light in the viewport. The shadow you see in the screenshot is just outside the viewport, so it's a shadow that comes from a 0.0f judgment on the shadow map.

Question 2

This is the fundamental problem. No render on shadow map in shadow pass.

Once this is done, I'll find the first question somehow, but the render itself doesn't work, so there's no shadow of the object -> the cause is unknown

Source indicates that the ShadowShader class is rendering a shadow map (ShadowPassRender)

What affects this is the degree of view-project matrix created at the time of the light source (the Update ShaderVariables portion of the Shadow Shader class).

I'm most suspicious of this one, but the process of making it is not different from the example, so I don't know where it's wrong.

I'm using the light itself as a blin pong, and I'm gonna take this as an example and fix it for the project.

code that generate View-Projection matrix for shadow mapping

void CShadowShader::UpdateShaderVariables(ID3D12GraphicsCommandList* pd3dCommandList, XMFLOAT3 xmf3TargetPos)
{
    XMFLOAT3 TargetPos = {950, 0, 950};
    XMMATRIX lightView = XMMatrixLookAtLH(XMLoadFloat3(&m_pLight->GetPosition()), XMLoadFloat3(&TargetPos), XMLoadFloat3(&m_pLight->GetUp()));

    // Transform bounding sphere to light space.
    XMFLOAT3 xmf3CenterLS;
    XMStoreFloat3(&xmf3CenterLS, XMVector3TransformCoord(XMLoadFloat3(&TargetPos), lightView));

    // Ortho frustum in light space encloses scene.

    float l = xmf3CenterLS.x - 3000;
    float b = xmf3CenterLS.y - 3000;
    float n = xmf3CenterLS.z - 3000;
    float r = xmf3CenterLS.x + 3000;
    float t = xmf3CenterLS.y + 3000;
    float f = xmf3CenterLS.z + 3000;

    XMMATRIX lightProj = XMMatrixOrthographicOffCenterLH(l, r, b, t, n, f);

    // Transform NDC space [-1,+1]^2 to texture space [0,1]^2
    XMMATRIX T(
        0.5f, 0.0f, 0.0f, 0.0f,
        0.0f, -0.5f, 0.0f, 0.0f,
        0.0f, 0.0f, 1.0f, 0.0f,
        0.5f, 0.5f, 0.0f, 1.0f);

    XMMATRIX S = lightView * lightProj * T;

    XMFLOAT4X4 m_xmf4x4ShadowTransform;

    XMStoreFloat4x4(&m_xmf4x4ShadowTransform, S);

    CB_SHADOW cbShadow{ m_xmf4x4ShadowTransform, m_pLight->GetPosition() };

    m_ubShadowCB->CopyData(0, cbShadow); 
    pd3dCommandList->SetGraphicsRootConstantBufferView(3, m_ubShadowCB->Resource()->GetGPUVirtualAddress());
}

make PSO for shadow pass

void CShadowShader::CreateShader(ID3D12Device* pd3dDevice, ID3D12RootSignature* pd3dGraphicsRootSignature)
{
    m_ubShadowCB = new UploadBuffer<CB_SHADOW>(pd3dDevice, 1, true);

    ID3DBlob* pd3dVertexShaderBlob = NULL, * pd3dPixelShaderBlob = NULL;

    D3D12_GRAPHICS_PIPELINE_STATE_DESC d3dPipelineStateDesc;
    ::ZeroMemory(&d3dPipelineStateDesc, sizeof(D3D12_GRAPHICS_PIPELINE_STATE_DESC));
    d3dPipelineStateDesc.pRootSignature = pd3dGraphicsRootSignature;
    d3dPipelineStateDesc.VS = CreateVertexShader(&pd3dVertexShaderBlob);
    d3dPipelineStateDesc.PS = CreatePixelShader(&pd3dPixelShaderBlob);
    d3dPipelineStateDesc.RasterizerState = CreateRasterizerState();

    d3dPipelineStateDesc.RasterizerState.DepthBias = 10000.0f;
    d3dPipelineStateDesc.RasterizerState.DepthBiasClamp = 0.0f;
    d3dPipelineStateDesc.RasterizerState.SlopeScaledDepthBias = 1.0f;

    d3dPipelineStateDesc.BlendState = CreateBlendState();
    d3dPipelineStateDesc.DepthStencilState = CreateDepthStencilState();
    d3dPipelineStateDesc.InputLayout = CreateInputLayout();
    d3dPipelineStateDesc.SampleMask = UINT_MAX;
    d3dPipelineStateDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
    d3dPipelineStateDesc.NumRenderTargets = 0;
    d3dPipelineStateDesc.RTVFormats[0] = DXGI_FORMAT_UNKNOWN;
    d3dPipelineStateDesc.DSVFormat = DXGI_FORMAT_D24_UNORM_S8_UINT;
    d3dPipelineStateDesc.SampleDesc.Count = 1;
    d3dPipelineStateDesc.Flags = D3D12_PIPELINE_STATE_FLAG_NONE;
    auto tmp = pd3dDevice->CreateGraphicsPipelineState(&d3dPipelineStateDesc, __uuidof(ID3D12PipelineState), (void**)&m_pd3dPipelineState);


    if (pd3dVertexShaderBlob)
        pd3dVertexShaderBlob->Release();

    if (pd3dPixelShaderBlob)
        pd3dPixelShaderBlob->Release();

    if (d3dPipelineStateDesc.InputLayout.pInputElementDescs)
        delete[] d3dPipelineStateDesc.InputLayout.pInputElementDescs;
}

Shader for Shadow pass

#include "Common.hlsli"

struct VertexIn
{
    float3 PosL : POSITION;
};

struct VertexOut
{
    float4 PosH : SV_POSITION;
};

VertexOut VS(VertexIn vin)
{
    VertexOut vout = (VertexOut) 0.0f;

    MATERIAL matData = material;
    
    // Transform to world space.
    float4 posW = mul(float4(vin.PosL, 1.0f), gmtxWorld);

    // Transform to homogeneous clip space.
    vout.PosH = mul(posW, gmtxShadowTransform);
    
    return vout;
}

// This is only used for alpha cut out geometry, so that shadows 
// show up correctly.  Geometry that does not need to sample a
// texture can use a NULL pixel shader for depth pass.
void PS(VertexOut pin)
{
    // Fetch the material data.
    MATERIAL matData = material;
    float4 diffuseAlbedo = matData.DiffuseAlbedo;
}

Default.hlsl for render pass (there's few korean comments. not important)

#include "Common.hlsli"

//정점 셰이더의 입력을 위한 구조체를 선언한다.
struct VS_DEFAULT_INPUT
{
    float3 position : POSITION;
    float3 normal : NORMAL;
};

//정점 셰이더의 출력(픽셀 셰이더의 입력)을 위한 구조체를 선언한다.
struct VS_DEFAULT_OUTPUT
{
    float4 position : SV_POSITION;
    float4 position_shadow : POSITION0;
    float3 position_w : POSITION1;
    float3 normal : NORMAL;
};


VS_DEFAULT_OUTPUT VS_Default(VS_DEFAULT_INPUT input)
{
    VS_DEFAULT_OUTPUT output;
    output.position = mul(mul(float4(input.position, 1.0f), gmtxWorld), gmtxViewProj);
    output.position_w = mul(float4(input.position, 1.0f), gmtxWorld).xyz;
    output.normal = normalize(mul(float4(input.normal, 0.0f), gmtxWorld).xyz);
    output.position_shadow = mul(float4(output.position_w, 1.0f), gmtxShadowTransform);
    
    return (output);
}

float4 PS_Default(VS_DEFAULT_OUTPUT input) : SV_TARGET
{
    float4 cColor = float4(0.0f, 0.0f, 0.0f, 0.0f);
    
    cColor += material.AmbientLight * material.DiffuseAlbedo;
    
    float3 toEyeW = normalize(cameraPos - input.position_w);
    
    float3 shadowFactor = float3(1.0f, 1.0f, 1.0f);
    shadowFactor[0] = CalcShadowFactor(input.position_shadow);
    
    for (int i = 0; i < nLights; i++)
    {
        cColor += ComputeLighting(light[i], input.position_w, input.normal, toEyeW, shadowFactor[0]);
    }
    // Add in specular reflections.
    
    float3 r = reflect(-toEyeW, input.normal);
    float4 reflectionColor = { 1.0f, 1.0f, 1.0f, 0.0f };
    
    float3 fresnelFactor = SchlickFresnel(material.FresnelR0, input.normal, r);
    cColor.rgb += material.Shininess * fresnelFactor * reflectionColor.rgb;
    
    // Common convention to take alpha from diffuse albedo.
    
    cColor.a = material.DiffuseAlbedo.a;
    
    
    return (cColor);
}

GitHub Link: https://github.com/kcjsend2/3DGP-BulletPhysics

Bullet physical engine is included, so bullet engine will need to be received and connected to the project to build.

See Chapter 20 Shadow Mapping in Frank Luna's Introduction to 3d game programming with directx 12 for examples.

The framework is independent, so it's very different from the example.

Bullet physics engine is included, so bullet engine will need to be received and connected to the project to build.

Answer 1

I fixed it. just because of hlsl shader and direct x uses different type of matrix. hlsl shader uses column major, and direct x uses row major matrix. and I also calculate wrong with matrix multipication order.

worng one is first codes of the question

...and this is fixed code:

XMVECTOR lightPos = XMLoadFloat3(&m_pLight->GetPosition());
    XMVECTOR TargetPos = XMLoadFloat3(&xmf3TargetPos);
    XMVECTOR lightUp = XMLoadFloat3(&m_pLight->GetUp());

    XMMATRIX lightView = XMMatrixLookAtLH(lightPos, TargetPos, lightUp);

    /*XMVECTOR lightLook = Vector3::Normalize(lightPos - TargetPos);*/

    // Transform bounding sphere to light space.
    XMFLOAT3 xmf3CenterLS;
    XMStoreFloat3(&xmf3CenterLS, XMVector3TransformCoord(XMLoadFloat3(&xmf3TargetPos), lightView));

    // Ortho frustum in light space encloses scene.

    float l = xmf3CenterLS.x - 800;
    float b = xmf3CenterLS.y - 800;
    float n = xmf3CenterLS.z - 800;
    float r = xmf3CenterLS.x + 800;
    float t = xmf3CenterLS.y + 800;
    float f = xmf3CenterLS.z + 800;

    XMMATRIX lightProj = XMMatrixOrthographicOffCenterLH(l, r, b, t, n, f);

    // Transform NDC space [-1,+1]^2 to texture space [0,1]^2
    XMMATRIX T(
        0.5f, 0.0f, 0.0f, 0.0f,
        0.0f, -0.5f, 0.0f, 0.0f,
        0.0f, 0.0f, 1.0f, 0.0f,
        0.5f, 0.5f, 0.0f, 1.0f);

    XMMATRIX S = lightView * lightProj;

    XMFLOAT4X4 xmf4x4LightViewProj;
    XMStoreFloat4x4(&xmf4x4LightViewProj, XMMatrixTranspose(S));

    S = S * T;

    XMFLOAT4X4 xmf4x4ShadowTransform;
    XMStoreFloat4x4(&xmf4x4ShadowTransform, XMMatrixTranspose(S));

    CB_SHADOW cbShadow{ xmf4x4ShadowTransform, xmf4x4LightViewProj, m_pLight->GetPosition() };

    m_ubShadowCB->CopyData(0, cbShadow); 
    pd3dCommandList->SetGraphicsRootConstantBufferView(3, m_ubShadowCB->Resource()->GetGPUVirtualAddress());