D3D12: fixed depth-stencil texture copies (close #679)

Author: TheMostDiligent

Graphics/GraphicsEngine/include/TextureBase.hpp

@@ -403,6 +403,11 @@ class TextureBase : public DeviceObjectBase<typename EngineImplTraits::TextureIn
     static constexpr Uint8                    InvalidViewIndex = 0xFFu;
     std::array<Uint8, TEXTURE_VIEW_NUM_VIEWS> m_ViewIndices{};
 
+    // The number of planes in the format. For majority of formats, this is 1.
+    // Depth-stencil formats may have 2 planes (depth and stencil).
+    // YUV formats may have 3 planes (Y, U, V).
+    Uint8 m_FormatPlaneCount = 1;
+
     RESOURCE_STATE m_State = RESOURCE_STATE_UNKNOWN;
 
     std::unique_ptr<SparseTextureProperties> m_pSparseProps;

Graphics/GraphicsEngineD3D12/include/DeviceContextD3D12Impl.hpp

@@ -308,12 +308,17 @@ class DeviceContextD3D12Impl final : public DeviceContextNextGenBase<EngineD3D12
                             Uint64                         NumBytes,
                             RESOURCE_STATE_TRANSITION_MODE StateTransitionMode);
 
+    struct SubresCopyMapping
+    {
+        Uint32 Src = 0;
+        Uint32 Dst = 0;
+    };
     void CopyTextureRegion(class TextureD3D12Impl*        pSrcTexture,
-                           Uint32                         SrcSubResIndex,
                            const D3D12_BOX*               pD3D12SrcBox,
                            RESOURCE_STATE_TRANSITION_MODE SrcTextureTransitionMode,
                            class TextureD3D12Impl*        pDstTexture,
-                           Uint32                         DstSubResIndex,
+                           const SubresCopyMapping*       Planes,
+                           Uint32                         NumPlanes,
                            Uint32                         DstX,
                            Uint32                         DstY,
                            Uint32                         DstZ,

Graphics/GraphicsEngineD3D12/include/TextureD3D12Impl.hpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2022 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -90,6 +90,11 @@ class TextureD3D12Impl final : public TextureBase<EngineD3D12ImplTraits>, public
         return m_Desc.Usage == USAGE_SPARSE && m_Desc.Type == RESOURCE_DIM_TEX_2D_ARRAY && m_pDevice->GetDummyNVApiHeap() != nullptr;
     }
 
+    Uint8 GetFormatPlaneCount() const
+    {
+        return m_FormatPlaneCount;
+    }
+
 protected:
     void CreateViewInternal(const struct TextureViewDesc& ViewDesc, ITextureView** ppView, bool bIsDefaultView) override final;
 

Graphics/GraphicsEngineD3D12/src/DeviceContextD3D12Impl.cpp

@@ -30,6 +30,7 @@
 #include "DeviceContextD3D12Impl.hpp"
 
 #include <sstream>
+#include <array>
 
 #include "RenderDeviceD3D12Impl.hpp"
 #include "PipelineStateD3D12Impl.hpp"
@@ -1957,19 +1958,29 @@ void DeviceContextD3D12Impl::CopyTexture(const CopyTextureAttribs& CopyAttribs)
         pD3D12SrcBox       = &D3D12SrcBox;
     }
 
