Skip to content

Commit 144a083

Browse files
simollsimoll
committed
Uppercased vars for coding standards / added CreateDXRDevice helper / simplified tests/ added SERInvokeNoSBTTest
1 parent 6bcb151 commit 144a083

3 files changed

Lines changed: 1169 additions & 1279 deletions

File tree

‎tools/clang/unittests/HLSLExec/DXRUtil.h‎

Lines changed: 134 additions & 137 deletions
Original file line numberDiff line numberDiff line change
@@ -10,216 +10,213 @@
1010
// //
1111
///////////////////////////////////////////////////////////////////////////////
1212

13+
#pragma once
14+
1315
//= DXR Utility
1416
//============================================================================
1517
#define SHADER_ID_SIZE_IN_BYTES 32
1618

1719
#ifndef ROUND_UP
18-
#define ROUND_UP(v, powerOf2Alignment) \
19-
(((v) + (powerOf2Alignment)-1) & ~((powerOf2Alignment)-1))
20+
#define ROUND_UP(v, PowerOf2Alignment) \
21+
(((v) + (PowerOf2Alignment)-1) & ~((PowerOf2Alignment)-1))
2022
#endif
2123
struct SceneConsts {
22-
DirectX::XMFLOAT4 eye;
24+
DirectX::XMFLOAT4 Eye;
2325
DirectX::XMFLOAT4 U;
2426
DirectX::XMFLOAT4 V;
2527
DirectX::XMFLOAT4 W;
26-
float sceneScale;
27-
unsigned windowSize[2];
28-
int rayFlags;
28+
float SceneScale;
29+
unsigned WindowSize[2];
30+
int RayFlags;
2931
};
3032

3133
struct Instance {
32-
D3D12_RAYTRACING_GEOMETRY_TYPE type;
33-
DirectX::XMFLOAT4X4 matrix;
34-
UINT geometryCount;
35-
UINT bottomASIdx;
36-
UINT instanceID;
37-
UINT mask;
38-
UINT flags;
34+
D3D12_RAYTRACING_GEOMETRY_TYPE Type;
35+
DirectX::XMFLOAT4X4 Matrix;
36+
UINT GeometryCount;
37+
UINT BottomASIdx;
38+
UINT InstanceID;
39+
UINT Mask;
40+
UINT Flags;
3941
};
4042

