yum-mirror/slang

Making it easier to work with shaders

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

Ellie Hermaszewskaformatf65d756bf

master
branchesmasterall refs →
11.5 KiB294 linesraw
1// debug-command-encoder.h
2#pragma once
3#include "debug-base.h"
4
5namespace gfx
6{
7using namespace Slang;
8
9namespace debug
10{
11
12class DebugResourceCommandEncoderImpl
13{
14public:
15    virtual DebugCommandBuffer* getCommandBuffer() = 0;
16    virtual bool getIsOpen() = 0;
17    virtual IResourceCommandEncoder* getBaseResourceEncoder() = 0;
18    virtual void* getInterface(SlangUUID const& uuid) = 0;
19    SlangResult queryInterface(SlangUUID const& uuid, void** outObject)
20    {
21        if (auto ptr = getInterface(uuid))
22        {
23            *outObject = ptr;
24            return SLANG_OK;
25        }
26        return SLANG_E_NO_INTERFACE;
27    }
28    uint32_t addRef() { return 1; }
29    uint32_t release() { return 1; }
30
31public:
32    virtual SLANG_NO_THROW void SLANG_MCALL copyBuffer(
33        IBufferResource* dst,
34        Offset dstOffset,
35        IBufferResource* src,
36        Offset srcOffset,
37        Size size);
38    virtual SLANG_NO_THROW void SLANG_MCALL
39    uploadBufferData(IBufferResource* dst, Offset offset, Size size, void* data);
40    virtual SLANG_NO_THROW void SLANG_MCALL writeTimestamp(IQueryPool* pool, GfxIndex index);
41    virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
42        GfxCount count,
43        ITextureResource* const* textures,
44        ResourceState src,
45        ResourceState dst);
46    virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(
47        GfxCount count,
48        IBufferResource* const* buffers,
49        ResourceState src,
50        ResourceState dst);
51    virtual SLANG_NO_THROW void SLANG_MCALL copyTexture(
52        ITextureResource* dst,
53        ResourceState dstState,
54        SubresourceRange dstSubresource,
55        ITextureResource::Offset3D dstOffset,
56        ITextureResource* src,
57        ResourceState srcState,
58        SubresourceRange srcSubresource,
59        ITextureResource::Offset3D srcOffset,
60        ITextureResource::Extents extent);
61    virtual SLANG_NO_THROW void SLANG_MCALL uploadTextureData(
62        ITextureResource* dst,
63        SubresourceRange subResourceRange,
64        ITextureResource::Offset3D offset,
65        ITextureResource::Extents extent,
66        ITextureResource::SubresourceData* subResourceData,
67        GfxCount subResourceDataCount);
68    virtual SLANG_NO_THROW void SLANG_MCALL clearResourceView(
69        IResourceView* view,
70        ClearValue* clearValue,
71        ClearResourceViewFlags::Enum flags);
72    virtual SLANG_NO_THROW void SLANG_MCALL resolveResource(
73        ITextureResource* source,
74        ResourceState sourceState,
75        SubresourceRange sourceRange,
76        ITextureResource* dest,
77        ResourceState destState,
78        SubresourceRange destRange);
79    virtual SLANG_NO_THROW void SLANG_MCALL copyTextureToBuffer(
80        IBufferResource* dst,
81        Offset dstOffset,
82        Size dstSize,
83        Size dstRowStride,
84        ITextureResource* src,
85        ResourceState srcState,
86        SubresourceRange srcSubresource,
87        ITextureResource::Offset3D srcOffset,
88        ITextureResource::Extents extent);
89    virtual SLANG_NO_THROW void SLANG_MCALL textureSubresourceBarrier(
90        ITextureResource* texture,
91        SubresourceRange subresourceRange,
92        ResourceState src,
93        ResourceState dst);
94    virtual SLANG_NO_THROW void SLANG_MCALL resolveQuery(
95        IQueryPool* queryPool,
96        GfxIndex index,
97        GfxCount count,
98        IBufferResource* buffer,
99        Offset offset);
100    virtual SLANG_NO_THROW void SLANG_MCALL beginDebugEvent(const char* name, float rgbColor[3]);
101    virtual SLANG_NO_THROW void SLANG_MCALL endDebugEvent();
102};
103
104class DebugComputeCommandEncoder : public UnownedDebugObject<IComputeCommandEncoder>,
105                                   public DebugResourceCommandEncoderImpl
106{
107public:
108    SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(DebugResourceCommandEncoderImpl)
109    virtual DebugCommandBuffer* getCommandBuffer() override { return commandBuffer; }
110    virtual bool getIsOpen() override { return isOpen; }
111    virtual IResourceCommandEncoder* getBaseResourceEncoder() override { return baseObject; }
112    virtual void* getInterface(SlangUUID const& uuid) override
113    {
114        if (uuid == GfxGUID::IID_IResourceCommandEncoder ||
115            uuid == GfxGUID::IID_IComputeCommandEncoder || uuid == ISlangUnknown::getTypeGuid())
116        {
117            return this;
118        }
119        return nullptr;
120    }
121
122public:
123    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
124    virtual SLANG_NO_THROW Result SLANG_MCALL
125    bindPipeline(IPipelineState* state, IShaderObject** outRootShaderObject) override;
126    virtual SLANG_NO_THROW Result SLANG_MCALL
127    bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) override;
128    virtual SLANG_NO_THROW Result SLANG_MCALL dispatchCompute(int x, int y, int z) override;
129    virtual SLANG_NO_THROW Result SLANG_MCALL
130    dispatchComputeIndirect(IBufferResource* cmdBuffer, Offset offset) override;
131
132public:
133    DebugCommandBuffer* commandBuffer;
134    bool isOpen = false;
135};
136
137class DebugResourceCommandEncoder : public UnownedDebugObject<IResourceCommandEncoder>,
138                                    public DebugResourceCommandEncoderImpl
139{
140public:
141    SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(DebugResourceCommandEncoderImpl)
142    virtual DebugCommandBuffer* getCommandBuffer() override { return commandBuffer; }
143    virtual bool getIsOpen() override { return isOpen; }
144    virtual IResourceCommandEncoder* getBaseResourceEncoder() override { return baseObject; }
145    virtual void* getInterface(SlangUUID const& uuid) override
146    {
147        if (uuid == GfxGUID::IID_IResourceCommandEncoder || uuid == ISlangUnknown::getTypeGuid())
148        {
149            return this;
150        }
151        return nullptr;
152    }
153
154public:
155    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
156
157public:
158    DebugCommandBuffer* commandBuffer;
159    bool isOpen = false;
160};
161
162class DebugRenderCommandEncoder : public UnownedDebugObject<IRenderCommandEncoder>,
163                                  public DebugResourceCommandEncoderImpl
164{
165public:
166    SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(DebugResourceCommandEncoderImpl)
167    virtual DebugCommandBuffer* getCommandBuffer() override { return commandBuffer; }
168    virtual bool getIsOpen() override { return isOpen; }
169    virtual IResourceCommandEncoder* getBaseResourceEncoder() override { return baseObject; }
170    virtual void* getInterface(SlangUUID const& uuid) override
171    {
172        if (uuid == GfxGUID::IID_IResourceCommandEncoder ||
173            uuid == GfxGUID::IID_IRenderCommandEncoder || uuid == ISlangUnknown::getTypeGuid())
174        {
175            return this;
176        }
177        return nullptr;
178    }
179
180public:
181    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
182    virtual SLANG_NO_THROW Result SLANG_MCALL
183    bindPipeline(IPipelineState* state, IShaderObject** outRootShaderObject) override;
184    virtual SLANG_NO_THROW Result SLANG_MCALL
185    bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) override;
186    virtual SLANG_NO_THROW void SLANG_MCALL
187    setViewports(GfxCount count, const Viewport* viewports) override;
188    virtual SLANG_NO_THROW void SLANG_MCALL
189    setScissorRects(GfxCount count, const ScissorRect* scissors) override;
190    virtual SLANG_NO_THROW void SLANG_MCALL
191    setPrimitiveTopology(PrimitiveTopology topology) override;
192    virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
193        GfxIndex startSlot,
194        GfxCount slotCount,
195        IBufferResource* const* buffers,
196        const Offset* offsets) override;
197    virtual SLANG_NO_THROW void SLANG_MCALL
198    setIndexBuffer(IBufferResource* buffer, Format indexFormat, Offset offset = 0) override;
199    virtual SLANG_NO_THROW Result SLANG_MCALL
200    draw(GfxCount vertexCount, GfxIndex startVertex = 0) override;
201    virtual SLANG_NO_THROW Result SLANG_MCALL
202    drawIndexed(GfxCount indexCount, GfxIndex startIndex = 0, GfxIndex baseVertex = 0) override;
203    virtual SLANG_NO_THROW Result SLANG_MCALL drawIndirect(
204        GfxCount maxDrawCount,
205        IBufferResource* argBuffer,
206        Offset argOffset,
207        IBufferResource* countBuffer,
208        Offset countOffset) override;
209    virtual SLANG_NO_THROW Result SLANG_MCALL drawIndexedIndirect(
210        GfxCount maxDrawCount,
211        IBufferResource* argBuffer,
212        Offset argOffset,
213        IBufferResource* countBuffer,
214        Offset countOffset) override;
215    virtual SLANG_NO_THROW void SLANG_MCALL setStencilReference(uint32_t referenceValue) override;
216    virtual SLANG_NO_THROW Result SLANG_MCALL setSamplePositions(
217        GfxCount samplesPerPixel,
218        GfxCount pixelCount,
219        const SamplePosition* samplePositions) override;
220    virtual SLANG_NO_THROW Result SLANG_MCALL drawInstanced(
221        GfxCount vertexCount,
222        GfxCount instanceCount,
223        GfxIndex startVertex,
224        GfxIndex startInstanceLocation) override;
225
226    virtual SLANG_NO_THROW Result SLANG_MCALL drawIndexedInstanced(
227        GfxCount indexCount,
228        GfxCount instanceCount,
229        GfxIndex startIndexLocation,
230        GfxIndex baseVertexLocation,
231        GfxIndex startInstanceLocation) override;
232
233    virtual SLANG_NO_THROW Result SLANG_MCALL drawMeshTasks(int x, int y, int z) override;
234
235public:
236    DebugCommandBuffer* commandBuffer;
237    bool isOpen = false;
238};
239
240class DebugRayTracingCommandEncoder : public UnownedDebugObject<IRayTracingCommandEncoder>,
241                                      public DebugResourceCommandEncoderImpl
242{
243public:
244    SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(DebugResourceCommandEncoderImpl)
245    virtual DebugCommandBuffer* getCommandBuffer() override { return commandBuffer; }
246    virtual bool getIsOpen() override { return isOpen; }
247    virtual IResourceCommandEncoder* getBaseResourceEncoder() override { return baseObject; }
248    virtual void* getInterface(SlangUUID const& uuid) override
249    {
250        if (uuid == GfxGUID::IID_IResourceCommandEncoder ||
251            uuid == GfxGUID::IID_IRayTracingCommandEncoder || uuid == ISlangUnknown::getTypeGuid())
252        {
253            return this;
254        }
255        return nullptr;
256    }
257
258public:
259    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
260    virtual SLANG_NO_THROW void SLANG_MCALL buildAccelerationStructure(
261        const IAccelerationStructure::BuildDesc& desc,
262        GfxCount propertyQueryCount,
263        AccelerationStructureQueryDesc* queryDescs) override;
264    virtual SLANG_NO_THROW void SLANG_MCALL copyAccelerationStructure(
265        IAccelerationStructure* dest,
266        IAccelerationStructure* src,
267        AccelerationStructureCopyMode mode) override;
268    virtual SLANG_NO_THROW void SLANG_MCALL queryAccelerationStructureProperties(
269        GfxCount accelerationStructureCount,
270        IAccelerationStructure* const* accelerationStructures,
271        GfxCount queryCount,
272        AccelerationStructureQueryDesc* queryDescs) override;
273    virtual SLANG_NO_THROW void SLANG_MCALL
274    serializeAccelerationStructure(DeviceAddress dest, IAccelerationStructure* source) override;
275    virtual SLANG_NO_THROW void SLANG_MCALL
276    deserializeAccelerationStructure(IAccelerationStructure* dest, DeviceAddress source) override;
277    virtual SLANG_NO_THROW Result SLANG_MCALL
278    bindPipeline(IPipelineState* state, IShaderObject** outRootObject) override;
279    virtual SLANG_NO_THROW Result SLANG_MCALL
280    bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) override;
281    virtual SLANG_NO_THROW Result SLANG_MCALL dispatchRays(
282        GfxIndex rayGenShaderIndex,
283        IShaderTable* shaderTable,
284        GfxCount width,
285        GfxCount height,
286        GfxCount depth) override;
287
288public:
289    DebugCommandBuffer* commandBuffer;
290    bool isOpen = false;
291};
292
293} // namespace debug
294} // namespace gfx