Split render-d3d12.h/cpp into a set of smaller files (#2231)

* Split render-d3d12 into numerous smaller files to make the code easier to parse

* Added all new D3D12 files created from splitting render-d3d12

* Fixed several uses of attachment still floating around; Changed resource-d3d12 and descriptor-heap-d3d12 to match naming conventions of new d3d12 implementation header files

* Readded files with name changes because changing them from inside VS apparently results in them being treated as new files

* Merged in externals changes from master

* Small cleanup changes

* Rerun CI

Co-authored-by: Theresa Foley <10618364+tangent-vector@users.noreply.github.com>

1 files changed, 106 insertions, 0 deletions

diff --git a/tools/gfx/d3d12/d3d12-shader-table.cpp b/tools/gfx/d3d12/d3d12-shader-table.cpp
new file mode 100644
index 000000000..ef4feecc7
--- /dev/null
+++ b/tools/gfx/d3d12/d3d12-shader-table.cpp
@@ -0,0 +1,106 @@
+// d3d12-shader-table.cpp
+#include "d3d12-shader-table.h"
+
+#include "d3d12-device.h"
+#include "d3d12-pipeline-state.h"
+#include "d3d12-transient-heap.h"
+
+namespace gfx
+{
+namespace d3d12
+{
+
+using namespace Slang;
+
+RefPtr<BufferResource> ShaderTableImpl::createDeviceBuffer(
+    PipelineStateBase* pipeline,
+    TransientResourceHeapBase* transientHeap,
+    IResourceCommandEncoder* encoder)
+{
+    uint32_t raygenTableSize = m_rayGenShaderCount * D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES;
+    uint32_t missTableSize = m_missShaderCount * D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES;
+    uint32_t hitgroupTableSize = m_hitGroupCount * D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES;
+    m_rayGenTableOffset = 0;
+    m_missTableOffset = (uint32_t)D3DUtil::calcAligned(
+        raygenTableSize, D3D12_RAYTRACING_SHADER_TABLE_BYTE_ALIGNMENT);
+    m_hitGroupTableOffset = (uint32_t)D3DUtil::calcAligned(
+        m_missTableOffset + missTableSize, D3D12_RAYTRACING_SHADER_TABLE_BYTE_ALIGNMENT);
+    uint32_t tableSize = m_hitGroupTableOffset + hitgroupTableSize;
+
+    auto pipelineImpl = static_cast<RayTracingPipelineStateImpl*>(pipeline);
+    ComPtr<IBufferResource> bufferResource;
+    IBufferResource::Desc bufferDesc = {};
+    bufferDesc.memoryType = gfx::MemoryType::DeviceLocal;
+    bufferDesc.defaultState = ResourceState::General;
+    bufferDesc.type = IResource::Type::Buffer;
+    bufferDesc.sizeInBytes = tableSize;
+    m_device->createBufferResource(bufferDesc, nullptr, bufferResource.writeRef());
+
+    ComPtr<ID3D12StateObjectProperties> stateObjectProperties;
+    pipelineImpl->m_stateObject->QueryInterface(stateObjectProperties.writeRef());
+
+    TransientResourceHeapImpl* transientHeapImpl =
+        static_cast<TransientResourceHeapImpl*>(transientHeap);
+
+    IBufferResource* stagingBuffer = nullptr;
+    Offset stagingBufferOffset = 0;
+    transientHeapImpl->allocateStagingBuffer(
+        tableSize, stagingBuffer, stagingBufferOffset, MemoryType::Upload);
+
+    assert(stagingBuffer);
+    void* stagingPtr = nullptr;
+    stagingBuffer->map(nullptr, &stagingPtr);
+
+    auto copyShaderIdInto = [&](void* dest, String& name, const ShaderRecordOverwrite& overwrite)
+    {
+        if (name.getLength())
+        {
+            void* shaderId = stateObjectProperties->GetShaderIdentifier(name.toWString().begin());
+            memcpy(dest, shaderId, D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES);
+        }
+        else
+        {
+            memset(dest, 0, D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES);
+        }
+        if (overwrite.size)
+        {
+            memcpy((uint8_t*)dest + overwrite.offset, overwrite.data, overwrite.size);
+        }
+    };
+
+    uint8_t* stagingBufferPtr = (uint8_t*)stagingPtr + stagingBufferOffset;
+    for (uint32_t i = 0; i < m_rayGenShaderCount; i++)
+    {
+        copyShaderIdInto(
+            stagingBufferPtr + m_rayGenTableOffset + D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES * i,
+            m_shaderGroupNames[i],
+            m_recordOverwrites[i]);
+    }
+    for (uint32_t i = 0; i < m_missShaderCount; i++)
+    {
+        copyShaderIdInto(
+            stagingBufferPtr + m_missTableOffset + D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES * i,
+            m_shaderGroupNames[m_rayGenShaderCount + i],
+            m_recordOverwrites[m_rayGenShaderCount + i]);
+    }
+    for (uint32_t i = 0; i < m_hitGroupCount; i++)
+    {
+        copyShaderIdInto(
+            stagingBufferPtr + m_hitGroupTableOffset + D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES * i,
+            m_shaderGroupNames[m_rayGenShaderCount + m_missShaderCount + i],
+            m_recordOverwrites[m_rayGenShaderCount + m_missShaderCount + i]);
+    }
+
+    stagingBuffer->unmap(nullptr);
+    encoder->copyBuffer(bufferResource, 0, stagingBuffer, stagingBufferOffset, tableSize);
+    encoder->bufferBarrier(
+        1,
+        bufferResource.readRef(),
+        gfx::ResourceState::CopyDestination,
+        gfx::ResourceState::ShaderResource);
+    RefPtr<BufferResource> resultPtr = static_cast<BufferResource*>(bufferResource.get());
+    return _Move(resultPtr);
+}
+
+} // namespace d3d12
+} // namespace gfx