529 lines
24 KiB
C++
529 lines
24 KiB
C++
// Copyright (c) 2012-2022 Wojciech Figat. All rights reserved.
|
|
|
|
#include "DynamicDiffuseGlobalIllumination.h"
|
|
#include "GlobalSurfaceAtlasPass.h"
|
|
#include "../GlobalSignDistanceFieldPass.h"
|
|
#include "../RenderList.h"
|
|
#include "Engine/Core/Random.h"
|
|
#include "Engine/Core/Types/Variant.h"
|
|
#include "Engine/Core/Math/Int3.h"
|
|
#include "Engine/Core/Math/Matrix3x3.h"
|
|
#include "Engine/Core/Math/Quaternion.h"
|
|
#include "Engine/Engine/Engine.h"
|
|
#include "Engine/Content/Content.h"
|
|
#include "Engine/Debug/DebugDraw.h"
|
|
#include "Engine/Graphics/GPUDevice.h"
|
|
#include "Engine/Graphics/RenderTask.h"
|
|
#include "Engine/Graphics/RenderBuffers.h"
|
|
#include "Engine/Graphics/RenderTargetPool.h"
|
|
#include "Engine/Graphics/Shaders/GPUShader.h"
|
|
#include "Engine/Level/Actors/BrushMode.h"
|
|
#include "Engine/Renderer/GBufferPass.h"
|
|
|
|
// Implementation based on:
|
|
// "Dynamic Diffuse Global Illumination with Ray-Traced Irradiance Probes", Journal of Computer Graphics Tools, April 2019
|
|
// Zander Majercik, Jean-Philippe Guertin, Derek Nowrouzezahrai, and Morgan McGuire
|
|
// https://morgan3d.github.io/articles/2019-04-01-ddgi/index.html and https://gdcvault.com/play/1026182/
|
|
//
|
|
// Additional references:
|
|
// "Scaling Probe-Based Real-Time Dynamic Global Illumination for Production", https://jcgt.org/published/0010/02/01/
|
|
// "Dynamic Diffuse Global Illumination with Ray-Traced Irradiance Fields", https://jcgt.org/published/0008/02/01/
|
|
|
|
// This must match HLSL
|
|
#define DDGI_TRACE_RAYS_GROUP_SIZE_X 32
|
|
#define DDGI_TRACE_RAYS_LIMIT 512 // Limit of rays per-probe (runtime value can be smaller)
|
|
#define DDGI_PROBE_RESOLUTION_IRRADIANCE 6 // Resolution (in texels) for probe irradiance data (excluding 1px padding on each side)
|
|
#define DDGI_PROBE_RESOLUTION_DISTANCE 14 // Resolution (in texels) for probe distance data (excluding 1px padding on each side)
|
|
#define DDGI_PROBE_UPDATE_BORDERS_GROUP_SIZE 8
|
|
#define DDGI_PROBE_CLASSIFY_GROUP_SIZE 32
|
|
|
|
PACK_STRUCT(struct Data0
|
|
{
|
|
DynamicDiffuseGlobalIlluminationPass::ConstantsData DDGI;
|
|
GlobalSignDistanceFieldPass::ConstantsData GlobalSDF;
|
|
GlobalSurfaceAtlasPass::ConstantsData GlobalSurfaceAtlas;
|
|
GBufferData GBuffer;
|
|
Vector3 Padding0;
|
|
float IndirectLightingIntensity;
|
|
});
|
|
|
|
class DDGICustomBuffer : public RenderBuffers::CustomBuffer
|
|
{
|
|
public:
|
|
int32 ProbeRaysCount = 0;
|
|
float ProbesSpacing = 0.0f;
|
|
Int3 ProbeCounts = Int3::Zero;
|
|
Vector3 ProbesOrigin;
|
|
Int3 ProbeScrollOffsets;
|
|
Int3 ProbeScrollDirections;
|
|
bool ProbeScrollClear[3];
|
|
GPUTexture* ProbesTrace = nullptr; // Probes ray tracing: (RGB: hit radiance, A: hit distance)
|
|
GPUTexture* ProbesState = nullptr; // Probes state: (RGB: world-space offset, A: state)
|
|
GPUTexture* ProbesIrradiance = nullptr; // Probes irradiance (RGB: sRGB color)
|
|
GPUTexture* ProbesDistance = nullptr; // Probes distance (R: mean distance, G: mean distance^2)
|
|
DynamicDiffuseGlobalIlluminationPass::BindingData Result;
|
|
|
|
FORCE_INLINE void Clear()
|
|
{
|
|
ProbesOrigin = Vector3::Zero;
|
|
ProbeScrollOffsets = Int3::Zero;
|
|
ProbeScrollDirections = Int3::Zero;
|
|
ProbeScrollClear[0] = false;
|
|
ProbeScrollClear[1] = false;
|
|
ProbeScrollClear[2] = false;
|
|
RenderTargetPool::Release(ProbesTrace);
|
|
RenderTargetPool::Release(ProbesState);
|
|
RenderTargetPool::Release(ProbesIrradiance);
|
|
RenderTargetPool::Release(ProbesDistance);
|
|
}
|
|
|
|
~DDGICustomBuffer()
|
|
{
|
|
Clear();
|
|
}
|
|
};
|
|
|
|
void CalculateVolumeRandomRotation(Matrix3x3& matrix)
|
|
{
|
|
// Reference: James Arvo's algorithm Graphics Gems 3 (pages 117-120)
|
|
// http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.53.1357&rep=rep1&type=pdf
|
|
|
|
float u1 = TWO_PI * Random::Rand();
|
|
float cos1 = Math::Cos(u1);
|
|
float sin1 = Math::Sin(u1);
|
|
float u2 = TWO_PI * Random::Rand();
|
|
float cos2 = Math::Cos(u2);
|
|
float sin2 = Math::Sin(u2);
|
|
|
|
float u3 = Random::Rand();
|
|
float sq3 = 2.0f * sqrtf(u3 * (1.0f - u3));
|
|
|
|
float s2 = 2.0f * u3 * sin2 * sin2 - 1.0f;
|
|
float c2 = 2.0f * u3 * cos2 * cos2 - 1.0f;
|
|
float sc = 2.0f * u3 * sin2 * cos2;
|
|
|
|
matrix.M11 = cos1 * c2 - sin1 * sc;
|
|
matrix.M12 = sin1 * c2 + cos1 * sc;
|
|
matrix.M13 = sq3 * cos2;
|
|
|
|
matrix.M21 = cos1 * sc - sin1 * s2;
|
|
matrix.M22 = sin1 * sc + cos1 * s2;
|
|
matrix.M23 = sq3 * sin2;
|
|
|
|
matrix.M31 = cos1 * (sq3 * cos2) - sin1 * (sq3 * sin2);
|
|
matrix.M32 = sin1 * (sq3 * cos2) + cos1 * (sq3 * sin2);
|
|
matrix.M33 = 1.0f - 2.0f * u3;
|
|
}
|
|
|
|
int32 AbsFloor(const float value)
|
|
{
|
|
return value >= 0.0f ? (int32)Math::Floor(value) : (int32)Math::Ceil(value);
|
|
}
|
|
|
|
int32 GetSignNotZero(const float value)
|
|
{
|
|
return value >= 0.0f ? 1 : -1;
|
|
}
|
|
|
|
Vector3 GetVolumeOrigin(DDGICustomBuffer& ddgiData)
|
|
{
|
|
return ddgiData.ProbesOrigin + Vector3(ddgiData.ProbeScrollOffsets) * ddgiData.ProbesSpacing;
|
|
}
|
|
|
|
void CalculateVolumeScrolling(DDGICustomBuffer& ddgiData, const Vector3& viewOrigin)
|
|
{
|
|
// Reset the volume origin and scroll offsets for each axis
|
|
for (int32 axis = 0; axis < 3; axis++)
|
|
{
|
|
if (ddgiData.ProbeScrollOffsets.Raw[axis] != 0 && (ddgiData.ProbeScrollOffsets.Raw[axis] % ddgiData.ProbeCounts.Raw[axis] == 0))
|
|
{
|
|
ddgiData.ProbesOrigin.Raw[axis] += (float)ddgiData.ProbeCounts.Raw[axis] * ddgiData.ProbesSpacing * (float)ddgiData.ProbeScrollDirections.Raw[axis];
|
|
ddgiData.ProbeScrollOffsets.Raw[axis] = 0;
|
|
}
|
|
}
|
|
|
|
// Calculate the count of grid cells between the view origin and the scroll anchor
|
|
const Vector3 translation = viewOrigin - GetVolumeOrigin(ddgiData);
|
|
for (int32 axis = 0; axis < 3; axis++)
|
|
{
|
|
const int32 scroll = AbsFloor(translation.Raw[axis] / ddgiData.ProbesSpacing);
|
|
ddgiData.ProbeScrollOffsets.Raw[axis] += scroll;
|
|
ddgiData.ProbeScrollClear[axis] = scroll != 0;
|
|
ddgiData.ProbeScrollDirections.Raw[axis] = GetSignNotZero(translation.Raw[axis]);
|
|
}
|
|
}
|
|
|
|
String DynamicDiffuseGlobalIlluminationPass::ToString() const
|
|
{
|
|
return TEXT("DynamicDiffuseGlobalIlluminationPass");
|
|
}
|
|
|
|
bool DynamicDiffuseGlobalIlluminationPass::Init()
|
|
{
|
|
// Check platform support
|
|
const auto device = GPUDevice::Instance;
|
|
_supported = device->GetFeatureLevel() >= FeatureLevel::SM5 && device->Limits.HasCompute && device->Limits.HasTypedUAVLoad;
|
|
return false;
|
|
}
|
|
|
|
bool DynamicDiffuseGlobalIlluminationPass::setupResources()
|
|
{
|
|
if (!_supported)
|
|
return true;
|
|
|
|
// Load shader
|
|
if (!_shader)
|
|
{
|
|
_shader = Content::LoadAsyncInternal<Shader>(TEXT("Shaders/GI/DDGI"));
|
|
if (_shader == nullptr)
|
|
return true;
|
|
#if COMPILE_WITH_DEV_ENV
|
|
_shader.Get()->OnReloading.Bind<DynamicDiffuseGlobalIlluminationPass, &DynamicDiffuseGlobalIlluminationPass::OnShaderReloading>(this);
|
|
#endif
|
|
}
|
|
if (!_shader->IsLoaded())
|
|
return true;
|
|
|
|
// Initialize resources
|
|
const auto shader = _shader->GetShader();
|
|
_cb0 = shader->GetCB(0);
|
|
if (!_cb0)
|
|
return true;
|
|
_csClassify = shader->GetCS("CS_Classify");
|
|
_csTraceRays = shader->GetCS("CS_TraceRays");
|
|
_csUpdateProbesIrradiance = shader->GetCS("CS_UpdateProbes", 0);
|
|
_csUpdateProbesDistance = shader->GetCS("CS_UpdateProbes", 1);
|
|
_csUpdateBordersIrradianceRow = shader->GetCS("CS_UpdateBorders", 0);
|
|
_csUpdateBordersIrradianceCollumn = shader->GetCS("CS_UpdateBorders", 1);
|
|
_csUpdateBordersDistanceRow = shader->GetCS("CS_UpdateBorders", 2);
|
|
_csUpdateBordersDistanceCollumn = shader->GetCS("CS_UpdateBorders", 3);
|
|
auto device = GPUDevice::Instance;
|
|
auto psDesc = GPUPipelineState::Description::DefaultFullscreenTriangle;
|
|
if (!_psIndirectLighting)
|
|
{
|
|
_psIndirectLighting = device->CreatePipelineState();
|
|
psDesc.PS = shader->GetPS("PS_IndirectLighting");
|
|
psDesc.BlendMode = BlendingMode::Additive;
|
|
if (_psIndirectLighting->Init(psDesc))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#if COMPILE_WITH_DEV_ENV
|
|
|
|
void DynamicDiffuseGlobalIlluminationPass::OnShaderReloading(Asset* obj)
|
|
{
|
|
LastFrameShaderReload = Engine::FrameCount;
|
|
_csClassify = nullptr;
|
|
_csTraceRays = nullptr;
|
|
_csUpdateProbesIrradiance = nullptr;
|
|
_csUpdateProbesDistance = nullptr;
|
|
_csUpdateBordersIrradianceRow = nullptr;
|
|
_csUpdateBordersIrradianceCollumn = nullptr;
|
|
_csUpdateBordersDistanceRow = nullptr;
|
|
_csUpdateBordersDistanceCollumn = nullptr;
|
|
SAFE_DELETE_GPU_RESOURCE(_psIndirectLighting);
|
|
invalidateResources();
|
|
}
|
|
|
|
#endif
|
|
|
|
void DynamicDiffuseGlobalIlluminationPass::Dispose()
|
|
{
|
|
RendererPass::Dispose();
|
|
|
|
// Cleanup
|
|
_cb0 = nullptr;
|
|
_csTraceRays = nullptr;
|
|
_shader = nullptr;
|
|
SAFE_DELETE_GPU_RESOURCE(_psIndirectLighting);
|
|
#if USE_EDITOR
|
|
_debugModel = nullptr;
|
|
_debugMaterial = nullptr;
|
|
#endif
|
|
}
|
|
|
|
bool DynamicDiffuseGlobalIlluminationPass::Get(const RenderBuffers* buffers, BindingData& result)
|
|
{
|
|
auto* ddgiData = buffers ? buffers->FindCustomBuffer<DDGICustomBuffer>(TEXT("DDGI")) : nullptr;
|
|
if (ddgiData && ddgiData->LastFrameUsed + 1 >= Engine::FrameCount) // Allow to use data from the previous frame (eg. particles in Editor using the Editor viewport in Game viewport - Game render task runs first)
|
|
{
|
|
result = ddgiData->Result;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool DynamicDiffuseGlobalIlluminationPass::Render(RenderContext& renderContext, GPUContext* context, GPUTextureView* lightBuffer)
|
|
{
|
|
// Skip if not supported
|
|
if (checkIfSkipPass())
|
|
return true;
|
|
if (renderContext.List->Scenes.Count() == 0)
|
|
return true;
|
|
auto& ddgiData = *renderContext.Buffers->GetCustomBuffer<DDGICustomBuffer>(TEXT("DDGI"));
|
|
|
|
// Render Global SDF and Global Surface Atlas for software raytracing
|
|
GlobalSignDistanceFieldPass::BindingData bindingDataSDF;
|
|
if (GlobalSignDistanceFieldPass::Instance()->Render(renderContext, context, bindingDataSDF))
|
|
return true;
|
|
GlobalSurfaceAtlasPass::BindingData bindingDataSurfaceAtlas;
|
|
if (GlobalSurfaceAtlasPass::Instance()->Render(renderContext, context, bindingDataSurfaceAtlas))
|
|
return true;
|
|
|
|
// Skip if already done in the current frame
|
|
const auto currentFrame = Engine::FrameCount;
|
|
if (ddgiData.LastFrameUsed == currentFrame)
|
|
return false;
|
|
ddgiData.LastFrameUsed = currentFrame;
|
|
PROFILE_GPU_CPU("Dynamic Diffuse Global Illumination");
|
|
|
|
// TODO: configurable via graphics settings
|
|
const Quality quality = Quality::Ultra;
|
|
bool debugProbes = true; // TODO: add debug option to draw probes locations -> in Graphics window - Editor-only
|
|
// TODO: configurable via postFx settings (maybe use Global SDF distance?)
|
|
const float indirectLightingIntensity = 1.0f;
|
|
const Vector3 giDistance(2000, 2000, 2000); // GI distance around the view (in each direction)
|
|
const float giResolution = 100.0f; // GI probes placement spacing
|
|
const Int3 probesCounts(Vector3::Ceil(giDistance / giResolution));
|
|
const Vector3 probesDistance = Vector3(probesCounts) * giResolution;
|
|
const int32 probeRaysCount = Math::Min(Math::AlignUp(256, DDGI_TRACE_RAYS_GROUP_SIZE_X), DDGI_TRACE_RAYS_LIMIT); // TODO: make it based on the GI Quality
|
|
const float probeHistoryWeight = 0.97f;
|
|
|
|
// Init buffers
|
|
const int32 probesCount = probesCounts.X * probesCounts.Y * probesCounts.Z;
|
|
if (probesCount == 0 || indirectLightingIntensity <= ZeroTolerance)
|
|
return true;
|
|
int32 probesCountX = probesCounts.X * probesCounts.Y;
|
|
int32 probesCountY = probesCounts.Z;
|
|
bool clear = false;
|
|
if (Math::NotNearEqual(ddgiData.ProbesSpacing, giResolution) || ddgiData.ProbeCounts != probesCounts || ddgiData.ProbeRaysCount != probeRaysCount)
|
|
{
|
|
PROFILE_CPU_NAMED("Init");
|
|
ddgiData.Clear();
|
|
ddgiData.ProbeRaysCount = probeRaysCount;
|
|
ddgiData.ProbesSpacing = giResolution;
|
|
ddgiData.ProbeCounts = probesCounts;
|
|
|
|
// Allocate probes textures
|
|
uint64 memUsage = 0;
|
|
auto desc = GPUTextureDescription::New2D(probesCountX, probesCountY, PixelFormat::Unknown);
|
|
// TODO rethink probes data placement in memory -> what if we get [50x50x30] resolution? That's 75000 probes! Use sparse storage with active-only probes
|
|
#define INIT_TEXTURE(texture, format, width, height) desc.Format = format; desc.Width = width; desc.Height = height; ddgiData.texture = RenderTargetPool::Get(desc); if (!ddgiData.texture) return true; memUsage += ddgiData.texture->GetMemoryUsage()
|
|
desc.Flags = GPUTextureFlags::ShaderResource | GPUTextureFlags::UnorderedAccess;
|
|
INIT_TEXTURE(ProbesTrace, PixelFormat::R16G16B16A16_Float, probeRaysCount, probesCount);
|
|
INIT_TEXTURE(ProbesState, PixelFormat::R16G16B16A16_Float, probesCountX, probesCountY); // TODO: optimize to a RGBA32 (pos offset can be normalized to [0-0.5] range of ProbesSpacing and packed with state flag)
|
|
INIT_TEXTURE(ProbesIrradiance, PixelFormat::R11G11B10_Float, probesCountX * (DDGI_PROBE_RESOLUTION_IRRADIANCE + 2), probesCountY * (DDGI_PROBE_RESOLUTION_IRRADIANCE + 2));
|
|
INIT_TEXTURE(ProbesDistance, PixelFormat::R16G16_Float, probesCountX * (DDGI_PROBE_RESOLUTION_DISTANCE + 2), probesCountY * (DDGI_PROBE_RESOLUTION_DISTANCE + 2));
|
|
#undef INIT_TEXTURE
|
|
LOG(Info, "Dynamic Diffuse Global Illumination memory usage: {0} MB, probes: {1}", memUsage / 1024 / 1024, probesCount);
|
|
clear = true;
|
|
}
|
|
#if USE_EDITOR
|
|
clear |= ddgiData.LastFrameUsed <= LastFrameShaderReload;
|
|
#endif
|
|
if (clear)
|
|
{
|
|
// Clear probes
|
|
PROFILE_GPU("Clear");
|
|
context->ClearUA(ddgiData.ProbesState, Vector4::Zero);
|
|
context->ClearUA(ddgiData.ProbesIrradiance, Vector4::Zero);
|
|
context->ClearUA(ddgiData.ProbesDistance, Vector4::Zero);
|
|
}
|
|
|
|
// Compute random rotation matrix for probe rays orientation (randomized every frame)
|
|
Matrix3x3 raysRotationMatrix;
|
|
CalculateVolumeRandomRotation(raysRotationMatrix);
|
|
|
|
// Compute scrolling (probes are placed around camera but are scrolling to increase stability during movement)
|
|
Vector3 viewOrigin = renderContext.View.Position;
|
|
Vector3 viewDirection = renderContext.View.Direction;
|
|
const float probesDistanceMax = probesDistance.MaxValue();
|
|
const Vector2 viewRayHit = CollisionsHelper::LineHitsBox(viewOrigin, viewOrigin + viewDirection * (probesDistanceMax * 2.0f), viewOrigin - probesDistance, viewOrigin + probesDistance);
|
|
const float viewOriginOffset = viewRayHit.Y * probesDistanceMax * 0.8f;
|
|
viewOrigin += viewDirection * viewOriginOffset;
|
|
const float viewOriginSnapping = giResolution;
|
|
viewOrigin = Vector3::Floor(viewOrigin / viewOriginSnapping) * viewOriginSnapping;
|
|
CalculateVolumeScrolling(ddgiData, viewOrigin);
|
|
|
|
// Upload constants
|
|
{
|
|
ddgiData.Result.Constants.ProbesOrigin = ddgiData.ProbesOrigin;
|
|
ddgiData.Result.Constants.ProbesSpacing = ddgiData.ProbesSpacing;
|
|
Quaternion& raysRotation = *(Quaternion*)&ddgiData.Result.Constants.RaysRotation;
|
|
Quaternion::RotationMatrix(raysRotationMatrix, raysRotation);
|
|
raysRotation.Conjugate();
|
|
ddgiData.Result.Constants.ProbesCounts[0] = probesCounts.X;
|
|
ddgiData.Result.Constants.ProbesCounts[1] = probesCounts.Y;
|
|
ddgiData.Result.Constants.ProbesCounts[2] = probesCounts.Z;
|
|
ddgiData.Result.Constants.ProbesScrollOffsets = ddgiData.ProbeScrollOffsets;
|
|
ddgiData.Result.Constants.ProbeScrollDirections = ddgiData.ProbeScrollDirections;
|
|
ddgiData.Result.Constants.ProbeScrollClear[0] = ddgiData.ProbeScrollClear[0] != 0;
|
|
ddgiData.Result.Constants.ProbeScrollClear[1] = ddgiData.ProbeScrollClear[1] != 0;
|
|
ddgiData.Result.Constants.ProbeScrollClear[2] = ddgiData.ProbeScrollClear[2] != 0;
|
|
ddgiData.Result.Constants.RayMaxDistance = 10000.0f; // TODO: adjust to match perf/quality ratio (make it based on Global SDF and Global Surface Atlas distance)
|
|
ddgiData.Result.Constants.ViewDir = viewDirection;
|
|
ddgiData.Result.Constants.RaysCount = probeRaysCount;
|
|
ddgiData.Result.Constants.ProbeHistoryWeight = probeHistoryWeight;
|
|
ddgiData.Result.Constants.IrradianceGamma = 5.0f;
|
|
ddgiData.Result.ProbesState = ddgiData.ProbesState->View();
|
|
ddgiData.Result.ProbesDistance = ddgiData.ProbesDistance->View();
|
|
ddgiData.Result.ProbesIrradiance = ddgiData.ProbesIrradiance->View();
|
|
|
|
Data0 data;
|
|
data.DDGI = ddgiData.Result.Constants;
|
|
data.GlobalSDF = bindingDataSDF.Constants;
|
|
data.GlobalSurfaceAtlas = bindingDataSurfaceAtlas.Constants;
|
|
data.IndirectLightingIntensity = indirectLightingIntensity;
|
|
GBufferPass::SetInputs(renderContext.View, data.GBuffer);
|
|
context->UpdateCB(_cb0, &data);
|
|
context->BindCB(0, _cb0);
|
|
}
|
|
|
|
// Classify probes (activation/deactivation and relocation)
|
|
{
|
|
PROFILE_GPU_CPU("Probes Classification");
|
|
uint32 threadGroups = Math::DivideAndRoundUp(probesCount, DDGI_PROBE_CLASSIFY_GROUP_SIZE);
|
|
for (int32 i = 0; i < 4; i++)
|
|
{
|
|
context->BindSR(i, bindingDataSDF.Cascades[i]->ViewVolume());
|
|
}
|
|
context->BindUA(0, ddgiData.Result.ProbesState);
|
|
context->Dispatch(_csClassify, threadGroups, 1, 1);
|
|
context->ResetUA();
|
|
}
|
|
|
|
// Trace rays from probes
|
|
{
|
|
PROFILE_GPU_CPU("Trace Rays");
|
|
|
|
// Global SDF with Global Surface Atlas software raytracing (X - per probe ray, Y - per probe)
|
|
ASSERT_LOW_LAYER((probeRaysCount % DDGI_TRACE_RAYS_GROUP_SIZE_X) == 0);
|
|
for (int32 i = 0; i < 4; i++)
|
|
{
|
|
context->BindSR(i, bindingDataSDF.Cascades[i]->ViewVolume());
|
|
context->BindSR(i + 4, bindingDataSDF.CascadeMips[i]->ViewVolume());
|
|
}
|
|
context->BindSR(8, bindingDataSurfaceAtlas.Chunks ? bindingDataSurfaceAtlas.Chunks->View() : nullptr);
|
|
context->BindSR(9, bindingDataSurfaceAtlas.CulledObjects ? bindingDataSurfaceAtlas.CulledObjects->View() : nullptr);
|
|
context->BindSR(10, bindingDataSurfaceAtlas.AtlasDepth->View());
|
|
context->BindSR(11, bindingDataSurfaceAtlas.AtlasLighting->View());
|
|
context->BindSR(12, ddgiData.Result.ProbesState);
|
|
context->BindUA(0, ddgiData.ProbesTrace->View());
|
|
context->Dispatch(_csTraceRays, probeRaysCount / DDGI_TRACE_RAYS_GROUP_SIZE_X, probesCount, 1);
|
|
context->ResetUA();
|
|
context->ResetSR();
|
|
|
|
#if 0
|
|
// Probes trace debug preview
|
|
context->SetViewportAndScissors(renderContext.View.ScreenSize.X, renderContext.View.ScreenSize.Y);
|
|
context->SetRenderTarget(lightBuffer);
|
|
context->Draw(ddgiData.ProbesTrace);
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
// Update probes
|
|
{
|
|
PROFILE_GPU_CPU("Update Probes");
|
|
context->BindSR(0, ddgiData.Result.ProbesState);
|
|
context->BindSR(1, ddgiData.ProbesTrace->View());
|
|
|
|
// Update irradiance
|
|
context->BindUA(0, ddgiData.Result.ProbesIrradiance);
|
|
context->Dispatch(_csUpdateProbesIrradiance, probesCountX, probesCountY, 1);
|
|
uint32 threadGroupsX = Math::DivideAndRoundUp(probesCountX * (DDGI_PROBE_RESOLUTION_IRRADIANCE + 2), DDGI_PROBE_UPDATE_BORDERS_GROUP_SIZE);
|
|
uint32 threadGroupsY = Math::DivideAndRoundUp(probesCountY, DDGI_PROBE_UPDATE_BORDERS_GROUP_SIZE);
|
|
context->Dispatch(_csUpdateBordersIrradianceRow, threadGroupsX, threadGroupsY, 1);
|
|
threadGroupsX = Math::DivideAndRoundUp(probesCountX, DDGI_PROBE_UPDATE_BORDERS_GROUP_SIZE);
|
|
threadGroupsY = Math::DivideAndRoundUp(probesCountY * (DDGI_PROBE_RESOLUTION_IRRADIANCE + 2), DDGI_PROBE_UPDATE_BORDERS_GROUP_SIZE);
|
|
context->Dispatch(_csUpdateBordersIrradianceCollumn, threadGroupsX, threadGroupsY, 1);
|
|
|
|
// Update distance
|
|
context->BindUA(0, ddgiData.Result.ProbesDistance);
|
|
context->Dispatch(_csUpdateProbesDistance, probesCountX, probesCountY, 1);
|
|
threadGroupsX = Math::DivideAndRoundUp(probesCountX * (DDGI_PROBE_RESOLUTION_DISTANCE + 2), DDGI_PROBE_UPDATE_BORDERS_GROUP_SIZE);
|
|
threadGroupsY = Math::DivideAndRoundUp(probesCountY, DDGI_PROBE_UPDATE_BORDERS_GROUP_SIZE);
|
|
context->Dispatch(_csUpdateBordersDistanceRow, threadGroupsX, threadGroupsY, 1);
|
|
threadGroupsX = Math::DivideAndRoundUp(probesCountX, DDGI_PROBE_UPDATE_BORDERS_GROUP_SIZE);
|
|
threadGroupsY = Math::DivideAndRoundUp(probesCountY * (DDGI_PROBE_RESOLUTION_DISTANCE + 2), DDGI_PROBE_UPDATE_BORDERS_GROUP_SIZE);
|
|
context->Dispatch(_csUpdateBordersDistanceCollumn, threadGroupsX, threadGroupsY, 1);
|
|
}
|
|
|
|
// Render indirect lighting
|
|
{
|
|
PROFILE_GPU_CPU("Indirect Lighting");
|
|
#if 0
|
|
// DDGI indirect lighting debug preview
|
|
context->Clear(lightBuffer, Color::Transparent);
|
|
#endif
|
|
context->ResetUA();
|
|
context->BindSR(0, renderContext.Buffers->GBuffer0->View());
|
|
context->BindSR(1, renderContext.Buffers->GBuffer1->View());
|
|
context->BindSR(2, renderContext.Buffers->GBuffer2->View());
|
|
context->BindSR(3, renderContext.Buffers->DepthBuffer->View());
|
|
context->BindSR(4, ddgiData.Result.ProbesState);
|
|
context->BindSR(5, ddgiData.Result.ProbesDistance);
|
|
context->BindSR(6, ddgiData.Result.ProbesIrradiance);
|
|
context->SetViewportAndScissors(renderContext.View.ScreenSize.X, renderContext.View.ScreenSize.Y);
|
|
context->SetRenderTarget(lightBuffer);
|
|
context->SetState(_psIndirectLighting);
|
|
context->DrawFullscreenTriangle();
|
|
}
|
|
|
|
#if USE_EDITOR
|
|
// Probes debug drawing
|
|
if (debugProbes)
|
|
{
|
|
PROFILE_GPU_CPU("Debug Probes");
|
|
if (!_debugModel)
|
|
_debugModel = Content::LoadAsyncInternal<Model>(TEXT("Editor/Primitives/Sphere"));
|
|
if (!_debugMaterial)
|
|
_debugMaterial = Content::LoadAsyncInternal<MaterialBase>(TEXT("Editor/DebugMaterials/DDGIDebugProbes"));
|
|
if (_debugModel && _debugModel->IsLoaded() && _debugModel->CanBeRendered() && _debugMaterial && _debugMaterial->IsLoaded())
|
|
{
|
|
RenderContext debugRenderContext(renderContext);
|
|
debugRenderContext.List = RenderList::GetFromPool();
|
|
debugRenderContext.View.Pass = DrawPass::GBuffer;
|
|
debugRenderContext.View.Prepare(debugRenderContext);
|
|
Matrix world;
|
|
Matrix::Scaling(Vector3(0.2f), world);
|
|
const Mesh& debugMesh = _debugModel->LODs[0].Meshes[0];
|
|
for (int32 probeIndex = 0; probeIndex < probesCount; probeIndex++)
|
|
debugMesh.Draw(debugRenderContext, _debugMaterial, world, StaticFlags::None, true, DrawPass::GBuffer, (float)probeIndex);
|
|
debugRenderContext.List->SortDrawCalls(debugRenderContext, false, DrawCallsListType::GBuffer);
|
|
context->SetViewportAndScissors(debugRenderContext.View.ScreenSize.X, debugRenderContext.View.ScreenSize.Y);
|
|
GPUTextureView* targetBuffers[5] =
|
|
{
|
|
lightBuffer,
|
|
renderContext.Buffers->GBuffer0->View(),
|
|
renderContext.Buffers->GBuffer1->View(),
|
|
renderContext.Buffers->GBuffer2->View(),
|
|
renderContext.Buffers->GBuffer3->View(),
|
|
};
|
|
context->SetRenderTarget(*renderContext.Buffers->DepthBuffer, ToSpan(targetBuffers, ARRAY_COUNT(targetBuffers)));
|
|
{
|
|
// Pass DDGI data to the material
|
|
_debugMaterial->SetParameterValue(TEXT("ProbesState"), Variant(ddgiData.ProbesState));
|
|
_debugMaterial->SetParameterValue(TEXT("ProbesIrradiance"), Variant(ddgiData.ProbesIrradiance));
|
|
_debugMaterial->SetParameterValue(TEXT("ProbesDistance"), Variant(ddgiData.ProbesDistance));
|
|
auto cb = _debugMaterial->GetShader()->GetCB(3);
|
|
if (cb)
|
|
{
|
|
context->UpdateCB(cb, &ddgiData.Result.Constants);
|
|
context->BindCB(3, cb);
|
|
}
|
|
}
|
|
debugRenderContext.List->ExecuteDrawCalls(debugRenderContext, DrawCallsListType::GBuffer);
|
|
RenderList::ReturnToPool(debugRenderContext.List);
|
|
context->UnBindCB(3);
|
|
context->ResetRenderTarget();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return false;
|
|
}
|