+ 镜中世界的绘制

* 修复MiniEngine使用stencil缓冲的bug
* 修复深度缓冲区默认值

Author: [email protected]

Chapter 11 Stenciling/Core/Graphics/Command/CommandContext.h

@@ -210,6 +210,8 @@ class GraphicsContext : public CommandContext
     void SetScissor( UINT left, UINT top, UINT right, UINT bottom );
     void SetViewportAndScissor( const D3D12_VIEWPORT& vp, const D3D12_RECT& rect );
     void SetViewportAndScissor( UINT x, UINT y, UINT w, UINT h );
+    void SetStencilRef(UINT StencilRef);
+    void SetBlendFactor(Color BlendFactor);
     void SetPrimitiveTopology(D3D12_PRIMITIVE_TOPOLOGY Topology);
 
     // 设置流水线状态
@@ -342,6 +344,16 @@ inline void GraphicsContext::SetScissor(UINT left, UINT top, UINT right, UINT bo
     SetScissor(CD3DX12_RECT(left, top, right, bottom));
 }
 
+inline void GraphicsContext::SetStencilRef(UINT ref)
+{
+    m_CommandList->OMSetStencilRef(ref);
+}
+
+inline void GraphicsContext::SetBlendFactor(Color BlendFactor)
+{
+    m_CommandList->OMSetBlendFactor(BlendFactor.GetPtr());
+}
+
 inline void GraphicsContext::SetPrimitiveTopology(D3D12_PRIMITIVE_TOPOLOGY Topology)
 {
     m_CommandList->IASetPrimitiveTopology(Topology);

Chapter 11 Stenciling/Core/Graphics/GraphicsCommon.cpp

@@ -57,8 +57,9 @@ namespace Graphics
     D3D12_DEPTH_STENCIL_DESC DepthStateDisabled;
     D3D12_DEPTH_STENCIL_DESC DepthStateReadWrite;
     D3D12_DEPTH_STENCIL_DESC DepthStateReadOnly;
-    D3D12_DEPTH_STENCIL_DESC DepthStateReadOnlyReversed;
     D3D12_DEPTH_STENCIL_DESC DepthStateTestEqual;
+    D3D12_DEPTH_STENCIL_DESC StencilStateTest;
+    D3D12_DEPTH_STENCIL_DESC StencilStateTestEqual;
 
 //     CommandSignature DispatchIndirectCommandSignature(1);
 //     CommandSignature DrawIndirectCommandSignature(1);
@@ -164,12 +165,19 @@ void Graphics::InitializeCommonState(void)
     DepthStateReadOnly = DepthStateReadWrite;
     DepthStateReadOnly.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ZERO;
 
-    DepthStateReadOnlyReversed = DepthStateReadOnly;
-    DepthStateReadOnlyReversed.DepthFunc = D3D12_COMPARISON_FUNC_LESS;
-
     DepthStateTestEqual = DepthStateReadOnly;
     DepthStateTestEqual.DepthFunc = D3D12_COMPARISON_FUNC_EQUAL;
 
+    StencilStateTest = DepthStateReadOnly;
+    StencilStateTest.StencilEnable = TRUE;
+    StencilStateTest.FrontFace.StencilPassOp = D3D12_STENCIL_OP_REPLACE;
+    StencilStateTest.BackFace = StencilStateTest.FrontFace;
+    
+    StencilStateTestEqual = DepthStateReadWrite;
+    StencilStateTestEqual.StencilEnable = TRUE;
+    StencilStateTestEqual.FrontFace.StencilFunc = D3D12_COMPARISON_FUNC_EQUAL;
+    StencilStateTestEqual.BackFace = StencilStateTestEqual.FrontFace;
+
     D3D12_BLEND_DESC alphaBlend = {};
     alphaBlend.IndependentBlendEnable = FALSE;
     alphaBlend.RenderTarget[0].BlendEnable = FALSE;

Chapter 11 Stenciling/Core/Graphics/GraphicsCommon.h

@@ -56,8 +56,11 @@ namespace Graphics
     extern D3D12_DEPTH_STENCIL_DESC DepthStateDisabled;
     extern D3D12_DEPTH_STENCIL_DESC DepthStateReadWrite;
     extern D3D12_DEPTH_STENCIL_DESC DepthStateReadOnly;
-    extern D3D12_DEPTH_STENCIL_DESC DepthStateReadOnlyReversed;
     extern D3D12_DEPTH_STENCIL_DESC DepthStateTestEqual;
+    // 模板测试。禁止深度写入，只有通过了深度测试+模板测试的才写入值
+    extern D3D12_DEPTH_STENCIL_DESC StencilStateTest;
+    // 模板测试。只有模板值相同才允许写入
+    extern D3D12_DEPTH_STENCIL_DESC StencilStateTestEqual;
 
 //     extern CommandSignature DispatchIndirectCommandSignature;
 //     extern CommandSignature DrawIndirectCommandSignature;

Chapter 11 Stenciling/Core/Graphics/Resource/BufferManager.cpp

@@ -29,7 +29,7 @@ namespace Graphics
 
 #define T2X_COLOR_FORMAT DXGI_FORMAT_R10G10B10A2_UNORM
 #define HDR_MOTION_FORMAT DXGI_FORMAT_R16G16B16A16_FLOAT
-#define DSV_FORMAT DXGI_FORMAT_D32_FLOAT
+#define DSV_FORMAT DXGI_FORMAT_D24_UNORM_S8_UINT
 
 void Graphics::InitializeRenderingBuffers( uint32_t bufferWidth, uint32_t bufferHeight )
 {

Chapter 11 Stenciling/Core/Graphics/Resource/DepthBuffer.cpp

@@ -25,6 +25,8 @@ void DepthBuffer::Create( const std::wstring& Name, uint32_t Width, uint32_t Hei
 
     D3D12_CLEAR_VALUE ClearValue = {};
     ClearValue.Format = Format;
+    ClearValue.DepthStencil.Depth = 1.0f;
+    ClearValue.DepthStencil.Stencil = 0;
     CreateTextureResource(Graphics::g_Device, Name, ResourceDesc, ClearValue, VidMemPtr);
     CreateDerivedViews(Graphics::g_Device, Format);
 }
@@ -36,6 +38,8 @@ void DepthBuffer::Create( const std::wstring& Name, uint32_t Width, uint32_t Hei
 
     D3D12_CLEAR_VALUE ClearValue = {};
     ClearValue.Format = Format;
+    ClearValue.DepthStencil.Depth = 1.0f;
+    ClearValue.DepthStencil.Stencil = 0;
     CreateTextureResource(Graphics::g_Device, Name, ResourceDesc, ClearValue, VidMemPtr);
     CreateDerivedViews(Graphics::g_Device, Format);
 }
@@ -123,6 +127,7 @@ void DepthBuffer::CreateDerivedViews( ID3D12Device* Device, DXGI_FORMAT Format )
             m_hStencilSRV = Graphics::AllocateDescriptor(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
 
         SRVDesc.Format = stencilReadFormat;
+        SRVDesc.Texture2D.PlaneSlice = 1;
         Device->CreateShaderResourceView( Resource, &SRVDesc, m_hStencilSRV );
     }
 }

Chapter 11 Stenciling/GameApp.cpp

@@ -59,13 +59,38 @@ void GameApp::Startup(void)
 
     // 默认PSO
     m_mapPSO[E_EPT_DEFAULT] = defaultPSO;
+
+    // 模板PSO 禁止深度写入。如果通过了深度+模板测试，则在对应的模板中写入预设值
+    GraphicsPSO stencilTestPSO = defaultPSO;
+    stencilTestPSO.SetDepthStencilState(Graphics::StencilStateTest);
+    stencilTestPSO.Finalize();
+    m_mapPSO[E_EPT_STENCILTEST] = stencilTestPSO;
+
+    // 模板绘制PSO 通过上一步写入了值，这一步进行判断，如果当前像素的模板值等于预设值，则通过测试
+    // 因为要绘制镜子中的物体，所以需要顶点反向
+    GraphicsPSO stencilDrawPSO = defaultPSO;
+    stencilDrawPSO.SetRasterizerState(Graphics::RasterizerDefault);
+    stencilDrawPSO.SetDepthStencilState(Graphics::StencilStateTestEqual);
+    stencilDrawPSO.Finalize();
+    m_mapPSO[E_EPT_STENCILDRAW] = stencilDrawPSO;
+
+    // 透明PSO 绘制半透明的镜子
+    GraphicsPSO transparencyPSO = defaultPSO;
+    auto blend = Graphics::BlendTraditional;
+    // 目标的alpha用0，这样透过去的目标就不再变淡了
+    blend.RenderTarget[0].DestBlendAlpha = D3D12_BLEND_ZERO; 
+    transparencyPSO.SetBlendState(blend);
+    transparencyPSO.Finalize();
+    m_mapPSO[E_EPT_TRANSPARENT] = transparencyPSO;
 }
 
 void GameApp::Cleanup(void)
 {
     m_mapGeometries.clear();
     m_mapMaterial.clear();
     m_mapPSO.clear();
+
+    m_vecAll.clear();
 }
 
 void GameApp::Update(float deltaT)
