yum-mirror/slang

Making it easier to work with shaders

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

Jay KwakCheck the available VK extensions before using CoopVec APIs in GFX (#6849)591affaf7

master
branchesmasterall refs →
20.8 KiB706 linesraw
1// debug-device.cpp
2#include "debug-device.h"
3
4#include "debug-buffer.h"
5#include "debug-command-queue.h"
6#include "debug-fence.h"
7#include "debug-framebuffer.h"
8#include "debug-helper-functions.h"
9#include "debug-pipeline-state.h"
10#include "debug-query.h"
11#include "debug-render-pass.h"
12#include "debug-resource-views.h"
13#include "debug-sampler-state.h"
14#include "debug-shader-object.h"
15#include "debug-shader-program.h"
16#include "debug-shader-table.h"
17#include "debug-swap-chain.h"
18#include "debug-texture.h"
19#include "debug-transient-heap.h"
20#include "debug-vertex-layout.h"
21
22namespace gfx
23{
24using namespace Slang;
25
26namespace debug
27{
28
29SlangResult DebugDevice::queryInterface(SlangUUID const& uuid, void** outObject) noexcept
30{
31    void* intf = getInterface(uuid);
32    if (intf)
33    {
34        addRef();
35        *outObject = intf;
36        return SLANG_OK;
37    }
38
39    // Fallback to trying to get the interface from the debugged object
40    return baseObject->queryInterface(uuid, outObject);
41}
42
43Result DebugDevice::getNativeDeviceHandles(InteropHandles* outHandles)
44{
45    return baseObject->getNativeDeviceHandles(outHandles);
46}
47
48Result DebugDevice::getFeatures(
49    const char** outFeatures,
50    Size bufferSize,
51    GfxCount* outFeatureCount)
52{
53    SLANG_GFX_API_FUNC;
54
55    return baseObject->getFeatures(outFeatures, bufferSize, outFeatureCount);
56}
57
58Result DebugDevice::getFormatSupportedResourceStates(Format format, ResourceStateSet* outStates)
59{
60    SLANG_GFX_API_FUNC;
61    return baseObject->getFormatSupportedResourceStates(format, outStates);
62}
63
64DebugDevice::DebugDevice()
65{
66    SLANG_GFX_API_FUNC_NAME("CreateDevice");
67    GFX_DIAGNOSE_INFO("Debug layer is enabled.");
68}
69
70SLANG_NO_THROW bool SLANG_MCALL DebugDevice::hasFeature(const char* feature)
71{
72    SLANG_GFX_API_FUNC;
73
74    return baseObject->hasFeature(feature);
75}
76
77Result DebugDevice::getSlangSession(slang::ISession** outSlangSession)
78{
79    SLANG_GFX_API_FUNC;
80
81    return baseObject->getSlangSession(outSlangSession);
82}
83
84Result DebugDevice::createTransientResourceHeap(
85    const ITransientResourceHeap::Desc& desc,
86    ITransientResourceHeap** outHeap)
87{
88    SLANG_GFX_API_FUNC;
89
90    RefPtr<DebugTransientResourceHeap> outObject = new DebugTransientResourceHeap();
91    auto result = baseObject->createTransientResourceHeap(desc, outObject->baseObject.writeRef());
92    if (SLANG_FAILED(result))
93        return result;
94    returnComPtr(outHeap, outObject);
95    return result;
96}
97
98Result DebugDevice::createTextureResource(
99    const ITextureResource::Desc& desc,
100    const ITextureResource::SubresourceData* initData,
101    ITextureResource** outResource)
102{
103    SLANG_GFX_API_FUNC;
104
105    RefPtr<DebugTextureResource> outObject = new DebugTextureResource();
106    auto result =
107        baseObject->createTextureResource(desc, initData, outObject->baseObject.writeRef());
108    if (SLANG_FAILED(result))
109        return result;
110    returnComPtr(outResource, outObject);
111    return result;
112}
113
114Result DebugDevice::createTextureFromNativeHandle(
115    InteropHandle handle,
116    const ITextureResource::Desc& srcDesc,
117    ITextureResource** outResource)
118{
119    SLANG_GFX_API_FUNC;
120
121    RefPtr<DebugTextureResource> outObject = new DebugTextureResource();
122    auto result = baseObject->createTextureFromNativeHandle(
123        handle,
124        srcDesc,
125        outObject->baseObject.writeRef());
126    if (SLANG_FAILED(result))
127        return result;
128    returnComPtr(outResource, outObject);
129    return result;
130}
131
132Result DebugDevice::createTextureFromSharedHandle(
133    InteropHandle handle,
134    const ITextureResource::Desc& srcDesc,
135    const size_t size,
136    ITextureResource** outResource)
137{
138    SLANG_GFX_API_FUNC;
139
140    RefPtr<DebugTextureResource> outObject = new DebugTextureResource();
141    auto result = baseObject->createTextureFromSharedHandle(
142        handle,
143        srcDesc,
144        size,
145        outObject->baseObject.writeRef());
146    if (SLANG_FAILED(result))
147        return result;
148    returnComPtr(outResource, outObject);
149    return result;
150}
151
152Result DebugDevice::createBufferResource(
153    const IBufferResource::Desc& desc,
154    const void* initData,
155    IBufferResource** outResource)
156{
157    SLANG_GFX_API_FUNC;
158
159    RefPtr<DebugBufferResource> outObject = new DebugBufferResource();
160    auto result =
161        baseObject->createBufferResource(desc, initData, outObject->baseObject.writeRef());
162    if (SLANG_FAILED(result))
163        return result;
164    returnComPtr(outResource, outObject);
165    return result;
166}
167
168Result DebugDevice::createBufferFromNativeHandle(
169    InteropHandle handle,
170    const IBufferResource::Desc& srcDesc,
171    IBufferResource** outResource)
172{
173    SLANG_GFX_API_FUNC;
174
175    RefPtr<DebugBufferResource> outObject = new DebugBufferResource();
176    auto result =
177        baseObject->createBufferFromNativeHandle(handle, srcDesc, outObject->baseObject.writeRef());
178    if (SLANG_FAILED(result))
179        return result;
180    returnComPtr(outResource, outObject);
181    return result;
182}
183
184Result DebugDevice::createBufferFromSharedHandle(
185    InteropHandle handle,
186    const IBufferResource::Desc& srcDesc,
187    IBufferResource** outResource)
188{
189    SLANG_GFX_API_FUNC;
190
191    RefPtr<DebugBufferResource> outObject = new DebugBufferResource();
192    auto result =
193        baseObject->createBufferFromSharedHandle(handle, srcDesc, outObject->baseObject.writeRef());
194    if (SLANG_FAILED(result))
195        return result;
196    returnComPtr(outResource, outObject);
197    return result;
198}
199
200Result DebugDevice::createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler)
201{
202    SLANG_GFX_API_FUNC;
203
204    RefPtr<DebugSamplerState> outObject = new DebugSamplerState();
205    auto result = baseObject->createSamplerState(desc, outObject->baseObject.writeRef());
206    if (SLANG_FAILED(result))
207        return result;
208    returnComPtr(outSampler, outObject);
209    return result;
210}
211
212Result DebugDevice::createTextureView(
213    ITextureResource* texture,
214    IResourceView::Desc const& desc,
215    IResourceView** outView)
216{
217    SLANG_GFX_API_FUNC;
218
219    RefPtr<DebugResourceView> outObject = new DebugResourceView();
220    auto result =
221        baseObject->createTextureView(getInnerObj(texture), desc, outObject->baseObject.writeRef());
222    if (SLANG_FAILED(result))
223        return result;
224    returnComPtr(outView, outObject);
225    return result;
226}
227
228Result DebugDevice::createBufferView(
229    IBufferResource* buffer,
230    IBufferResource* counterBuffer,
231    IResourceView::Desc const& desc,
232    IResourceView** outView)
233{
234    SLANG_GFX_API_FUNC;
235
236    RefPtr<DebugResourceView> outObject = new DebugResourceView();
237    auto result = baseObject->createBufferView(
238        getInnerObj(buffer),
239        getInnerObj(counterBuffer),
240        desc,
241        outObject->baseObject.writeRef());
242    if (SLANG_FAILED(result))
243        return result;
244    returnComPtr(outView, outObject);
245    return result;
246}
247
248Result DebugDevice::getAccelerationStructurePrebuildInfo(
249    const IAccelerationStructure::BuildInputs& buildInputs,
250    IAccelerationStructure::PrebuildInfo* outPrebuildInfo)
251{
252    SLANG_GFX_API_FUNC;
253    validateAccelerationStructureBuildInputs(buildInputs);
254    return baseObject->getAccelerationStructurePrebuildInfo(buildInputs, outPrebuildInfo);
255}
256
257Result DebugDevice::createAccelerationStructure(
258    const IAccelerationStructure::CreateDesc& desc,
259    IAccelerationStructure** outAS)
260{
261    SLANG_GFX_API_FUNC;
262    auto innerDesc = desc;
263    innerDesc.buffer = getInnerObj(innerDesc.buffer);
264    RefPtr<DebugAccelerationStructure> outObject = new DebugAccelerationStructure();
265    auto result =
266        baseObject->createAccelerationStructure(innerDesc, outObject->baseObject.writeRef());
267    if (SLANG_FAILED(result))
268        return result;
269    returnComPtr(outAS, outObject);
270    return SLANG_OK;
271}
272
273Result DebugDevice::createFramebufferLayout(
274    IFramebufferLayout::Desc const& desc,
275    IFramebufferLayout** outFrameBuffer)
276{
277    SLANG_GFX_API_FUNC;
278
279    RefPtr<DebugFramebufferLayout> outObject = new DebugFramebufferLayout();
280    auto result = baseObject->createFramebufferLayout(desc, outObject->baseObject.writeRef());
281    if (SLANG_FAILED(result))
282        return result;
283    returnComPtr(outFrameBuffer, outObject);
284    return result;
285}
286
287Result DebugDevice::createFramebuffer(IFramebuffer::Desc const& desc, IFramebuffer** outFrameBuffer)
288{
289    SLANG_GFX_API_FUNC;
290
291    auto innerDesc = desc;
292    innerDesc.layout = getInnerObj(desc.layout);
293    innerDesc.depthStencilView = getInnerObj(desc.depthStencilView);
294    List<IResourceView*> innerRenderTargets;
295    for (GfxIndex i = 0; i < desc.renderTargetCount; i++)
296    {
297        auto innerRenderTarget = getInnerObj(desc.renderTargetViews[i]);
298        innerRenderTargets.add(innerRenderTarget);
299    }
300    innerDesc.renderTargetViews = innerRenderTargets.getBuffer();
301
302    RefPtr<DebugFramebuffer> outObject = new DebugFramebuffer();
303    auto result = baseObject->createFramebuffer(innerDesc, outObject->baseObject.writeRef());
304    if (SLANG_FAILED(result))
305        return result;
306    returnComPtr(outFrameBuffer, outObject);
307    return result;
308}
309
310Result DebugDevice::createRenderPassLayout(
311    const IRenderPassLayout::Desc& desc,
312    IRenderPassLayout** outRenderPassLayout)
313{
314    SLANG_GFX_API_FUNC;
315
316    auto innerDesc = desc;
317    innerDesc.framebufferLayout = getInnerObj(desc.framebufferLayout);
318    RefPtr<DebugRenderPassLayout> outObject = new DebugRenderPassLayout();
319    auto result = baseObject->createRenderPassLayout(innerDesc, outObject->baseObject.writeRef());
320    if (SLANG_FAILED(result))
321        return result;
322    returnComPtr(outRenderPassLayout, outObject);
323    return result;
324}
325
326Result DebugDevice::createSwapchain(
327    ISwapchain::Desc const& desc,
328    WindowHandle window,
329    ISwapchain** outSwapchain)
330{
331    SLANG_GFX_API_FUNC;
332
333    auto innerDesc = desc;
334    innerDesc.queue = getInnerObj(desc.queue);
335    RefPtr<DebugSwapchain> outObject = new DebugSwapchain();
336    outObject->queue = getDebugObj(desc.queue);
337    auto result = baseObject->createSwapchain(innerDesc, window, outObject->baseObject.writeRef());
338    if (SLANG_FAILED(result))
339        return result;
340    returnComPtr(outSwapchain, outObject);
341    return Result();
342}
343
344Result DebugDevice::createInputLayout(IInputLayout::Desc const& desc, IInputLayout** outLayout)
345{
346    SLANG_GFX_API_FUNC;
347
348    RefPtr<DebugInputLayout> outObject = new DebugInputLayout();
349    auto result = baseObject->createInputLayout(desc, outObject->baseObject.writeRef());
350    if (SLANG_FAILED(result))
351        return result;
352    returnComPtr(outLayout, outObject);
353    return result;
354}
355
356Result DebugDevice::createCommandQueue(const ICommandQueue::Desc& desc, ICommandQueue** outQueue)
357{
358    SLANG_GFX_API_FUNC;
359
360    RefPtr<DebugCommandQueue> outObject = new DebugCommandQueue();
361    auto result = baseObject->createCommandQueue(desc, outObject->baseObject.writeRef());
362    if (SLANG_FAILED(result))
363        return result;
364    returnComPtr(outQueue, outObject);
365    return result;
366}
367
368Result DebugDevice::createShaderObject(
369    slang::TypeReflection* type,
370    ShaderObjectContainerType containerType,
371    IShaderObject** outShaderObject)
372{
373    SLANG_GFX_API_FUNC;
374
375    RefPtr<DebugShaderObject> outObject = new DebugShaderObject();
376    auto typeName = type->getName();
377    auto result =
378        baseObject->createShaderObject(type, containerType, outObject->baseObject.writeRef());
379    outObject->m_typeName = typeName;
380    outObject->m_device = this;
381    outObject->m_slangType = type;
382    if (SLANG_FAILED(result))
383        return result;
384    returnComPtr(outShaderObject, outObject);
385    return result;
386}
387
388Result DebugDevice::createShaderObject2(
389    slang::ISession* session,
390    slang::TypeReflection* type,
391    ShaderObjectContainerType containerType,
392    IShaderObject** outShaderObject)
393{
394    SLANG_GFX_API_FUNC;
395
396    RefPtr<DebugShaderObject> outObject = new DebugShaderObject();
397    auto typeName = type->getName();
398    auto result = baseObject->createShaderObject2(
399        session,
400        type,
401        containerType,
402        outObject->baseObject.writeRef());
403    outObject->m_typeName = typeName;
404    outObject->m_device = this;
405    outObject->m_slangType = type;
406    if (SLANG_FAILED(result))
407        return result;
408    returnComPtr(outShaderObject, outObject);
409    return result;
410}
411
412Result DebugDevice::createMutableShaderObject(
413    slang::TypeReflection* type,
414    ShaderObjectContainerType containerType,
415    IShaderObject** outShaderObject)
416{
417    SLANG_GFX_API_FUNC;
418
419    RefPtr<DebugShaderObject> outObject = new DebugShaderObject();
420    auto typeName = type->getName();
421    auto result = baseObject->createMutableShaderObject(
422        type,
423        containerType,
424        outObject->baseObject.writeRef());
425    outObject->m_typeName = typeName;
426    outObject->m_device = this;
427    outObject->m_slangType = type;
428    if (SLANG_FAILED(result))
429        return result;
430    returnComPtr(outShaderObject, outObject);
431    return result;
432}
433
434Result DebugDevice::createMutableShaderObject2(
435    slang::ISession* session,
436    slang::TypeReflection* type,
437    ShaderObjectContainerType containerType,
438    IShaderObject** outShaderObject)
439{
440    SLANG_GFX_API_FUNC;
441
442    RefPtr<DebugShaderObject> outObject = new DebugShaderObject();
443    auto typeName = type->getName();
444    auto result = baseObject->createMutableShaderObject2(
445        session,
446        type,
447        containerType,
448        outObject->baseObject.writeRef());
449    outObject->m_typeName = typeName;
450    outObject->m_device = this;
451    outObject->m_slangType = type;
452    if (SLANG_FAILED(result))
453        return result;
454    returnComPtr(outShaderObject, outObject);
455    return result;
456}
457
458Result DebugDevice::createMutableRootShaderObject(
459    IShaderProgram* program,
460    IShaderObject** outRootObject)
461{
462    SLANG_GFX_API_FUNC;
463    RefPtr<DebugShaderObject> outObject = new DebugShaderObject();
464    auto result = baseObject->createMutableRootShaderObject(
465        getInnerObj(program),
466        outObject->baseObject.writeRef());
467    if (SLANG_FAILED(result))
468        return result;
469    outObject->m_device = this;
470    outObject->m_slangType = nullptr;
471    outObject->m_rootComponentType = getDebugObj(program)->m_slangProgram;
472    returnComPtr(outRootObject, outObject);
473    return result;
474}
475
476Result DebugDevice::createShaderObjectFromTypeLayout(
477    slang::TypeLayoutReflection* typeLayout,
478    IShaderObject** outShaderObject)
479{
480    SLANG_GFX_API_FUNC;
481
482    RefPtr<DebugShaderObject> outObject = new DebugShaderObject();
483    auto result =
484        baseObject->createShaderObjectFromTypeLayout(typeLayout, outObject->baseObject.writeRef());
485    auto type = typeLayout->getType();
486    auto typeName = type->getName();
487    outObject->m_typeName = typeName;
488    outObject->m_device = this;
489    outObject->m_slangType = type;
490    if (SLANG_FAILED(result))
491        return result;
492    returnComPtr(outShaderObject, outObject);
493    return result;
494}
495
496Result DebugDevice::createMutableShaderObjectFromTypeLayout(
497    slang::TypeLayoutReflection* typeLayout,
498    IShaderObject** outShaderObject)
499{
500    SLANG_GFX_API_FUNC;
501    RefPtr<DebugShaderObject> outObject = new DebugShaderObject();
502    auto result = baseObject->createMutableShaderObjectFromTypeLayout(
503        typeLayout,
504        outObject->baseObject.writeRef());
505    if (SLANG_FAILED(result))
506        return result;
507    auto type = typeLayout->getType();
508    auto typeName = type->getName();
509    outObject->m_typeName = typeName;
510    outObject->m_device = this;
511    outObject->m_slangType = type;
512    returnComPtr(outShaderObject, outObject);
513    return result;
514}
515
516Result DebugDevice::createProgram(
517    const IShaderProgram::Desc& desc,
518    IShaderProgram** outProgram,
519    ISlangBlob** outDiagnostics)
520{
521    SLANG_GFX_API_FUNC;
522
523    RefPtr<DebugShaderProgram> outObject = new DebugShaderProgram();
524    auto result = baseObject->createProgram(desc, outObject->baseObject.writeRef(), outDiagnostics);
525    if (SLANG_FAILED(result))
526        return result;
527    outObject->m_slangProgram = desc.slangGlobalScope;
528    returnComPtr(outProgram, outObject);
529    return result;
530}
531
532Result DebugDevice::createProgram2(
533    const IShaderProgram::CreateDesc2& desc,
534    IShaderProgram** outProgram,
535    ISlangBlob** outDiagnostics)
536{
537    SLANG_GFX_API_FUNC;
538    IShaderProgram::Desc desc1 = {};
539    RefPtr<DebugShaderProgram> outObject = new DebugShaderProgram();
540    auto result =
541        baseObject->createProgram2(desc, outObject->baseObject.writeRef(), outDiagnostics);
542    if (SLANG_FAILED(result))
543        return result;
544    auto base = static_cast<ShaderProgramBase*>(outObject->baseObject.get());
545    outObject->m_slangProgram = base->desc.slangGlobalScope;
546    returnComPtr(outProgram, outObject);
547    return result;
548}
549
550Result DebugDevice::createGraphicsPipelineState(
551    const GraphicsPipelineStateDesc& desc,
552    IPipelineState** outState)
553{
554    SLANG_GFX_API_FUNC;
555
556    GraphicsPipelineStateDesc innerDesc = desc;
557    innerDesc.program = getInnerObj(desc.program);
558    innerDesc.inputLayout = getInnerObj(desc.inputLayout);
559    innerDesc.framebufferLayout = getInnerObj(desc.framebufferLayout);
560    RefPtr<DebugPipelineState> outObject = new DebugPipelineState();
561    auto result =
562        baseObject->createGraphicsPipelineState(innerDesc, outObject->baseObject.writeRef());
563    if (SLANG_FAILED(result))
564        return result;
565    returnComPtr(outState, outObject);
566    return result;
567}
568
569Result DebugDevice::createComputePipelineState(
570    const ComputePipelineStateDesc& desc,
571    IPipelineState** outState)
572{
573    SLANG_GFX_API_FUNC;
574
575    ComputePipelineStateDesc innerDesc = desc;
576    innerDesc.program = getInnerObj(desc.program);
577
578    RefPtr<DebugPipelineState> outObject = new DebugPipelineState();
579    auto result =
580        baseObject->createComputePipelineState(innerDesc, outObject->baseObject.writeRef());
581    if (SLANG_FAILED(result))
582        return result;
583    returnComPtr(outState, outObject);
584    return result;
585}
586
587Result DebugDevice::createRayTracingPipelineState(
588    const RayTracingPipelineStateDesc& desc,
589    IPipelineState** outState)
590{
591    SLANG_GFX_API_FUNC;
592
593    RayTracingPipelineStateDesc innerDesc = desc;
594    innerDesc.program = getInnerObj(desc.program);
595
596    RefPtr<DebugPipelineState> outObject = new DebugPipelineState();
597    auto result =
598        baseObject->createRayTracingPipelineState(innerDesc, outObject->baseObject.writeRef());
599    if (SLANG_FAILED(result))
600        return result;
601    returnComPtr(outState, outObject);
602    return result;
603}
604
605SlangResult DebugDevice::readTextureResource(
606    ITextureResource* resource,
607    ResourceState state,
608    ISlangBlob** outBlob,
609    size_t* outRowPitch,
610    size_t* outPixelSize)
611{
612    SLANG_GFX_API_FUNC;
613    return baseObject
614        ->readTextureResource(getInnerObj(resource), state, outBlob, outRowPitch, outPixelSize);
615}
616
617SlangResult DebugDevice::readBufferResource(
618    IBufferResource* buffer,
619    size_t offset,
620    size_t size,
621    ISlangBlob** outBlob)
622{
623    SLANG_GFX_API_FUNC;
624    return baseObject->readBufferResource(getInnerObj(buffer), offset, size, outBlob);
625}
626
627const DeviceInfo& DebugDevice::getDeviceInfo() const
628{
629    SLANG_GFX_API_FUNC;
630    return baseObject->getDeviceInfo();
631}
632
633Result DebugDevice::createQueryPool(const IQueryPool::Desc& desc, IQueryPool** outPool)
634{
635    SLANG_GFX_API_FUNC;
636    RefPtr<DebugQueryPool> result = new DebugQueryPool();
637    result->desc = desc;
638    SLANG_RETURN_ON_FAIL(baseObject->createQueryPool(desc, result->baseObject.writeRef()));
639    returnComPtr(outPool, result);
640    return SLANG_OK;
641}
642
643Result DebugDevice::createFence(const IFence::Desc& desc, IFence** outFence)
644{
645    SLANG_GFX_API_FUNC;
646    RefPtr<DebugFence> result = new DebugFence();
647    SLANG_RETURN_ON_FAIL(baseObject->createFence(desc, result->baseObject.writeRef()));
648    returnComPtr(outFence, result);
649    return SLANG_OK;
650}
651
652Result DebugDevice::waitForFences(
653    GfxCount fenceCount,
654    IFence** fences,
655    uint64_t* values,
656    bool waitForAll,
657    uint64_t timeout)
658{
659    SLANG_GFX_API_FUNC;
660    ShortList<IFence*> innerFences;
661    for (GfxCount i = 0; i < fenceCount; i++)
662    {
663        innerFences.add(getInnerObj(fences[i]));
664    }
665    return baseObject->waitForFences(
666        fenceCount,
667        innerFences.getArrayView().getBuffer(),
668        values,
669        waitForAll,
670        timeout);
671}
672
673Result DebugDevice::getTextureAllocationInfo(
674    const ITextureResource::Desc& desc,
675    size_t* outSize,
676    size_t* outAlignment)
677{
678    SLANG_GFX_API_FUNC;
679    return baseObject->getTextureAllocationInfo(desc, outSize, outAlignment);
680}
681
682Result DebugDevice::getTextureRowAlignment(size_t* outAlignment)
683{
684    SLANG_GFX_API_FUNC;
685    return baseObject->getTextureRowAlignment(outAlignment);
686}
687
688Result DebugDevice::getCooperativeVectorProperties(
689    CooperativeVectorProperties* properties,
690    uint32_t* propertyCount)
691{
692    SLANG_GFX_API_FUNC;
693    return baseObject->getCooperativeVectorProperties(properties, propertyCount);
694}
695
696Result DebugDevice::createShaderTable(const IShaderTable::Desc& desc, IShaderTable** outTable)
697{
698    SLANG_GFX_API_FUNC;
699    RefPtr<DebugShaderTable> result = new DebugShaderTable();
700    SLANG_RETURN_ON_FAIL(baseObject->createShaderTable(desc, result->baseObject.writeRef()));
701    returnComPtr(outTable, result);
702    return SLANG_OK;
703}
704
705} // namespace debug
706} // namespace gfx