I3DHOcclusionShaders.h Source File

instant3Dhub

• Source
• Instant3DHubShader
• Public

I3DHOcclusionShaders.h

Go to the documentation of this file.

1

5

6#pragma once

7

8#include "CoreMinimal.h"

9

10#include "DataDrivenShaderPlatformInfo.h"

11#include "GlobalShader.h"

12#include "Misc/EngineVersionComparison.h"

13#include "RHIAccess.h"

14#include "RHIFeatureLevel.h"

15#include "SceneView.h"

16#include "ShaderCompilerCore.h"

17#include "ShaderCore.h"

18#include "ShaderParameterMacros.h"

19#include "ShaderParameterStruct.h"

20#include "ShaderParameterUtils.h"

21#include "ShaderPermutation.h"

22#include "ShaderPrintParameters.h"

23

24// ----------------------------------------------------------

25// Structured Types

26// ----------------------------------------------------------

27

28struct FI3DHBoxScreenRect

29{

30 // Pixels: PixelFootprint of Rect full view resolution

31 FIntVector4 Pixels; // 4x 32bit

32 // DominantFacePlane: Plane in Viewport UV Space

33 FVector3f DominantFacePlane; // 3x 32bit

34 // Depth: Closest Depth of Rect

35 float Depth; // 32bit

36};

37

38struct FI3DHOcclusionTestStageDebugInfo

39{

40 int32 StageId;

41 int32 StageLevel;

42 uint32 NumActiveBoxes;

43 uint32 Padding;

44};

45

46// ----------------------------------------------------------

47// Shaders

48// ----------------------------------------------------------

49

50BEGIN_SHADER_PARAMETER_STRUCT(FI3DHHZBParameters, INSTANT3DHUBSHADER_API)

51 SHADER_PARAMETER_RDG_TEXTURE(Texture2D, ClosestHZBTexture)

52 SHADER_PARAMETER_RDG_TEXTURE(Texture2D, FurthestHZBTexture)

53 SHADER_PARAMETER_SAMPLER(SamplerState, HZBTextureSampler)

54 SHADER_PARAMETER(FVector2f, HZBSize)

55 SHADER_PARAMETER(FVector2f, HZBViewSize)

56 SHADER_PARAMETER(uint32, bIsFurthestHZBValid)

57 SHADER_PARAMETER(uint32, bIsClosestHZBValid)

58END_SHADER_PARAMETER_STRUCT()

59

60BEGIN_SHADER_PARAMETER_STRUCT(FI3DHBoxParameters, INSTANT3DHUBSHADER_API)

61 SHADER_PARAMETER(FMatrix44f, RelativeToWorldMatrix)

62 SHADER_PARAMETER(FVector3f, ReferenceOriginHigh)

63 SHADER_PARAMETER(uint32, bUseLocalToReferenceMatrices)

64 SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer, BoxCentersBuffer)

65 SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer, BoxExtentsBuffer)

66 SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer, BoxLocalToReferenceMatricesBuffer)

67 SHADER_PARAMETER(uint32, NumBoxes)

68END_SHADER_PARAMETER_STRUCT()

69

70class INSTANT3DHUBSHADER_API FI3DHCoarseOcclusionTestCS : public FGlobalShader

71{

72public:

73 DECLARE_GLOBAL_SHADER(FI3DHCoarseOcclusionTestCS);

74 SHADER_USE_PARAMETER_STRUCT(FI3DHCoarseOcclusionTestCS, FGlobalShader);

75

76 class FIsFirstPass : SHADER_PERMUTATION_BOOL("IS_FIRST_PASS");

77 using FPermutationDomain = TShaderPermutationDomain<FIsFirstPass>;

78

79 static constexpr int32 ThreadGroupSize = 64;

80

81 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

82 SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View)

83 SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer, ClipPlanesBuffer)

84 SHADER_PARAMETER_RDG_BUFFER_UAV(RWStructuredBuffer, RWBoxScreenRectsBuffer)

85 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWTestViewStateBuffer)

86 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWTestResultsBuffer)

87 SHADER_PARAMETER_STRUCT_INCLUDE(FI3DHHZBParameters, HZBParameters)

88 SHADER_PARAMETER_STRUCT_INCLUDE(FI3DHBoxParameters, BoxParameters)

