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.1 KiB357 linesraw
1// vk-command-encoder.h
2#pragma once
3
4#include "vk-base.h"
5#include "vk-pipeline-state.h"
6
7namespace gfx
8{
9
10using namespace Slang;
11
12namespace vk
13{
14
15class PipelineCommandEncoder : public ComObject
16{
17public:
18    CommandBufferImpl* m_commandBuffer;
19    VkCommandBuffer m_vkCommandBuffer;
20    VkCommandBuffer m_vkPreCommandBuffer = VK_NULL_HANDLE;
21    VkPipeline m_boundPipelines[3] = {};
22    DeviceImpl* m_device = nullptr;
23    RefPtr<PipelineStateImpl> m_currentPipeline;
24
25    VulkanApi* m_api;
26
27    static int getBindPointIndex(VkPipelineBindPoint bindPoint);
28
29    void init(CommandBufferImpl* commandBuffer);
30
31    void endEncodingImpl();
32
33    static void _uploadBufferData(
34        VkCommandBuffer commandBuffer,
35        TransientResourceHeapImpl* transientHeap,
36        BufferResourceImpl* buffer,
37        Offset offset,
38        Size size,
39        void* data);
40
41    void uploadBufferDataImpl(IBufferResource* buffer, Offset offset, Size size, void* data);
42
43    Result bindRootShaderObjectImpl(
44        RootShaderObjectImpl* rootShaderObject,
45        VkPipelineBindPoint bindPoint);
46
47    Result setPipelineStateImpl(IPipelineState* state, IShaderObject** outRootObject);
48
49    Result setPipelineStateWithRootObjectImpl(IPipelineState* state, IShaderObject* rootObject);
50
51    Result bindRenderState(VkPipelineBindPoint pipelineBindPoint);
52};
53
54class ResourceCommandEncoder : public IResourceCommandEncoder, public PipelineCommandEncoder
55{
56public:
57    virtual void* getInterface(SlangUUID const& guid)
58    {
59        if (guid == GfxGUID::IID_IResourceCommandEncoder || guid == ISlangUnknown::getTypeGuid())
60            return this;
61        return nullptr;
62    }
63    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
64    queryInterface(SlangUUID const& uuid, void** outObject) override
65    {
66        if (auto ptr = getInterface(uuid))
67        {
68            *outObject = ptr;
69            return SLANG_OK;
70        }
71        return SLANG_E_NO_INTERFACE;
72    }
73    virtual SLANG_NO_THROW uint32_t SLANG_MCALL addRef() override { return 1; }
74    virtual SLANG_NO_THROW uint32_t SLANG_MCALL release() override { return 1; }
75
76    virtual SLANG_NO_THROW void SLANG_MCALL copyBuffer(
77        IBufferResource* dst,
78        Offset dstOffset,
79        IBufferResource* src,
80        Offset srcOffset,
81        Size size) override;
82    virtual SLANG_NO_THROW void SLANG_MCALL
83    uploadBufferData(IBufferResource* buffer, Offset offset, Size size, void* data) override;
84    virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
85        GfxCount count,
86        ITextureResource* const* textures,
87        ResourceState src,
88        ResourceState dst) override;
89    virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(
90        GfxCount count,
91        IBufferResource* const* buffers,
92        ResourceState src,
93        ResourceState dst) override;
94    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
95
96    virtual SLANG_NO_THROW void SLANG_MCALL
97    writeTimestamp(IQueryPool* queryPool, GfxIndex index) override;
98
99    virtual SLANG_NO_THROW void SLANG_MCALL copyTexture(
100        ITextureResource* dst,
101        ResourceState dstState,
102        SubresourceRange dstSubresource,
103        ITextureResource::Offset3D dstOffset,
104        ITextureResource* src,
105        ResourceState srcState,
106        SubresourceRange srcSubresource,
107        ITextureResource::Offset3D srcOffset,
108        ITextureResource::Extents extent) override;
109
110    virtual SLANG_NO_THROW void SLANG_MCALL uploadTextureData(
111        ITextureResource* dst,
112        SubresourceRange subResourceRange,
113        ITextureResource::Offset3D offset,
114        ITextureResource::Extents extend,
115        ITextureResource::SubresourceData* subResourceData,
116        GfxCount subResourceDataCount) override;
117
118    void _clearColorImage(TextureResourceViewImpl* viewImpl, ClearValue* clearValue);
119
120    void _clearDepthImage(
121        TextureResourceViewImpl* viewImpl,
122        ClearValue* clearValue,
123        ClearResourceViewFlags::Enum flags);
124
125    void _clearBuffer(
126        VkBuffer buffer,
127        uint64_t bufferSize,
128        const IResourceView::Desc& desc,
129        uint32_t clearValue);
130
131    virtual SLANG_NO_THROW void SLANG_MCALL clearResourceView(
132        IResourceView* view,
133        ClearValue* clearValue,
134        ClearResourceViewFlags::Enum flags) override;
135
136    virtual SLANG_NO_THROW void SLANG_MCALL resolveResource(
137        ITextureResource* source,
138        ResourceState sourceState,
139        SubresourceRange sourceRange,
140        ITextureResource* dest,
141        ResourceState destState,
142        SubresourceRange destRange) override;
143
144    virtual SLANG_NO_THROW void SLANG_MCALL resolveQuery(
145        IQueryPool* queryPool,
146        GfxIndex index,
147        GfxCount count,
148        IBufferResource* buffer,
149        Offset offset) override;
150
151    virtual SLANG_NO_THROW void SLANG_MCALL copyTextureToBuffer(
152        IBufferResource* dst,
153        Offset dstOffset,
154        Size dstSize,
155        Size dstRowStride,
156        ITextureResource* src,
157        ResourceState srcState,
158        SubresourceRange srcSubresource,
159        ITextureResource::Offset3D srcOffset,
160        ITextureResource::Extents extent) override;
161
162    virtual SLANG_NO_THROW void SLANG_MCALL textureSubresourceBarrier(
163        ITextureResource* texture,
164        SubresourceRange subresourceRange,
165        ResourceState src,
166        ResourceState dst) override;
167
168    virtual SLANG_NO_THROW void SLANG_MCALL
169    beginDebugEvent(const char* name, float rgbColor[3]) override;
170    virtual SLANG_NO_THROW void SLANG_MCALL endDebugEvent() override;
171};
172
173class RenderCommandEncoder : public IRenderCommandEncoder, public ResourceCommandEncoder
174{
175    SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(ResourceCommandEncoder)
176    virtual void* getInterface(SlangUUID const& uuid) override
177    {
178        if (uuid == GfxGUID::IID_IResourceCommandEncoder ||
179            uuid == GfxGUID::IID_IRenderCommandEncoder || uuid == ISlangUnknown::getTypeGuid())
180        {
181            return this;
182        }
183        return nullptr;
184    }
185
186public:
187    List<VkViewport> m_viewports;
188    List<VkRect2D> m_scissorRects;
189
190public:
191    void beginPass(IRenderPassLayout* renderPass, IFramebuffer* framebuffer);
192
193    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
194
195    virtual SLANG_NO_THROW Result SLANG_MCALL
196    bindPipeline(IPipelineState* pipelineState, IShaderObject** outRootObject) override;
197
198    virtual SLANG_NO_THROW Result SLANG_MCALL
199    bindPipelineWithRootObject(IPipelineState* pipelineState, IShaderObject* rootObject) override;
200
201    virtual SLANG_NO_THROW void SLANG_MCALL
202    setViewports(GfxCount count, const Viewport* viewports) override;
203
204    virtual SLANG_NO_THROW void SLANG_MCALL
205    setScissorRects(GfxCount count, const ScissorRect* rects) override;
206
207    virtual SLANG_NO_THROW void SLANG_MCALL
208    setPrimitiveTopology(PrimitiveTopology topology) override;
209
210    virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
211        GfxIndex startSlot,
212        GfxCount slotCount,
213        IBufferResource* const* buffers,
214        const Offset* offsets) override;
215
216    virtual SLANG_NO_THROW void SLANG_MCALL
217    setIndexBuffer(IBufferResource* buffer, Format indexFormat, Offset offset = 0) override;
218
219    Result prepareDraw();
220
221    virtual SLANG_NO_THROW Result SLANG_MCALL
222    draw(GfxCount vertexCount, GfxIndex startVertex = 0) override;
223    virtual SLANG_NO_THROW Result SLANG_MCALL
224    drawIndexed(GfxCount indexCount, GfxIndex startIndex = 0, GfxIndex baseVertex = 0) override;
225
226    virtual SLANG_NO_THROW void SLANG_MCALL setStencilReference(uint32_t referenceValue) override;
227
228    virtual SLANG_NO_THROW Result SLANG_MCALL drawIndirect(
229        GfxCount maxDrawCount,
230        IBufferResource* argBuffer,
231        Offset argOffset,
232        IBufferResource* countBuffer,
233        Offset countOffset) override;
234
235    virtual SLANG_NO_THROW Result SLANG_MCALL drawIndexedIndirect(
236        GfxCount maxDrawCount,
237        IBufferResource* argBuffer,
238        Offset argOffset,
239        IBufferResource* countBuffer,
240        Offset countOffset) override;
241
242    virtual SLANG_NO_THROW Result SLANG_MCALL setSamplePositions(
243        GfxCount samplesPerPixel,
244        GfxCount pixelCount,
245        const SamplePosition* samplePositions) override;
246
247    virtual SLANG_NO_THROW Result SLANG_MCALL drawInstanced(
248        GfxCount vertexCount,
249        GfxCount instanceCount,
250        GfxIndex startVertex,
251        GfxIndex startInstanceLocation) override;
252
253    virtual SLANG_NO_THROW Result SLANG_MCALL drawIndexedInstanced(
254        GfxCount indexCount,
255        GfxCount instanceCount,
256        GfxIndex startIndexLocation,
257        GfxIndex baseVertexLocation,
258        GfxIndex startInstanceLocation) override;
259
260    virtual SLANG_NO_THROW Result SLANG_MCALL drawMeshTasks(int x, int y, int z) override;
261};
262
263class ComputeCommandEncoder : public IComputeCommandEncoder, public ResourceCommandEncoder
264{
265public:
266    SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(ResourceCommandEncoder)
267    virtual void* getInterface(SlangUUID const& uuid) override
268    {
269        if (uuid == GfxGUID::IID_IResourceCommandEncoder ||
270            uuid == GfxGUID::IID_IComputeCommandEncoder || uuid == ISlangUnknown::getTypeGuid())
271        {
272            return this;
273        }
274        return nullptr;
275    }
276
277    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
278
279    virtual SLANG_NO_THROW Result SLANG_MCALL
280    bindPipeline(IPipelineState* pipelineState, IShaderObject** outRootObject) override;
281
282    virtual SLANG_NO_THROW Result SLANG_MCALL
283    bindPipelineWithRootObject(IPipelineState* pipelineState, IShaderObject* rootObject) override;
284
285    virtual SLANG_NO_THROW Result SLANG_MCALL dispatchCompute(int x, int y, int z) override;
286
287    virtual SLANG_NO_THROW Result SLANG_MCALL
288    dispatchComputeIndirect(IBufferResource* argBuffer, Offset offset) override;
289};
290
291class RayTracingCommandEncoder : public IRayTracingCommandEncoder, public ResourceCommandEncoder
292{
293public:
294    SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(ResourceCommandEncoder)
295    virtual void* getInterface(SlangUUID const& uuid) override
296    {
297        if (uuid == GfxGUID::IID_IResourceCommandEncoder ||
298            uuid == GfxGUID::IID_IRayTracingCommandEncoder || uuid == ISlangUnknown::getTypeGuid())
299        {
300            return this;
301        }
302        return nullptr;
303    }
304
305public:
306    void _memoryBarrier(
307        int count,
308        IAccelerationStructure* const* structures,
309        AccessFlag srcAccess,
310        AccessFlag destAccess);
311
312    void _queryAccelerationStructureProperties(
313        GfxCount accelerationStructureCount,
314        IAccelerationStructure* const* accelerationStructures,
315        GfxCount queryCount,
316        AccelerationStructureQueryDesc* queryDescs);
317
318    virtual SLANG_NO_THROW void SLANG_MCALL buildAccelerationStructure(
319        const IAccelerationStructure::BuildDesc& desc,
320        GfxCount propertyQueryCount,
321        AccelerationStructureQueryDesc* queryDescs) override;
322
323    virtual SLANG_NO_THROW void SLANG_MCALL copyAccelerationStructure(
324        IAccelerationStructure* dest,
325        IAccelerationStructure* src,
326        AccelerationStructureCopyMode mode) override;
327
328    virtual SLANG_NO_THROW void SLANG_MCALL queryAccelerationStructureProperties(
329        GfxCount accelerationStructureCount,
330        IAccelerationStructure* const* accelerationStructures,
331        GfxCount queryCount,
332        AccelerationStructureQueryDesc* queryDescs) override;
333
334    virtual SLANG_NO_THROW void SLANG_MCALL
335    serializeAccelerationStructure(DeviceAddress dest, IAccelerationStructure* source) override;
336
337    virtual SLANG_NO_THROW void SLANG_MCALL
338    deserializeAccelerationStructure(IAccelerationStructure* dest, DeviceAddress source) override;
339
340    virtual SLANG_NO_THROW Result SLANG_MCALL
341    bindPipeline(IPipelineState* pipeline, IShaderObject** outRootObject) override;
342
343    virtual SLANG_NO_THROW Result SLANG_MCALL
344    bindPipelineWithRootObject(IPipelineState* pipelineState, IShaderObject* rootObject) override;
345
346    virtual SLANG_NO_THROW Result SLANG_MCALL dispatchRays(
347        GfxIndex raygenShaderIndex,
348        IShaderTable* shaderTable,
349        GfxCount width,
350        GfxCount height,
351        GfxCount depth) override;
352
353    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
354};
355
356} // namespace vk
357} // namespace gfx