yum-mirror/slang

Making it easier to work with shaders

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

Ellie HermaszewskaMove switch statement bodies to their own lines (#5493)b118451e3

master
branchesmasterall refs →
15.4 KiB558 linesraw
1// debug-command-encoder.cpp
2#include "debug-command-encoder.h"
3
4#include "debug-buffer.h"
5#include "debug-command-buffer.h"
6#include "debug-helper-functions.h"
7#include "debug-pipeline-state.h"
8#include "debug-query.h"
9#include "debug-resource-views.h"
10#include "debug-texture.h"
11
12namespace gfx
13{
14using namespace Slang;
15
16namespace debug
17{
18
19void DebugComputeCommandEncoder::endEncoding()
20{
21    SLANG_GFX_API_FUNC;
22    isOpen = false;
23    baseObject->endEncoding();
24}
25
26Result DebugComputeCommandEncoder::bindPipeline(
27    IPipelineState* state,
28    IShaderObject** outRootShaderObject)
29{
30    SLANG_GFX_API_FUNC;
31
32    auto innerState = getInnerObj(state);
33    IShaderObject* innerRootObject = nullptr;
34    commandBuffer->rootObject.reset();
35    auto result = baseObject->bindPipeline(innerState, &innerRootObject);
36    commandBuffer->rootObject.baseObject.attach(innerRootObject);
37    *outRootShaderObject = &commandBuffer->rootObject;
38    return result;
39}
40
41Result DebugComputeCommandEncoder::bindPipelineWithRootObject(
42    IPipelineState* state,
43    IShaderObject* rootObject)
44{
45    SLANG_GFX_API_FUNC;
46    return baseObject->bindPipelineWithRootObject(getInnerObj(state), getInnerObj(rootObject));
47}
48
49Result DebugComputeCommandEncoder::dispatchCompute(int x, int y, int z)
50{
51    SLANG_GFX_API_FUNC;
52    return baseObject->dispatchCompute(x, y, z);
53}
54
55Result DebugComputeCommandEncoder::dispatchComputeIndirect(
56    IBufferResource* cmdBuffer,
57    Offset offset)
58{
59    SLANG_GFX_API_FUNC;
60    return baseObject->dispatchComputeIndirect(getInnerObj(cmdBuffer), offset);
61}
62
63void DebugRenderCommandEncoder::endEncoding()
64{
65    SLANG_GFX_API_FUNC;
66    isOpen = false;
67    baseObject->endEncoding();
68}
69
70Result DebugRenderCommandEncoder::bindPipeline(
71    IPipelineState* state,
72    IShaderObject** outRootShaderObject)
73{
74    SLANG_GFX_API_FUNC;
75
76    auto innerState = getInnerObj(state);
77    IShaderObject* innerRootObject = nullptr;
78    commandBuffer->rootObject.reset();
79    auto result = baseObject->bindPipeline(innerState, &innerRootObject);
80    commandBuffer->rootObject.baseObject.attach(innerRootObject);
81    *outRootShaderObject = &commandBuffer->rootObject;
82    return result;
83}
84
85Result DebugRenderCommandEncoder::bindPipelineWithRootObject(
86    IPipelineState* state,
87    IShaderObject* rootObject)
88{
89    SLANG_GFX_API_FUNC;
90    return baseObject->bindPipelineWithRootObject(getInnerObj(state), getInnerObj(rootObject));
91}
92
93void DebugRenderCommandEncoder::setViewports(GfxCount count, const Viewport* viewports)
94{
95    SLANG_GFX_API_FUNC;
96    baseObject->setViewports(count, viewports);
97}
98
99void DebugRenderCommandEncoder::setScissorRects(GfxCount count, const ScissorRect* scissors)
100{
101    SLANG_GFX_API_FUNC;
102    baseObject->setScissorRects(count, scissors);
103}
104
105void DebugRenderCommandEncoder::setPrimitiveTopology(PrimitiveTopology topology)
106{
107    SLANG_GFX_API_FUNC;
108    baseObject->setPrimitiveTopology(topology);
109}
110
111void DebugRenderCommandEncoder::setVertexBuffers(
112    GfxIndex startSlot,
113    GfxCount slotCount,
114    IBufferResource* const* buffers,
115    const Offset* offsets)
116{
117    SLANG_GFX_API_FUNC;
118
119    List<IBufferResource*> innerBuffers;
120    for (GfxIndex i = 0; i < slotCount; i++)
121    {
122        innerBuffers.add(static_cast<DebugBufferResource*>(buffers[i])->baseObject.get());
123    }
124    baseObject->setVertexBuffers(startSlot, slotCount, innerBuffers.getBuffer(), offsets);
125}
126
127void DebugRenderCommandEncoder::setIndexBuffer(
128    IBufferResource* buffer,
129    Format indexFormat,
130    Offset offset)
131{
132    SLANG_GFX_API_FUNC;
133    auto innerBuffer = static_cast<DebugBufferResource*>(buffer)->baseObject.get();
134    baseObject->setIndexBuffer(innerBuffer, indexFormat, offset);
135}
136
137Result DebugRenderCommandEncoder::draw(GfxCount vertexCount, GfxIndex startVertex)
138{
139    SLANG_GFX_API_FUNC;
140    return baseObject->draw(vertexCount, startVertex);
141}
142
143Result DebugRenderCommandEncoder::drawIndexed(
144    GfxCount indexCount,
145    GfxIndex startIndex,
146    GfxIndex baseVertex)
147{
148    SLANG_GFX_API_FUNC;
149    return baseObject->drawIndexed(indexCount, startIndex, baseVertex);
150}
151
152Result DebugRenderCommandEncoder::drawIndirect(
153    GfxCount maxDrawCount,
154    IBufferResource* argBuffer,
155    Offset argOffset,
156    IBufferResource* countBuffer,
157    Offset countOffset)
158{
159    SLANG_GFX_API_FUNC;
160    return baseObject->drawIndirect(
161        maxDrawCount,
162        getInnerObj(argBuffer),
163        argOffset,
164        getInnerObj(countBuffer),
165        countOffset);
166}
167
168Result DebugRenderCommandEncoder::drawIndexedIndirect(
169    GfxCount maxDrawCount,
170    IBufferResource* argBuffer,
171    Offset argOffset,
172    IBufferResource* countBuffer,
173    Offset countOffset)
174{
175    SLANG_GFX_API_FUNC;
176    return baseObject->drawIndexedIndirect(
177        maxDrawCount,
178        getInnerObj(argBuffer),
179        argOffset,
180        getInnerObj(countBuffer),
181        countOffset);
182}
183
184void DebugRenderCommandEncoder::setStencilReference(uint32_t referenceValue)
185{
186    SLANG_GFX_API_FUNC;
187    return baseObject->setStencilReference(referenceValue);
188}
189
190Result DebugRenderCommandEncoder::setSamplePositions(
191    GfxCount samplesPerPixel,
192    GfxCount pixelCount,
193    const SamplePosition* samplePositions)
194{
195    SLANG_GFX_API_FUNC;
196    return baseObject->setSamplePositions(samplesPerPixel, pixelCount, samplePositions);
197}
198
199Result DebugRenderCommandEncoder::drawInstanced(
200    GfxCount vertexCount,
201    GfxCount instanceCount,
202    GfxIndex startVertex,
203    GfxIndex startInstanceLocation)
204{
205    SLANG_GFX_API_FUNC;
206    return baseObject
207        ->drawInstanced(vertexCount, instanceCount, startVertex, startInstanceLocation);
208}
209
210Result DebugRenderCommandEncoder::drawIndexedInstanced(
211    GfxCount indexCount,
212    GfxCount instanceCount,
213    GfxIndex startIndexLocation,
214    GfxIndex baseVertexLocation,
215    GfxIndex startInstanceLocation)
216{
217    SLANG_GFX_API_FUNC;
218    return baseObject->drawIndexedInstanced(
219        indexCount,
220        instanceCount,
221        startIndexLocation,
222        baseVertexLocation,
223        startInstanceLocation);
224}
225
226Result DebugRenderCommandEncoder::drawMeshTasks(int x, int y, int z)
227{
228    SLANG_GFX_API_FUNC;
229    return baseObject->drawMeshTasks(x, y, z);
230}
231
232void DebugResourceCommandEncoder::endEncoding()
233{
234    SLANG_GFX_API_FUNC;
235    isOpen = false;
236    baseObject->endEncoding();
237}
238
239void DebugResourceCommandEncoderImpl::writeTimestamp(IQueryPool* pool, GfxIndex index)
240{
241    SLANG_GFX_API_FUNC;
242    getBaseResourceEncoder()->writeTimestamp(static_cast<DebugQueryPool*>(pool)->baseObject, index);
243}
244
245void DebugResourceCommandEncoderImpl::copyBuffer(
246    IBufferResource* dst,
247    Offset dstOffset,
248    IBufferResource* src,
249    Offset srcOffset,
250    Size size)
251{
252    SLANG_GFX_API_FUNC;
253    auto dstImpl = static_cast<DebugBufferResource*>(dst);
254    auto srcImpl = static_cast<DebugBufferResource*>(src);
255    getBaseResourceEncoder()
256        ->copyBuffer(dstImpl->baseObject, dstOffset, srcImpl->baseObject, srcOffset, size);
257}
258
259void DebugResourceCommandEncoderImpl::uploadBufferData(
260    IBufferResource* dst,
261    Offset offset,
262    Size size,
263    void* data)
264{
265    SLANG_GFX_API_FUNC;
266    auto dstImpl = static_cast<DebugBufferResource*>(dst);
267    getBaseResourceEncoder()->uploadBufferData(dstImpl->baseObject, offset, size, data);
268}
269
270void DebugResourceCommandEncoderImpl::textureBarrier(
271    GfxCount count,
272    ITextureResource* const* textures,
273    ResourceState src,
274    ResourceState dst)
275{
276    SLANG_GFX_API_FUNC;
277
278    List<ITextureResource*> innerTextures;
279    for (GfxIndex i = 0; i < count; i++)
280    {
281        innerTextures.add(static_cast<DebugTextureResource*>(textures[i])->baseObject.get());
282    }
283    getBaseResourceEncoder()->textureBarrier(count, innerTextures.getBuffer(), src, dst);
284}
285
286void DebugResourceCommandEncoderImpl::bufferBarrier(
287    GfxCount count,
288    IBufferResource* const* buffers,
289    ResourceState src,
290    ResourceState dst)
291{
292    SLANG_GFX_API_FUNC;
293
294    List<IBufferResource*> innerBuffers;
295    for (GfxIndex i = 0; i < count; i++)
296    {
297        innerBuffers.add(static_cast<DebugBufferResource*>(buffers[i])->baseObject.get());
298    }
299    getBaseResourceEncoder()->bufferBarrier(count, innerBuffers.getBuffer(), src, dst);
300}
301
302void DebugResourceCommandEncoderImpl::copyTexture(
303    ITextureResource* dst,
304    ResourceState dstState,
305    SubresourceRange dstSubresource,
306    ITextureResource::Offset3D dstOffset,
307    ITextureResource* src,
308    ResourceState srcState,
309    SubresourceRange srcSubresource,
310    ITextureResource::Offset3D srcOffset,
311    ITextureResource::Extents extent)
312{
313    SLANG_GFX_API_FUNC;
314    getBaseResourceEncoder()->copyTexture(
315        getInnerObj(dst),
316        dstState,
317        dstSubresource,
318        dstOffset,
319        getInnerObj(src),
320        srcState,
321        srcSubresource,
322        srcOffset,
323        extent);
324}
325
326void DebugResourceCommandEncoderImpl::uploadTextureData(
327    ITextureResource* dst,
328    SubresourceRange subResourceRange,
329    ITextureResource::Offset3D offset,
330    ITextureResource::Extents extent,
331    ITextureResource::SubresourceData* subResourceData,
332    GfxCount subResourceDataCount)
333{
334    SLANG_GFX_API_FUNC;
335    getBaseResourceEncoder()->uploadTextureData(
336        getInnerObj(dst),
337        subResourceRange,
338        offset,
339        extent,
340        subResourceData,
341        subResourceDataCount);
342}
343
344void DebugResourceCommandEncoderImpl::clearResourceView(
345    IResourceView* view,
346    ClearValue* clearValue,
347    ClearResourceViewFlags::Enum flags)
348{
349    SLANG_GFX_API_FUNC;
350    switch (view->getViewDesc()->type)
351    {
352    case IResourceView::Type::DepthStencil:
353    case IResourceView::Type::RenderTarget:
354    case IResourceView::Type::UnorderedAccess:
355        break;
356    default:
357        GFX_DIAGNOSE_ERROR_FORMAT(
358            "Resource view %lld cannot be cleared. Only DepthStencil, "
359            "RenderTarget or UnorderedAccess views can be cleared.",
360            getDebugObj(view)->uid);
361    }
362    getBaseResourceEncoder()->clearResourceView(getInnerObj(view), clearValue, flags);
363}
364
365void DebugResourceCommandEncoderImpl::resolveResource(
366    ITextureResource* source,
367    ResourceState sourceState,
368    SubresourceRange sourceRange,
369    ITextureResource* dest,
370    ResourceState destState,
371    SubresourceRange destRange)
372{
373    SLANG_GFX_API_FUNC;
374    getBaseResourceEncoder()->resolveResource(
375        getInnerObj(source),
376        sourceState,
377        sourceRange,
378        getInnerObj(dest),
379        destState,
380        destRange);
381}
382
383void DebugResourceCommandEncoderImpl::resolveQuery(
384    IQueryPool* queryPool,
385    GfxIndex index,
386    GfxCount count,
387    IBufferResource* buffer,
388    Offset offset)
389{
390    SLANG_GFX_API_FUNC;
391    getBaseResourceEncoder()
392        ->resolveQuery(getInnerObj(queryPool), index, count, getInnerObj(buffer), offset);
393}
394
395void DebugResourceCommandEncoderImpl::copyTextureToBuffer(
396    IBufferResource* dst,
397    Offset dstOffset,
398    Size dstSize,
399    Size dstRowStride,
400    ITextureResource* src,
401    ResourceState srcState,
402    SubresourceRange srcSubresource,
403    ITextureResource::Offset3D srcOffset,
404    ITextureResource::Extents extent)
405{
406    SLANG_GFX_API_FUNC;
407    getBaseResourceEncoder()->copyTextureToBuffer(
408        getInnerObj(dst),
409        dstOffset,
410        dstSize,
411        dstRowStride,
412        getInnerObj(src),
413        srcState,
414        srcSubresource,
415        srcOffset,
416        extent);
417}
418
419void DebugResourceCommandEncoderImpl::textureSubresourceBarrier(
420    ITextureResource* texture,
421    SubresourceRange subresourceRange,
422    ResourceState src,
423    ResourceState dst)
424{
425    SLANG_GFX_API_FUNC;
426    getBaseResourceEncoder()
427        ->textureSubresourceBarrier(getInnerObj(texture), subresourceRange, src, dst);
428}
429
430void DebugResourceCommandEncoderImpl::beginDebugEvent(const char* name, float rgbColor[3])
431{
432    SLANG_GFX_API_FUNC;
433    getBaseResourceEncoder()->beginDebugEvent(name, rgbColor);
434}
435
436void DebugResourceCommandEncoderImpl::endDebugEvent()
437{
438    SLANG_GFX_API_FUNC;
439    getBaseResourceEncoder()->endDebugEvent();
440}
441
442void DebugRayTracingCommandEncoder::endEncoding()
443{
444    SLANG_GFX_API_FUNC;
445    isOpen = false;
446    baseObject->endEncoding();
447}
448
449void DebugRayTracingCommandEncoder::buildAccelerationStructure(
450    const IAccelerationStructure::BuildDesc& desc,
451    GfxCount propertyQueryCount,
452    AccelerationStructureQueryDesc* queryDescs)
453{
454    SLANG_GFX_API_FUNC;
455    IAccelerationStructure::BuildDesc innerDesc = desc;
456    innerDesc.dest = getInnerObj(innerDesc.dest);
457    innerDesc.source = getInnerObj(innerDesc.source);
458    List<AccelerationStructureQueryDesc> innerQueryDescs;
459    innerQueryDescs.addRange(queryDescs, propertyQueryCount);
460    for (auto& innerQueryDesc : innerQueryDescs)
461    {
462        innerQueryDesc.queryPool = getInnerObj(innerQueryDesc.queryPool);
463    }
464    validateAccelerationStructureBuildInputs(desc.inputs);
465    baseObject->buildAccelerationStructure(
466        innerDesc,
467        propertyQueryCount,
468        innerQueryDescs.getBuffer());
469}
470
471void DebugRayTracingCommandEncoder::copyAccelerationStructure(
472    IAccelerationStructure* dest,
473    IAccelerationStructure* src,
474    AccelerationStructureCopyMode mode)
475{
476    SLANG_GFX_API_FUNC;
477    auto innerDest = getInnerObj(dest);
478    auto innerSrc = getInnerObj(src);
479    baseObject->copyAccelerationStructure(innerDest, innerSrc, mode);
480}
481
482void DebugRayTracingCommandEncoder::queryAccelerationStructureProperties(
483    GfxCount accelerationStructureCount,
484    IAccelerationStructure* const* accelerationStructures,
485    GfxCount queryCount,
486    AccelerationStructureQueryDesc* queryDescs)
487{
488    SLANG_GFX_API_FUNC;
489    List<IAccelerationStructure*> innerAS;
490    for (GfxIndex i = 0; i < accelerationStructureCount; i++)
491    {
492        innerAS.add(getInnerObj(accelerationStructures[i]));
493    }
494    List<AccelerationStructureQueryDesc> innerQueryDescs;
495    innerQueryDescs.addRange(queryDescs, queryCount);
496    for (auto& innerQueryDesc : innerQueryDescs)
497    {
498        innerQueryDesc.queryPool = getInnerObj(innerQueryDesc.queryPool);
499    }
500    baseObject->queryAccelerationStructureProperties(
501        accelerationStructureCount,
502        innerAS.getBuffer(),
503        queryCount,
504        innerQueryDescs.getBuffer());
505}
506
507void DebugRayTracingCommandEncoder::serializeAccelerationStructure(
508    DeviceAddress dest,
509    IAccelerationStructure* source)
510{
511    SLANG_GFX_API_FUNC;
512    baseObject->serializeAccelerationStructure(dest, getInnerObj(source));
513}
514
515void DebugRayTracingCommandEncoder::deserializeAccelerationStructure(
516    IAccelerationStructure* dest,
517    DeviceAddress source)
518{
519    SLANG_GFX_API_FUNC;
520    baseObject->deserializeAccelerationStructure(getInnerObj(dest), source);
521}
522
523Result DebugRayTracingCommandEncoder::bindPipeline(
524    IPipelineState* state,
525    IShaderObject** outRootObject)
526{
527    SLANG_GFX_API_FUNC;
528    auto innerPipeline = getInnerObj(state);
529    IShaderObject* innerRootObject = nullptr;
530    commandBuffer->rootObject.reset();
531    Result result = baseObject->bindPipeline(innerPipeline, &innerRootObject);
532    commandBuffer->rootObject.baseObject.attach(innerRootObject);
533    *outRootObject = &commandBuffer->rootObject;
534    return result;
535}
536
537Result DebugRayTracingCommandEncoder::bindPipelineWithRootObject(
538    IPipelineState* state,
539    IShaderObject* rootObject)
540{
541    SLANG_GFX_API_FUNC;
542    return baseObject->bindPipelineWithRootObject(getInnerObj(state), getInnerObj(rootObject));
543}
544
545Result DebugRayTracingCommandEncoder::dispatchRays(
546    GfxIndex rayGenShaderIndex,
547    IShaderTable* shaderTable,
548    GfxCount width,
549    GfxCount height,
550    GfxCount depth)
551{
552    SLANG_GFX_API_FUNC;
553    return baseObject
554        ->dispatchRays(rayGenShaderIndex, getInnerObj(shaderTable), width, height, depth);
555}
556
557} // namespace debug
558} // namespace gfx