89 SHADER_PARAMETER(uint32, NumClipPlanes)

90 SHADER_PARAMETER(float, SmallFeatureCullingThreshold)

91 SHADER_PARAMETER(float, ViewZMin)

92 SHADER_PARAMETER(float, ViewZMax)

93 END_SHADER_PARAMETER_STRUCT()

94

95 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

96 {

97 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

98 }

99

100 static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)

101 {

102 OutEnvironment.SetDefine(TEXT("THREADGROUPSIZE"), ThreadGroupSize);

103

104 const FPermutationDomain PermutationVector(Parameters.PermutationId);

105 if (!PermutationVector.Get<FIsFirstPass>())

106 {

107 OutEnvironment.CompilerFlags.Add(CFLAG_AllowTypedUAVLoads);

108 }

109 }

110};

111class INSTANT3DHUBSHADER_API FI3DHRefineOcclusionTestCS : public FGlobalShader

112{

113public:

114 DECLARE_GLOBAL_SHADER(FI3DHRefineOcclusionTestCS);

115 SHADER_USE_PARAMETER_STRUCT(FI3DHRefineOcclusionTestCS, FGlobalShader);

116

117 static constexpr int32 ThreadGroupSize = 64;

118

119 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

120 SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View)

121 SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer, BoxScreenRectsBuffer)

122 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, ActiveBoxIndexBuffer)

123 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, ActiveBoxCountBuffer)

124 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWTestViewStateBuffer)

125 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWTestResultsBuffer)

126 SHADER_PARAMETER_STRUCT_INCLUDE(FI3DHHZBParameters, HZBParameters)

127 SHADER_PARAMETER_STRUCT_INCLUDE(FI3DHBoxParameters, BoxParameters)

128 SHADER_PARAMETER(uint32, HZBLevelOffset)

129 RDG_BUFFER_ACCESS(IndirectDispatchArgs, ERHIAccess::IndirectArgs)

130 END_SHADER_PARAMETER_STRUCT()

131

132 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

133 {

134 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

135 }

136

137 static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)

138 {

139 OutEnvironment.SetDefine(TEXT("THREADGROUPSIZE"), ThreadGroupSize);

140 OutEnvironment.CompilerFlags.Add(CFLAG_AllowTypedUAVLoads);

141 }

142};

143

144class INSTANT3DHUBSHADER_API FI3DHRasterOcclusionTestVS : public FGlobalShader

145{

146 DECLARE_GLOBAL_SHADER(FI3DHRasterOcclusionTestVS);

147 SHADER_USE_PARAMETER_STRUCT(FI3DHRasterOcclusionTestVS, FGlobalShader);

148

149 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

150 SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View)

151 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, ActiveBoxIndexBuffer)

152 SHADER_PARAMETER_STRUCT_INCLUDE(FI3DHBoxParameters, BoxParameters)

153 RDG_BUFFER_ACCESS(IndirectDrawArgsBuffer, ERHIAccess::IndirectArgs)

154 END_SHADER_PARAMETER_STRUCT()

155

156 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

157 {

158 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

159 }

160};

161

162class INSTANT3DHUBSHADER_API FI3DHRasterOcclusionTestPS : public FGlobalShader

163{

164 DECLARE_GLOBAL_SHADER(FI3DHRasterOcclusionTestPS);

165 SHADER_USE_PARAMETER_STRUCT(FI3DHRasterOcclusionTestPS, FGlobalShader);

166

167 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

168 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWTestResultsBuffer)

169 END_SHADER_PARAMETER_STRUCT()

170

171 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

172 {

173 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

174 }

175};

176

177BEGIN_SHADER_PARAMETER_STRUCT(FI3DHRasterOcclusionTestParameters, INSTANT3DHUBSHADER_API)

178 SHADER_PARAMETER_STRUCT_INCLUDE(FI3DHRasterOcclusionTestVS::FParameters, VS)

179 SHADER_PARAMETER_STRUCT_INCLUDE(FI3DHRasterOcclusionTestPS::FParameters, PS)

180 RENDER_TARGET_BINDING_SLOTS()

181END_SHADER_PARAMETER_STRUCT()

182

183class INSTANT3DHUBSHADER_API FI3DHActiveBoxFilterCS : public FGlobalShader

