nick/WickedEngine
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Visibility pipeline updates (#677)

Browse Source
This commit is contained in:
Turánszki János
2023-05-16 09:29:14 +02:00
committed by GitHub
parent 9f3c9e58b6
commit 32da5c3b16
13 changed files with 737 additions and 719 deletions
Download Patch File Download Diff File Expand all files Collapse all files
WickedEngine/offlineshadercompiler.cpp
-1
View File
@@ -196,7 +196,6 @@ wi::vector<ShaderEntry> shaders = {
{"rtao_denoise_filterCS", wi::graphics::ShaderStage::CS },
{"visibility_resolveCS", wi::graphics::ShaderStage::CS },
{"visibility_resolveCS_MSAA", wi::graphics::ShaderStage::CS },
{"visibility_indirect_prepareCS", wi::graphics::ShaderStage::CS },
{"visibility_velocityCS", wi::graphics::ShaderStage::CS },
{"visibility_skyCS", wi::graphics::ShaderStage::CS },
{"surfel_coverageCS", wi::graphics::ShaderStage::CS },
WickedEngine/shaders/ShaderInterop_Renderer.h
+1 -11
View File
@@ -409,21 +409,11 @@ struct ShaderMaterial
// For binning shading based on shader types:
struct ShaderTypeBin
{
uint shaderType;
uint offset;
uint count;
uint padding;
uint dispatchX;
uint dispatchY;
uint dispatchZ;
uint padding1;
uint4 padding2[14]; // force 256-byte alignment that's necessary for constant buffers :(
uint shaderType;
};
#ifdef __cplusplus
static_assert(sizeof(ShaderTypeBin) == 256); // 256 byte forced constant buffer alignment for DX12
#endif // __cplusplus
static const uint SHADERTYPE_BIN_COUNT = 10;
struct VisibilityTile
WickedEngine/shaders/Shaders_SOURCE.vcxitems
+1
View File
@@ -39,6 +39,7 @@
<None Include="$(MSBuildThisFileDirectory)PixelPacking_RGBE.hlsli" />
<None Include="$(MSBuildThisFileDirectory)quad.hlsli" />
<None Include="$(MSBuildThisFileDirectory)raytracingHF.hlsli" />
<None Include="$(MSBuildThisFileDirectory)shadingHF.hlsli" />
<None Include="$(MSBuildThisFileDirectory)shadowHF.hlsli" />
<None Include="$(MSBuildThisFileDirectory)skyAtmosphere.hlsli" />
<None Include="$(MSBuildThisFileDirectory)skyHF.hlsli" />
WickedEngine/shaders/Shaders_SOURCE.vcxitems.filters
+3
View File
@@ -150,6 +150,9 @@
<None Include="$(MSBuildThisFileDirectory)fogHF.hlsli">
<Filter>HF</Filter>
</None>
<None Include="$(MSBuildThisFileDirectory)shadingHF.hlsli">
<Filter>HF</Filter>
</None>
</ItemGroup>
<ItemGroup>
<FxCompile Include="$(MSBuildThisFileDirectory)hairparticle_simulateCS.hlsl">
WickedEngine/shaders/objectHF.hlsli
+22 -663
View File
File diff suppressed because it is too large Load Diff
WickedEngine/shaders/shadingHF.hlsli
+644
View File
File diff suppressed because it is too large Load Diff
WickedEngine/shaders/visibility_resolveCS.hlsl
+1 -1
View File
@@ -112,7 +112,7 @@ void main(uint2 Gid : SV_GroupID, uint groupIndex : SV_GroupIndex)
{
uint bin_tile_list_offset = groupIndex * GetCamera().visibility_tilecount_flat;
uint tile_offset = 0;
InterlockedAdd(output_bins[groupIndex].count, 1, tile_offset);
InterlockedAdd(output_bins[groupIndex].dispatchX, 1, tile_offset);
VisibilityTile tile;
tile.visibility_tile_id = pack_pixel(Gid.xy);
WickedEngine/shaders/visibility_shadeCS.hlsl
+8 -3
View File
@@ -9,9 +9,14 @@
#include "ShaderInterop_Renderer.h"
#include "raytracingHF.hlsli"
#include "brdf.hlsli"
#include "objectHF.hlsli"
#include "shadingHF.hlsli"
struct VisibilityPushConstants
{
uint global_tile_offset;
};
PUSHCONSTANT(push, VisibilityPushConstants);
ConstantBuffer<ShaderTypeBin> bin : register(b10);
StructuredBuffer<VisibilityTile> binned_tiles : register(t0);
Texture2D<uint4> input_payload_0 : register(t2);
Texture2D<uint4> input_payload_1 : register(t3);
@@ -21,7 +26,7 @@ RWTexture2D<float4> output : register(u0);
[numthreads(VISIBILITY_BLOCKSIZE, VISIBILITY_BLOCKSIZE, 1)]
void main(uint Gid : SV_GroupID, uint groupIndex : SV_GroupIndex)
{
const uint tile_offset = bin.offset + Gid.x;
const uint tile_offset = push.global_tile_offset + Gid.x;
VisibilityTile tile = binned_tiles[tile_offset];
[branch] if (!tile.check_thread_valid(groupIndex)) return;
const uint2 GTid = remap_lane_8x8(groupIndex);
WickedEngine/shaders/visibility_skyCS.hlsl
+7 -2
View File
@@ -3,7 +3,12 @@
#include "skyHF.hlsli"
#include "fogHF.hlsli"
ConstantBuffer<ShaderTypeBin> bin : register(b10);
struct VisibilityPushConstants
{
uint global_tile_offset;
};
PUSHCONSTANT(push, VisibilityPushConstants);
StructuredBuffer<VisibilityTile> binned_tiles : register(t0);
RWTexture2D<float4> output : register(u0);
@@ -11,7 +16,7 @@ RWTexture2D<float4> output : register(u0);
[numthreads(VISIBILITY_BLOCKSIZE, VISIBILITY_BLOCKSIZE, 1)]
void main(uint Gid : SV_GroupID, uint groupIndex : SV_GroupIndex)
{
const uint tile_offset = bin.offset + Gid.x;
const uint tile_offset = push.global_tile_offset + Gid.x;
VisibilityTile tile = binned_tiles[tile_offset];
[branch]
if (!tile.check_thread_valid(groupIndex))
WickedEngine/shaders/visibility_surfaceCS.hlsl
+8 -3
View File
@@ -9,9 +9,14 @@
#include "ShaderInterop_Renderer.h"
#include "raytracingHF.hlsli"
#include "surfaceHF.hlsli"
#include "objectHF.hlsli"
#include "shadingHF.hlsli"
struct VisibilityPushConstants
{
uint global_tile_offset;
};
PUSHCONSTANT(push, VisibilityPushConstants);
ConstantBuffer<ShaderTypeBin> bin : register(b10);
StructuredBuffer<VisibilityTile> binned_tiles : register(t0);
RWTexture2D<float4> output : register(u0);
@@ -23,7 +28,7 @@ RWTexture2D<uint4> output_payload_1 : register(u4);
[numthreads(VISIBILITY_BLOCKSIZE, VISIBILITY_BLOCKSIZE, 1)]
void main(uint Gid : SV_GroupID, uint groupIndex : SV_GroupIndex)
{
const uint tile_offset = bin.offset + Gid.x;
const uint tile_offset = push.global_tile_offset + Gid.x;
VisibilityTile tile = binned_tiles[tile_offset];
const uint2 GTid = remap_lane_8x8(groupIndex);
const uint2 pixel = unpack_pixel(tile.visibility_tile_id) * VISIBILITY_BLOCKSIZE + GTid;
WickedEngine/wiEnums.h
-1
View File
@@ -372,7 +372,6 @@ namespace wi::enums
CSTYPE_SURFEL_INTEGRATE,
CSTYPE_VISIBILITY_RESOLVE,
CSTYPE_VISIBILITY_RESOLVE_MSAA,
CSTYPE_VISIBILITY_INDIRECT_PREPARE,
CSTYPE_VISIBILITY_SKY,
CSTYPE_VISIBILITY_VELOCITY,
CSTYPE_VISIBILITY_SURFACE_REDUCED_PERMUTATION_BEGIN,
WickedEngine/wiRenderer.cpp
+41 -33
View File
@@ -1044,7 +1044,6 @@ void LoadShaders()
wi::jobsystem::Execute(ctx, [](wi::jobsystem::JobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_VISIBILITY_RESOLVE], "visibility_resolveCS.cso"); });
wi::jobsystem::Execute(ctx, [](wi::jobsystem::JobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_VISIBILITY_RESOLVE_MSAA], "visibility_resolveCS_MSAA.cso"); });
wi::jobsystem::Execute(ctx, [](wi::jobsystem::JobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_VISIBILITY_INDIRECT_PREPARE], "visibility_indirect_prepareCS.cso"); });
wi::jobsystem::Execute(ctx, [](wi::jobsystem::JobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_VISIBILITY_SKY], "visibility_skyCS.cso"); });
wi::jobsystem::Execute(ctx, [](wi::jobsystem::JobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_VISIBILITY_VELOCITY], "visibility_velocityCS.cso"); });
@@ -9221,7 +9220,7 @@ void CreateVisibilityResources(VisibilityResources& res, XMUINT2 resolution)
GPUBufferDesc desc;
desc.stride = sizeof(ShaderTypeBin);
desc.size = desc.stride * (MaterialComponent::SHADERTYPE_COUNT + 1); // +1 for sky
desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS | BindFlag::CONSTANT_BUFFER;
desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
desc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED | ResourceMiscFlag::INDIRECT_ARGS;
bool success = device->CreateBuffer(&desc, nullptr, &res.bins);
assert(success);
@@ -9270,11 +9269,18 @@ void Visibility_Prepare(
// Beginning barriers, clears:
{
barrier_stack.push_back(GPUBarrier::Buffer(&res.bins, ResourceState::CONSTANT_BUFFER | ResourceState::INDIRECT_ARGUMENT, ResourceState::UNORDERED_ACCESS));
barrier_stack.push_back(GPUBarrier::Buffer(&res.binned_tiles, ResourceState::SHADER_RESOURCE, ResourceState::UNORDERED_ACCESS));
barrier_stack_flush(cmd);
device->ClearUAV(&res.bins, 0, cmd);
barrier_stack.push_back(GPUBarrier::Memory(&res.bins));
ShaderTypeBin bins[SHADERTYPE_BIN_COUNT + 1];
for (uint i = 0; i < arraysize(bins); ++i)
{
ShaderTypeBin& bin = bins[i];
bin.dispatchX = 0; // will be used for atomic add in shader
bin.dispatchY = 1;
bin.dispatchZ = 1;
bin.shaderType = i;
}
device->UpdateBuffer(&res.bins, bins, cmd);
barrier_stack.push_back(GPUBarrier::Buffer(&res.bins, ResourceState::COPY_DST, ResourceState::UNORDERED_ACCESS));
barrier_stack.push_back(GPUBarrier::Buffer(&res.binned_tiles, ResourceState::UNDEFINED, ResourceState::UNORDERED_ACCESS));
barrier_stack_flush(cmd);
}
@@ -9357,25 +9363,13 @@ void Visibility_Prepare(
{
barrier_stack.push_back(GPUBarrier::Image(res.primitiveID_resolved, ResourceState::UNORDERED_ACCESS, res.primitiveID_resolved->desc.layout));
}
barrier_stack.push_back(GPUBarrier::Memory(&res.bins));
barrier_stack.push_back(GPUBarrier::Buffer(&res.bins, ResourceState::UNORDERED_ACCESS, ResourceState::INDIRECT_ARGUMENT));
barrier_stack.push_back(GPUBarrier::Buffer(&res.binned_tiles, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE));
barrier_stack_flush(cmd);
device->EventEnd(cmd);
}
// Indirect prepare:
{
device->EventBegin("Indirect Prepare", cmd);
device->BindComputeShader(&shaders[CSTYPE_VISIBILITY_INDIRECT_PREPARE], cmd);
device->BindUAV(&res.bins, 0, cmd);
device->Dispatch(1, 1, 1, cmd);
device->EventEnd(cmd);
}
barrier_stack.push_back(GPUBarrier::Buffer(&res.bins, ResourceState::UNORDERED_ACCESS, ResourceState::CONSTANT_BUFFER | ResourceState::INDIRECT_ARGUMENT));
barrier_stack.push_back(GPUBarrier::Buffer(&res.binned_tiles, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE));
barrier_stack_flush(cmd);
wi::profiler::EndRange(range);
device->EventEnd(cmd);
}
@@ -9405,20 +9399,24 @@ void Visibility_Surface(
device->BindUAV(&res.texture_payload_0, 3, cmd);
device->BindUAV(&res.texture_payload_1, 4, cmd);
const uint visibility_tilecount_flat = res.tile_count.x * res.tile_count.y;
uint visibility_tile_offset = 0;
// surface dispatches per material type:
device->EventBegin("Surface parameters", cmd);
for (uint i = 0; i < MaterialComponent::SHADERTYPE_COUNT; ++i)
{
device->BindComputeShader(&shaders[CSTYPE_VISIBILITY_SURFACE_PERMUTATION_BEGIN + i], cmd);
device->BindConstantBuffer(&res.bins, 10, cmd, i * sizeof(ShaderTypeBin));
device->PushConstants(&visibility_tile_offset, sizeof(visibility_tile_offset), cmd);
device->DispatchIndirect(&res.bins, i * sizeof(ShaderTypeBin) + offsetof(ShaderTypeBin, dispatchX), cmd);
visibility_tile_offset += visibility_tilecount_flat;
}
device->EventEnd(cmd);
// sky dispatch:
device->EventBegin("Sky", cmd);
device->BindComputeShader(&shaders[CSTYPE_VISIBILITY_SKY], cmd);
device->BindConstantBuffer(&res.bins, 10, cmd, MaterialComponent::SHADERTYPE_COUNT * sizeof(ShaderTypeBin));
device->PushConstants(&visibility_tile_offset, sizeof(visibility_tile_offset), cmd);
device->DispatchIndirect(&res.bins, MaterialComponent::SHADERTYPE_COUNT * sizeof(ShaderTypeBin) + offsetof(ShaderTypeBin, dispatchX), cmd);
device->EventEnd(cmd);
@@ -9449,15 +9447,20 @@ void Visibility_Surface_Reduced(
device->BindUAV(&res.texture_normals, 1, cmd);
device->BindUAV(&res.texture_roughness, 2, cmd);
const uint visibility_tilecount_flat = res.tile_count.x * res.tile_count.y;
uint visibility_tile_offset = 0;
// surface dispatches per material type:
device->EventBegin("Surface parameters", cmd);
for (uint i = 0; i < MaterialComponent::SHADERTYPE_COUNT; ++i)
{
if (i == MaterialComponent::SHADERTYPE_UNLIT)
continue; // this won't need surface parameter write out
device->BindComputeShader(&shaders[CSTYPE_VISIBILITY_SURFACE_REDUCED_PERMUTATION_BEGIN + i], cmd);
device->BindConstantBuffer(&res.bins, 10, cmd, i * sizeof(ShaderTypeBin));
device->DispatchIndirect(&res.bins, i * sizeof(ShaderTypeBin) + offsetof(ShaderTypeBin, dispatchX), cmd);
if (i != MaterialComponent::SHADERTYPE_UNLIT) // this won't need surface parameter write out
{
device->BindComputeShader(&shaders[CSTYPE_VISIBILITY_SURFACE_REDUCED_PERMUTATION_BEGIN + i], cmd);
device->PushConstants(&visibility_tile_offset, sizeof(visibility_tile_offset), cmd);
device->DispatchIndirect(&res.bins, i * sizeof(ShaderTypeBin) + offsetof(ShaderTypeBin, dispatchX), cmd);
}
visibility_tile_offset += visibility_tilecount_flat;
}
device->EventEnd(cmd);
@@ -9490,14 +9493,19 @@ void Visibility_Shade(
device->BindResource(&res.texture_payload_1, 3, cmd);
device->BindUAV(&output, 0, cmd);
const uint visibility_tilecount_flat = res.tile_count.x * res.tile_count.y;
uint visibility_tile_offset = 0;
// shading dispatches per material type:
for (uint i = 0; i < MaterialComponent::SHADERTYPE_COUNT; ++i)
{
if (i == MaterialComponent::SHADERTYPE_UNLIT)
continue; // the unlit shader is special, it had already written out its final color in the surface shader
device->BindComputeShader(&shaders[CSTYPE_VISIBILITY_SHADE_PERMUTATION_BEGIN + i], cmd);
device->BindConstantBuffer(&res.bins, 10, cmd, i * sizeof(ShaderTypeBin));
device->DispatchIndirect(&res.bins, i * sizeof(ShaderTypeBin) + offsetof(ShaderTypeBin, dispatchX), cmd);
if (i != MaterialComponent::SHADERTYPE_UNLIT) // the unlit shader is special, it had already written out its final color in the surface shader
{
device->BindComputeShader(&shaders[CSTYPE_VISIBILITY_SHADE_PERMUTATION_BEGIN + i], cmd);
device->PushConstants(&visibility_tile_offset, sizeof(visibility_tile_offset), cmd);
device->DispatchIndirect(&res.bins, i * sizeof(ShaderTypeBin) + offsetof(ShaderTypeBin, dispatchX), cmd);
}
visibility_tile_offset += visibility_tilecount_flat;
}
barrier_stack.push_back(GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout));
WickedEngine/wiVersion.cpp
+1 -1
View File
@@ -9,7 +9,7 @@ namespace wi::version
// minor features, major updates, breaking compatibility changes
const int minor = 71;
// minor bug fixes, alterations, refactors, updates
const int revision = 203;
const int revision = 204;
const std::string version_string = std::to_string(major) + "." + std::to_string(minor) + "." + std::to_string(revision);