@@ -171,7 +196,14 @@ void GameApp::updateSkull(float deltaT)
     auto rotationMatrix = Math::AffineTransform::MakeYRotation(Math::XM_PIDIV2);
     auto scallMatrix = Math::AffineTransform::MakeScale({ 0.45f, 0.45f, 0.45f });
     auto translateMatrix = Math::AffineTransform::MakeTranslation(mSkullTranslation);
-    mSkullRitem->modeToWorld = Math::Transpose(Math::Matrix4(translateMatrix * scallMatrix * rotationMatrix));
+    auto world = Math::Matrix4(translateMatrix * scallMatrix * rotationMatrix);
+    mSkullRitem->modeToWorld = Math::Transpose(world);
+
+    // xy平面
+    XMVECTOR mirrorPlane = XMVectorSet(0.0f, 0.0f, 1.0f, 0.0f);
+    XMMATRIX R = XMMatrixReflect(mirrorPlane);
+    mReflectedSkullRitem->modeToWorld = Math::Transpose(Math::Matrix4(R) * world);
+    mReflectedFloorlRItem->modeToWorld = Math::Transpose(Math::Matrix4(R));
 }
 
 void GameApp::RenderScene(void)
@@ -185,40 +217,49 @@ void GameApp::RenderScene(void)
     gfxContext.ClearColor(Graphics::g_SceneColorBuffer);
 
     gfxContext.TransitionResource(Graphics::g_SceneDepthBuffer, D3D12_RESOURCE_STATE_DEPTH_WRITE, true);