184{

185public:

186 DECLARE_GLOBAL_SHADER(FI3DHActiveBoxFilterCS);

187 SHADER_USE_PARAMETER_STRUCT(FI3DHActiveBoxFilterCS, FGlobalShader);

188

189 static constexpr int32 ThreadGroupSize = 64;

190

191 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

192 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, TestViewStateBuffer)

193 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, TestResultsBuffer)

194 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWActiveBoxCountBuffer)

195 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWActiveBoxIndexBuffer)

196 SHADER_PARAMETER(uint32, NumBoxes)

197 END_SHADER_PARAMETER_STRUCT()

198

199 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

200 {

201 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

202 }

203

204 static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)

205 {

206 OutEnvironment.SetDefine(TEXT("THREADGROUPSIZE"), ThreadGroupSize);

207 }

208};

209

210class INSTANT3DHUBSHADER_API FI3DHBuildIndirectDispatchArgsCS : public FGlobalShader

211{

212public:

213 DECLARE_GLOBAL_SHADER(FI3DHBuildIndirectDispatchArgsCS);

214 SHADER_USE_PARAMETER_STRUCT(FI3DHBuildIndirectDispatchArgsCS, FGlobalShader);

215

216 static constexpr int32 ThreadGroupSize = 1;

217

218 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

219 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, InstanceCountBuffer)

220 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWIndirectArgsBuffer)

221 END_SHADER_PARAMETER_STRUCT()

222

223 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

224 {

225 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

226 }

227

228 static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)

229 {

230 OutEnvironment.SetDefine(TEXT("INDIRECT_THREADGROUPSIZE"), FI3DHRefineOcclusionTestCS::ThreadGroupSize);

231 }

232};

233

234class INSTANT3DHUBSHADER_API FI3DHBuildIndirectDrawArgsCS : public FGlobalShader

235{

236public:

237 DECLARE_GLOBAL_SHADER(FI3DHBuildIndirectDrawArgsCS);

238 SHADER_USE_PARAMETER_STRUCT(FI3DHBuildIndirectDrawArgsCS, FGlobalShader);

239

240 static constexpr int32 ThreadGroupSize = 1;

241

242 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

243 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, InstanceCountBuffer)

244 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWIndirectArgsBuffer)

245 SHADER_PARAMETER(uint32, IndexCountPerInstance)

246 END_SHADER_PARAMETER_STRUCT()

247

248 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

249 {

250 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

251 }

252};

253

254// ----------------------------------------------------------

255// Debug Shaders

256// ----------------------------------------------------------

257

258class INSTANT3DHUBSHADER_API FI3DHDebugDrawOcclusionTestVS : public FGlobalShader

259{

260 DECLARE_GLOBAL_SHADER(FI3DHDebugDrawOcclusionTestVS);

261 SHADER_USE_PARAMETER_STRUCT(FI3DHDebugDrawOcclusionTestVS, FGlobalShader);

262

263 class FUseDebugInfoBuffer : SHADER_PERMUTATION_BOOL("USE_DEBUG_INFO_BUFFER");

264 using FPermutationDomain = TShaderPermutationDomain<FUseDebugInfoBuffer>;

265

266 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

267 SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View)

268 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, TestResultsBuffer)

269 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, BoxUserDebugFlagsBuffer)

270 SHADER_PARAMETER_STRUCT_INCLUDE(FI3DHBoxParameters, BoxParameters)

271 END_SHADER_PARAMETER_STRUCT()

272

273 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

274 {

275 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

276 }

277};

278

279class INSTANT3DHUBSHADER_API FI3DHDebugDrawOcclusionTestPS : public FGlobalShader

280{

281 DECLARE_GLOBAL_SHADER(FI3DHDebugDrawOcclusionTestPS);

282 SHADER_USE_PARAMETER_STRUCT(FI3DHDebugDrawOcclusionTestPS, FGlobalShader);

283

284 class FUseDebugInfoBuffer : SHADER_PERMUTATION_BOOL("USE_DEBUG_INFO_BUFFER");

285 using FPermutationDomain = TShaderPermutationDomain<FUseDebugInfoBuffer>;

286

287 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

288 SHADER_PARAMETER(uint32, UserDebugFlagMask)

289 SHADER_PARAMETER(uint32, ColorMode)

290 SHADER_PARAMETER(uint32, bDrawIfVisible)

291 SHADER_PARAMETER(uint32, bDrawIfInvisible)

292 SHADER_PARAMETER(uint32, bDrawIfHasAnyMaskedDebugFlags)

293 SHADER_PARAMETER(uint32, bDrawIfHasAllMaskedDebugFlags)

294 END_SHADER_PARAMETER_STRUCT()

295

296 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

297 {

298 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

299 }

300};

