yum-mirror/slang

Making it easier to work with shaders

git clone https://git.yummers.dev/yum-mirror/slang

Ellie Hermaszewskaformatf65d756bf

master
branchesmasterall refs →
12.2 KiB346 linesraw
1// d3d12-command-encoder.h
2#pragma once
3
4#include "d3d12-base.h"
5#include "d3d12-buffer.h"
6#include "d3d12-framebuffer.h"
7#include "d3d12-render-pass.h"
8#include "d3d12-submitter.h"
9
10namespace gfx
11{
12namespace d3d12
13{
14
15using namespace Slang;
16
17static const Int kMaxRTVCount = 8;
18
19class PipelineCommandEncoder
20{
21public:
22    bool m_isOpen = false;
23    bool m_bindingDirty = true;
24    CommandBufferImpl* m_commandBuffer;
25    TransientResourceHeapImpl* m_transientHeap;
26    DeviceImpl* m_renderer;
27    ID3D12Device* m_device;
28    ID3D12GraphicsCommandList* m_d3dCmdList;
29    ID3D12GraphicsCommandList6* m_d3dCmdList6;
30    ID3D12GraphicsCommandList* m_preCmdList = nullptr;
31
32    RefPtr<PipelineStateBase> m_currentPipeline;
33
34    static int getBindPointIndex(PipelineType type);
35
36    void init(CommandBufferImpl* commandBuffer);
37
38    void endEncodingImpl() { m_isOpen = false; }
39
40    Result bindPipelineImpl(IPipelineState* pipelineState, IShaderObject** outRootObject);
41
42    Result bindPipelineWithRootObjectImpl(IPipelineState* pipelineState, IShaderObject* rootObject);
43
44    /// Specializes the pipeline according to current root-object argument values,
45    /// applys the root object bindings and binds the pipeline state.
46    /// The newly specialized pipeline is held alive by the pipeline cache so users of
47    /// `newPipeline` do not need to maintain its lifespan.
48    Result _bindRenderState(Submitter* submitter, RefPtr<PipelineStateBase>& newPipeline);
49};
50
51class ResourceCommandEncoderImpl : public IResourceCommandEncoder, public PipelineCommandEncoder
52{
53public:
54    virtual void* getInterface(SlangUUID const& uuid)
55    {
56        if (uuid == GfxGUID::IID_IResourceCommandEncoder || uuid == ISlangUnknown::getTypeGuid())
57            return this;
58        return nullptr;
59    }
60    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
61    queryInterface(SlangUUID const& uuid, void** outObject) override
62    {
63        if (auto ptr = getInterface(uuid))
64        {
65            *outObject = ptr;
66            return SLANG_OK;
67        }
68        return SLANG_E_NO_INTERFACE;
69    }
70    virtual SLANG_NO_THROW uint32_t SLANG_MCALL addRef() override { return 1; }
71    virtual SLANG_NO_THROW uint32_t SLANG_MCALL release() override { return 1; }
72
73    virtual SLANG_NO_THROW void SLANG_MCALL copyBuffer(
74        IBufferResource* dst,
75        Offset dstOffset,
76        IBufferResource* src,
77        Offset srcOffset,
78        Size size) override;
79    virtual SLANG_NO_THROW void SLANG_MCALL
80    uploadBufferData(IBufferResource* dst, Offset offset, Size size, void* data) override;
81    virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
82        GfxCount count,
83        ITextureResource* const* textures,
84        ResourceState src,
85        ResourceState dst) override;
86    virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(
87        GfxCount count,
88        IBufferResource* const* buffers,
89        ResourceState src,
90        ResourceState dst) override;
91    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override {}
92    virtual SLANG_NO_THROW void SLANG_MCALL
93    writeTimestamp(IQueryPool* pool, GfxIndex index) override;
94    virtual SLANG_NO_THROW void SLANG_MCALL copyTexture(
95        ITextureResource* dst,
96        ResourceState dstState,
97        SubresourceRange dstSubresource,
98        ITextureResource::Offset3D dstOffset,
99        ITextureResource* src,
100        ResourceState srcState,
101        SubresourceRange srcSubresource,
102        ITextureResource::Offset3D srcOffset,
103        ITextureResource::Extents extent) override;
104
105    virtual SLANG_NO_THROW void SLANG_MCALL uploadTextureData(
106        ITextureResource* dst,
107        SubresourceRange subResourceRange,
108        ITextureResource::Offset3D offset,
109        ITextureResource::Extents extent,
110        ITextureResource::SubresourceData* subResourceData,
111        GfxCount subResourceDataCount) override;
112
113    virtual SLANG_NO_THROW void SLANG_MCALL clearResourceView(
114        IResourceView* view,
115        ClearValue* clearValue,
116        ClearResourceViewFlags::Enum flags) override;
117
118    virtual SLANG_NO_THROW void SLANG_MCALL resolveResource(
119        ITextureResource* source,
120        ResourceState sourceState,
121        SubresourceRange sourceRange,
122        ITextureResource* dest,
123        ResourceState destState,
124        SubresourceRange destRange) override;
125
126    virtual SLANG_NO_THROW void SLANG_MCALL resolveQuery(
127        IQueryPool* queryPool,
128        GfxIndex index,
129        GfxCount count,
130        IBufferResource* buffer,
131        Offset offset) override;
132
133    virtual SLANG_NO_THROW void SLANG_MCALL copyTextureToBuffer(
134        IBufferResource* dst,
135        Offset dstOffset,
136        Size dstSize,
137        Size dstRowStride,
138        ITextureResource* src,
139        ResourceState srcState,
140        SubresourceRange srcSubresource,
141        ITextureResource::Offset3D srcOffset,
142        ITextureResource::Extents extent) override;
143
144    virtual SLANG_NO_THROW void SLANG_MCALL textureSubresourceBarrier(
145        ITextureResource* texture,
146        SubresourceRange subresourceRange,
147        ResourceState src,
148        ResourceState dst) override;
149
150    virtual SLANG_NO_THROW void SLANG_MCALL
151    beginDebugEvent(const char* name, float rgbColor[3]) override;
152    virtual SLANG_NO_THROW void SLANG_MCALL endDebugEvent() override;
153};
154
155class ComputeCommandEncoderImpl : public IComputeCommandEncoder, public ResourceCommandEncoderImpl
156{
157public:
158    SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(ResourceCommandEncoderImpl)
159    virtual void* getInterface(SlangUUID const& uuid) override
160    {
161        if (uuid == GfxGUID::IID_IComputeCommandEncoder ||
162            uuid == GfxGUID::IID_IResourceCommandEncoder || uuid == ISlangUnknown::getTypeGuid())
163            return this;
164        return nullptr;
165    }
166
167public:
168    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
169    void init(
170        DeviceImpl* renderer,
171        TransientResourceHeapImpl* transientHeap,
172        CommandBufferImpl* cmdBuffer);
173
174    virtual SLANG_NO_THROW Result SLANG_MCALL
175    bindPipeline(IPipelineState* state, IShaderObject** outRootObject) override;
176
177    virtual SLANG_NO_THROW Result SLANG_MCALL
178    bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) override;
179
180    virtual SLANG_NO_THROW Result SLANG_MCALL dispatchCompute(int x, int y, int z) override;
181
182    virtual SLANG_NO_THROW Result SLANG_MCALL
183    dispatchComputeIndirect(IBufferResource* argBuffer, Offset offset) override;
184};
185
186struct BoundVertexBuffer
187{
188    RefPtr<BufferResourceImpl> m_buffer;
189    int m_offset;
190};
191
192class RenderCommandEncoderImpl : public IRenderCommandEncoder, public ResourceCommandEncoderImpl
193{
194public:
195    SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(ResourceCommandEncoderImpl)
196    virtual void* getInterface(SlangUUID const& uuid) override
197    {
198        if (uuid == GfxGUID::IID_IRenderCommandEncoder ||
199            uuid == GfxGUID::IID_IResourceCommandEncoder || uuid == ISlangUnknown::getTypeGuid())
200            return this;
201        return nullptr;
202    }
203
204public:
205    RefPtr<RenderPassLayoutImpl> m_renderPass;
206    RefPtr<FramebufferImpl> m_framebuffer;
207
208    List<BoundVertexBuffer> m_boundVertexBuffers;
209
210    RefPtr<BufferResourceImpl> m_boundIndexBuffer;
211
212    D3D12_VIEWPORT m_viewports[kMaxRTVCount];
213    D3D12_RECT m_scissorRects[kMaxRTVCount];
214
215    DXGI_FORMAT m_boundIndexFormat;
216    UINT m_boundIndexOffset;
217
218    D3D12_PRIMITIVE_TOPOLOGY_TYPE m_primitiveTopologyType;
219    D3D12_PRIMITIVE_TOPOLOGY m_primitiveTopology;
220
221    void init(
222        DeviceImpl* renderer,
223        TransientResourceHeapImpl* transientHeap,
224        CommandBufferImpl* cmdBuffer,
225        RenderPassLayoutImpl* renderPass,
226        FramebufferImpl* framebuffer);
227
228    virtual SLANG_NO_THROW Result SLANG_MCALL
229    bindPipeline(IPipelineState* state, IShaderObject** outRootObject) override;
230
231    virtual SLANG_NO_THROW Result SLANG_MCALL
232    bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) override;
233
234    virtual SLANG_NO_THROW void SLANG_MCALL
235    setViewports(GfxCount count, const Viewport* viewports) override;
236
237    virtual SLANG_NO_THROW void SLANG_MCALL
238    setScissorRects(GfxCount count, const ScissorRect* rects) override;
239
240    virtual SLANG_NO_THROW void SLANG_MCALL
241    setPrimitiveTopology(PrimitiveTopology topology) override;
242
243    virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
244        GfxIndex startSlot,
245        GfxCount slotCount,
246        IBufferResource* const* buffers,
247        const Offset* offsets) override;
248
249    virtual SLANG_NO_THROW void SLANG_MCALL
250    setIndexBuffer(IBufferResource* buffer, Format indexFormat, Offset offset = 0) override;
251
252    Result prepareDraw();
253    virtual SLANG_NO_THROW Result SLANG_MCALL
254    draw(GfxCount vertexCount, GfxIndex startVertex = 0) override;
255    virtual SLANG_NO_THROW Result SLANG_MCALL
256    drawIndexed(GfxCount indexCount, GfxIndex startIndex = 0, GfxIndex baseVertex = 0) override;
257    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
258
259    virtual SLANG_NO_THROW void SLANG_MCALL setStencilReference(uint32_t referenceValue) override;
260
261    virtual SLANG_NO_THROW Result SLANG_MCALL drawIndirect(
262        GfxCount maxDrawCount,
263        IBufferResource* argBuffer,
264        Offset argOffset,
265        IBufferResource* countBuffer,
266        Offset countOffset) override;
267
268    virtual SLANG_NO_THROW Result SLANG_MCALL drawIndexedIndirect(
269        GfxCount maxDrawCount,
270        IBufferResource* argBuffer,
271        Offset argOffset,
272        IBufferResource* countBuffer,
273        Offset countOffset) override;
274
275    virtual SLANG_NO_THROW Result SLANG_MCALL setSamplePositions(
276        GfxCount samplesPerPixel,
277        GfxCount pixelCount,
278        const SamplePosition* samplePositions) override;
279
280    virtual SLANG_NO_THROW Result SLANG_MCALL drawInstanced(
281        GfxCount vertexCount,
282        GfxCount instanceCount,
283        GfxIndex startVertex,
284        GfxIndex startInstanceLocation) override;
285
286    virtual SLANG_NO_THROW Result SLANG_MCALL drawIndexedInstanced(
287        GfxCount indexCount,
288        GfxCount instanceCount,
289        GfxIndex startIndexLocation,
290        GfxIndex baseVertexLocation,
291        GfxIndex startInstanceLocation) override;
292
293    virtual SLANG_NO_THROW Result SLANG_MCALL drawMeshTasks(int x, int y, int z) override;
294};
295
296#if SLANG_GFX_HAS_DXR_SUPPORT
297class RayTracingCommandEncoderImpl : public IRayTracingCommandEncoder,
298                                     public ResourceCommandEncoderImpl
299{
300public:
301    SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(ResourceCommandEncoderImpl)
302    virtual void* getInterface(SlangUUID const& uuid) override
303    {
304        if (uuid == GfxGUID::IID_IRayTracingCommandEncoder ||
305            uuid == GfxGUID::IID_IResourceCommandEncoder || uuid == ISlangUnknown::getTypeGuid())
306            return this;
307        return nullptr;
308    }
309
310public:
311    virtual SLANG_NO_THROW void SLANG_MCALL buildAccelerationStructure(
312        const IAccelerationStructure::BuildDesc& desc,
313        GfxCount propertyQueryCount,
314        AccelerationStructureQueryDesc* queryDescs) override;
315    virtual SLANG_NO_THROW void SLANG_MCALL copyAccelerationStructure(
316        IAccelerationStructure* dest,
317        IAccelerationStructure* src,
318        AccelerationStructureCopyMode mode) override;
319    virtual SLANG_NO_THROW void SLANG_MCALL queryAccelerationStructureProperties(
320        GfxCount accelerationStructureCount,
321        IAccelerationStructure* const* accelerationStructures,
322        GfxCount queryCount,
323        AccelerationStructureQueryDesc* queryDescs) override;
324    virtual SLANG_NO_THROW void SLANG_MCALL
325    serializeAccelerationStructure(DeviceAddress dest, IAccelerationStructure* source) override;
326    virtual SLANG_NO_THROW void SLANG_MCALL
327    deserializeAccelerationStructure(IAccelerationStructure* dest, DeviceAddress source) override;
328    virtual SLANG_NO_THROW Result SLANG_MCALL
329    bindPipeline(IPipelineState* state, IShaderObject** outRootObject) override;
330    virtual SLANG_NO_THROW Result SLANG_MCALL
331    bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) override
332    {
333        return bindPipelineWithRootObjectImpl(state, rootObject);
334    }
335    virtual SLANG_NO_THROW Result SLANG_MCALL dispatchRays(
336        GfxIndex rayGenShaderIndex,
337        IShaderTable* shaderTable,
338        GfxCount width,
339        GfxCount height,
340        GfxCount depth) override;
341    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override {}
342};
343#endif
344
345} // namespace d3d12
346} // namespace gfx