-    UINT DstSubResIndex = D3D12CalcSubresource(CopyAttribs.DstMipLevel, CopyAttribs.DstSlice, 0, DstTexDesc.MipLevels, DstTexDesc.GetArraySize());
-    UINT SrcSubResIndex = D3D12CalcSubresource(CopyAttribs.SrcMipLevel, CopyAttribs.SrcSlice, 0, SrcTexDesc.MipLevels, SrcTexDesc.GetArraySize());
-    CopyTextureRegion(pSrcTexD3D12, SrcSubResIndex, pD3D12SrcBox, CopyAttribs.SrcTextureTransitionMode,
-                      pDstTexD3D12, DstSubResIndex, CopyAttribs.DstX, CopyAttribs.DstY, CopyAttribs.DstZ,
+    static constexpr Uint32                            MaxFormatPlaneCount = 2; // Depth and stencil planes
+    std::array<SubresCopyMapping, MaxFormatPlaneCount> Planes;
+
+    Uint32 NumPlanes = std::min(pSrcTexD3D12->GetFormatPlaneCount(), pDstTexD3D12->GetFormatPlaneCount());
+    VERIFY(NumPlanes <= MaxFormatPlaneCount, "Number of planes (", NumPlanes, ") exceeds maximum supported plane count (", MaxFormatPlaneCount, ")");
+    NumPlanes = std::min(NumPlanes, MaxFormatPlaneCount);
+    for (Uint32 i = 0; i < NumPlanes; ++i)
+    {
+        Planes[i].Dst = D3D12CalcSubresource(CopyAttribs.DstMipLevel, CopyAttribs.DstSlice, i, DstTexDesc.MipLevels, DstTexDesc.GetArraySize());
+        Planes[i].Src = D3D12CalcSubresource(CopyAttribs.SrcMipLevel, CopyAttribs.SrcSlice, i, SrcTexDesc.MipLevels, SrcTexDesc.GetArraySize());
+    }
+    CopyTextureRegion(pSrcTexD3D12, pD3D12SrcBox, CopyAttribs.SrcTextureTransitionMode, pDstTexD3D12,
+                      Planes.data(), NumPlanes,
+                      CopyAttribs.DstX, CopyAttribs.DstY, CopyAttribs.DstZ,
                       CopyAttribs.DstTextureTransitionMode);
 }
 
 void DeviceContextD3D12Impl::CopyTextureRegion(TextureD3D12Impl*              pSrcTexture,
-                                               Uint32                         SrcSubResIndex,
                                                const D3D12_BOX*               pD3D12SrcBox,
                                                RESOURCE_STATE_TRANSITION_MODE SrcTextureTransitionMode,
                                                TextureD3D12Impl*              pDstTexture,
-                                               Uint32                         DstSubResIndex,
+                                               const SubresCopyMapping*       Planes,
+                                               Uint32                         NumPlanes,
                                                Uint32                         DstX,
                                                Uint32                         DstY,
                                                Uint32                         DstZ,
@@ -1997,35 +2008,43 @@ void DeviceContextD3D12Impl::CopyTextureRegion(TextureD3D12Impl*              pS
     }
     TransitionOrVerifyTextureState(CmdCtx, *pDstTexture, DstTextureTransitionMode, RESOURCE_STATE_COPY_DEST, "Using resource as copy destination (DeviceContextD3D12Impl::CopyTextureRegion)");
 
-    D3D12_TEXTURE_COPY_LOCATION DstLocation = {}, SrcLocation = {};
+    D3D12_TEXTURE_COPY_LOCATION DstLocation{};
+    D3D12_TEXTURE_COPY_LOCATION SrcLocation{};
 
     SrcLocation.pResource = pSrcTexture->GetD3D12Resource();
-    if (pSrcTexture->GetDesc().Usage == USAGE_STAGING)
-    {
-        SrcLocation.Type            = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
-        SrcLocation.PlacedFootprint = pSrcTexture->GetStagingFootprint(SrcSubResIndex);
-    }
-    else
-    {
-        SrcLocation.Type             = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
-        SrcLocation.SubresourceIndex = SrcSubResIndex;
-    }
-
     DstLocation.pResource = pDstTexture->GetD3D12Resource();
-    if (pDstTexture->GetDesc().Usage == USAGE_STAGING)
-    {
-        DstLocation.Type            = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
-        DstLocation.PlacedFootprint = pDstTexture->GetStagingFootprint(DstSubResIndex);
-    }
-    else
-    {
-        DstLocation.Type             = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
-        DstLocation.SubresourceIndex = DstSubResIndex;
-    }
 
     CmdCtx.FlushResourceBarriers();
-    CmdCtx.GetCommandList()->CopyTextureRegion(&DstLocation, DstX, DstY, DstZ, &SrcLocation, pD3D12SrcBox);
-    ++m_State.NumCommands;
+
+    for (Uint32 plane = 0; plane < NumPlanes; ++plane)
+    {
+        Uint32 SrcSubResIndex = Planes[plane].Src;
+        Uint32 DstSubResIndex = Planes[plane].Dst;
+        if (pSrcTexture->GetDesc().Usage == USAGE_STAGING)
+        {
+            SrcLocation.Type            = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
+            SrcLocation.PlacedFootprint = pSrcTexture->GetStagingFootprint(SrcSubResIndex);
+        }
+        else
+        {
+            SrcLocation.Type             = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
+            SrcLocation.SubresourceIndex = SrcSubResIndex;
+        }
+
+        if (pDstTexture->GetDesc().Usage == USAGE_STAGING)
+        {
+            DstLocation.Type            = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
+            DstLocation.PlacedFootprint = pDstTexture->GetStagingFootprint(DstSubResIndex);
+        }
+        else
+        {
+            DstLocation.Type             = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
+            DstLocation.SubresourceIndex = DstSubResIndex;
+        }
+
+        CmdCtx.GetCommandList()->CopyTextureRegion(&DstLocation, DstX, DstY, DstZ, &SrcLocation, pD3D12SrcBox);
+        ++m_State.NumCommands;
+    }
 }
 
 void DeviceContextD3D12Impl::CopyTextureRegion(ID3D12Resource*                pd3d12Buffer,

Graphics/GraphicsEngineD3D12/src/TextureD3D12Impl.cpp

@@ -152,6 +152,10 @@ TextureD3D12Impl::TextureD3D12Impl(IReferenceCounters*        pRefCounters,
     D3D12_RESOURCE_DESC d3d12TexDesc       = GetD3D12TextureDesc();
     const bool          bInitializeTexture = (pInitData != nullptr && pInitData->pSubResources != nullptr && pInitData->NumSubresources > 0);
 
+    ID3D12Device* pd3d12Device = pRenderDeviceD3D12->GetD3D12Device();
+    if (UINT8 FormatPlaneCount = D3D12GetFormatPlaneCount(pd3d12Device, d3d12TexDesc.Format))
+        m_FormatPlaneCount = FormatPlaneCount;
+
     const SoftwareQueueIndex CmdQueueInd = pInitData != nullptr && pInitData->pContext != nullptr ?
         ClassPtrCast<DeviceContextD3D12Impl>(pInitData->pContext)->GetCommandQueueId() :
         SoftwareQueueIndex{PlatformMisc::GetLSB(m_Desc.ImmediateContextMask)};
@@ -185,7 +189,6 @@ TextureD3D12Impl::TextureD3D12Impl(IReferenceCounters*        pRefCounters,
         pClearValue = &ClearValue;
     }
 
-    ID3D12Device* pd3d12Device = pRenderDeviceD3D12->GetD3D12Device();
     if (m_Desc.Usage == USAGE_SPARSE)
     {
         d3d12TexDesc.Layout = D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE;
@@ -506,6 +509,10 @@ TextureD3D12Impl::TextureD3D12Impl(IReferenceCounters*        pRefCounters,
     m_pd3d12Resource = pTexture;
     SetState(InitialState);
 
+    ID3D12Device* pd3d12Device = pDeviceD3D12->GetD3D12Device();
+    if (UINT8 FormatPlaneCount = D3D12GetFormatPlaneCount(pd3d12Device, m_pd3d12Resource->GetDesc().Format))
+        m_FormatPlaneCount = FormatPlaneCount;
+
     if (m_Desc.Usage == USAGE_SPARSE)
         InitSparseProperties();
 }

Graphics/GraphicsEngineVulkan/src/TextureVkImpl.cpp

@@ -469,10 +469,10 @@ void TextureVkImpl::InitializeContentOnDevice(const TextureData&          InitDa
             // bufferRowLength and bufferImageHeight specify the data in buffer memory as a subregion
             // of a larger two- or three-dimensional image, and control the addressing calculations of
             // data in buffer memory. If either of these values is zero, that aspect of the buffer memory
-            // is considered to be tightly packed according to the imageExtent. (18.4)
+            // is considered to be tightly packed according to the imageExtent.
             CopyRegion.bufferRowLength   = 0;
             CopyRegion.bufferImageHeight = 0;
-            // For block-compression formats, all parameters are still specified in texels rather than compressed texel blocks (18.4.1)
+            // For block-compression formats, all parameters are still specified in texels rather than compressed texel blocks
             CopyRegion.imageOffset = VkOffset3D{0, 0, 0};
             CopyRegion.imageExtent = VkExtent3D{MipInfo.LogicalWidth, MipInfo.LogicalHeight, MipInfo.Depth};
 
@@ -485,9 +485,9 @@ void TextureVkImpl::InitializeContentOnDevice(const TextureData&          InitDa
             // For compressed-block formats, MipInfo.RowSize is the size of one row of blocks
             VERIFY(SubResData.DepthStride == 0 || SubResData.DepthStride >= (MipInfo.StorageHeight / FmtAttribs.BlockHeight) * MipInfo.RowSize, "Depth stride is too small");
 
-            // bufferOffset must be a multiple of 4 (18.4)
+            // bufferOffset must be a multiple of 4
             // If the calling command's VkImage parameter is a compressed image, bufferOffset
-            // must be a multiple of the compressed texel block size in bytes (18.4). This
+            // must be a multiple of the compressed texel block size in bytes. This
             // is automatically guaranteed as MipWidth and MipHeight are rounded to block size
             uploadBufferSize += (MipInfo.MipSize + 3) & (~3);
             ++subres;
@@ -569,7 +569,7 @@ void TextureVkImpl::InitializeContentOnDevice(const TextureData&          InitDa
     // Copy commands MUST be recorded outside of a render pass instance. This is OK here
     // as copy will be the only command in the cmd buffer
     CmdBuffer.CopyBufferToImage(StagingBuffer, m_VulkanImage,
-                                CurrentLayout, // dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL (18.4)
+                                CurrentLayout, // dstImageLayout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL
                                 static_cast<uint32_t>(Regions.size()), Regions.data());
 
     GetDevice()->ExecuteAndDisposeTransientCmdBuff(CmdQueueInd, CmdBuffer.GetVkCmdBuffer(), std::move(CmdPool));