301

302BEGIN_SHADER_PARAMETER_STRUCT(FI3DHDebugDrawOcclusionTestParameters, INSTANT3DHUBSHADER_API)

303 SHADER_PARAMETER_STRUCT_INCLUDE(FI3DHDebugDrawOcclusionTestVS::FParameters, VS)

304 SHADER_PARAMETER_STRUCT_INCLUDE(FI3DHDebugDrawOcclusionTestPS::FParameters, PS)

305 RENDER_TARGET_BINDING_SLOTS()

306END_SHADER_PARAMETER_STRUCT()

307

308class INSTANT3DHUBSHADER_API FI3DHDebugPrintOcclusionTestCS : public FGlobalShader

309{

310 DECLARE_GLOBAL_SHADER(FI3DHDebugPrintOcclusionTestCS);

311 SHADER_USE_PARAMETER_STRUCT(FI3DHDebugPrintOcclusionTestCS, FGlobalShader);

312

313 static constexpr int32 ThreadGroupSize = 32;

314

315 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

316 SHADER_PARAMETER_STRUCT_INCLUDE(ShaderPrint::FShaderParameters, ShaderPrintUniformBuffer)

317 SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer, StageDebugInfoBuffer)

318 SHADER_PARAMETER(uint32, NumStages)

319 SHADER_PARAMETER(uint32, NumBoxes)

320 SHADER_PARAMETER(uint32, NumTestedViews)

321 END_SHADER_PARAMETER_STRUCT()

322

323 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

324 {

325 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5) && ShaderPrint::IsSupported(Parameters.Platform);

326 }

327

328 static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)

329 {

330 OutEnvironment.SetDefine(TEXT("THREADGROUPSIZE"), ThreadGroupSize);

331 ShaderPrint::ModifyCompilationEnvironment(Parameters, OutEnvironment);

332 }

333};

334

335class INSTANT3DHUBSHADER_API FI3DHWriteStageDebugInfoCS : public FGlobalShader

336{

337 DECLARE_GLOBAL_SHADER(FI3DHWriteStageDebugInfoCS);

338 SHADER_USE_PARAMETER_STRUCT(FI3DHWriteStageDebugInfoCS, FGlobalShader);

339

340 static constexpr int32 ThreadGroupSize = 1;

341

342 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

343 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, ActiveBoxCountBuffer)

344 SHADER_PARAMETER_RDG_BUFFER_UAV(RWStructuredBuffer, RWStageDebugInfoBuffer)

345 SHADER_PARAMETER(uint32, ViewIndex)

346 SHADER_PARAMETER(uint32, NumStages)

347 SHADER_PARAMETER(uint32, StageDebugInfoIndex)

348 SHADER_PARAMETER(int32, StageId)

349 SHADER_PARAMETER(int32, StageLevel)

350 END_SHADER_PARAMETER_STRUCT()

351

352 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

353 {

354 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

355 }

356

357 static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)

358 {

359 OutEnvironment.SetDefine(TEXT("THREADGROUPSIZE"), ThreadGroupSize);

360 }

361};

362

363// ----------------------------------------------------------

364// HZB

365// ----------------------------------------------------------

366

367class INSTANT3DHUBSHADER_API FI3DHHZBBuildCS : public FGlobalShader