-    gfxContext.ClearDepth(Graphics::g_SceneDepthBuffer);
+    gfxContext.ClearDepthAndStencil(Graphics::g_SceneDepthBuffer);
 
     gfxContext.SetRenderTarget(Graphics::g_SceneColorBuffer.GetRTV(), Graphics::g_SceneDepthBuffer.GetDSV());
 
-    // 设置渲染流水线
-    gfxContext.SetPipelineState(m_mapPSO[E_EPT_DEFAULT]);
-
     // 设置根签名
     gfxContext.SetRootSignature(m_RootSignature);
     // 设置顶点拓扑结构
     gfxContext.SetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 
-    // 设置通用的常量缓冲区
-    PassConstants psc;
-    psc.viewProj = Transpose(m_ViewProjMatrix);
-    psc.eyePosW = m_Camera.GetPosition();
-    psc.ambientLight = { 0.25f, 0.25f, 0.35f, 1.0f };
-    psc.Lights[0].Direction = { 0.57735f, -0.57735f, 0.57735f };
-    psc.Lights[0].Strength = { 0.6f, 0.6f, 0.6f };
-    psc.Lights[1].Direction = { -0.57735f, -0.57735f, 0.57735f };
-    psc.Lights[1].Strength = { 0.3f, 0.3f, 0.3f };
-    psc.Lights[2].Direction = { 0.0f, -0.707f, -0.707f };
-    psc.Lights[2].Strength = { 0.15f, 0.15f, 0.15f };
-    gfxContext.SetDynamicConstantBufferView(1, sizeof(psc), &psc);
+    // 设置显示物体的常量缓冲区
+    setLightContantsBuff(gfxContext);
 
     // 开始绘制
