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, 305 insertions, 0 deletions

diff --git a/tools/gfx/d3d12/d3d12-command-encoder.h b/tools/gfx/d3d12/d3d12-command-encoder.h
new file mode 100644
index 000000000..bf2f7710b
--- /dev/null
+++ b/tools/gfx/d3d12/d3d12-command-encoder.h
@@ -0,0 +1,305 @@
+// d3d12-command-encoder.h
+#pragma once
+
+#include "d3d12-base.h"
+#include "d3d12-buffer.h"
+#include "d3d12-framebuffer.h"
+#include "d3d12-render-pass.h"
+#include "d3d12-submitter.h"
+
+namespace gfx
+{
+namespace d3d12
+{
+
+using namespace Slang;
+
+static const Int kMaxRTVCount = 8;
+
+class PipelineCommandEncoder
+{
+public:
+    bool m_isOpen = false;
+    bool m_bindingDirty = true;
+    CommandBufferImpl* m_commandBuffer;
+    TransientResourceHeapImpl* m_transientHeap;
+    DeviceImpl* m_renderer;
+    ID3D12Device* m_device;
+    ID3D12GraphicsCommandList* m_d3dCmdList;
+    ID3D12GraphicsCommandList* m_preCmdList = nullptr;
+
+    RefPtr<PipelineStateBase> m_currentPipeline;
+
+    static int getBindPointIndex(PipelineType type);
+
+    void init(CommandBufferImpl* commandBuffer);
+
+    void endEncodingImpl() { m_isOpen = false; }
+
+    Result bindPipelineImpl(IPipelineState* pipelineState, IShaderObject** outRootObject);
+
+    Result bindPipelineWithRootObjectImpl(IPipelineState* pipelineState, IShaderObject* rootObject);
+
+    /// Specializes the pipeline according to current root-object argument values,
+    /// applys the root object bindings and binds the pipeline state.
+    /// The newly specialized pipeline is held alive by the pipeline cache so users of
+    /// `newPipeline` do not need to maintain its lifespan.
+    Result _bindRenderState(Submitter* submitter, RefPtr<PipelineStateBase>& newPipeline);
+};
+
+class ResourceCommandEncoderImpl
+    : public IResourceCommandEncoder
+    , public PipelineCommandEncoder
+{
+public:
+    virtual SLANG_NO_THROW void SLANG_MCALL copyBuffer(
+        IBufferResource* dst,
+        Offset dstOffset,
+        IBufferResource* src,
+        Offset srcOffset,
+        Size size) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        uploadBufferData(IBufferResource* dst, Offset offset, Size size, void* data) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
+        GfxCount count,
+        ITextureResource* const* textures,
+        ResourceState src,
+        ResourceState dst) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(
+        GfxCount count,
+        IBufferResource* const* buffers,
+        ResourceState src,
+        ResourceState dst) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() {}
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        writeTimestamp(IQueryPool* pool, GfxIndex index) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL copyTexture(
+        ITextureResource* dst,
+        ResourceState dstState,
+        SubresourceRange dstSubresource,
+        ITextureResource::Offset3D dstOffset,
+        ITextureResource* src,
+        ResourceState srcState,
+        SubresourceRange srcSubresource,
+        ITextureResource::Offset3D srcOffset,
+        ITextureResource::Extents extent) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL uploadTextureData(
+        ITextureResource* dst,
+        SubresourceRange subResourceRange,
+        ITextureResource::Offset3D offset,
+        ITextureResource::Extents extent,
+        ITextureResource::SubresourceData* subResourceData,
+        GfxCount subResourceDataCount) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL clearResourceView(
+        IResourceView* view, ClearValue* clearValue, ClearResourceViewFlags::Enum flags) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL resolveResource(
+        ITextureResource* source,
+        ResourceState sourceState,
+        SubresourceRange sourceRange,
+        ITextureResource* dest,
+        ResourceState destState,
+        SubresourceRange destRange) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL resolveQuery(
+        IQueryPool* queryPool,
+        GfxIndex index,
+        GfxCount count,
+        IBufferResource* buffer,
+        Offset offset) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL copyTextureToBuffer(
+        IBufferResource* dst,
+        Offset dstOffset,
+        Size dstSize,
+        Size dstRowStride,
+        ITextureResource* src,
+        ResourceState srcState,
+        SubresourceRange srcSubresource,
+        ITextureResource::Offset3D srcOffset,
+        ITextureResource::Extents extent) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL textureSubresourceBarrier(
+        ITextureResource* texture,
+        SubresourceRange subresourceRange,
+        ResourceState src,
+        ResourceState dst) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        beginDebugEvent(const char* name, float rgbColor[3]) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL endDebugEvent() override;
+};
+
+class ComputeCommandEncoderImpl
+    : public IComputeCommandEncoder
+    , public ResourceCommandEncoderImpl
+{
+public:
+    SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(ResourceCommandEncoderImpl)
+public:
+    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
+    void init(
+        DeviceImpl* renderer,
+        TransientResourceHeapImpl* transientHeap,
+        CommandBufferImpl* cmdBuffer);
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        bindPipeline(IPipelineState* state, IShaderObject** outRootObject) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL dispatchCompute(int x, int y, int z) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        dispatchComputeIndirect(IBufferResource* argBuffer, Offset offset) override;
+};
+
+struct BoundVertexBuffer
+{
+    RefPtr<BufferResourceImpl> m_buffer;
+    int m_offset;
+};
+
+class RenderCommandEncoderImpl
+    : public IRenderCommandEncoder
+    , public ResourceCommandEncoderImpl
+{
+public:
+    SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(ResourceCommandEncoderImpl)
+public:
+    RefPtr<RenderPassLayoutImpl> m_renderPass;
+    RefPtr<FramebufferImpl> m_framebuffer;
+
+    List<BoundVertexBuffer> m_boundVertexBuffers;
+
+    RefPtr<BufferResourceImpl> m_boundIndexBuffer;
+
+    D3D12_VIEWPORT m_viewports[kMaxRTVCount];
+    D3D12_RECT m_scissorRects[kMaxRTVCount];
+
+    DXGI_FORMAT m_boundIndexFormat;
+    UINT m_boundIndexOffset;
+
+    D3D12_PRIMITIVE_TOPOLOGY_TYPE m_primitiveTopologyType;
+    D3D12_PRIMITIVE_TOPOLOGY m_primitiveTopology;
+
+    void init(
+        DeviceImpl* renderer,
+        TransientResourceHeapImpl* transientHeap,
+        CommandBufferImpl* cmdBuffer,
+        RenderPassLayoutImpl* renderPass,
+        FramebufferImpl* framebuffer);
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        bindPipeline(IPipelineState* state, IShaderObject** outRootObject) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setViewports(GfxCount count, const Viewport* viewports) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setScissorRects(GfxCount count, const ScissorRect* rects) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setPrimitiveTopology(PrimitiveTopology topology) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
+        GfxIndex startSlot,
+        GfxCount slotCount,
+        IBufferResource* const* buffers,
+        const Offset* offsets) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setIndexBuffer(IBufferResource* buffer, Format indexFormat, Offset offset = 0) override;
+
+    void prepareDraw();
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        draw(GfxCount vertexCount, GfxIndex startVertex = 0) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        drawIndexed(GfxCount indexCount, GfxIndex startIndex = 0, GfxIndex baseVertex = 0) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL setStencilReference(uint32_t referenceValue) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL drawIndirect(
+        GfxCount maxDrawCount,
+        IBufferResource* argBuffer,
+        Offset argOffset,
+        IBufferResource* countBuffer,
+        Offset countOffset) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedIndirect(
+        GfxCount maxDrawCount,
+        IBufferResource* argBuffer,
+        Offset argOffset,
+        IBufferResource* countBuffer,
+        Offset countOffset) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL setSamplePositions(
+        GfxCount samplesPerPixel,
+        GfxCount pixelCount,
+        const SamplePosition* samplePositions) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL drawInstanced(
+        GfxCount vertexCount,
+        GfxCount instanceCount,
+        GfxIndex startVertex,
+        GfxIndex startInstanceLocation) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedInstanced(
+        GfxCount indexCount,
+        GfxCount instanceCount,
+        GfxIndex startIndexLocation,
+        GfxIndex baseVertexLocation,
+        GfxIndex startInstanceLocation) override;
+};
+
+#if SLANG_GFX_HAS_DXR_SUPPORT
+class RayTracingCommandEncoderImpl
+    : public IRayTracingCommandEncoder
+    , public ResourceCommandEncoderImpl
+{
+public:
+    SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(ResourceCommandEncoderImpl)
+public:
+    virtual SLANG_NO_THROW void SLANG_MCALL buildAccelerationStructure(
+        const IAccelerationStructure::BuildDesc& desc,
+        GfxCount propertyQueryCount,
+        AccelerationStructureQueryDesc* queryDescs) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL copyAccelerationStructure(
+        IAccelerationStructure* dest,
+        IAccelerationStructure* src,
+        AccelerationStructureCopyMode mode) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL queryAccelerationStructureProperties(
+        GfxCount accelerationStructureCount,
+        IAccelerationStructure* const* accelerationStructures,
+        GfxCount queryCount,
+        AccelerationStructureQueryDesc* queryDescs) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        serializeAccelerationStructure(DeviceAddress dest, IAccelerationStructure* source) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL deserializeAccelerationStructure(
+        IAccelerationStructure* dest, DeviceAddress source) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        bindPipeline(IPipelineState* state, IShaderObject** outRootObject) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) override
+    {
+        return bindPipelineWithRootObjectImpl(state, rootObject);
+    }
+    virtual SLANG_NO_THROW void SLANG_MCALL dispatchRays(
+        GfxIndex rayGenShaderIndex,
+        IShaderTable* shaderTable,
+        GfxCount width,
+        GfxCount height,
+        GfxCount depth) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() {}
+};
+#endif
+
+} // namespace d3d12
+} // namespace gfx