368{

369 DECLARE_GLOBAL_SHADER(FI3DHHZBBuildCS);

370 SHADER_USE_PARAMETER_STRUCT(FI3DHHZBBuildCS, FGlobalShader)

371

372 static constexpr int32 GroupTileSize = 8;

373 static constexpr int32 MaxMipBatchSize = 4;

374

375 class FDimFurthest : SHADER_PERMUTATION_BOOL("DIM_FURTHEST");

376 class FDimClosest : SHADER_PERMUTATION_BOOL("DIM_CLOSEST");

377 class FDimMipLevelCount : SHADER_PERMUTATION_RANGE_INT("DIM_MIP_LEVEL_COUNT", 1, MaxMipBatchSize);

378 using FPermutationDomain = TShaderPermutationDomain<FDimFurthest, FDimClosest, FDimMipLevelCount>;

379

380 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

381 SHADER_PARAMETER(FVector4f, DispatchThreadIdToBufferUV)

382 SHADER_PARAMETER(FIntVector4, PixelViewPortMinMax)

383 SHADER_PARAMETER(FVector2f, InputViewportMaxBound)

384 SHADER_PARAMETER(FVector2f, InvSize)

385

386 SHADER_PARAMETER_RDG_TEXTURE_SRV(Texture2D, ParentTextureMip)

387 SHADER_PARAMETER_SAMPLER(SamplerState, ParentTextureMipSampler)

388

389 SHADER_PARAMETER_RDG_TEXTURE_UAV_ARRAY(RWTexture2D<float>, FurthestHZBOutput, [MaxMipBatchSize])

390 SHADER_PARAMETER_RDG_TEXTURE_UAV_ARRAY(RWTexture2D<float>, ClosestHZBOutput, [MaxMipBatchSize])

391 END_SHADER_PARAMETER_STRUCT()

392

393 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

394 {

395 FPermutationDomain PermutationVector(Parameters.PermutationId);

396

397 if (!PermutationVector.Get<FDimFurthest>() && !PermutationVector.Get<FDimClosest>())

398 {

399 return false;

400 }

401

402 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

403 }

404

405 static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)

406 {

407 // Deactivate unused features

408 OutEnvironment.SetDefine(TEXT("VIS_BUFFER_FORMAT"), 0);

409 OutEnvironment.SetDefine(TEXT("DIM_FROXELS"), 0);

410 }

411};

412

413// ----------------------------------------------------------

414// BVH Shaders

415// ----------------------------------------------------------

416

417struct FI3DHBVHNode

418{

419 FVector3f AABBMin; // 12 bytes

420 uint32 LeftChild; // 4 bytes

421 FVector3f AABBMax; // 12 bytes

422 uint32 RightChild; // 4 bytes

423};

424

425class INSTANT3DHUBSHADER_API FI3DHComputeMortonCodesCS : public FGlobalShader

426{

427public:

428 DECLARE_GLOBAL_SHADER(FI3DHComputeMortonCodesCS);

429 SHADER_USE_PARAMETER_STRUCT(FI3DHComputeMortonCodesCS, FGlobalShader);

430

431 static constexpr int32 ThreadGroupSize = 64;

432

433 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

434 SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View)

435 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWMortonCodesBuffer)

436 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWSortedIndicesBuffer)

437 SHADER_PARAMETER_STRUCT_INCLUDE(FI3DHBoxParameters, BoxParameters)

438 SHADER_PARAMETER(float, ViewZMin)

439 SHADER_PARAMETER(float, ViewZMax)

440 END_SHADER_PARAMETER_STRUCT()

441

442 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

443 {

444 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

445 }

446

447 static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)

448 {

449 OutEnvironment.SetDefine(TEXT("THREADGROUPSIZE"), ThreadGroupSize);

450 }

451};

452

453class INSTANT3DHUBSHADER_API FI3DHBuildBVHBottomUpCS : public FGlobalShader

454{

455public:

456 DECLARE_GLOBAL_SHADER(FI3DHBuildBVHBottomUpCS);

457 SHADER_USE_PARAMETER_STRUCT(FI3DHBuildBVHBottomUpCS, FGlobalShader);

458

459 static constexpr int32 ThreadGroupSize = 64;

460 static constexpr uint32 UnvisitedNode = 0xFFFFFFFFu;

461

462 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

463 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, SortedMortonCodesBuffer)

464 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, SortedIndicesBuffer)

465 SHADER_PARAMETER_RDG_BUFFER_UAV(RWStructuredBuffer, RWBVHNodesBuffer)

466 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWNodeParentBuffer)

467 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWAtomicRangeBuffer)

468 SHADER_PARAMETER_STRUCT_INCLUDE(FI3DHBoxParameters, BoxParameters)

469 SHADER_PARAMETER(uint32, NumLeaves)