+    // 渲染普通目标
+    gfxContext.SetPipelineState(m_mapPSO[E_EPT_DEFAULT]);
     drawRenderItems(gfxContext, m_vecRenderItems[(int)RenderLayer::Opaque]);
 
+    // 设置模板写入PSO，对于镜子区域，进行模板+深度测试，通过的话，在模板缓冲区写入1
+    gfxContext.SetStencilRef(1);
+    gfxContext.SetPipelineState(m_mapPSO[E_EPT_STENCILTEST]);
+    drawRenderItems(gfxContext, m_vecRenderItems[(int)RenderLayer::Mirrors]);
+
+    // 设置镜中物体的常量缓冲区
+    setLightContantsBuff(gfxContext, true);
+
+    // 绘制镜中物体，只有通过了模板测试，也就是会处于镜中才会绘制
+    gfxContext.SetPipelineState(m_mapPSO[E_EPT_STENCILDRAW]);
+    drawRenderItems(gfxContext, m_vecRenderItems[(int)RenderLayer::Reflected]);
+    gfxContext.SetStencilRef(0);
+
+    // 设置显示物体的常量缓冲区
+    setLightContantsBuff(gfxContext);
+
+    // 绘制镜子
+    gfxContext.SetPipelineState(m_mapPSO[E_EPT_TRANSPARENT]);
+    drawRenderItems(gfxContext, m_vecRenderItems[(int)RenderLayer::Transparent]);
+
     gfxContext.TransitionResource(Graphics::g_SceneColorBuffer, D3D12_RESOURCE_STATE_PRESENT);
 
     gfxContext.Finish(true);
 }
 
