1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
#include "tools/unit-test/slang-unit-test.h"
#include "slang-gfx.h"
#include "gfx-test-util.h"
#include "tools/gfx-util/shader-cursor.h"
#include "source/core/slang-basic.h"
using namespace gfx;
namespace gfx_test
{
static ComPtr<IBufferResource> createBuffer(IDevice* device, uint32_t content)
{
ComPtr<IBufferResource> buffer;
IBufferResource::Desc bufferDesc = {};
bufferDesc.sizeInBytes = sizeof(uint32_t);
bufferDesc.format = gfx::Format::Unknown;
bufferDesc.elementSize = sizeof(float);
bufferDesc.allowedStates = ResourceStateSet(
ResourceState::ShaderResource,
ResourceState::UnorderedAccess,
ResourceState::CopyDestination,
ResourceState::CopySource);
bufferDesc.defaultState = ResourceState::UnorderedAccess;
bufferDesc.memoryType = MemoryType::DeviceLocal;
ComPtr<IBufferResource> numbersBuffer;
GFX_CHECK_CALL_ABORT(
device->createBufferResource(bufferDesc, (void*)&content, buffer.writeRef()));
return buffer;
}
void rootShaderParameterTestImpl(IDevice* device, UnitTestContext* context)
{
Slang::ComPtr<ITransientResourceHeap> transientHeap;
ITransientResourceHeap::Desc transientHeapDesc = {};
transientHeapDesc.constantBufferSize = 4096;
GFX_CHECK_CALL_ABORT(
device->createTransientResourceHeap(transientHeapDesc, transientHeap.writeRef()));
ComPtr<IShaderProgram> shaderProgram;
slang::ProgramLayout* slangReflection;
GFX_CHECK_CALL_ABORT(loadComputeProgram(device, shaderProgram, "root-shader-parameter", "computeMain", slangReflection));
ComputePipelineStateDesc pipelineDesc = {};
pipelineDesc.program = shaderProgram.get();
ComPtr<gfx::IPipelineState> pipelineState;
GFX_CHECK_CALL_ABORT(
device->createComputePipelineState(pipelineDesc, pipelineState.writeRef()));
Slang::List<ComPtr<IBufferResource>> buffers;
Slang::List<ComPtr<IResourceView>> srvs, uavs;
for (uint32_t i = 0; i < 9; i++)
{
buffers.add(createBuffer(device, i == 0 ? 10 : i));
ComPtr<IResourceView> bufferView;
IResourceView::Desc viewDesc = {};
viewDesc.type = IResourceView::Type::UnorderedAccess;
viewDesc.format = Format::Unknown;
GFX_CHECK_CALL_ABORT(
device->createBufferView(buffers[i], nullptr, viewDesc, bufferView.writeRef()));
uavs.add(bufferView);
viewDesc.type = IResourceView::Type::ShaderResource;
viewDesc.format = Format::Unknown;
GFX_CHECK_CALL_ABORT(
device->createBufferView(buffers[i], nullptr, viewDesc, bufferView.writeRef()));
srvs.add(bufferView);
}
ComPtr<IShaderObject> rootObject;
device->createMutableRootShaderObject(shaderProgram, rootObject.writeRef());
ComPtr<IShaderObject> g, s1, s2;
device->createMutableShaderObject(
slangReflection->findTypeByName("S0"), ShaderObjectContainerType::None, g.writeRef());
device->createMutableShaderObject(
slangReflection->findTypeByName("S1"), ShaderObjectContainerType::None, s1.writeRef());
device->createMutableShaderObject(
slangReflection->findTypeByName("S1"), ShaderObjectContainerType::None, s2.writeRef());
{
auto cursor = ShaderCursor(s1);
cursor["c0"].setResource(srvs[2]);
cursor["c1"].setResource(uavs[3]);
cursor["c2"].setResource(srvs[4]);
}
{
auto cursor = ShaderCursor(s2);
cursor["c0"].setResource(srvs[5]);
cursor["c1"].setResource(uavs[6]);
cursor["c2"].setResource(srvs[7]);
}
{
auto cursor = ShaderCursor(g);
cursor["b0"].setResource(srvs[0]);
cursor["b1"].setResource(srvs[1]);
cursor["s1"].setObject(s1);
cursor["s2"].setObject(s2);
}
{
auto cursor = ShaderCursor(rootObject);
cursor["g"].setObject(g);
cursor["buffer"].setResource(uavs[8]);
}
{
ICommandQueue::Desc queueDesc = { ICommandQueue::QueueType::Graphics };
auto queue = device->createCommandQueue(queueDesc);
auto commandBuffer = transientHeap->createCommandBuffer();
{
auto encoder = commandBuffer->encodeComputeCommands();
encoder->bindPipelineWithRootObject(pipelineState, rootObject);
encoder->dispatchCompute(1, 1, 1);
encoder->endEncoding();
}
commandBuffer->close();
queue->executeCommandBuffer(commandBuffer);
queue->waitOnHost();
}
compareComputeResult(
device, buffers[8], Slang::makeArray<uint32_t>(10 - 1 + 2 - 3 + 4 + 5 - 6 + 7));
}
SLANG_UNIT_TEST(rootShaderParameterD3D12)
{
runTestImpl(rootShaderParameterTestImpl, unitTestContext, Slang::RenderApiFlag::D3D12);
}
}
|