470 END_SHADER_PARAMETER_STRUCT()

471

472 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

473 {

474 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

475 }

476

477 static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)

478 {

479 OutEnvironment.SetDefine(TEXT("THREADGROUPSIZE"), ThreadGroupSize);

480 OutEnvironment.SetDefine(TEXT("UNVISITED_NODE"), UnvisitedNode);

481 OutEnvironment.CompilerFlags.Add(CFLAG_AllowTypedUAVLoads);

482 }

483};

484

485class INSTANT3DHUBSHADER_API FI3DHComputeBVHNodeDepthCS : public FGlobalShader

486{

487public:

488 DECLARE_GLOBAL_SHADER(FI3DHComputeBVHNodeDepthCS);

489 SHADER_USE_PARAMETER_STRUCT(FI3DHComputeBVHNodeDepthCS, FGlobalShader);

490

491 static constexpr int32 ThreadGroupSize = 64;

492

493 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

494 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, NodeParentBuffer)

495 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWInternalNodeDepthBuffer)

496 SHADER_PARAMETER(uint32, NumLeaves)

497 SHADER_PARAMETER(uint32, NumInternalNodes)

498 END_SHADER_PARAMETER_STRUCT()

499

500 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

501 {

502 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

503 }

504

505 static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)

506 {

507 OutEnvironment.SetDefine(TEXT("THREADGROUPSIZE"), ThreadGroupSize);

508 }

509};

510

511class INSTANT3DHUBSHADER_API FI3DHPropagateLeafVisibilityBVHBottomUpCS : public FGlobalShader

512{

513public:

514 DECLARE_GLOBAL_SHADER(FI3DHPropagateLeafVisibilityBVHBottomUpCS);

515 SHADER_USE_PARAMETER_STRUCT(FI3DHPropagateLeafVisibilityBVHBottomUpCS, FGlobalShader);

516

517 static constexpr int32 ThreadGroupSize = 64;

518

519 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

520 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, SortedIndicesBuffer)

521 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, NodeParentBuffer)

522 SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer, BVHNodesBuffer)

523 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, TestViewStateBuffer)

524 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, TestResultsBuffer)

525 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWAtomicVisitedBuffer)

526 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWBVHNodeStateBuffer)

527 SHADER_PARAMETER(uint32, NumLeaves)

528 END_SHADER_PARAMETER_STRUCT()

529

530 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

531 {

532 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

533 }

534

535 static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)

536 {

537 OutEnvironment.SetDefine(TEXT("THREADGROUPSIZE"), ThreadGroupSize);

538 }

539};

540

541class INSTANT3DHUBSHADER_API FI3DHActiveBVHNodeFilterCS : public FGlobalShader

542{

543public:

544 DECLARE_GLOBAL_SHADER(FI3DHActiveBVHNodeFilterCS);

545 SHADER_USE_PARAMETER_STRUCT(FI3DHActiveBVHNodeFilterCS, FGlobalShader);

546

547 static constexpr int32 ThreadGroupSize = 64;

548

549 class FIsFirstPass : SHADER_PERMUTATION_BOOL("IS_FIRST_PASS");

550 using FPermutationDomain = TShaderPermutationDomain<FIsFirstPass>;

551

552 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

553 SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer, BVHNodesBuffer)

554 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWActiveBVHNodeCountBuffer)

555 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWActiveBVHNodeIndexBuffer)

556 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWBVHNodeStateBuffer)

557 SHADER_PARAMETER(uint32, NumLeaves)

558 SHADER_PARAMETER(uint32, NumInternalNodes)

559 END_SHADER_PARAMETER_STRUCT()

560

561 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

562 {

563 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

564 }

565

566 static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)

567 {

568 OutEnvironment.SetDefine(TEXT("THREADGROUPSIZE"), ThreadGroupSize);

569 }

570};

571

572class INSTANT3DHUBSHADER_API FI3DHPreclassifyBVHNodesCS : public FGlobalShader

573{

574public:

575 DECLARE_GLOBAL_SHADER(FI3DHPreclassifyBVHNodesCS);

576 SHADER_USE_PARAMETER_STRUCT(FI3DHPreclassifyBVHNodesCS, FGlobalShader);

577

578 static constexpr int32 ThreadGroupSize = 64;

579

580 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

581 SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View)