-void GameApp::drawRenderItems(GraphicsContext& gfxContext, std::vector<std::unique_ptr<RenderItem>>& ritems)
+void GameApp::drawRenderItems(GraphicsContext& gfxContext, std::vector<RenderItem*>& ritems)
 {
     for (auto& item : ritems)
     {
@@ -248,6 +289,40 @@ void GameApp::drawRenderItems(GraphicsContext& gfxContext, std::vector<std::uniq
     }
 }
 
+void GameApp::setLightContantsBuff(GraphicsContext& gfxContext, bool inMirror /* = false */)
+{
+    if (!inMirror)
+    {
+        // 设置通用的常量缓冲区
+        PassConstants psc;
+        psc.viewProj = Transpose(m_ViewProjMatrix);
+        psc.eyePosW = m_Camera.GetPosition();
+        psc.ambientLight = { 0.25f, 0.25f, 0.35f, 1.0f };
+        psc.Lights[0].Direction = { 0.57735f, -0.57735f, 0.57735f };
+        psc.Lights[0].Strength = { 0.6f, 0.6f, 0.6f };
+        psc.Lights[1].Direction = { -0.57735f, -0.57735f, 0.57735f };
+        psc.Lights[1].Strength = { 0.3f, 0.3f, 0.3f };
+        psc.Lights[2].Direction = { 0.0f, -0.707f, -0.707f };
+        psc.Lights[2].Strength = { 0.15f, 0.15f, 0.15f };
+        gfxContext.SetDynamicConstantBufferView(1, sizeof(psc), &psc);
+    }
+    else
+    {
+        // 设置镜子中的光照，偷个懒，直接设置了
+        PassConstants psc;
+        psc.viewProj = Transpose(m_ViewProjMatrix);
+        psc.eyePosW = m_Camera.GetPosition();
+        psc.ambientLight = { 0.25f, 0.25f, 0.35f, 1.0f };
+        psc.Lights[0].Direction = { 0.57735f, -0.57735f, -0.57735f };
+        psc.Lights[0].Strength = { 0.6f, 0.6f, 0.6f };
+        psc.Lights[1].Direction = { -0.57735f, -0.57735f, -0.57735f };
+        psc.Lights[1].Strength = { 0.3f, 0.3f, 0.3f };
+        psc.Lights[2].Direction = { 0.0f, -0.707f, 0.707f };
+        psc.Lights[2].Strength = { 0.15f, 0.15f, 0.15f };
+        gfxContext.SetDynamicConstantBufferView(1, sizeof(psc), &psc);
+    }
+}
+
 void GameApp::buildRoomGeo()
 {
     // Create and specify geometry.  For this sample we draw a floor
@@ -448,7 +523,7 @@ void GameApp::buildRenderItem()
     floorRItem->BaseVertexLocation = m_mapGeometries["roomGeo"]->geoMap["floor"].BaseVertexLocation;
     floorRItem->geo = m_mapGeometries["roomGeo"].get();
     floorRItem->mat = m_mapMaterial["checkertile"].get();
-    m_vecRenderItems[(int)RenderLayer::Opaque].push_back(std::move(floorRItem));
+    m_vecRenderItems[(int)RenderLayer::Opaque].push_back(floorRItem.get());
 
     // 墙壁
     auto wallRItem = std::make_unique<RenderItem>();
@@ -457,16 +532,7 @@ void GameApp::buildRenderItem()
     wallRItem->BaseVertexLocation = m_mapGeometries["roomGeo"]->geoMap["wall"].BaseVertexLocation;
     wallRItem->geo = m_mapGeometries["roomGeo"].get();
     wallRItem->mat = m_mapMaterial["bricks"].get();
-    m_vecRenderItems[(int)RenderLayer::Opaque].push_back(std::move(wallRItem));
-
-    // 镜子
-    auto mirrorRItem = std::make_unique<RenderItem>();
-    mirrorRItem->IndexCount = m_mapGeometries["roomGeo"]->geoMap["mirror"].IndexCount;
-    mirrorRItem->StartIndexLocation = m_mapGeometries["roomGeo"]->geoMap["mirror"].StartIndexLocation;
-    mirrorRItem->BaseVertexLocation = m_mapGeometries["roomGeo"]->geoMap["mirror"].BaseVertexLocation;
-    mirrorRItem->geo = m_mapGeometries["roomGeo"].get();
-    mirrorRItem->mat = m_mapMaterial["icemirror"].get();
-    m_vecRenderItems[(int)RenderLayer::Opaque].push_back(std::move(mirrorRItem));
+    m_vecRenderItems[(int)RenderLayer::Opaque].push_back(wallRItem.get());
 
     // skull
     auto skullRItem = std::make_unique<RenderItem>();
@@ -476,5 +542,42 @@ void GameApp::buildRenderItem()
     skullRItem->geo = m_mapGeometries["skullGeo"].get();
     skullRItem->mat = m_mapMaterial["skullMat"].get();
     mSkullRitem = skullRItem.get();
-    m_vecRenderItems[(int)RenderLayer::Opaque].push_back(std::move(skullRItem));
+    m_vecRenderItems[(int)RenderLayer::Opaque].push_back(skullRItem.get());
+
+    // 镜子
+    auto mirrorRItem = std::make_unique<RenderItem>();
+    mirrorRItem->IndexCount = m_mapGeometries["roomGeo"]->geoMap["mirror"].IndexCount;
+    mirrorRItem->StartIndexLocation = m_mapGeometries["roomGeo"]->geoMap["mirror"].StartIndexLocation;
+    mirrorRItem->BaseVertexLocation = m_mapGeometries["roomGeo"]->geoMap["mirror"].BaseVertexLocation;
+    mirrorRItem->geo = m_mapGeometries["roomGeo"].get();
+    mirrorRItem->mat = m_mapMaterial["icemirror"].get();
+    m_vecRenderItems[(int)RenderLayer::Mirrors].push_back(mirrorRItem.get());
+    m_vecRenderItems[(int)RenderLayer::Transparent].push_back(mirrorRItem.get());
+
+    // 镜子中的skull
+    auto reflectedSkullRItem = std::make_unique<RenderItem>();
+    reflectedSkullRItem->IndexCount = m_mapGeometries["skullGeo"]->geoMap["skull"].IndexCount;
+    reflectedSkullRItem->StartIndexLocation = m_mapGeometries["skullGeo"]->geoMap["skull"].StartIndexLocation;
+    reflectedSkullRItem->BaseVertexLocation = m_mapGeometries["skullGeo"]->geoMap["skull"].BaseVertexLocation;
+    reflectedSkullRItem->geo = m_mapGeometries["skullGeo"].get();
+    reflectedSkullRItem->mat = m_mapMaterial["skullMat"].get();
+    mReflectedSkullRitem = reflectedSkullRItem.get();
+    m_vecRenderItems[(int)RenderLayer::Reflected].push_back(reflectedSkullRItem.get());
+
+    // 镜子中的floor
+    auto reflectedFloorlRItem = std::make_unique<RenderItem>();
+    reflectedFloorlRItem->IndexCount = m_mapGeometries["roomGeo"]->geoMap["floor"].IndexCount;
+    reflectedFloorlRItem->StartIndexLocation = m_mapGeometries["roomGeo"]->geoMap["floor"].StartIndexLocation;
+    reflectedFloorlRItem->BaseVertexLocation = m_mapGeometries["roomGeo"]->geoMap["floor"].BaseVertexLocation;
+    reflectedFloorlRItem->geo = m_mapGeometries["roomGeo"].get();
+    reflectedFloorlRItem->mat = m_mapMaterial["checkertile"].get();
+    mReflectedFloorlRItem = reflectedFloorlRItem.get();
+    m_vecRenderItems[(int)RenderLayer::Reflected].push_back(reflectedFloorlRItem.get());
+
+    m_vecAll.push_back(std::move(floorRItem));
+    m_vecAll.push_back(std::move(wallRItem));
+    m_vecAll.push_back(std::move(skullRItem));
+    m_vecAll.push_back(std::move(mirrorRItem));
+    m_vecAll.push_back(std::move(reflectedSkullRItem));
+    m_vecAll.push_back(std::move(reflectedFloorlRItem));
 }

Chapter 11 Stenciling/GameApp.h

@@ -30,7 +30,8 @@ class GameApp : public GameCore::IGameApp
 
     void updateSkull(float deltaT);
 
-    void drawRenderItems(GraphicsContext& gfxContext, std::vector<std::unique_ptr<RenderItem>>& ritems);
+    void drawRenderItems(GraphicsContext& gfxContext, std::vector<RenderItem*>& ritems);
+    void setLightContantsBuff(GraphicsContext& gfxContext, bool inMirror = false);
 
 private:
     // 几何结构map
@@ -48,7 +49,8 @@ class GameApp : public GameCore::IGameApp
         Shadow,
         Count
     };
-    std::vector<std::unique_ptr<RenderItem>> m_vecRenderItems[(int)RenderLayer::Count];
+    std::vector<RenderItem*> m_vecRenderItems[(int)RenderLayer::Count];
+    std::vector<std::unique_ptr<RenderItem>> m_vecAll;
 
 private:
     // 根签名
@@ -57,14 +59,21 @@ class GameApp : public GameCore::IGameApp
     // 渲染流水线
     enum ePSOType
     {
-        E_EPT_DEFAULT = 1
+        E_EPT_DEFAULT = 1,
+        E_EPT_STENCILTEST = 2,
+        E_EPT_STENCILDRAW = 3,
+        E_EPT_TRANSPARENT = 4,
     };
     std::unordered_map<int, GraphicsPSO> m_mapPSO;
 
     // render item skull point
     RenderItem* mSkullRitem = nullptr;
     Math::Vector3 mSkullTranslation = { 0.0f, 1.0f, -5.0f };
 
+    // 镜中的skull
+    RenderItem* mReflectedSkullRitem = nullptr;
+    RenderItem* mReflectedFloorlRItem = nullptr;
+
     // 摄像机
     // 以(0, 0, -m_radius) 为初始位置
     Math::Camera m_Camera;