4143
class ShaderTable {
4244
public:
43-
void Init(ID3D12Device *device, int raygenCount, int missCount,
44-
int hitGroupCount, int rayTypeCount, int rootTableDwords) {
45-
m_rayTypeCount = rayTypeCount;
46-
m_raygenCount = raygenCount;
47-
m_missCount = missCount * rayTypeCount;
48-
m_hitGroupCount = hitGroupCount * rayTypeCount;
49-
m_rootTableSizeInBytes = rootTableDwords * 4;
50-
m_shaderRecordSizeInBytes =
51-
ROUND_UP(m_rootTableSizeInBytes + SHADER_ID_SIZE_IN_BYTES,
45+
void Init(ID3D12Device *Device, int RaygenCount, int MissCount,
46+
int HitGroupCount, int RayTypeCount, int RootTableDwords) {
47+
RayTypeCount = RayTypeCount;
48+
RaygenCount = RaygenCount;
49+
MissCount = MissCount * RayTypeCount;
50+
HitGroupCount = HitGroupCount * RayTypeCount;
51+
RootTableSizeInBytes = RootTableDwords * 4;
52+
ShaderRecordSizeInBytes =
53+
ROUND_UP(RootTableSizeInBytes + SHADER_ID_SIZE_IN_BYTES,
5254
D3D12_RAYTRACING_SHADER_RECORD_BYTE_ALIGNMENT);
53-
m_missStartIdx = m_raygenCount;
54-
m_hitGroupStartIdx = m_missStartIdx + m_missCount;
55+
MissStartIdx = RaygenCount;
56+
HitGroupStartIdx = MissStartIdx + MissCount;
5557

56-
const int m_totalSizeInBytes =
57-
(m_raygenCount + m_missCount + m_hitGroupCount) *
58-
m_shaderRecordSizeInBytes;
58+
const int TotalSizeInBytes =
59+
(RaygenCount + MissCount + HitGroupCount) * ShaderRecordSizeInBytes;
5960

60-
D3D12_RESOURCE_DESC desc = CD3DX12_RESOURCE_DESC::Buffer(
61-
m_totalSizeInBytes, D3D12_RESOURCE_FLAG_NONE,
61+
D3D12_RESOURCE_DESC Desc = CD3DX12_RESOURCE_DESC::Buffer(
62+
TotalSizeInBytes, D3D12_RESOURCE_FLAG_NONE,
6263
std::max(D3D12_RAYTRACING_SHADER_RECORD_BYTE_ALIGNMENT,
6364
D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT));
64-
CD3DX12_HEAP_PROPERTIES heap =
65+
CD3DX12_HEAP_PROPERTIES Heap =
6566
CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT);
66-
VERIFY_SUCCEEDED(device->CreateCommittedResource(
67-
&heap, D3D12_HEAP_FLAG_NONE, &desc,
67+
VERIFY_SUCCEEDED(Device->CreateCommittedResource(
68+
&Heap, D3D12_HEAP_FLAG_NONE, &Desc,
6869
D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, nullptr,
69-
IID_PPV_ARGS(&m_sbtResource)));
70-
m_sbtResource->SetName(L"SBT Resource Heap");
71-
CD3DX12_HEAP_PROPERTIES upload =
70+
IID_PPV_ARGS(&SBTResource)));
71+
SBTResource->SetName(L"SBT Resource Heap");
72+
CD3DX12_HEAP_PROPERTIES Upload =
7273
CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD);
73-
VERIFY_SUCCEEDED(device->CreateCommittedResource(
74-
&upload, D3D12_HEAP_FLAG_NONE, &desc, D3D12_RESOURCE_STATE_GENERIC_READ,
75-
nullptr, IID_PPV_ARGS(&m_sbtUploadResource)));
76-
m_sbtUploadResource->SetName(L"SBT Upload Heap");
74+
VERIFY_SUCCEEDED(Device->CreateCommittedResource(
75+
&Upload, D3D12_HEAP_FLAG_NONE, &Desc, D3D12_RESOURCE_STATE_GENERIC_READ,
76+
nullptr, IID_PPV_ARGS(&SBTUploadResource)));
77+
SBTUploadResource->SetName(L"SBT Upload Heap");
7778

78-
VERIFY_SUCCEEDED(m_sbtUploadResource->Map(0, nullptr, (void **)&m_hostPtr));
79+
VERIFY_SUCCEEDED(SBTUploadResource->Map(0, nullptr, (void **)&HostPtr));
7980
}
8081

81-
void Upload(ID3D12GraphicsCommandList *cmdlist) {
82-
CD3DX12_RESOURCE_BARRIER barrier = CD3DX12_RESOURCE_BARRIER::Transition(
83-
m_sbtResource, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,
82+
void Upload(ID3D12GraphicsCommandList *CmdList) {
83+
CD3DX12_RESOURCE_BARRIER Barrier = CD3DX12_RESOURCE_BARRIER::Transition(
84+
SBTResource, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,
8485
D3D12_RESOURCE_STATE_COPY_DEST);
85-
cmdlist->ResourceBarrier(1, &barrier);
86-
cmdlist->CopyResource(m_sbtResource, m_sbtUploadResource);
87-
CD3DX12_RESOURCE_BARRIER barrier2 = CD3DX12_RESOURCE_BARRIER::Transition(
88-
m_sbtResource, D3D12_RESOURCE_STATE_COPY_DEST,
86+
CmdList->ResourceBarrier(1, &Barrier);
87+
CmdList->CopyResource(SBTResource, SBTUploadResource);
88+
CD3DX12_RESOURCE_BARRIER Barrier2 = CD3DX12_RESOURCE_BARRIER::Transition(
89+
SBTResource, D3D12_RESOURCE_STATE_COPY_DEST,
8990
D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
90-
cmdlist->ResourceBarrier(1, &barrier2);
91+
CmdList->ResourceBarrier(1, &Barrier2);
9192
}
9293

93-
int GetShaderRecordSizeInBytes() { return m_shaderRecordSizeInBytes; }
94+
int GetShaderRecordSizeInBytes() { return ShaderRecordSizeInBytes; }
9495

95-
int GetRaygenShaderRecordIdx(int idx) { return idx; }
96-
int GetMissShaderRecordIdx(int idx, int rayType) {
97-
return m_missStartIdx + idx * m_rayTypeCount + rayType;
96+
int GetRaygenShaderRecordIdx(int Idx) { return Idx; }
97+
int GetMissShaderRecordIdx(int Idx, int RayType) {
98+
return MissStartIdx + Idx * RayTypeCount + RayType;
9899
}
99-
int GetHitGroupShaderRecordIdx(int idx, int rayType) {
100-
return m_hitGroupStartIdx + idx * m_rayTypeCount + rayType;
100+
int GetHitGroupShaderRecordIdx(int Idx, int RayType) {
101+
return HitGroupStartIdx + Idx * RayTypeCount + RayType;
101102
}
102103

103-
void *GetRaygenShaderIdPtr(int idx) {
104-
return m_hostPtr +
105-
GetRaygenShaderRecordIdx(idx) * m_shaderRecordSizeInBytes;
104+
void *GetRaygenShaderIdPtr(int Idx) {
105+
return HostPtr + GetRaygenShaderRecordIdx(Idx) * ShaderRecordSizeInBytes;
106106
}
107-
void *GetMissShaderIdPtr(int idx, int rayType) {
108-
return m_hostPtr +
109-
GetMissShaderRecordIdx(idx, rayType) * m_shaderRecordSizeInBytes;
107+
void *GetMissShaderIdPtr(int Idx, int RayType) {
108+
return HostPtr +
109+
GetMissShaderRecordIdx(Idx, RayType) * ShaderRecordSizeInBytes;
110110
}
111-
void *GetHitGroupShaderIdPtr(int idx, int rayType) {
112-
return m_hostPtr +
113-
GetHitGroupShaderRecordIdx(idx, rayType) * m_shaderRecordSizeInBytes;
111+
void *GetHitGroupShaderIdPtr(int Idx, int RayType) {
112+
return HostPtr +
113+
GetHitGroupShaderRecordIdx(Idx, RayType) * ShaderRecordSizeInBytes;
114114
}
115115

116-
void *GetRaygenRootTablePtr(int idx) {
117-
return (char *)GetRaygenShaderIdPtr(idx) + SHADER_ID_SIZE_IN_BYTES;
116+
void *GetRaygenRootTablePtr(int Idx) {
117+
return (char *)GetRaygenShaderIdPtr(Idx) + SHADER_ID_SIZE_IN_BYTES;
118118
}
119-
void *GetMissRootTablePtr(int idx, int rayType) {
120-
return (char *)GetMissShaderIdPtr(idx, rayType) + SHADER_ID_SIZE_IN_BYTES;
119+
void *GetMissRootTablePtr(int Idx, int RayType) {
120+
return (char *)GetMissShaderIdPtr(Idx, RayType) + SHADER_ID_SIZE_IN_BYTES;
121121
}
122-
void *GetHitGroupRootTablePtr(int idx, int rayType) {
123-
return (char *)GetHitGroupShaderIdPtr(idx, rayType) +
122+
void *GetHitGroupRootTablePtr(int Idx, int RayType) {
123+
return (char *)GetHitGroupShaderIdPtr(Idx, RayType) +
124124
SHADER_ID_SIZE_IN_BYTES;
125125
}
126126

127-
int GetRaygenRangeInBytes() {
128-
return m_raygenCount * m_shaderRecordSizeInBytes;
129-
}
130-
int GetMissRangeInBytes() { return m_missCount * m_shaderRecordSizeInBytes; }
127+
int GetRaygenRangeInBytes() { return RaygenCount * ShaderRecordSizeInBytes; }
128+
int GetMissRangeInBytes() { return MissCount * ShaderRecordSizeInBytes; }
131129
int GetHitGroupRangeInBytes() {
132-
return m_hitGroupCount * m_shaderRecordSizeInBytes;
130+
return HitGroupCount * ShaderRecordSizeInBytes;
133131
}
134132

135133
D3D12_GPU_VIRTUAL_ADDRESS GetRaygenStartGpuVA() {
136-
return m_sbtResource->GetGPUVirtualAddress() +
137-
GetRaygenShaderRecordIdx(0) * m_shaderRecordSizeInBytes;
134+
return SBTResource->GetGPUVirtualAddress() +
135+
GetRaygenShaderRecordIdx(0) * ShaderRecordSizeInBytes;
138136
}
139137
D3D12_GPU_VIRTUAL_ADDRESS GetMissStartGpuVA() {
140-
return m_sbtResource->GetGPUVirtualAddress() +
141-
GetMissShaderRecordIdx(0, 0) * m_shaderRecordSizeInBytes;
138+
return SBTResource->GetGPUVirtualAddress() +
139+
GetMissShaderRecordIdx(0, 0) * ShaderRecordSizeInBytes;
142140
}
143141
D3D12_GPU_VIRTUAL_ADDRESS GetHitGroupStartGpuVA() {
144-
return m_sbtResource->GetGPUVirtualAddress() +
145-
GetHitGroupShaderRecordIdx(0, 0) * m_shaderRecordSizeInBytes;
142+
return SBTResource->GetGPUVirtualAddress() +
143+
GetHitGroupShaderRecordIdx(0, 0) * ShaderRecordSizeInBytes;
146144
}
147145

148146
private:
149-
CComPtr<ID3D12Resource> m_sbtResource;
150-
CComPtr<ID3D12Resource> m_sbtUploadResource;
151-
char *m_hostPtr = nullptr;
152-
int m_rayTypeCount = 0;
153-
int m_raygenCount = 0;
154-
int m_missCount = 0;
155-
int m_hitGroupCount = 0;
156-
int m_rootTableSizeInBytes = 0;
157-
int m_shaderRecordSizeInBytes = 0;
158-
int m_missStartIdx = 0;
159-
int m_hitGroupStartIdx = 0;
147+
CComPtr<ID3D12Resource> SBTResource;
148+
CComPtr<ID3D12Resource> SBTUploadResource;
149+
char *HostPtr = nullptr;
150+
int RayTypeCount = 0;
151+
int RaygenCount = 0;
152+
int MissCount = 0;
153+
int HitGroupCount = 0;
154+
int RootTableSizeInBytes = 0;
155+
int ShaderRecordSizeInBytes = 0;
156+
int MissStartIdx = 0;
157+
int HitGroupStartIdx = 0;
160158
};
161159

162160
//-----------------------------------------------------------------------------
163161
void AllocateBuffer(
164-
ID3D12Device *pDevice, UINT64 bufferSize, ID3D12Resource **ppResource,
165-
bool allowUAV = false,
166-
D3D12_RESOURCE_STATES initialResourceState = D3D12_RESOURCE_STATE_COMMON,
167-
const wchar_t *resourceName = nullptr) {
168-
auto uploadHeapProperties = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT);
169-
auto bufferDesc = CD3DX12_RESOURCE_DESC::Buffer(
170-
bufferSize, allowUAV ? D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS
162+
ID3D12Device *Device, UINT64 BufferSize, ID3D12Resource **Resource,
163+
bool AllowUAV = false,
164+
D3D12_RESOURCE_STATES InitialResourceState = D3D12_RESOURCE_STATE_COMMON,
165+
const wchar_t *ResourceName = nullptr) {
166+
auto UploadHeapProperties = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT);
167+
auto BufferDesc = CD3DX12_RESOURCE_DESC::Buffer(
168+
BufferSize, AllowUAV ? D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS
171169
: D3D12_RESOURCE_FLAG_NONE);
172-
VERIFY_SUCCEEDED(pDevice->CreateCommittedResource(
173-
&uploadHeapProperties, D3D12_HEAP_FLAG_NONE, &bufferDesc,
174-
initialResourceState, nullptr, IID_PPV_ARGS(ppResource)));
175-
if (resourceName) {
176-
(*ppResource)->SetName(resourceName);
170+
VERIFY_SUCCEEDED(Device->CreateCommittedResource(
171+
&UploadHeapProperties, D3D12_HEAP_FLAG_NONE, &BufferDesc,
172+
InitialResourceState, nullptr, IID_PPV_ARGS(Resource)));
173+
if (ResourceName) {
174+
(*Resource)->SetName(ResourceName);
177175
}
178176
}
179177

180178
//-----------------------------------------------------------------------------
181-
void ReallocScratchResource(ID3D12Device *pDevice, ID3D12Resource **ppResource,
182-
UINT64 nbytes) {
183-
184-
if (!(*ppResource) || (*ppResource)->GetDesc().Width < nbytes) {
185-
AllocateBuffer(pDevice, nbytes, ppResource, true,
179+
void ReallocScratchResource(ID3D12Device *Device, ID3D12Resource **Resource,
180+
UINT64 NBytes) {
181+
if (!(*Resource) || (*Resource)->GetDesc().Width < NBytes) {
182+
AllocateBuffer(Device, NBytes, Resource, true,
186183
D3D12_RESOURCE_STATE_UNORDERED_ACCESS, L"scratchResource");
187184
}
188185
}
189186

190187
//-----------------------------------------------------------------------------
191-
void AllocateUploadBuffer(ID3D12Device *pDevice, const void *pData,
192-
UINT64 datasize, ID3D12Resource **ppResource,
193-
const wchar_t *resourceName = nullptr) {
194-
auto uploadHeapProperties = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD);
195-
auto bufferDesc = CD3DX12_RESOURCE_DESC::Buffer(datasize);
196-
VERIFY_SUCCEEDED(pDevice->CreateCommittedResource(
197-
&uploadHeapProperties, D3D12_HEAP_FLAG_NONE, &bufferDesc,
198-
D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(ppResource)));
199-
if (resourceName) {
200-
(*ppResource)->SetName(resourceName);
201-
}
202-
void *pMappedData;
203-
VERIFY_SUCCEEDED((*ppResource)->Map(0, nullptr, &pMappedData));
204-
memcpy(pMappedData, pData, datasize);
205-
(*ppResource)->Unmap(0, nullptr);
188+
void AllocateUploadBuffer(ID3D12Device *Device, const void *Data,
189+
UINT64 DataSize, ID3D12Resource **Resource,
190+
const wchar_t *ResourceName = nullptr) {
191+
auto UploadHeapProperties = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD);
192+
auto BufferDesc = CD3DX12_RESOURCE_DESC::Buffer(DataSize);
193+
VERIFY_SUCCEEDED(Device->CreateCommittedResource(
194+
&UploadHeapProperties, D3D12_HEAP_FLAG_NONE, &BufferDesc,
195+
D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(Resource)));
196+
if (ResourceName) {
197+
(*Resource)->SetName(ResourceName);
198+
}
199+
void *MappedData;
200+
VERIFY_SUCCEEDED((*Resource)->Map(0, nullptr, &MappedData));
201+
memcpy(MappedData, Data, DataSize);
202+
(*Resource)->Unmap(0, nullptr);
206203
}
207204

208205
//-----------------------------------------------------------------------------
209-
void AllocateBufferFromUpload(ID3D12Device *pDevice,
210-
ID3D12GraphicsCommandList *pCommandList,
211-
ID3D12Resource *uploadSource,
212-
ID3D12Resource **ppResource,
213-
D3D12_RESOURCE_STATES targetResourceState,
214-
const wchar_t *resourceName = nullptr) {
215-
const bool allowUAV =
216-
targetResourceState == D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
217-
AllocateBuffer(pDevice, uploadSource->GetDesc().Width, ppResource, allowUAV,
218-
D3D12_RESOURCE_STATE_COPY_DEST, resourceName);
219-
pCommandList->CopyResource(*ppResource, uploadSource);
220-
CD3DX12_RESOURCE_BARRIER barrier = CD3DX12_RESOURCE_BARRIER::Transition(
221-
*ppResource, D3D12_RESOURCE_STATE_COPY_DEST, targetResourceState);
222-
pCommandList->ResourceBarrier(1, (const D3D12_RESOURCE_BARRIER *)&barrier);
206+
void AllocateBufferFromUpload(ID3D12Device *Device,
207+
ID3D12GraphicsCommandList *CommandList,
208+
ID3D12Resource *UploadSource,
209+
ID3D12Resource **Resource,
210+
D3D12_RESOURCE_STATES TargetResourceState,
211+
const wchar_t *ResourceName = nullptr) {
212+
const bool AllowUAV =
213+
TargetResourceState == D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
214+
AllocateBuffer(Device, UploadSource->GetDesc().Width, Resource, AllowUAV,
215+
D3D12_RESOURCE_STATE_COPY_DEST, ResourceName);
216+
CommandList->CopyResource(*Resource, UploadSource);
217+
CD3DX12_RESOURCE_BARRIER Barrier = CD3DX12_RESOURCE_BARRIER::Transition(
218+
*Resource, D3D12_RESOURCE_STATE_COPY_DEST, TargetResourceState);
219+
CommandList->ResourceBarrier(1, (const D3D12_RESOURCE_BARRIER *)&Barrier);
223220
}
224221

225222
//= DXR Utility

0 commit comments

Comments
 (0)