582 SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer, BVHNodesBuffer)

583 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWBVHNodeStateBuffer)

584 SHADER_PARAMETER(FMatrix44f, RelativeToWorldMatrix)

585 SHADER_PARAMETER(FMatrix44f, RelativeWorldToReferenceMatrix)

586 SHADER_PARAMETER(FVector3f, ReferenceOriginHigh)

587 SHADER_PARAMETER(uint32, NumInternalNodes)

588 END_SHADER_PARAMETER_STRUCT()

589

590 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

591 {

592 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

593 }

594

595 static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)

596 {

597 OutEnvironment.SetDefine(TEXT("THREADGROUPSIZE"), ThreadGroupSize);

598 }

599};

600

601class INSTANT3DHUBSHADER_API FI3DHRasterBVHNodeVS : public FGlobalShader

602{

603 DECLARE_GLOBAL_SHADER(FI3DHRasterBVHNodeVS);

604 SHADER_USE_PARAMETER_STRUCT(FI3DHRasterBVHNodeVS, FGlobalShader);

605

606 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

607 SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View)

608 SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer, BVHNodesBuffer)

609 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, ActiveBVHNodeIndexBuffer)

610 SHADER_PARAMETER(FMatrix44f, RelativeToWorldMatrix)

611 SHADER_PARAMETER(FVector3f, ReferenceOriginHigh)

612 RDG_BUFFER_ACCESS(IndirectDrawArgsBuffer, ERHIAccess::IndirectArgs)

613 END_SHADER_PARAMETER_STRUCT()

614

615 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

616 {

617 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

618 }

619};

620

621class INSTANT3DHUBSHADER_API FI3DHRasterBVHNodePS : public FGlobalShader

622{

623 DECLARE_GLOBAL_SHADER(FI3DHRasterBVHNodePS);

624 SHADER_USE_PARAMETER_STRUCT(FI3DHRasterBVHNodePS, FGlobalShader);

625

626 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

627 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWBVHNodeStateBuffer)

628 END_SHADER_PARAMETER_STRUCT()

629

630 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

631 {

632 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

633 }

634};

635

636BEGIN_SHADER_PARAMETER_STRUCT(FI3DHRasterBVHNodeParameters, INSTANT3DHUBSHADER_API)

637 SHADER_PARAMETER_STRUCT_INCLUDE(FI3DHRasterBVHNodeVS::FParameters, VS)

638 SHADER_PARAMETER_STRUCT_INCLUDE(FI3DHRasterBVHNodePS::FParameters, PS)

639 RENDER_TARGET_BINDING_SLOTS()

640END_SHADER_PARAMETER_STRUCT()

641

642class INSTANT3DHUBSHADER_API FI3DHPropagateBVHNodeStateCS : public FGlobalShader

643{

644public:

645 DECLARE_GLOBAL_SHADER(FI3DHPropagateBVHNodeStateCS);

646 SHADER_USE_PARAMETER_STRUCT(FI3DHPropagateBVHNodeStateCS, FGlobalShader);

647

648 static constexpr int32 ThreadGroupSize = 64;

649

650 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

651 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, InternalNodeDepthBuffer)

652 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, NodeParentBuffer)

653 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWBVHNodeStateBuffer)

654 SHADER_PARAMETER(uint32, NumLeaves)

655 SHADER_PARAMETER(uint32, NumInternalNodes)

656 SHADER_PARAMETER(uint32, MaxDepthLimit)

657 END_SHADER_PARAMETER_STRUCT()

658

659 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

660 {

661 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

662 }

663

664 static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)

665 {

666 OutEnvironment.SetDefine(TEXT("THREADGROUPSIZE"), ThreadGroupSize);

667 OutEnvironment.CompilerFlags.Add(CFLAG_AllowTypedUAVLoads);

668 }

669};

670

671class INSTANT3DHUBSHADER_API FI3DHApplyBVHResultsCS : public FGlobalShader

672{

673public:

674 DECLARE_GLOBAL_SHADER(FI3DHApplyBVHResultsCS);

675 SHADER_USE_PARAMETER_STRUCT(FI3DHApplyBVHResultsCS, FGlobalShader);

676

677 static constexpr int32 ThreadGroupSize = 64;

678

679 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

680 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, SortedMortonCodesBuffer)

681 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, SortedIndicesBuffer)

682 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, BVHNodeStateBuffer)

683 SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer, RWTestViewStateBuffer)

684 SHADER_PARAMETER(uint32, NumLeaves)

685 END_SHADER_PARAMETER_STRUCT()

686

687 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

688 {

689 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

690 }

691

692 static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)

693 {

694 OutEnvironment.SetDefine(TEXT("THREADGROUPSIZE"), ThreadGroupSize);

695 }

696};

697

698class INSTANT3DHUBSHADER_API FI3DHDebugDrawBVHVS : public FGlobalShader

699{

700 DECLARE_GLOBAL_SHADER(FI3DHDebugDrawBVHVS);

701 SHADER_USE_PARAMETER_STRUCT(FI3DHDebugDrawBVHVS, FGlobalShader);

702

703 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

704 SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View)

705 SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer, BVHNodesBuffer)

706 SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer, BVHNodeStateBuffer)

707 SHADER_PARAMETER(FMatrix44f, RelativeToWorldMatrix)

708 SHADER_PARAMETER(FVector3f, ReferenceOriginHigh)

709 SHADER_PARAMETER(uint32, NumInternalNodes)

710 END_SHADER_PARAMETER_STRUCT()

711

712 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

713 {

714 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

715 }

716};

717

718class INSTANT3DHUBSHADER_API FI3DHDebugDrawBVHPS : public FGlobalShader

719{

720 DECLARE_GLOBAL_SHADER(FI3DHDebugDrawBVHPS);

721 SHADER_USE_PARAMETER_STRUCT(FI3DHDebugDrawBVHPS, FGlobalShader);

722

723 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

724 END_SHADER_PARAMETER_STRUCT()

725

726 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

727 {

728 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

729 }

730};

731

732BEGIN_SHADER_PARAMETER_STRUCT(FI3DHDebugDrawBVHParameters, INSTANT3DHUBSHADER_API)

733 SHADER_PARAMETER_STRUCT_INCLUDE(FI3DHDebugDrawBVHVS::FParameters, VS)

734 SHADER_PARAMETER_STRUCT_INCLUDE(FI3DHDebugDrawBVHPS::FParameters, PS)

735 RENDER_TARGET_BINDING_SLOTS()

736END_SHADER_PARAMETER_STRUCT()

737

738#if UE_VERSION_OLDER_THAN(5, 5, 0)

739// Copy of Source/Runtime/Renderer/Private/ScreenPass.cpp

740// Necessary because prior to 5.5.0 `AddDownsampleDepthPass` is not exported

741class INSTANT3DHUBSHADER_API FI3DHDownsampleDepthPS : public FGlobalShader

742{

743public:

744 DECLARE_GLOBAL_SHADER(FI3DHDownsampleDepthPS);

745 SHADER_USE_PARAMETER_STRUCT(FI3DHDownsampleDepthPS, FGlobalShader);

746

747 class FOutputMinAndMaxDepth : SHADER_PERMUTATION_BOOL("OUTPUT_MIN_AND_MAX_DEPTH");

748

749 using FPermutationDomain = TShaderPermutationDomain<FOutputMinAndMaxDepth>;

750

751 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )

752 SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View)

753 SHADER_PARAMETER_RDG_TEXTURE(Texture2D, DepthTexture)

754 SHADER_PARAMETER(FVector2f, DstToSrcPixelScale)

755 SHADER_PARAMETER(FIntVector4, DstPixelCoordMinAndMax)

756 SHADER_PARAMETER(FIntVector4, SrcPixelCoordMinAndMax)

757 SHADER_PARAMETER(FVector2f, SourceMaxUV)

758 SHADER_PARAMETER(FVector2f, DestinationResolution)

759 SHADER_PARAMETER(uint32, DownsampleDepthFilter)

760 RENDER_TARGET_BINDING_SLOTS()

761 END_SHADER_PARAMETER_STRUCT()

762

763 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)

764 {

765 return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);

766 }

767};

768#endif

FGlobalShader

FGlobalShaderPermutationParameters

FParameters

FShaderCompilerEnvironment

FShaderParameters

Parameters

TShaderPermutationDomain

---

Generated by  1.14.0