Sugarboss/HauntedBloodlines
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
545eca8660d2c2e22b6407fd85aed6f5aa47d605
HauntedBloodlines/Assets/HTraceWSGI/Scripts/Passes/HTraceMainPass.cs
Akis Zachariadis 545eca8660 First Commit
2025-05-29 22:31:40 +03:00

1778 lines
128 KiB
C#
Raw Blame History

using System;
using HTraceWSGI.Scripts.Globals;
using HTraceWSGI.Scripts.Pipeline;
using HTraceWSGI.Scripts.Structs;
using UnityEngine;
using UnityEngine.Experimental.Rendering;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using ProfilingScope = UnityEngine.Rendering.ProfilingScope;
namespace HTraceWSGI.Scripts.Passes
{
internal class HTraceMainPass : CustomPass
{
private const string HRenderAO_SHADER_NAME = "HRenderAO";
private const string HTracingScreenSpace_SHADER_NAME = "HTracingScreenSpace";
private const string HTracingWorldSpace_SHADER_NAME = "HTracingWorldSpace";
private const string HRadianceCache_SHADER_NAME = "HRadianceCache";
private const string HTemporalReprojection_SHADER_NAME = "HTemporalReprojection";
private const string HSpatialPrepass_SHADER_NAME = "HSpatialPrepass";
private const string HProbeAmbientOcclusion_SHADER_NAME = "HProbeAmbientOcclusion";
private const string HFilterOctahedral_SHADER_NAME = "HReSTIR";
private const string HCopy_SHADER_NAME = "HCopy";
private const string HRayGeneration_SHADER_NAME = "HRayGeneration";
private const string VoxelVisualization_SHADER_NAME = "VoxelVisualization";
private const string HReservoirValidation_SHADER_NAME = "HReservoirValidation";
private const string HDepthPyramid_SHADER_NAME = "HDepthPyramid";
private const string HDebugPassthrough_SHADER_NAME = "HDebugPassthrough";
private const string HInterpolation_SHADER_NAME = "HInterpolation";
private const string HTemporalDenoiser_SHADER_NAME = "HTemporalDenoiser";
#region SHADER PROPERTIES IDS ----------------------------->
private static readonly int _DepthIntermediate = Shader.PropertyToID("_DepthIntermediate");
private static readonly int _DepthIntermediate_Output = Shader.PropertyToID("_DepthIntermediate_Output");
private static readonly int _DepthPyramid_OutputMIP0 = Shader.PropertyToID("_DepthPyramid_OutputMIP0");
private static readonly int _DepthPyramid_OutputMIP1 = Shader.PropertyToID("_DepthPyramid_OutputMIP1");
private static readonly int _DepthPyramid_OutputMIP2 = Shader.PropertyToID("_DepthPyramid_OutputMIP2");
private static readonly int _DepthPyramid_OutputMIP3 = Shader.PropertyToID("_DepthPyramid_OutputMIP3");
private static readonly int _DepthPyramid_OutputMIP4 = Shader.PropertyToID("_DepthPyramid_OutputMIP4");
private static readonly int _DepthPyramid_OutputMIP5 = Shader.PropertyToID("_DepthPyramid_OutputMIP5");
private static readonly int _DepthPyramid_OutputMIP6 = Shader.PropertyToID("_DepthPyramid_OutputMIP6");
private static readonly int _DepthPyramid_OutputMIP7 = Shader.PropertyToID("_DepthPyramid_OutputMIP7");
private static readonly int _DepthPyramid_OutputMIP8 = Shader.PropertyToID("_DepthPyramid_OutputMIP8");
private static readonly int _DepthPyramid = Shader.PropertyToID("_DepthPyramid");
private static readonly int _BentNormalAmbientOcclusion_Output = Shader.PropertyToID("_BentNormalAmbientOcclusion_Output");
private static readonly int _NormalDepthHalf_Output = Shader.PropertyToID("_NormalDepthHalf_Output");
private static readonly int _Camera_FOV = Shader.PropertyToID("_Camera_FOV");
private static readonly int _AmbientOcclusion = Shader.PropertyToID("_AmbientOcclusion");
private static readonly int _NormalDepthHalf = Shader.PropertyToID("_NormalDepthHalf");
private static readonly int _BentNormalAO_Output = Shader.PropertyToID("_BentNormalAO_Output");
private static readonly int _GeometryNormal_Output = Shader.PropertyToID("_GeometryNormal_Output");
private static readonly int _PointDistribution_Output = Shader.PropertyToID("_PointDistribution_Output");
private static readonly int _SpatialOffsetsBuffer_Output = Shader.PropertyToID("_SpatialOffsetsBuffer_Output");
private static readonly int _GeometryNormal = Shader.PropertyToID("_GeometryNormal");
private static readonly int _ProbeNormalDepth_Output = Shader.PropertyToID("_ProbeNormalDepth_Output");
private static readonly int _ProbeDiffuse_Output = Shader.PropertyToID("_ProbeDiffuse_Output");
private static readonly int _SSAO = Shader.PropertyToID("_SSAO");
private static readonly int _ProbeSSAO_Output = Shader.PropertyToID("_ProbeSSAO_Output");
private static readonly int _ProbeNormalDepth = Shader.PropertyToID("_ProbeNormalDepth");
private static readonly int _HistoryIndirection = Shader.PropertyToID("_HistoryIndirection");
private static readonly int _ProbeWorldPosNormal_History = Shader.PropertyToID("_ProbeWorldPosNormal_History");
private static readonly int _ReprojectionCoords_Output = Shader.PropertyToID("_ReprojectionCoords_Output");
private static readonly int _ReprojectionWeights_Output = Shader.PropertyToID("_ReprojectionWeights_Output");
private static readonly int _PersistentReprojectionWeights_Output = Shader.PropertyToID("_PersistentReprojectionWeights_Output");
private static readonly int _PersistentReprojectionCoord_Output = Shader.PropertyToID("_PersistentReprojectionCoord_Output");
private static readonly int _ReprojectionCoords = Shader.PropertyToID("_ReprojectionCoords");
private static readonly int _RayDirectionsJittered_Output = Shader.PropertyToID("_RayDirectionsJittered_Output");
private static readonly int _IndirectCoordsSS_Output = Shader.PropertyToID("_IndirectCoordsSS_Output");
private static readonly int _IndirectCoordsOV_Output = Shader.PropertyToID("_IndirectCoordsOV_Output");
private static readonly int _IndirectCoordsSF_Output = Shader.PropertyToID("_IndirectCoordsSF_Output");
private static readonly int _RayCounter_Output = Shader.PropertyToID("_RayCounter_Output");
private static readonly int _RayCounter = Shader.PropertyToID("_RayCounter");
private static readonly int _TracingCoords = Shader.PropertyToID("_TracingCoords");
private static readonly int _IndirectArguments_Output = Shader.PropertyToID("_IndirectArguments_Output");
private static readonly int _RayCounterIndex = Shader.PropertyToID("_RayCounterIndex");
private static readonly int _NormalDepth_History = Shader.PropertyToID("_NormalDepth_History");
private static readonly int _RayDirection = Shader.PropertyToID("_RayDirection");
private static readonly int _HitDistance_Output = Shader.PropertyToID("_HitDistance_Output");
private static readonly int _HitCoord_Output = Shader.PropertyToID("_HitCoord_Output");
private static readonly int _IndexXR = Shader.PropertyToID("_IndexXR");
private static readonly int _ColorPyramid_History = Shader.PropertyToID("_ColorPyramid_History");
private static readonly int _Radiance_History = Shader.PropertyToID("_Radiance_History");
private static readonly int _HitCoord = Shader.PropertyToID("_HitCoord");
private static readonly int _HitRadiance_Output = Shader.PropertyToID("_HitRadiance_Output");
private static readonly int _HitDistance = Shader.PropertyToID("_HitDistance");
private static readonly int _TracingRayCounter_Output = Shader.PropertyToID("_TracingRayCounter_Output");
private static readonly int _TracingCoords_Output = Shader.PropertyToID("_TracingCoords_Output");
private static readonly int _VoxelPayload_Output = Shader.PropertyToID("_VoxelPayload_Output");
private static readonly int _PointDistribution = Shader.PropertyToID("_PointDistribution");
private static readonly int _RayLength = Shader.PropertyToID("_RayLength");
private static readonly int _VoxelPayload = Shader.PropertyToID("_VoxelPayload");
private static readonly int _HashUpdateFrameIndex = Shader.PropertyToID("_HashUpdateFrameIndex");
private static readonly int _RadianceAtlas = Shader.PropertyToID("_RadianceAtlas");
private static readonly int _RayDistanceSS = Shader.PropertyToID("_RayDistanceSS");
private static readonly int _RayDistanceWS = Shader.PropertyToID("_RayDistanceWS");
private static readonly int _ReprojectionWeights = Shader.PropertyToID("_ReprojectionWeights");
private static readonly int _PersistentReprojectionCoord = Shader.PropertyToID("_PersistentReprojectionCoord");
private static readonly int _ProbeAmbientOcclusion_History = Shader.PropertyToID("_ProbeAmbientOcclusion_History");
private static readonly int _ProbeAmbientOcclusion_Output = Shader.PropertyToID("_ProbeAmbientOcclusion_Output");
private static readonly int _ProbeNormalDepth_History = Shader.PropertyToID("_ProbeNormalDepth_History");
private static readonly int _SpatialOffsets_Output = Shader.PropertyToID("_SpatialOffsets_Output");
private static readonly int _SpatialWeights_Output = Shader.PropertyToID("_SpatialWeights_Output");
private static readonly int _SpatialOffsetsBuffer = Shader.PropertyToID("_SpatialOffsetsBuffer");
private static readonly int _SpatialWeightsPacked = Shader.PropertyToID("_SpatialWeightsPacked");
private static readonly int _SpatialOffsetsPacked = Shader.PropertyToID("_SpatialOffsetsPacked");
private static readonly int _ProbeAmbientOcclusion = Shader.PropertyToID("_ProbeAmbientOcclusion");
private static readonly int _ProbeAmbientOcclusion_OutputFiltered = Shader.PropertyToID("_ProbeAmbientOcclusion_OutputFiltered");
private static readonly int _ShadowGuidanceMask = Shader.PropertyToID("_ShadowGuidanceMask");
private static readonly int _RayDistance = Shader.PropertyToID("_RayDistance");
private static readonly int _ProbeDiffuse = Shader.PropertyToID("_ProbeDiffuse");
private static readonly int _ReservoirAtlas_Output = Shader.PropertyToID("_ReservoirAtlas_Output");
private static readonly int _ReservoirAtlas_History = Shader.PropertyToID("_ReservoirAtlas_History");
private static readonly int _ReservoirAtlasRayData_Output = Shader.PropertyToID("_ReservoirAtlasRayData_Output");
private static readonly int _ReservoirAtlasRadianceData_Output = Shader.PropertyToID("_ReservoirAtlasRadianceData_Output");
private static readonly int _UseDiffuseWeight = Shader.PropertyToID("_UseDiffuseWeight");
private static readonly int _PassNumber = Shader.PropertyToID("_PassNumber");
private static readonly int _ReservoirAtlasRayData = Shader.PropertyToID("_ReservoirAtlasRayData");
private static readonly int _ReservoirAtlasRadianceData = Shader.PropertyToID("_ReservoirAtlasRadianceData");
private static readonly int _ShadowGuidanceMask_History = Shader.PropertyToID("_ShadowGuidanceMask_History");
private static readonly int _ShadowGuidanceMask_Output = Shader.PropertyToID("_ShadowGuidanceMask_Output");
private static readonly int _ReservoirAtlasRayData_Disocclusion = Shader.PropertyToID("_ReservoirAtlasRayData_Disocclusion");
private static readonly int _ReservoirAtlas = Shader.PropertyToID("_ReservoirAtlas");
private static readonly int _ReservoirAtlasRadianceData_Inout = Shader.PropertyToID("_ReservoirAtlasRadianceData_Inout");
private static readonly int _SampleCount_History = Shader.PropertyToID("_SampleCount_History");
private static readonly int _SampleCount_Output = Shader.PropertyToID("_SampleCount_Output");
private static readonly int _SampleCount = Shader.PropertyToID("_SampleCount");
private static readonly int _ReprojectionCoord = Shader.PropertyToID("_ReprojectionCoord");
private static readonly int _HistoryArrayIndex = Shader.PropertyToID("_HistoryArrayIndex");
private static readonly int _ProbeWorldPosNormal_HistoryOutput = Shader.PropertyToID("_ProbeWorldPosNormal_HistoryOutput");
private static readonly int _Temp = Shader.PropertyToID("_Temp");
private static readonly int _PackedSH_A_Output = Shader.PropertyToID("_PackedSH_A_Output");
private static readonly int _PackedSH_B_Output = Shader.PropertyToID("_PackedSH_B_Output");
private static readonly int _ProbeSSAO = Shader.PropertyToID("_ProbeSSAO");
private static readonly int _PackedSH_A = Shader.PropertyToID("_PackedSH_A");
private static readonly int _PackedSH_B = Shader.PropertyToID("_PackedSH_B");
private static readonly int _BentNormalsAO = Shader.PropertyToID("_BentNormalsAO");
private static readonly int _Radiance_Output = Shader.PropertyToID("_Radiance_Output");
private static readonly int _AO_Intensity = Shader.PropertyToID("_AO_Intensity");
private static readonly int _Radiance = Shader.PropertyToID("_Radiance");
private static readonly int _LuminanceDelta_Output = Shader.PropertyToID("_LuminanceDelta_Output");
private static readonly int _LuminanceDelta_History = Shader.PropertyToID("_LuminanceDelta_History");
private static readonly int _Radiance_HistoryOutput = Shader.PropertyToID("_Radiance_HistoryOutput");
private static readonly int _NormalDepth_HistoryOutput = Shader.PropertyToID("_NormalDepth_HistoryOutput");
private static readonly int _ShadowGuidanceMask_Samplecount = Shader.PropertyToID("_ShadowGuidanceMask_Samplecount");
private static readonly int _ShadowGuidanceMask_SamplecountHistoryOutput = Shader.PropertyToID("_ShadowGuidanceMask_SamplecountHistoryOutput");
private static readonly int _ShadowGuidanceMask_CheckerboardHistoryOutput = Shader.PropertyToID("_ShadowGuidanceMask_CheckerboardHistoryOutput");
private static readonly int _ShadowGuidanceMask_Accumulated = Shader.PropertyToID("_ShadowGuidanceMask_Accumulated");
private static readonly int _ShadowGuidanceMask_HistoryOutput = Shader.PropertyToID("_ShadowGuidanceMask_HistoryOutput");
private static readonly int _StencilRef = Shader.PropertyToID("_StencilRef");
private static readonly int _StencilMask = Shader.PropertyToID("_StencilMask");
private static readonly int _InputA = Shader.PropertyToID("_InputA");
private static readonly int _InputB = Shader.PropertyToID("_InputB");
private static readonly int _Output = Shader.PropertyToID("_Output");
private static readonly int _DebugCameraFrustum = Shader.PropertyToID("_DebugCameraFrustum");
private static readonly int _DebugRayDirection = Shader.PropertyToID("_DebugRayDirection");
private static readonly int _Visualization_Output = Shader.PropertyToID("_Visualization_Output");
private static readonly int _MultibounceMode = Shader.PropertyToID("_MultibounceMode");
//Globals
private static readonly int g_VoxelPositionPyramid = Shader.PropertyToID("_VoxelPositionPyramid");
private static readonly int g_HTraceShadowmap = Shader.PropertyToID("_HTraceShadowmap");
private static readonly int g_Gbuffertexture0 = Shader.PropertyToID("_GBufferTexture0");
private static readonly int g_CustomMotionVectors = Shader.PropertyToID("g_CustomMotionVectors");
private static readonly int g_HTraceBufferGI = Shader.PropertyToID("_HTraceBufferGI");
private static readonly int g_TestCheckbox = Shader.PropertyToID("_TestCheckbox");
private static readonly int g_ProbeSize = Shader.PropertyToID("_ProbeSize");
private static readonly int g_OctahedralSize = Shader.PropertyToID("_OctahedralSize");
private static readonly int g_HFrameIndex = Shader.PropertyToID("_HFrameIndex");
private static readonly int g_ReprojectSkippedFrame = Shader.PropertyToID("_ReprojectSkippedFrame");
private static readonly int g_PersistentHistorySamples = Shader.PropertyToID("_PersistentHistorySamples");
private static readonly int g_SkyOcclusionCone = Shader.PropertyToID("_SkyOcclusionCone");
private static readonly int g_DirectionalLightIntensity = Shader.PropertyToID("_DirectionalLightIntensity");
private static readonly int g_SurfaceDiffuseIntensity = Shader.PropertyToID("_SurfaceDiffuseIntensity");
private static readonly int g_SkyLightIntensity = Shader.PropertyToID("_SkyLightIntensity");
private static readonly int g_HashBuffer_Key = Shader.PropertyToID("_HashBuffer_Key");
private static readonly int g_HashBuffer_Payload = Shader.PropertyToID("_HashBuffer_Payload");
private static readonly int g_HashBuffer_Counter = Shader.PropertyToID("_HashBuffer_Counter");
private static readonly int g_HashBuffer_Radiance = Shader.PropertyToID("_HashBuffer_Radiance");
private static readonly int g_HashBuffer_Position = Shader.PropertyToID("_HashBuffer_Position");
private static readonly int g_HashStorageSize = Shader.PropertyToID("_HashStorageSize");
private static readonly int g_HashUpdateFraction = Shader.PropertyToID("_HashUpdateFraction");
private static readonly int g_GeometryNormal = Shader.PropertyToID("_GeometryNormal");
#endregion SHADER PROPERTIES IDS ----------------------------->
private static readonly ProfilingSampler s_ComposeMotionVectorsProfilingSampler = new ProfilingSampler("Compose Motion Vectors");
private static readonly ProfilingSampler s_DepthPyramidGenerationProfilingSampler = new ProfilingSampler("Depth Pyramid Generation");
private static readonly ProfilingSampler s_RenderAmbientOcclsuionProfilingSampler = new ProfilingSampler("Render Ambient Occlsuion");
private static readonly ProfilingSampler s_ProbeGBufferDownsamplingProfilingSampler = new ProfilingSampler("Probe GBuffer Downsampling");
private static readonly ProfilingSampler s_ProbeTemporalReprojectionProfilingSampler = new ProfilingSampler("Probe Temporal Reprojection");
private static readonly ProfilingSampler s_RayGenerationProfilingSampler = new ProfilingSampler("Ray Generation");
private static readonly ProfilingSampler s_ClearTargetsProfilingSampler = new ProfilingSampler("Clear Targets");
private static readonly ProfilingSampler s_ScreenSpaceLightingProfilingSampler = new ProfilingSampler("Screen Space Lighting");
private static readonly ProfilingSampler s_RayCompactionProfilingSampler = new ProfilingSampler("Ray Compaction");
private static readonly ProfilingSampler s_WorldSpaceLightingProfilingSampler = new ProfilingSampler("World Space Lighting");
private static readonly ProfilingSampler s_WorldSpaceTracingProfilingSampler = new ProfilingSampler("World Space Tracing");
private static readonly ProfilingSampler s_LightEvaluationProfilingSampler = new ProfilingSampler("Light Evaluation");
private static readonly ProfilingSampler s_RadianceCachingProfilingSampler = new ProfilingSampler("Radiance Caching");
private static readonly ProfilingSampler s_CacheTracingUpdateProfilingSampler = new ProfilingSampler("Cache Tracing Update");
private static readonly ProfilingSampler s_CacheLightEvaluationProfilingSampler = new ProfilingSampler("Cache Light Evaluation");
private static readonly ProfilingSampler s_PrimaryCacheSpawnProfilingSampler = new ProfilingSampler("Primary Cache Spawn");
private static readonly ProfilingSampler s_CacheDataUpdateProfilingSampler = new ProfilingSampler("Cache Data Update");
private static readonly ProfilingSampler s_SpatialPrepassProfilingSampler = new ProfilingSampler("Spatial Prepass");
private static readonly ProfilingSampler s_ReSTIRTemporalReuseProfilingSampler = new ProfilingSampler("ReSTIR Temporal Reuse");
private static readonly ProfilingSampler s_ReservoirOcclusionValidationProfilingSampler = new ProfilingSampler("Reservoir Occlusion Validation");
private static readonly ProfilingSampler s_ReSTIRSpatialReuseProfilingSampler = new ProfilingSampler("ReSTIR Spatial Reuse");
private static readonly ProfilingSampler s_PersistentHistoryUpdateProfilingSampler = new ProfilingSampler("Persistent History Update");
private static readonly ProfilingSampler s_InterpolationProfilingSampler = new ProfilingSampler("Interpolation");
private static readonly ProfilingSampler s_TemporalDenoisingProfilingSampler = new ProfilingSampler("Temporal Denoising");
private static readonly ProfilingSampler s_SpatialCleanupProfilingSampler = new ProfilingSampler("Spatial Cleanup");
private static readonly ProfilingSampler s_CopyBuffersProfilingSampler = new ProfilingSampler("Copy Buffers");
private static readonly ProfilingSampler s_DebugPassthroughProfilingSampler = new ProfilingSampler("Debug Passthrough");
private static readonly ProfilingSampler s_VisualizeVoxelsProfilingSampler = new ProfilingSampler("Visualize Voxels");
// Local variables
private int HashStorageSize = 512000 * 2;
private int HashUpdateFraction = 10;
private int HashUpdateFrameIndex = 0;
private int HFrameIndex = 0;
private Vector3 PrevVoxelCameraPos = new Vector3(0, 0, 0);
private Vector2Int PrevScreenResolution = new Vector2Int(0, 0);
private Vector2Int DepthPyramidResolution = new Vector2Int(16, 16);
private Matrix4x4 DepthMatrixPrev = new Matrix4x4();
private Vector3 cameraPosistionPrev = new Vector3();
private int PersistentHistorySamples = 4;
private int _probeSize = 6;
private int _octahedralSize = 4;
private int _startFrameCounter = 0;
private bool _firstFrame = true;
private bool _prevDirectionalOcclusion;
private bool _prevDebugModeEnabled;
// Computes
private ComputeShader VoxelVisualization = null;
private ComputeShader HReservoirValidation = null;
private ComputeShader HTracingScreenSpace = null;
private ComputeShader HTracingWorldSpace = null;
private ComputeShader HRadianceCache = null;
private ComputeShader HTemporalReprojection = null;
private ComputeShader HReSTIR = null;
private ComputeShader HCopy = null;
private ComputeShader HSpatialPrepass = null;
private ComputeShader HProbeAmbientOcclusion = null;
private ComputeShader HProbeAtlasAccumulation = null;
private ComputeShader HRayGeneration = null;
private ComputeShader HRenderAO = null;
private ComputeShader HDepthPyramid = null;
private ComputeShader HPrefilterTemporal = null;
private ComputeShader HPrefilterSpatial = null;
private ComputeShader HDebugPassthrough = null;
private ComputeShader HInterpolation = null;
private ComputeShader HTemporalDenoiser = null;
// Materials, shaders, compute buffers
Material MotionVectorsMaterial;
Material VoxelVisualizationMaterial;
// Indirection dispatch buffers
ComputeBuffer RayCounter;
ComputeBuffer RayCounterWS;
ComputeBuffer IndirectArgumentsSS;
ComputeBuffer IndirectArgumentsWS;
ComputeBuffer IndirectArgumentsOV;
ComputeBuffer IndirectArgumentsSF;
ComputeBuffer IndirectCoordsSS;
ComputeBuffer IndirectCoordsWS;
ComputeBuffer IndirectCoordsOV;
ComputeBuffer IndirectCoordsSF;
// Spatial offsets buffers
ComputeBuffer PointDistributionBuffer;
ComputeBuffer SpatialOffsetsBuffer;
// Hash buffers
ComputeBuffer HashBuffer_Key;
ComputeBuffer HashBuffer_Payload;
ComputeBuffer HashBuffer_Counter;
ComputeBuffer HashBuffer_Radiance;
ComputeBuffer HashBuffer_Position;
#region RT HADNLES ------------------------------------>
// SSAO RT
RTHandle ProbeSSAO;
RTHandle NormalDepthHalf;
RTHandle BentNormalsAO;
RTHandle BentNormalsAO_Interpolated;
RTHandle BentNormalsAO_History;
RTHandle BentNormalsAO_Accumulated;
RTHandle BentNormalsAO_Samplecount;
RTHandle BentNormalsAO_SamplecountHistory;
// TRACING RT
RTHandle VoxelPayload;
RTHandle RayDirections;
RTHandle HitRadiance;
RTHandle HitDistanceScreenSpace;
RTHandle HitDistanceWorldSpace;
RTHandle HitCoordScreenSpace;
// PROBE AO RT
RTHandle ProbeAmbientOcclusion;
RTHandle ProbeAmbientOcclusion_History;
RTHandle ProbeAmbientOcclusion_Filtered;
// GBUFFER RT
RTHandle CustomCameraMotionVectors;
RTHandle GeometryNormal;
RTHandle NormalDepth_History;
RTHandle ProbeNormalDepth;
RTHandle ProbeNormalDepth_History;
RTHandle ProbeWorldPosNormal_History;
RTHandle ProbeNormalDepth_Intermediate;
RTHandle ProbeDiffuse;
RTHandle DepthPyramid;
RTHandle DepthIntermediate_Pyramid;
// REPROJECTION RT
RTHandle HistoryIndirection;
RTHandle ReprojectionCoord;
RTHandle PersistentReprojectionCoord;
RTHandle ReprojectionWeights;
RTHandle PersistentReprojectionWeights;
// SPATIAL PREPASS RT
RTHandle SpatialOffsetsPacked;
RTHandle SpatialWeightsPacked;
// RESERVOIR RT
RTHandle ReservoirAtlas;
RTHandle ReservoirAtlas_History;
RTHandle ReservoirAtlasRadianceData_A;
RTHandle ReservoirAtlasRadianceData_B;
RTHandle ReservoirAtlasRadianceData_C;
RTHandle ReservoirAtlasRayData_A;
RTHandle ReservoirAtlasRayData_B;
RTHandle ReservoirAtlasRayData_C;
// SHADOW GUIDANCE MASK RT
RTHandle ShadowGuidanceMask;
RTHandle ShadowGuidanceMask_Accumulated;
RTHandle ShadowGuidanceMask_Filtered;
RTHandle ShadowGuidanceMask_History;
RTHandle ShadowGuidanceMask_CheckerboardHistory;
RTHandle ShadowGuidanceMask_Samplecount;
RTHandle ShadowGuidanceMask_SamplecountHistory;
// INTERPOLATION RT
RTHandle PackedSH_A;
RTHandle PackedSH_B;
RTHandle Radiance_Interpolated;
// TEMPORAL DENOISER RT
RTHandle RadianceAccumulated;
RTHandle RadianceAccumulated_History;
RTHandle LuminanceDelta;
RTHandle LuminanceDelta_History;
// DEBUG RT
RTHandle VoxelVisualizationRayDirections;
RTHandle DebugOutput;
RTHandle RadianceCacheFiltered;
#endregion
#region MATERIAL & RESOURCE LOAD --------------------->
private void ResourcesLoad()
{
VoxelVisualization = HExtensions.LoadComputeShader(VoxelVisualization_SHADER_NAME);
HReservoirValidation = HExtensions.LoadComputeShader(HReservoirValidation_SHADER_NAME);
HTracingScreenSpace = HExtensions.LoadComputeShader(HTracingScreenSpace_SHADER_NAME);
HTracingWorldSpace = HExtensions.LoadComputeShader(HTracingWorldSpace_SHADER_NAME);
HRadianceCache = HExtensions.LoadComputeShader(HRadianceCache_SHADER_NAME);
HTemporalReprojection = HExtensions.LoadComputeShader(HTemporalReprojection_SHADER_NAME);
HSpatialPrepass = HExtensions.LoadComputeShader(HSpatialPrepass_SHADER_NAME);
HProbeAmbientOcclusion = HExtensions.LoadComputeShader(HProbeAmbientOcclusion_SHADER_NAME);
HReSTIR = HExtensions.LoadComputeShader(HFilterOctahedral_SHADER_NAME);
HCopy = HExtensions.LoadComputeShader(HCopy_SHADER_NAME);
HRayGeneration = HExtensions.LoadComputeShader(HRayGeneration_SHADER_NAME);
HRenderAO = HExtensions.LoadComputeShader(HRenderAO_SHADER_NAME);
HDepthPyramid = HExtensions.LoadComputeShader(HDepthPyramid_SHADER_NAME);
HDebugPassthrough = HExtensions.LoadComputeShader(HDebugPassthrough_SHADER_NAME);
HInterpolation = HExtensions.LoadComputeShader(HInterpolation_SHADER_NAME);
HTemporalDenoiser = HExtensions.LoadComputeShader(HTemporalDenoiser_SHADER_NAME);
}
private void MaterialSetup()
{
MotionVectorsMaterial = CoreUtils.CreateEngineMaterial(Shader.Find("Hidden/HDRP/CameraMotionVectors"));
VoxelVisualizationMaterial = CoreUtils.CreateEngineMaterial(Shader.Find("HTrace/VoxelVisualization"));
}
#endregion
#region TEXTURE AND BUFFER ALLOCATION --------------------------->
private void AllocateMainRT(bool onlyRelease = false)
{
void ReleaseTextures()
{
HExtensions.HRelease(VoxelPayload);
HExtensions.HRelease(RayDirections);
HExtensions.HRelease(HitRadiance);
HExtensions.HRelease(HitDistanceScreenSpace);
HExtensions.HRelease(HitDistanceWorldSpace);
HExtensions.HRelease(HitCoordScreenSpace);
HExtensions.HRelease(ProbeAmbientOcclusion);
HExtensions.HRelease(ProbeAmbientOcclusion_History);
HExtensions.HRelease(ProbeAmbientOcclusion_Filtered);
HExtensions.HRelease(CustomCameraMotionVectors);
HExtensions.HRelease(GeometryNormal);
HExtensions.HRelease(NormalDepth_History);
HExtensions.HRelease(ProbeNormalDepth);
HExtensions.HRelease(ProbeNormalDepth_History);
HExtensions.HRelease(ProbeWorldPosNormal_History);
HExtensions.HRelease(ProbeNormalDepth_Intermediate);
HExtensions.HRelease(ProbeDiffuse);
HExtensions.HRelease(HistoryIndirection);
HExtensions.HRelease(ReprojectionWeights);
HExtensions.HRelease(PersistentReprojectionWeights);
HExtensions.HRelease(ReprojectionCoord);
HExtensions.HRelease(PersistentReprojectionCoord);
HExtensions.HRelease(SpatialOffsetsPacked);
HExtensions.HRelease(SpatialWeightsPacked);
HExtensions.HRelease(ReservoirAtlas);
HExtensions.HRelease(ReservoirAtlas_History);
HExtensions.HRelease(ReservoirAtlasRadianceData_A);
HExtensions.HRelease(ReservoirAtlasRadianceData_B);
HExtensions.HRelease(ReservoirAtlasRadianceData_C);
HExtensions.HRelease(ReservoirAtlasRayData_A);
HExtensions.HRelease(ReservoirAtlasRayData_B);
HExtensions.HRelease(ReservoirAtlasRayData_C);
HExtensions.HRelease(ShadowGuidanceMask);
HExtensions.HRelease(ShadowGuidanceMask_Accumulated);
HExtensions.HRelease(ShadowGuidanceMask_Filtered);
HExtensions.HRelease(ShadowGuidanceMask_History);
HExtensions.HRelease(ShadowGuidanceMask_CheckerboardHistory);
HExtensions.HRelease(ShadowGuidanceMask_Samplecount);
HExtensions.HRelease(ShadowGuidanceMask_SamplecountHistory);
HExtensions.HRelease(PackedSH_A);
HExtensions.HRelease(PackedSH_B);
HExtensions.HRelease(Radiance_Interpolated);
HExtensions.HRelease(RadianceAccumulated);
HExtensions.HRelease(RadianceAccumulated_History);
HExtensions.HRelease(LuminanceDelta);
HExtensions.HRelease(LuminanceDelta_History);
HExtensions.HRelease(RadianceCacheFiltered);
HExtensions.HRelease(RayCounter);
HExtensions.HRelease(RayCounterWS);
HExtensions.HRelease(IndirectArgumentsSS);
HExtensions.HRelease(IndirectArgumentsWS);
HExtensions.HRelease(IndirectArgumentsOV);
HExtensions.HRelease(IndirectArgumentsSF);
HExtensions.HRelease(PointDistributionBuffer);
HExtensions.HRelease(SpatialOffsetsBuffer);
HExtensions.HRelease(HashBuffer_Key);
HExtensions.HRelease(HashBuffer_Payload);
HExtensions.HRelease(HashBuffer_Counter);
HExtensions.HRelease(HashBuffer_Radiance);
HExtensions.HRelease(HashBuffer_Position);
}
if (onlyRelease)
{
ReleaseTextures();
return;
}
ReleaseTextures();
Vector2 FullRes = Vector2.one;
Vector2 HalfRes = Vector2.one / 2;
Vector2 ProbeRes = Vector2.one / _probeSize;
Vector2 ProbeAtlasRes = Vector2.one / (float)_probeSize * (float)_octahedralSize;
// -------------------------------------- BUFFERS -------------------------------------- //
// Indirection dispatch buffers
RayCounter = new ComputeBuffer(10 * TextureXR.slices, sizeof(uint));
RayCounterWS = new ComputeBuffer(10 * TextureXR.slices, sizeof(uint));
IndirectArgumentsSS = new ComputeBuffer(3 * TextureXR.slices, sizeof(uint), ComputeBufferType.IndirectArguments);
IndirectArgumentsWS = new ComputeBuffer(3 * TextureXR.slices, sizeof(uint), ComputeBufferType.IndirectArguments);
IndirectArgumentsOV = new ComputeBuffer(3 * TextureXR.slices, sizeof(uint), ComputeBufferType.IndirectArguments);
IndirectArgumentsSF = new ComputeBuffer(3 * TextureXR.slices, sizeof(uint), ComputeBufferType.IndirectArguments);
// Spatial offsets buffers
PointDistributionBuffer = new ComputeBuffer(TextureXR.slices * 32 * 4, 2 * sizeof(float));
SpatialOffsetsBuffer = new ComputeBuffer(9 * 9, 2 * sizeof(int));
// Hash buffers
HashBuffer_Key = new ComputeBuffer(HashStorageSize, 1 * sizeof(uint));
HashBuffer_Payload = new ComputeBuffer(HashStorageSize / HashUpdateFraction, 2 * sizeof(uint));
HashBuffer_Counter = new ComputeBuffer(HashStorageSize, 1 * sizeof(uint));
HashBuffer_Radiance = new ComputeBuffer(HashStorageSize, 4 * sizeof(uint));
HashBuffer_Position = new ComputeBuffer(HashStorageSize, 4 * sizeof(uint));
// -------------------------------------- TRACING RT -------------------------------------- //
VoxelPayload = RTHandles.Alloc(ProbeAtlasRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R32G32_UInt, name: "_VoxelPayload", enableRandomWrite: true);
RayDirections = RTHandles.Alloc(ProbeAtlasRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R8G8B8A8_UNorm, name: "_RayDirections", enableRandomWrite: true);
HitDistanceScreenSpace = RTHandles.Alloc(ProbeAtlasRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16_UInt, name: "_HitDistanceScreenSpace", enableRandomWrite: true);
HitDistanceWorldSpace = RTHandles.Alloc(ProbeAtlasRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16_SFloat, name: "_HitDistanceWorldSpace", enableRandomWrite: true);
HitRadiance = RTHandles.Alloc(ProbeAtlasRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16B16A16_SFloat, name: "_HitRadiance", enableRandomWrite: true);
HitCoordScreenSpace = RTHandles.Alloc(FullRes, TextureXR.slices, dimension: TextureXR.dimension, useDynamicScale: true,
colorFormat: GraphicsFormat.R16G16_UInt, name: "_HitCoordScreenSpace", enableRandomWrite: true);
// -------------------------------------- PROBE AO RT -------------------------------------- //
ProbeAmbientOcclusion = RTHandles.Alloc(ProbeRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16_UInt, name: "_ProbeAmbientOcclusion", enableRandomWrite: true);
ProbeAmbientOcclusion_History = RTHandles.Alloc(ProbeRes, TextureXR.slices * PersistentHistorySamples, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16_UInt, name: "_ProbeAmbientOcclusion_History", enableRandomWrite: true);
ProbeAmbientOcclusion_Filtered = RTHandles.Alloc(ProbeRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R8_UNorm, name: "_ProbeAmbientOcclusion_Filtered", enableRandomWrite: true);
// -------------------------------------- GBUFFER RT -------------------------------------- //
CustomCameraMotionVectors = RTHandles.Alloc(FullRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16_SFloat, name: "_CustomCameraMotionVectors", enableRandomWrite: true);
GeometryNormal = RTHandles.Alloc(FullRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16B16A16_SFloat, name: "_GeometryNormal", enableRandomWrite: true);
NormalDepth_History = RTHandles.Alloc(FullRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R32G32_UInt, name: "_NormalDepth_History", enableRandomWrite: true);
ProbeNormalDepth = RTHandles.Alloc(ProbeRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R32G32_UInt, name: "_ProbeNormalDepth", enableRandomWrite: true);
ProbeNormalDepth_History = RTHandles.Alloc(ProbeRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R32G32_UInt, name: "_ProbeNormalDepth_History", enableRandomWrite: true);
ProbeWorldPosNormal_History = RTHandles.Alloc(ProbeRes, TextureXR.slices * PersistentHistorySamples, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R32G32B32A32_UInt, name: "_ProbeWorldPosNormal_History", enableRandomWrite: true);
ProbeNormalDepth_Intermediate = RTHandles.Alloc(ProbeRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R32G32_UInt, name: "_ProbeNormalDepth_Intermediate", enableRandomWrite: true);
ProbeDiffuse = RTHandles.Alloc(ProbeRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R8G8B8A8_UNorm, name: "_ProbeDiffuse", enableRandomWrite: true);
// -------------------------------------- REPROJECTION RT -------------------------------------- //
HistoryIndirection = RTHandles.Alloc(ProbeRes, TextureXR.slices * PersistentHistorySamples, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16_UInt, name: "_HistoryIndirection", enableRandomWrite: true);
ReprojectionWeights = RTHandles.Alloc(ProbeRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R8G8B8A8_UNorm, name: "_ReprojectionWeights", enableRandomWrite: true);
PersistentReprojectionWeights = RTHandles.Alloc(ProbeRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R8G8B8A8_UNorm, name: "_PersistentReprojectionWeights", enableRandomWrite: true);
ReprojectionCoord = RTHandles.Alloc(ProbeRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16_UInt, name: "_ReprojectionCoord", enableRandomWrite: true);
PersistentReprojectionCoord = RTHandles.Alloc(ProbeRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16_UInt, name: "_PersistentReprojectionCoord", enableRandomWrite: true);
// -------------------------------------- SPATIAL PREPASS RT -------------------------------------- //
SpatialOffsetsPacked = RTHandles.Alloc(ProbeRes, TextureXR.slices * 4, dimension: TextureXR.dimension, useDynamicScale: true,
colorFormat: GraphicsFormat.R32G32B32A32_UInt, name: "_SpatialOffsetsPacked", enableRandomWrite: true);
SpatialWeightsPacked = RTHandles.Alloc(ProbeRes, TextureXR.slices * 4, dimension: TextureXR.dimension, useDynamicScale: true,
colorFormat: GraphicsFormat.R16G16B16A16_UInt, name: "_SpatialWeightsPacked", enableRandomWrite: true);
// -------------------------------------- RESERVOIR RT -------------------------------------- //
ReservoirAtlas = RTHandles.Alloc(ProbeAtlasRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R32G32B32A32_UInt, name: "_ReservoirAtlas", enableRandomWrite: true);
ReservoirAtlas_History = RTHandles.Alloc(ProbeAtlasRes, TextureXR.slices * PersistentHistorySamples, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R32G32B32A32_UInt, name: "_ReservoirAtlas_History", enableRandomWrite: true);
ReservoirAtlasRadianceData_A = RTHandles.Alloc(ProbeAtlasRes , TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R32G32_UInt, name: "_ReservoirAtlasRadianceData_A", enableRandomWrite: true);
ReservoirAtlasRadianceData_B = RTHandles.Alloc(ProbeAtlasRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R32G32_UInt, name: "_ReservoirAtlasRadianceData_B", enableRandomWrite: true);
ReservoirAtlasRadianceData_C = RTHandles.Alloc(ProbeAtlasRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R32G32_UInt, name: "_ReservoirAtlasRadianceData_C", enableRandomWrite: true);
ReservoirAtlasRayData_A = RTHandles.Alloc(ProbeAtlasRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R32_UInt, name: "_ReservoirAtlasRayData_A", enableRandomWrite: true);
ReservoirAtlasRayData_B = RTHandles.Alloc(ProbeAtlasRes, TextureXR.slices * PersistentHistorySamples, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R32_UInt, name: "_ReservoirAtlasRayData_B", enableRandomWrite: true);
ReservoirAtlasRayData_C = RTHandles.Alloc(ProbeAtlasRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R32_UInt, name: "_ReservoirAtlasRayData_C", enableRandomWrite: true);
// -------------------------------------- SHADOW GUIDANCE MASK RT -------------------------------------- //
ShadowGuidanceMask = RTHandles.Alloc(ProbeAtlasRes, TextureXR.slices , dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R8_UNorm, name: "_ShadowGuidanceMask", enableRandomWrite: true);
ShadowGuidanceMask_Accumulated = RTHandles.Alloc(ProbeAtlasRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R8_UNorm, name: "_ShadowGuidanceMask_Accumulated", enableRandomWrite: true);
ShadowGuidanceMask_Filtered = RTHandles.Alloc(ProbeAtlasRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R8_UNorm, name: "_ShadowGuidanceMask_Filtered", enableRandomWrite: true);
ShadowGuidanceMask_History = RTHandles.Alloc(ProbeAtlasRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R8_UNorm, name: "_ShadowGuidanceMask_History", enableRandomWrite: true);
ShadowGuidanceMask_CheckerboardHistory = RTHandles.Alloc(ProbeAtlasRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R8_UNorm, name: "_ShadowGuidanceMask_CheckerboardHistory", enableRandomWrite: true);
ShadowGuidanceMask_Samplecount = RTHandles.Alloc(ProbeRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16_SFloat, name: "_ShadowGuidanceMask_Samplecount", enableRandomWrite: true);
ShadowGuidanceMask_SamplecountHistory = RTHandles.Alloc(ProbeRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16_SFloat, name: "_ShadowGuidanceMask_SamplecountHistory", enableRandomWrite: true);
// -------------------------------------- INTERPOLATION RT -------------------------------------- //
PackedSH_A = RTHandles.Alloc(ProbeRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R32G32B32A32_UInt, name: "_PackedSH_A", enableRandomWrite: true);
PackedSH_B = RTHandles.Alloc(ProbeRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R32G32B32A32_UInt, name: "_PackedSH_B", enableRandomWrite: true);
Radiance_Interpolated = RTHandles.Alloc(FullRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R32_UInt, name: "_Radiance_Interpolated", enableRandomWrite: true);
// -------------------------------------- TEMPORAL DENOISER RT -------------------------------------- //
RadianceAccumulated = RTHandles.Alloc(FullRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16B16A16_SFloat, name: "_RadianceAccumulated", enableRandomWrite: true);
RadianceAccumulated_History = RTHandles.Alloc(FullRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16B16A16_SFloat, name: "_RadianceAccumulated_History", enableRandomWrite: true);
LuminanceDelta = RTHandles.Alloc(FullRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16_SFloat, name: "_RadianceLumaDelta", enableRandomWrite: true);
LuminanceDelta_History = RTHandles.Alloc(FullRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16_SFloat, name: "_RadianceLumaDelta_History", enableRandomWrite: true);
// TODO: figure out if we need this, do not delete and do not allocate for now
// RadianceCacheFiltered = RTHandles.Alloc(600, 100, 100, dimension: TextureDimension.Tex3D,
// colorFormat: GraphicsFormat.B10G11R11_UFloatPack32, name: "_RadianceCacheFiltered", enableRandomWrite: true);
}
private void AllocateDepthPyramidRT(Vector2Int PyramidRes, bool onlyRelease = false)
{
void ReleaseTextures()
{
HExtensions.HRelease(DepthPyramid);
HExtensions.HRelease(DepthIntermediate_Pyramid);
}
if (onlyRelease)
{
ReleaseTextures();
return;
}
ReleaseTextures();
DepthPyramid = RTHandles.Alloc(PyramidRes.x, PyramidRes.y, TextureXR.slices, dimension: TextureDimension.Tex2DArray, useMipMap: true, autoGenerateMips: false,
colorFormat: GraphicsFormat.R16_SFloat, name: "_DepthPyramid", enableRandomWrite: true);
DepthIntermediate_Pyramid = RTHandles.Alloc(PyramidRes.x / 16, PyramidRes.y / 16, TextureXR.slices, dimension: TextureDimension.Tex2DArray,
colorFormat: GraphicsFormat.R16_SFloat, name: "_DepthIntermediate_Pyramid", enableRandomWrite: true);
}
private void AllocateSSAO_RT(bool onlyRelease = false)
{
void ReleaseTextures()
{
HExtensions.HRelease(ProbeSSAO);
HExtensions.HRelease(NormalDepthHalf);
HExtensions.HRelease(BentNormalsAO);
HExtensions.HRelease(BentNormalsAO_Interpolated);
HExtensions.HRelease(BentNormalsAO_History);
HExtensions.HRelease(BentNormalsAO_Accumulated);
HExtensions.HRelease(BentNormalsAO_Samplecount);
HExtensions.HRelease(BentNormalsAO_SamplecountHistory);
}
if (onlyRelease)
{
ReleaseTextures();
return;
}
ReleaseTextures();
Vector2 fullRes = Vector2.one;
Vector2 halfRes = Vector2.one / 2;
Vector2 probeSize = Vector2.one / _probeSize;
// -------------------------------------- SSAO RT -------------------------------------- //
if (HResources.ScreenSpaceLightingData.DirectionalOcclusion)
{
ProbeSSAO = RTHandles.Alloc(probeSize, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R8_UNorm, name: "_ProbeSSAO", enableRandomWrite: true);
BentNormalsAO = RTHandles.Alloc(fullRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16B16A16_SFloat, name: "_BentNormalsAO", enableRandomWrite: true);
BentNormalsAO_Interpolated = RTHandles.Alloc(fullRes, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16B16A16_SFloat, name: "_BentNormalsAO_Interpolated", enableRandomWrite: true);
NormalDepthHalf = RTHandles.Alloc(fullRes / 2, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16B16A16_SFloat, name: "_NormalDepthHalf", enableRandomWrite: true);
// TODO: porbably we will no need these, leave them for now, but don't allocate.
// BentNormalsAO_History = RTHandles.Alloc(FullRes, TextureXR.slices, dimension: TextureXR.dimension,
// colorFormat: GraphicsFormat.R16G16B16A16_SFloat, name: "_BentNormalsAO_History", enableRandomWrite: true);
//
// BentNormalsAO_Accumulated = RTHandles.Alloc(FullRes, TextureXR.slices, dimension: TextureXR.dimension,
// colorFormat: GraphicsFormat.R16G16B16A16_SFloat, name: "_BentNormalsAO_Accumulated", enableRandomWrite: true);
//
// BentNormalsAO_SamplecountHistory = RTHandles.Alloc(FullRes, TextureXR.slices, dimension: TextureXR.dimension,
// colorFormat: GraphicsFormat.R8_UInt, name: "_BentNormalsAO_SamplecountHistory", enableRandomWrite: true);
//
// BentNormalsAO_Samplecount = RTHandles.Alloc(FullRes, TextureXR.slices, dimension: TextureXR.dimension,
// colorFormat: GraphicsFormat.R8_UInt, name: "_BentNormalsAO_Samplecount", enableRandomWrite: true);
}
else //Warnings suppression
{
ProbeSSAO = RTHandles.Alloc(1,1, 1, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R8_UNorm, name: "_ProbeSSAO", enableRandomWrite: true);
BentNormalsAO = RTHandles.Alloc(1,1, 1, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16B16A16_SFloat, name: "_BentNormalsAO", enableRandomWrite: true);
BentNormalsAO_Interpolated = RTHandles.Alloc(1,1, 1, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16B16A16_SFloat, name: "_BentNormalsAO_Interpolated", enableRandomWrite: true);
NormalDepthHalf = RTHandles.Alloc(1,1, 1, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16B16A16_SFloat, name: "_NormalDepthHalf", enableRandomWrite: true);
}
}
private void AllocateDebugRT(bool onlyRelease = false)
{
void ReleaseTextures()
{
HExtensions.HRelease(VoxelVisualizationRayDirections);
HExtensions.HRelease(DebugOutput);
}
if (onlyRelease)
{
ReleaseTextures();
return;
}
ReleaseTextures();
Vector2 fullRes = Vector2.one;
// -------------------------------------- DEBUG RT -------------------------------------- //
if (HResources.GeneralData.DebugModeWS != DebugModeWS.None)
{
VoxelVisualizationRayDirections = RTHandles.Alloc(fullRes, TextureXR.slices, dimension: TextureXR.dimension, useDynamicScale: true,
colorFormat: GraphicsFormat.R16G16B16A16_SFloat, name: "_VoxelVisualizationRayDirections", enableRandomWrite: true);
DebugOutput = RTHandles.Alloc(fullRes, TextureXR.slices, dimension: TextureDimension.Tex2DArray,
colorFormat: GraphicsFormat.B10G11R11_UFloatPack32, name: "_DebugOutput", enableRandomWrite: true);
}
}
private void AllocateIndirectionBuffers(Vector2Int resolution, bool onlyRelease = false)
{
void ReleaseTextures()
{
HExtensions.HRelease(IndirectCoordsSS);
HExtensions.HRelease(IndirectCoordsWS);
HExtensions.HRelease(IndirectCoordsOV);
HExtensions.HRelease(IndirectCoordsSF);
}
if (onlyRelease)
{
ReleaseTextures();
return;
}
ReleaseTextures();
// -------------------------------------- BUFFERS -------------------------------------- //
int resolutionMul = resolution.x * resolution.y;
IndirectCoordsSS = new ComputeBuffer(resolutionMul * TextureXR.slices, 2 * sizeof(uint));
IndirectCoordsWS = new ComputeBuffer(resolutionMul * TextureXR.slices, 2 * sizeof(uint));
IndirectCoordsOV = new ComputeBuffer(resolutionMul * TextureXR.slices, 2 * sizeof(uint));
IndirectCoordsSF = new ComputeBuffer(resolutionMul * TextureXR.slices, 2 * sizeof(uint));
}
private void ReallocHashBuffers(bool onlyRelease = false)
{
void ReleaseTextures()
{
HExtensions.HRelease(HashBuffer_Key);
HExtensions.HRelease(HashBuffer_Payload);
HExtensions.HRelease(HashBuffer_Counter);
HExtensions.HRelease(HashBuffer_Radiance);
HExtensions.HRelease(HashBuffer_Position);
}
if (onlyRelease)
{
ReleaseTextures();
return;
}
ReleaseTextures();
HashBuffer_Key = new ComputeBuffer(HashStorageSize, 1 * sizeof(uint));
HashBuffer_Payload = new ComputeBuffer(HashStorageSize / HashUpdateFraction, 2 * sizeof(uint));
HashBuffer_Counter = new ComputeBuffer(HashStorageSize, 1 * sizeof(uint));
HashBuffer_Radiance = new ComputeBuffer(HashStorageSize, 4 * sizeof(uint));
HashBuffer_Position = new ComputeBuffer(HashStorageSize, 4 * sizeof(uint));
}
#endregion
protected override void Setup(ScriptableRenderContext renderContext, CommandBuffer cmd)
{
name = HTraceNames.HTRACE_MAIN_PASS_NAME_FRAME_DEBUG;
ResourcesLoad();
MaterialSetup();
AllocTextures();
_firstFrame = true;
_probeSize = HResources.GeneralData.RayCountMode.ParseToProbeSize();
VoxelizationRuntimeData.OnReallocTextures += () => ReallocHashBuffers();
HResources.GeneralData.OnRayCountChanged += RayCountChanged;
}
private void RayCountChanged(RayCountMode rayCountMode)
{
_probeSize = rayCountMode.ParseToProbeSize();
AllocTextures();
}
private void AllocTextures()
{
#if UNITY_EDITOR
if (Application.isPlaying == false) // if unity_editor we need only 1 eye render
TextureXR.maxViews = 1;
#endif
AllocateMainRT();
AllocateSSAO_RT();
ReallocHashBuffers();
AllocateDebugRT();
}
Vector2Int CalculateDepthPyramidResolution(Vector2Int screenResolution, int lowestMipLevel)
{
int lowestMipScale = (int)Mathf.Pow(2.0f, lowestMipLevel);
Vector2Int lowestMipResolutiom = new Vector2Int(Mathf.CeilToInt( (float)screenResolution.x / (float)lowestMipScale),
Mathf.CeilToInt( (float)screenResolution.y / (float)lowestMipScale));
Vector2Int paddedDepthPyramidResolution = lowestMipResolutiom * lowestMipScale;
return paddedDepthPyramidResolution;
}
Matrix4x4 ComputeFrustumCorners(Camera cam)
{
Transform cameraTransform = cam.transform;
Vector3[] frustumCorners = new Vector3[4];
cam.CalculateFrustumCorners(new Rect(0, 0, 1 / cam.rect.xMax, 1 / cam.rect.yMax), cam.farClipPlane, cam.stereoActiveEye, frustumCorners);
Vector3 bottomLeft = cameraTransform.TransformVector(frustumCorners[1]);
Vector3 topLeft = cameraTransform.TransformVector(frustumCorners[0]);
Vector3 bottomRight = cameraTransform.TransformVector(frustumCorners[2]);
Matrix4x4 frustumVectorsArray = Matrix4x4.identity;
frustumVectorsArray.SetRow(0, bottomLeft);
frustumVectorsArray.SetRow(1, bottomLeft + (bottomRight - bottomLeft) * 2);
frustumVectorsArray.SetRow(2, bottomLeft + (topLeft - bottomLeft) * 2);
return frustumVectorsArray;
}
protected override void Execute(CustomPassContext ctx)
{
var cmdList = ctx.cmd;
var camera = ctx.hdCamera.camera;
cmdList.SetGlobalTexture(g_HTraceBufferGI, RadianceAccumulated);
#if UNITY_EDITOR
if (HExtensions.PipelineSupportsSSGI == false)
return;
#endif
Texture VoxelData = Shader.GetGlobalTexture(g_VoxelPositionPyramid);
if (VoxelData == null || VoxelData.width != HResources.VoxelizationData.ExactData.Resolution.x)
return;
Texture ShadowmapData = Shader.GetGlobalTexture(g_HTraceShadowmap);
if (ShadowmapData == null || ShadowmapData.width != 2048)
return;
bool UseAPVMultibounce = HResources.DebugData.TestCheckbox;
;
cmdList.SetGlobalInt(g_TestCheckbox, HResources.DebugData.TestCheckbox ? 1 : 0);
HFrameIndex = HFrameIndex > 15 ? 0 : HFrameIndex;
HashUpdateFrameIndex = HashUpdateFrameIndex > HashUpdateFraction ? 0 : HashUpdateFrameIndex;
cmdList.SetGlobalInt(g_ProbeSize, _probeSize);
cmdList.SetGlobalInt(g_OctahedralSize, _octahedralSize);
cmdList.SetGlobalInt(g_HFrameIndex, HFrameIndex);
cmdList.SetGlobalInt(g_ReprojectSkippedFrame, Time.frameCount % 8 == 0 ? 1 : 0);
cmdList.SetGlobalInt(g_PersistentHistorySamples, PersistentHistorySamples);
// Constants set
cmdList.SetGlobalFloat(g_SkyOcclusionCone, HConfig.SkyOcclusionCone);
cmdList.SetGlobalFloat(g_DirectionalLightIntensity, HConfig.DirectionalLightIntensity);
cmdList.SetGlobalFloat(g_SurfaceDiffuseIntensity, HConfig.SurfaceDiffuseIntensity);
cmdList.SetGlobalFloat(g_SkyLightIntensity, HConfig.SkyLightIntensity);
//cmdList.SetGlobalInt("_TestCheckbox", DebugData.TestCheckbox == true ? 1 : 0);
cmdList.SetGlobalInt(g_ReprojectSkippedFrame, 0);
int screenResX = ctx.hdCamera.actualWidth;
int screenResY = ctx.hdCamera.actualHeight;
if (screenResX != PrevScreenResolution.x || screenResY != PrevScreenResolution.y)
{
DepthPyramidResolution = CalculateDepthPyramidResolution(new Vector2Int(screenResX, screenResY), 7);
AllocateDepthPyramidRT(DepthPyramidResolution);
AllocateIndirectionBuffers(new Vector2Int(screenResX, screenResY));
}
PrevScreenResolution = new Vector2Int(screenResX, screenResY);
// Calculate Resolution for Compute Shaders
Vector2Int runningRes = new Vector2Int(screenResX, screenResY);
Vector2 probeAtlasRes = runningRes * Vector2.one / _probeSize * _octahedralSize;
//Dispatch resolutions
int fullResX_8 = Mathf.CeilToInt((float)runningRes.x / 8);
int fullResY_8 = Mathf.CeilToInt((float)runningRes.y / 8);
int probeResX_8 = Mathf.CeilToInt(((float)runningRes.x / (float)_probeSize / 8.0f));
int probeResY_8 = Mathf.CeilToInt(((float)runningRes.y / (float)_probeSize / 8.0f));
int probeAtlasResX_8 = Mathf.CeilToInt((Mathf.CeilToInt((float)runningRes.x / (float)_probeSize) * (float)_octahedralSize) / 8);
int probeAtlasResY_8 = Mathf.CeilToInt((Mathf.CeilToInt((float)runningRes.y / (float)_probeSize) * (float)_octahedralSize) / 8);
bool useDirectionalOcclusion = HResources.ScreenSpaceLightingData.DirectionalOcclusion && HResources.ScreenSpaceLightingData.OcclusionIntensity > Single.Epsilon;
if (_prevDirectionalOcclusion != useDirectionalOcclusion)
AllocateSSAO_RT(!useDirectionalOcclusion); //release when disable occlusion
_prevDirectionalOcclusion = useDirectionalOcclusion;
if (_prevDebugModeEnabled == (HResources.GeneralData.DebugModeWS == DebugModeWS.None))
AllocateDebugRT(HResources.GeneralData.DebugModeWS == DebugModeWS.None); //release when disable debug
_prevDebugModeEnabled = HResources.GeneralData.DebugModeWS != DebugModeWS.None;
bool DiffuseBufferUnavailable = false;
Texture DiffuseBuffer = Shader.GetGlobalTexture(g_Gbuffertexture0);
if (DiffuseBuffer == null || HExtensions.HdrpAsset.currentPlatformRenderPipelineSettings.supportedLitShaderMode == RenderPipelineSettings.SupportedLitShaderMode.ForwardOnly || ctx.hdCamera.frameSettings.litShaderMode == LitShaderMode.Forward)
DiffuseBufferUnavailable = true;
ctx.cmd.SetGlobalBuffer(g_HashBuffer_Key, HashBuffer_Key);
ctx.cmd.SetGlobalBuffer(g_HashBuffer_Payload, HashBuffer_Payload);
ctx.cmd.SetGlobalBuffer(g_HashBuffer_Counter, HashBuffer_Counter);
ctx.cmd.SetGlobalBuffer(g_HashBuffer_Radiance, HashBuffer_Radiance);
ctx.cmd.SetGlobalBuffer(g_HashBuffer_Position, HashBuffer_Position);
ctx.cmd.SetGlobalInt(g_HashStorageSize, HashStorageSize);
ctx.cmd.SetGlobalInt(g_HashUpdateFraction, HashUpdateFraction);
cmdList.SetGlobalTexture(g_GeometryNormal, GeometryNormal);
cmdList.SetGlobalTexture(g_HTraceBufferGI, RadianceAccumulated);
if (camera.cameraType == CameraType.Reflection)
return;
if (_startFrameCounter < 2) { _startFrameCounter++; return; }
// ---------------------------------------- Compose Motion Vectors ---------------------------------------- //
using (new ProfilingScope(cmdList, s_ComposeMotionVectorsProfilingSampler))
{
MotionVectorsMaterial.SetInt(_StencilRef, 32);
MotionVectorsMaterial.SetInt(_StencilMask, 32);
CoreUtils.SetRenderTarget(cmdList, CustomCameraMotionVectors, ClearFlag.Color);
if (ctx.cameraDepthBuffer.rt.volumeDepth == TextureXR.slices)
cmdList.CopyTexture(ctx.cameraMotionVectorsBuffer, CustomCameraMotionVectors);
CoreUtils.DrawFullScreen(ctx.cmd, MotionVectorsMaterial, CustomCameraMotionVectors, ctx.cameraDepthBuffer, shaderPassId: 0, properties: ctx.propertyBlock);
cmdList.SetGlobalTexture(g_CustomMotionVectors, CustomCameraMotionVectors);
}
// ---------------------------------------- DEPTH PYRAMID GENERATION ---------------------------------------- //
using (new ProfilingScope(cmdList, s_DepthPyramidGenerationProfilingSampler))
{
int depthPyramidResX = DepthPyramidResolution.x / 16;
int depthPyramidResY = DepthPyramidResolution.y / 16;
// Generate 0-4 mip levels
int generateDepthPyramid_1_Kernel = HDepthPyramid.FindKernel("GenerateDepthPyramid_1");
cmdList.SetComputeTextureParam(HDepthPyramid, generateDepthPyramid_1_Kernel, _DepthPyramid_OutputMIP0, DepthPyramid, 0);
cmdList.SetComputeTextureParam(HDepthPyramid, generateDepthPyramid_1_Kernel, _DepthPyramid_OutputMIP1, DepthPyramid, 1);
cmdList.SetComputeTextureParam(HDepthPyramid, generateDepthPyramid_1_Kernel, _DepthPyramid_OutputMIP2, DepthPyramid, 2);
cmdList.SetComputeTextureParam(HDepthPyramid, generateDepthPyramid_1_Kernel, _DepthPyramid_OutputMIP3, DepthPyramid, 3);
cmdList.SetComputeTextureParam(HDepthPyramid, generateDepthPyramid_1_Kernel, _DepthPyramid_OutputMIP4, DepthPyramid, 4);
cmdList.SetComputeTextureParam(HDepthPyramid, generateDepthPyramid_1_Kernel, _DepthIntermediate_Output, DepthIntermediate_Pyramid);
cmdList.DispatchCompute(HDepthPyramid, generateDepthPyramid_1_Kernel, depthPyramidResX, depthPyramidResY, TextureXR.slices);
// Generate 5-7 mip levels
int generateDepthPyramid_2_Kernel = HDepthPyramid.FindKernel("GenerateDepthPyramid_2");
cmdList.SetComputeTextureParam(HDepthPyramid, generateDepthPyramid_2_Kernel, _DepthIntermediate, DepthIntermediate_Pyramid);
cmdList.SetComputeTextureParam(HDepthPyramid, generateDepthPyramid_2_Kernel, _DepthPyramid_OutputMIP5, DepthPyramid, 5);
cmdList.SetComputeTextureParam(HDepthPyramid, generateDepthPyramid_2_Kernel, _DepthPyramid_OutputMIP6, DepthPyramid, 6);
cmdList.SetComputeTextureParam(HDepthPyramid, generateDepthPyramid_2_Kernel, _DepthPyramid_OutputMIP7, DepthPyramid, 7);
cmdList.SetComputeTextureParam(HDepthPyramid, generateDepthPyramid_2_Kernel, _DepthPyramid_OutputMIP8, DepthPyramid, 8);
cmdList.DispatchCompute(HDepthPyramid, generateDepthPyramid_2_Kernel, depthPyramidResX / 8, depthPyramidResY / 8, TextureXR.slices);
}
using (new ProfilingScope(cmdList, s_RenderAmbientOcclsuionProfilingSampler))
{
int computeResX_GI = (runningRes.x / 2 + 8 - 1) / 8;
int computeResY_GI = (runningRes.y / 2 + 8 - 1) / 8;
if (useDirectionalOcclusion)
{
HInterpolation.EnableKeyword("USE_DIRECTIONAL_OCCLUSION");
HSpatialPrepass.EnableKeyword("USE_DIRECTIONAL_OCCLUSION");
int horizonTracing_Kernel = HRenderAO.FindKernel("HorizonTracing");
cmdList.SetComputeTextureParam(HRenderAO, horizonTracing_Kernel, _DepthPyramid, DepthPyramid);
cmdList.SetComputeTextureParam(HRenderAO, horizonTracing_Kernel, _BentNormalAmbientOcclusion_Output, BentNormalsAO);
cmdList.SetComputeTextureParam(HRenderAO, horizonTracing_Kernel, _NormalDepthHalf_Output, NormalDepthHalf);
cmdList.SetComputeFloatParam(HRenderAO, _Camera_FOV, camera.fieldOfView);
cmdList.DispatchCompute(HRenderAO, horizonTracing_Kernel, computeResX_GI, computeResY_GI, TextureXR.slices);
int occlusionInterpolation_Kernel = HRenderAO.FindKernel("OcclusionInterpolation");
cmdList.SetComputeTextureParam(HRenderAO, occlusionInterpolation_Kernel, _AmbientOcclusion, BentNormalsAO);
cmdList.SetComputeTextureParam(HRenderAO, occlusionInterpolation_Kernel, _NormalDepthHalf, NormalDepthHalf);
cmdList.SetComputeTextureParam(HRenderAO, occlusionInterpolation_Kernel, _BentNormalAO_Output, BentNormalsAO_Interpolated);
cmdList.SetComputeTextureParam(HRenderAO, occlusionInterpolation_Kernel, _GeometryNormal_Output, GeometryNormal);
cmdList.DispatchCompute(HRenderAO, occlusionInterpolation_Kernel, fullResX_8, fullResY_8, TextureXR.slices);
}
else
{
HInterpolation.DisableKeyword("USE_DIRECTIONAL_OCCLUSION");
HSpatialPrepass.DisableKeyword("USE_DIRECTIONAL_OCCLUSION");
}
}
// ---------------------------------------- PROBE GBUFFER DOWNSAMPLING ---------------------------------------- //
using (new ProfilingScope(cmdList, s_ProbeGBufferDownsamplingProfilingSampler))
{
// Fill sample offsets for disk filters
int pointDistributionFill_Kernel = HSpatialPrepass.FindKernel("PointDistributionFill");
cmdList.SetComputeBufferParam(HSpatialPrepass, pointDistributionFill_Kernel, _PointDistribution_Output, PointDistributionBuffer);
cmdList.DispatchCompute(HSpatialPrepass, pointDistributionFill_Kernel, 1, 1, 1);
// Fill 4x4 spatial offset buffer
int spatialOffsetsBufferFill_Kernel = HSpatialPrepass.FindKernel("SpatialOffsetsBufferFill");
cmdList.SetComputeBufferParam(HSpatialPrepass, spatialOffsetsBufferFill_Kernel, _SpatialOffsetsBuffer_Output, SpatialOffsetsBuffer);
cmdList.DispatchCompute(HSpatialPrepass, spatialOffsetsBufferFill_Kernel, 1, 1, 1);
// Calculate geometry normals
if (!useDirectionalOcclusion)
{
int geometryNormals_Kernel = HSpatialPrepass.FindKernel("GeometryNormals");
cmdList.SetComputeTextureParam(HSpatialPrepass, geometryNormals_Kernel, _GeometryNormal_Output, GeometryNormal);
cmdList.DispatchCompute(HSpatialPrepass, geometryNormals_Kernel, fullResX_8, fullResY_8, TextureXR.slices);
}
if (DiffuseBufferUnavailable) HSpatialPrepass.EnableKeyword("DIFFUSE_BUFFER_UNAVAILABLE");
if (!DiffuseBufferUnavailable) HSpatialPrepass.DisableKeyword("DIFFUSE_BUFFER_UNAVAILABLE");
// Downsample depth, normal, diffuse and ambient occlusion
int gBufferDownsample_Kernel = HSpatialPrepass.FindKernel("GBufferDownsample");
cmdList.SetComputeTextureParam(HSpatialPrepass, gBufferDownsample_Kernel, _GeometryNormal, GeometryNormal);
cmdList.SetComputeTextureParam(HSpatialPrepass, gBufferDownsample_Kernel, _ProbeNormalDepth_Output, ProbeNormalDepth_Intermediate);
cmdList.SetComputeTextureParam(HSpatialPrepass, gBufferDownsample_Kernel, _ProbeDiffuse_Output, ProbeDiffuse);
cmdList.SetComputeTextureParam(HSpatialPrepass, gBufferDownsample_Kernel, _SSAO, BentNormalsAO_Interpolated);
cmdList.SetComputeTextureParam(HSpatialPrepass, gBufferDownsample_Kernel, _ProbeSSAO_Output, ProbeSSAO);
cmdList.DispatchCompute(HSpatialPrepass, gBufferDownsample_Kernel, probeResX_8, probeResY_8, TextureXR.slices);
// Smooth geometry normals
int geometryNormalsSmoothing_Kernel = HSpatialPrepass.FindKernel("GeometryNormalsSmoothing");
cmdList.SetComputeTextureParam(HSpatialPrepass, geometryNormalsSmoothing_Kernel, _ProbeNormalDepth, ProbeNormalDepth_Intermediate);
cmdList.SetComputeTextureParam(HSpatialPrepass, geometryNormalsSmoothing_Kernel, _ProbeNormalDepth_Output, ProbeNormalDepth);
cmdList.DispatchCompute(HSpatialPrepass, geometryNormalsSmoothing_Kernel, probeResX_8, probeResY_8, TextureXR.slices);
}
// ---------------------------------------- PROBE TEMPORAL REPROJECTION ---------------------------------------- //
using (new ProfilingScope(cmdList, s_ProbeTemporalReprojectionProfilingSampler))
{
int probeReprojection_Kernel = HTemporalReprojection.FindKernel("ProbeReprojection");
cmdList.SetComputeTextureParam(HTemporalReprojection, probeReprojection_Kernel, _HistoryIndirection, HistoryIndirection);
cmdList.SetComputeTextureParam(HTemporalReprojection, probeReprojection_Kernel, _ProbeNormalDepth, ProbeNormalDepth);
cmdList.SetComputeTextureParam(HTemporalReprojection, probeReprojection_Kernel, _ProbeWorldPosNormal_History, ProbeWorldPosNormal_History);
cmdList.SetComputeTextureParam(HTemporalReprojection, probeReprojection_Kernel, _ReprojectionCoords_Output, ReprojectionCoord);
cmdList.SetComputeTextureParam(HTemporalReprojection, probeReprojection_Kernel, _ReprojectionWeights_Output, ReprojectionWeights);
cmdList.SetComputeTextureParam(HTemporalReprojection, probeReprojection_Kernel, _PersistentReprojectionWeights_Output, PersistentReprojectionWeights);
cmdList.SetComputeTextureParam(HTemporalReprojection, probeReprojection_Kernel, _PersistentReprojectionCoord_Output, PersistentReprojectionCoord);
cmdList.DispatchCompute(HTemporalReprojection, probeReprojection_Kernel, probeResX_8, probeResY_8, TextureXR.slices);
}
// ---------------------------------------- RAY GENERATION ---------------------------------------- //
using (new ProfilingScope(cmdList, s_RayGenerationProfilingSampler))
{
// Generate ray directions and compute lists of indirectly dispatched threads
int rayGeneration_Kernel = HRayGeneration.FindKernel("RayGeneration");
cmdList.SetComputeTextureParam(HRayGeneration, rayGeneration_Kernel, _ProbeNormalDepth, ProbeNormalDepth);
cmdList.SetComputeTextureParam(HRayGeneration, rayGeneration_Kernel, _ReprojectionCoords, ReprojectionCoord);
cmdList.SetComputeTextureParam(HRayGeneration, rayGeneration_Kernel, _RayDirectionsJittered_Output, RayDirections);
cmdList.SetComputeBufferParam(HRayGeneration, rayGeneration_Kernel, _IndirectCoordsSS_Output, IndirectCoordsSS);
cmdList.SetComputeBufferParam(HRayGeneration, rayGeneration_Kernel, _IndirectCoordsOV_Output, IndirectCoordsOV);
cmdList.SetComputeBufferParam(HRayGeneration, rayGeneration_Kernel, _IndirectCoordsSF_Output, IndirectCoordsSF);
cmdList.SetComputeBufferParam(HRayGeneration, rayGeneration_Kernel, _RayCounter_Output, RayCounter);
cmdList.DispatchCompute(HRayGeneration, rayGeneration_Kernel, probeAtlasResX_8, probeAtlasResY_8, TextureXR.slices);
// Prepare arguments for screen space indirect dispatch
int indirectArguments_Kernel = HRayGeneration.FindKernel("IndirectArguments");
cmdList.SetComputeBufferParam(HRayGeneration, indirectArguments_Kernel, _RayCounter, RayCounter);
cmdList.SetComputeBufferParam(HRayGeneration, indirectArguments_Kernel, _TracingCoords, IndirectCoordsSS);
cmdList.SetComputeBufferParam(HRayGeneration, indirectArguments_Kernel, _IndirectArguments_Output, IndirectArgumentsSS);
cmdList.SetComputeIntParam(HRayGeneration, _RayCounterIndex, 0);
cmdList.DispatchCompute(HRayGeneration, indirectArguments_Kernel, 1, 1, TextureXR.slices);
// Prepare arguments for occlusion validation indirect dispatch
cmdList.SetComputeBufferParam(HRayGeneration, indirectArguments_Kernel, _RayCounter, RayCounter);
cmdList.SetComputeBufferParam(HRayGeneration, indirectArguments_Kernel, _TracingCoords, IndirectCoordsOV);
cmdList.SetComputeBufferParam(HRayGeneration, indirectArguments_Kernel, _IndirectArguments_Output, IndirectArgumentsOV);
cmdList.SetComputeIntParam(HRayGeneration, _RayCounterIndex, 1);
cmdList.DispatchCompute(HRayGeneration, indirectArguments_Kernel, 1, 1, TextureXR.slices);
// Prepare arguments for spatial filter indirect dispatch
cmdList.SetComputeBufferParam(HRayGeneration, indirectArguments_Kernel, _RayCounter, RayCounter);
cmdList.SetComputeBufferParam(HRayGeneration, indirectArguments_Kernel, _TracingCoords, IndirectCoordsSF);
cmdList.SetComputeBufferParam(HRayGeneration, indirectArguments_Kernel, _IndirectArguments_Output, IndirectArgumentsSF);
cmdList.SetComputeIntParam(HRayGeneration, _RayCounterIndex, 2);
cmdList.DispatchCompute(HRayGeneration, indirectArguments_Kernel, 1, 1, TextureXR.slices);
}
// ---------------------------------------- CLEAR CHECKERBOARD TARGETS ---------------------------------------- //
using (new ProfilingScope(cmdList, s_ClearTargetsProfilingSampler))
{
// Clear hit targets
CoreUtils.SetRenderTarget(ctx.cmd, HitDistanceScreenSpace, ClearFlag.Color, Color.clear, 0, CubemapFace.Unknown, -1);
CoreUtils.SetRenderTarget(ctx.cmd, HitDistanceWorldSpace, ClearFlag.Color, Color.clear, 0, CubemapFace.Unknown, -1);
CoreUtils.SetRenderTarget(ctx.cmd, HitCoordScreenSpace, ClearFlag.Color, Color.clear, 0, CubemapFace.Unknown, -1);
CoreUtils.SetRenderTarget(ctx.cmd, HitRadiance, ClearFlag.Color, Color.clear, 0, CubemapFace.Unknown, -1);
// Clear voxel payload targets
CoreUtils.SetRenderTarget(ctx.cmd, VoxelPayload, ClearFlag.Color, Color.clear, 0, CubemapFace.Unknown, -1);
}
if (VoxelizationRuntimeData.VoxelizationModeChanged == true) return;
// ---------------------------------------- SCREEN SPACE LIGHTING ---------------------------------------- //
using (new ProfilingScope(cmdList, s_ScreenSpaceLightingProfilingSampler))
{
var color_History = ctx.hdCamera.GetPreviousFrameRT((int)HDCameraFrameHistoryType.ColorBufferMipChain);
if (HResources.ScreenSpaceLightingData.EvaluateHitLighting && !DiffuseBufferUnavailable) HTracingScreenSpace.EnableKeyword("HIT_SCREEN_SPACE_LIGHTING");
if (!HResources.ScreenSpaceLightingData.EvaluateHitLighting || DiffuseBufferUnavailable) HTracingScreenSpace.DisableKeyword("HIT_SCREEN_SPACE_LIGHTING");
// Trace screen-space rays
int tracingSS_Kernel = HTracingScreenSpace.FindKernel("ScreenSpaceTracing");
cmdList.SetComputeTextureParam(HTracingScreenSpace, tracingSS_Kernel, _ColorPyramid_History, color_History);
cmdList.SetComputeTextureParam(HTracingScreenSpace, tracingSS_Kernel, _ProbeNormalDepth, ProbeNormalDepth);
cmdList.SetComputeTextureParam(HTracingScreenSpace, tracingSS_Kernel, _NormalDepth_History, NormalDepth_History);
cmdList.SetComputeTextureParam(HTracingScreenSpace, tracingSS_Kernel, _DepthPyramid, DepthPyramid);
cmdList.SetComputeTextureParam(HTracingScreenSpace, tracingSS_Kernel, _GeometryNormal, GeometryNormal);
cmdList.SetComputeTextureParam(HTracingScreenSpace, tracingSS_Kernel, _RayDirection, RayDirections);
cmdList.SetComputeTextureParam(HTracingScreenSpace, tracingSS_Kernel, _HitRadiance_Output, HitRadiance);
cmdList.SetComputeTextureParam(HTracingScreenSpace, tracingSS_Kernel, _HitDistance_Output, HitDistanceScreenSpace);
cmdList.SetComputeTextureParam(HTracingScreenSpace, tracingSS_Kernel, _HitCoord_Output, HitCoordScreenSpace);
cmdList.SetComputeBufferParam(HTracingScreenSpace, tracingSS_Kernel, _RayCounter, RayCounter);
cmdList.SetComputeBufferParam(HTracingScreenSpace, tracingSS_Kernel, _TracingCoords, IndirectCoordsSS);
cmdList.SetComputeIntParam(HTracingScreenSpace, _IndexXR, 0);
cmdList.DispatchCompute(HTracingScreenSpace, tracingSS_Kernel, IndirectArgumentsSS, 0);
if (TextureXR.slices > 1)
{
cmdList.SetComputeIntParam(HTracingScreenSpace, _IndexXR, 1);
cmdList.DispatchCompute(HTracingScreenSpace, tracingSS_Kernel, IndirectArgumentsSS, sizeof(uint) * 3);
}
// Evaluate screen-space hit it requested
if (HResources.ScreenSpaceLightingData.EvaluateHitLighting && !DiffuseBufferUnavailable)
{
int lightEvaluationSS_Kernel = HTracingScreenSpace.FindKernel("LightEvaluation");
cmdList.SetComputeTextureParam(HTracingScreenSpace, lightEvaluationSS_Kernel, _ColorPyramid_History, color_History);
cmdList.SetComputeTextureParam(HTracingScreenSpace, lightEvaluationSS_Kernel, _Radiance_History, RadianceAccumulated);
cmdList.SetComputeTextureParam(HTracingScreenSpace, lightEvaluationSS_Kernel, _GeometryNormal, GeometryNormal);
cmdList.SetComputeTextureParam(HTracingScreenSpace, lightEvaluationSS_Kernel, _HitCoord, HitCoordScreenSpace);
cmdList.SetComputeTextureParam(HTracingScreenSpace, lightEvaluationSS_Kernel, _HitRadiance_Output, HitRadiance);
cmdList.SetComputeBufferParam(HTracingScreenSpace, lightEvaluationSS_Kernel, _RayCounter, RayCounter);
cmdList.SetComputeBufferParam(HTracingScreenSpace, lightEvaluationSS_Kernel, _TracingCoords, IndirectCoordsSS);
cmdList.SetComputeIntParam(HTracingScreenSpace, _IndexXR, 0);
cmdList.DispatchCompute(HTracingScreenSpace, lightEvaluationSS_Kernel, IndirectArgumentsSS, 0);
if (TextureXR.slices > 1)
{
cmdList.SetComputeIntParam(HTracingScreenSpace, _IndexXR, 1);
cmdList.DispatchCompute(HTracingScreenSpace, lightEvaluationSS_Kernel, IndirectArgumentsSS, sizeof(uint) * 3);
}
}
}
// ---------------------------------------- RAY COMPACTION ---------------------------------------- //
using (new ProfilingScope(cmdList, s_RayCompactionProfilingSampler))
{
// Compact rays
int rayCompactionKernel = HRayGeneration.FindKernel("RayCompaction");
cmdList.SetComputeTextureParam(HRayGeneration, rayCompactionKernel, _HitDistance, HitDistanceScreenSpace);
cmdList.SetComputeTextureParam(HRayGeneration, rayCompactionKernel, _HitDistance_Output, HitDistanceWorldSpace);
cmdList.SetComputeBufferParam(HRayGeneration, rayCompactionKernel, _RayCounter, RayCounter);
cmdList.SetComputeBufferParam(HRayGeneration, rayCompactionKernel, _TracingCoords, IndirectCoordsSS);
cmdList.SetComputeBufferParam(HRayGeneration, rayCompactionKernel, _TracingRayCounter_Output, RayCounterWS);
cmdList.SetComputeBufferParam(HRayGeneration, rayCompactionKernel, _TracingCoords_Output, IndirectCoordsWS);
cmdList.SetComputeIntParam(HRayGeneration, _IndexXR, 0);
cmdList.DispatchCompute(HRayGeneration, rayCompactionKernel, IndirectArgumentsSS, 0);
if (TextureXR.slices > 1)
{
cmdList.SetComputeIntParam(HRayGeneration, _IndexXR, 1);
cmdList.DispatchCompute(HRayGeneration, rayCompactionKernel, IndirectArgumentsSS, sizeof(uint) * 3);
}
// Prepare indirect arguments for world space lighting
int indirectArgumentsKernel = HRayGeneration.FindKernel("IndirectArguments");
cmdList.SetComputeBufferParam(HRayGeneration, indirectArgumentsKernel, _RayCounter, RayCounterWS);
cmdList.SetComputeBufferParam(HRayGeneration, indirectArgumentsKernel, _TracingCoords, IndirectCoordsWS);
cmdList.SetComputeBufferParam(HRayGeneration, indirectArgumentsKernel, _IndirectArguments_Output, IndirectArgumentsWS);
cmdList.SetComputeIntParam(HRayGeneration, _RayCounterIndex, 0);
cmdList.DispatchCompute(HRayGeneration, indirectArgumentsKernel, 1, 1, TextureXR.slices);
}
// TDR timeout protection
if (_firstFrame == true) { _firstFrame = false; return; }
// ---------------------------------------- WORLD SPACE LIGHTING ---------------------------------------- //
using (new ProfilingScope(cmdList, s_WorldSpaceLightingProfilingSampler))
{
if (HResources.GeneralData.Multibounce == Multibounce.None) { HTracingWorldSpace.DisableKeyword("MULTIBOUNCE_CACHE"); HTracingWorldSpace.DisableKeyword("MULTIBOUNCE_APV"); HTracingWorldSpace.EnableKeyword("MULTIBOUNCE_OFF"); }
if (HResources.GeneralData.Multibounce == Multibounce.IrradianceCache) { HTracingWorldSpace.DisableKeyword("MULTIBOUNCE_OFF"); HTracingWorldSpace.DisableKeyword("MULTIBOUNCE_APV"); HTracingWorldSpace.EnableKeyword("MULTIBOUNCE_CACHE"); }
if (HResources.GeneralData.Multibounce == Multibounce.AdaptiveProbeVolumes) { HTracingWorldSpace.DisableKeyword("MULTIBOUNCE_CACHE"); HTracingWorldSpace.DisableKeyword("MULTIBOUNCE_OFF"); HTracingWorldSpace.EnableKeyword("MULTIBOUNCE_APV"); }
// Trace world-space rays
using (new ProfilingScope(cmdList, s_WorldSpaceTracingProfilingSampler))
{
int wsTracingKernel = HTracingWorldSpace.FindKernel("WorldSpaceTracing");
cmdList.SetComputeTextureParam(HTracingWorldSpace, wsTracingKernel, _DepthPyramid, DepthPyramid);
cmdList.SetComputeTextureParam(HTracingWorldSpace, wsTracingKernel, _HitDistance, HitDistanceScreenSpace);
cmdList.SetComputeTextureParam(HTracingWorldSpace, wsTracingKernel, _ProbeNormalDepth, ProbeNormalDepth);
cmdList.SetComputeTextureParam(HTracingWorldSpace, wsTracingKernel, _GeometryNormal, GeometryNormal);
cmdList.SetComputeTextureParam(HTracingWorldSpace, wsTracingKernel, _RayDirection, RayDirections);
cmdList.SetComputeTextureParam(HTracingWorldSpace, wsTracingKernel, _HitDistance_Output, HitDistanceWorldSpace);
cmdList.SetComputeTextureParam(HTracingWorldSpace, wsTracingKernel, _VoxelPayload_Output, VoxelPayload);
cmdList.SetComputeTextureParam(HTracingWorldSpace, wsTracingKernel, _HitRadiance_Output, HitRadiance);
cmdList.SetComputeBufferParam(HTracingWorldSpace, wsTracingKernel, _PointDistribution, PointDistributionBuffer);
cmdList.SetComputeBufferParam(HTracingWorldSpace, wsTracingKernel, _TracingCoords, IndirectCoordsWS);
cmdList.SetComputeBufferParam(HTracingWorldSpace, wsTracingKernel, _RayCounter, RayCounterWS);
cmdList.SetComputeFloatParam(HTracingWorldSpace, _RayLength, HResources.GeneralData.RayLength);
cmdList.SetComputeIntParam(HTracingWorldSpace, _IndexXR, 0);
cmdList.DispatchCompute(HTracingWorldSpace, wsTracingKernel, IndirectArgumentsWS, 0);
if (TextureXR.slices > 1)
{
cmdList.SetComputeIntParam(HTracingWorldSpace, _IndexXR, 1);
cmdList.DispatchCompute(HTracingWorldSpace, wsTracingKernel, IndirectArgumentsWS, sizeof(uint) * 3);
}
}
// Evaluate world-space lighting
using (new ProfilingScope(cmdList, s_LightEvaluationProfilingSampler))
{
int lightEvaluation_Kernel = HTracingWorldSpace.FindKernel("LightEvaluation");
cmdList.SetComputeTextureParam(HTracingWorldSpace, lightEvaluation_Kernel, _VoxelPayload, VoxelPayload);
cmdList.SetComputeTextureParam(HTracingWorldSpace, lightEvaluation_Kernel, _ProbeNormalDepth, ProbeNormalDepth);
cmdList.SetComputeTextureParam(HTracingWorldSpace, lightEvaluation_Kernel, _HitRadiance_Output, HitRadiance);
cmdList.SetComputeBufferParam(HTracingWorldSpace, lightEvaluation_Kernel, _TracingCoords, IndirectCoordsWS);
cmdList.SetComputeBufferParam(HTracingWorldSpace, lightEvaluation_Kernel, _RayCounter, RayCounterWS);
cmdList.SetComputeIntParam(HTracingWorldSpace, _IndexXR, 0);
cmdList.DispatchCompute(HTracingWorldSpace, lightEvaluation_Kernel, IndirectArgumentsWS, 0);
if (TextureXR.slices > 1)
{
cmdList.SetComputeIntParam(HTracingWorldSpace, _IndexXR, 1);
cmdList.DispatchCompute(HTracingWorldSpace, lightEvaluation_Kernel, IndirectArgumentsWS, sizeof(uint) * 3);
}
}
}
// ---------------------------------------- RADIANCE CACHING ---------------------------------------- //
using (new ProfilingScope(cmdList, s_RadianceCachingProfilingSampler))
{
if (HResources.GeneralData.Multibounce == Multibounce.IrradianceCache)
{
HRadianceCache.SetInt(_HashUpdateFrameIndex, HashUpdateFrameIndex);
// Cache tracing update
using (new ProfilingScope(cmdList, s_CacheTracingUpdateProfilingSampler))
{
int cacheTracingUpdate_Kernel = HRadianceCache.FindKernel("CacheTracingUpdate");
cmdList.SetComputeFloatParam(HRadianceCache, _RayLength, HResources.GeneralData.RayLength);
cmdList.DispatchCompute(HRadianceCache, cacheTracingUpdate_Kernel, (HashStorageSize / HashUpdateFraction) / 64, 1, 1);
}
// Cache light evaluation at hit points
using (new ProfilingScope(cmdList, s_CacheLightEvaluationProfilingSampler))
{
int cacheLightEvaluation_Kernel = HRadianceCache.FindKernel("CacheLightEvaluation");
cmdList.DispatchCompute(HRadianceCache, cacheLightEvaluation_Kernel, (HashStorageSize / HashUpdateFraction) / 64, 1, 1);
}
// Cache writing at primary surfaces
using (new ProfilingScope(cmdList, s_PrimaryCacheSpawnProfilingSampler))
{
int cachePrimarySpawn_Kernel = HRadianceCache.FindKernel("CachePrimarySpawn");
cmdList.SetComputeTextureParam(HRadianceCache, cachePrimarySpawn_Kernel, _ReprojectionCoords, ReprojectionCoord);
cmdList.SetComputeTextureParam(HRadianceCache, cachePrimarySpawn_Kernel, _ProbeNormalDepth, ProbeNormalDepth);
cmdList.SetComputeTextureParam(HRadianceCache, cachePrimarySpawn_Kernel, _GeometryNormal, GeometryNormal);
cmdList.SetComputeTextureParam(HRadianceCache, cachePrimarySpawn_Kernel, _RadianceAtlas, HitRadiance);
cmdList.DispatchCompute(HRadianceCache, cachePrimarySpawn_Kernel, probeResX_8, probeResY_8, TextureXR.slices);
}
// Cache counter update, deallocation of out-of-bounds entries, filtered cache population
using (new ProfilingScope(cmdList, s_CacheDataUpdateProfilingSampler))
{
// Clear filtered cache every frame before writing to it
// CoreUtils.SetRenderTarget(ctx.cmd, RadianceCacheFiltered, ClearFlag.Color, Color.clear, 0, CubemapFace.Unknown, -1);
int cacheDataUpdate_Kernel = HRadianceCache.FindKernel("CacheDataUpdate");
cmdList.DispatchCompute(HRadianceCache, cacheDataUpdate_Kernel, HashStorageSize / 64, 1, 1);
}
}
}
// ---------------------------------------- SPATIAL PREPASS ---------------------------------------- //
using (new ProfilingScope(cmdList, s_SpatialPrepassProfilingSampler))
{
// Gather probe ambient occlusion from ray hit distance and temporally accumulate
int probeAmbientOcclusion_Kernel = HProbeAmbientOcclusion.FindKernel("ProbeAmbientOcclusion");
cmdList.SetComputeTextureParam(HProbeAmbientOcclusion, probeAmbientOcclusion_Kernel, _RayDistanceSS, HitDistanceScreenSpace);
cmdList.SetComputeTextureParam(HProbeAmbientOcclusion, probeAmbientOcclusion_Kernel, _RayDistanceWS, HitDistanceWorldSpace);
cmdList.SetComputeTextureParam(HProbeAmbientOcclusion, probeAmbientOcclusion_Kernel, _ProbeNormalDepth, ProbeNormalDepth);
cmdList.SetComputeTextureParam(HProbeAmbientOcclusion, probeAmbientOcclusion_Kernel, _ReprojectionWeights, PersistentReprojectionWeights);
cmdList.SetComputeTextureParam(HProbeAmbientOcclusion, probeAmbientOcclusion_Kernel, _PersistentReprojectionCoord, PersistentReprojectionCoord);
cmdList.SetComputeTextureParam(HProbeAmbientOcclusion, probeAmbientOcclusion_Kernel, _ProbeAmbientOcclusion_History, ProbeAmbientOcclusion_History);
cmdList.SetComputeTextureParam(HProbeAmbientOcclusion, probeAmbientOcclusion_Kernel, _ProbeAmbientOcclusion_Output, ProbeAmbientOcclusion);
cmdList.DispatchCompute(HProbeAmbientOcclusion, probeAmbientOcclusion_Kernel, probeResX_8, probeResY_8, TextureXR.slices);
// Prepare offsets and weights for further spatial passes
int spatialPrepass_Kernel = HSpatialPrepass.FindKernel("SpatialPrepass");
cmdList.SetComputeTextureParam(HSpatialPrepass, spatialPrepass_Kernel, _ProbeNormalDepth, ProbeNormalDepth);
cmdList.SetComputeTextureParam(HSpatialPrepass, spatialPrepass_Kernel, _ProbeAmbientOcclusion, ProbeAmbientOcclusion);
cmdList.SetComputeTextureParam(HSpatialPrepass, spatialPrepass_Kernel, _ProbeNormalDepth_History, ProbeNormalDepth_History);
cmdList.SetComputeTextureParam(HSpatialPrepass, spatialPrepass_Kernel, _SpatialOffsets_Output, SpatialOffsetsPacked);
cmdList.SetComputeTextureParam(HSpatialPrepass, spatialPrepass_Kernel, _SpatialWeights_Output, SpatialWeightsPacked);
cmdList.SetComputeBufferParam(HSpatialPrepass, spatialPrepass_Kernel, _PointDistribution, PointDistributionBuffer);
cmdList.SetComputeBufferParam(HSpatialPrepass, spatialPrepass_Kernel, _SpatialOffsetsBuffer, SpatialOffsetsBuffer);
cmdList.DispatchCompute(HSpatialPrepass, spatialPrepass_Kernel, probeResX_8, probeResY_8, TextureXR.slices);
// Spatially filter probe ambient occlusion
int probeAmbientOcclusionSpatialFilter_Kernel = HProbeAmbientOcclusion.FindKernel("ProbeAmbientOcclusionSpatialFilter");
cmdList.SetComputeTextureParam(HProbeAmbientOcclusion, probeAmbientOcclusionSpatialFilter_Kernel, _SpatialWeightsPacked, SpatialWeightsPacked);
cmdList.SetComputeTextureParam(HProbeAmbientOcclusion, probeAmbientOcclusionSpatialFilter_Kernel, _SpatialOffsetsPacked, SpatialOffsetsPacked);
cmdList.SetComputeTextureParam(HProbeAmbientOcclusion, probeAmbientOcclusionSpatialFilter_Kernel, _ProbeAmbientOcclusion, ProbeAmbientOcclusion);
cmdList.SetComputeTextureParam(HProbeAmbientOcclusion, probeAmbientOcclusionSpatialFilter_Kernel, _ProbeAmbientOcclusion_OutputFiltered, ProbeAmbientOcclusion_Filtered);
cmdList.DispatchCompute(HProbeAmbientOcclusion, probeAmbientOcclusionSpatialFilter_Kernel, probeResX_8, probeResY_8, TextureXR.slices);
}
// ---------------------------------------- ReSTIR TEMPORAL REUSE ---------------------------------------- //
using (new ProfilingScope(cmdList, s_ReSTIRTemporalReuseProfilingSampler))
{
int probeAtlasTemporalReuse_Kernel = HReSTIR.FindKernel("ProbeAtlasTemporalReuse");
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasTemporalReuse_Kernel, _DepthPyramid, DepthPyramid);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasTemporalReuse_Kernel, _ShadowGuidanceMask, ShadowGuidanceMask_Filtered);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasTemporalReuse_Kernel, _RayDirection, RayDirections);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasTemporalReuse_Kernel, _RayDistance, HitDistanceWorldSpace);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasTemporalReuse_Kernel, _RadianceAtlas, HitRadiance);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasTemporalReuse_Kernel, _ProbeDiffuse, ProbeDiffuse);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasTemporalReuse_Kernel, _ProbeNormalDepth, ProbeNormalDepth);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasTemporalReuse_Kernel, _ReprojectionWeights, PersistentReprojectionWeights);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasTemporalReuse_Kernel, _PersistentReprojectionCoord, PersistentReprojectionCoord);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasTemporalReuse_Kernel, _ReservoirAtlas_Output, ReservoirAtlas);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasTemporalReuse_Kernel, _ReservoirAtlas_History, ReservoirAtlas_History);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasTemporalReuse_Kernel, _ReservoirAtlasRayData_Output, ReservoirAtlasRayData_A);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasTemporalReuse_Kernel, _ReservoirAtlasRadianceData_Output, ReservoirAtlasRadianceData_A);
cmdList.SetComputeIntParam(HReSTIR, _UseDiffuseWeight, HResources.GeneralData.DebugModeWS == DebugModeWS.None ? 1 : 0);
cmdList.DispatchCompute(HReSTIR, probeAtlasTemporalReuse_Kernel, probeAtlasResX_8, probeAtlasResY_8, TextureXR.slices);
}
// ---------------------------------------- RESERVOIR OCCLUSION VALIDATION ---------------------------------------- //
using (new ProfilingScope(cmdList, s_ReservoirOcclusionValidationProfilingSampler))
{
// Run one pass of spatial reuse in disocclusion areas to generate shadow guidance mask
int probeAtlasSpatialReuse_Kernel = HReSTIR.FindKernel("ProbeAtlasSpatialReuseDisocclusion");
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ProbeDiffuse, ProbeDiffuse);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _SpatialWeightsPacked, SpatialWeightsPacked);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _SpatialOffsetsPacked, SpatialOffsetsPacked);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRayData, ReservoirAtlasRayData_A);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRadianceData, ReservoirAtlasRadianceData_A);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRayData_Output, ReservoirAtlasRayData_C);
cmdList.SetComputeBufferParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _TracingCoords, IndirectCoordsSF);
cmdList.SetComputeBufferParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _RayCounter, RayCounter);
cmdList.SetComputeIntParam(HReSTIR, _IndexXR, 0);
cmdList.DispatchCompute(HReSTIR, probeAtlasSpatialReuse_Kernel, IndirectArgumentsSF, 0);
if (TextureXR.slices > 1)
{
cmdList.SetComputeIntParam(HReSTIR, _IndexXR, 1);
cmdList.DispatchCompute(HReSTIR, probeAtlasSpatialReuse_Kernel, IndirectArgumentsSF, sizeof(uint) * 3);
}
// Reproject occlusion checkerboarded history
int reservoirOcclusionReprojection_Kernel = HReservoirValidation.FindKernel("OcclusionReprojection");
cmdList.SetComputeTextureParam(HReservoirValidation, reservoirOcclusionReprojection_Kernel, _ReprojectionCoords, ReprojectionCoord);
cmdList.SetComputeTextureParam(HReservoirValidation, reservoirOcclusionReprojection_Kernel, _ProbeAmbientOcclusion, ProbeAmbientOcclusion_Filtered);
cmdList.SetComputeTextureParam(HReservoirValidation, reservoirOcclusionReprojection_Kernel, _ShadowGuidanceMask_History, ShadowGuidanceMask_CheckerboardHistory);
cmdList.SetComputeTextureParam(HReservoirValidation, reservoirOcclusionReprojection_Kernel, _ShadowGuidanceMask_Output, ShadowGuidanceMask);
cmdList.DispatchCompute(HReservoirValidation, reservoirOcclusionReprojection_Kernel, probeAtlasResX_8, probeAtlasResY_8, TextureXR.slices);
// Validate reservoir occlusion
int reservoirOcclusionValidation_Kernel = HReservoirValidation.FindKernel("OcclusionValidation");
cmdList.SetComputeTextureParam(HReservoirValidation, reservoirOcclusionValidation_Kernel, _DepthPyramid, DepthPyramid);
cmdList.SetComputeTextureParam(HReservoirValidation, reservoirOcclusionValidation_Kernel, _ProbeNormalDepth, ProbeNormalDepth);
cmdList.SetComputeTextureParam(HReservoirValidation, reservoirOcclusionValidation_Kernel, _ReprojectionCoords, ReprojectionCoord);
cmdList.SetComputeTextureParam(HReservoirValidation, reservoirOcclusionValidation_Kernel, _ReservoirAtlasRayData, ReservoirAtlasRayData_B);
cmdList.SetComputeTextureParam(HReservoirValidation, reservoirOcclusionValidation_Kernel, _ReservoirAtlasRayData_Disocclusion, ReservoirAtlasRayData_C);
cmdList.SetComputeTextureParam(HReservoirValidation, reservoirOcclusionValidation_Kernel, _ReservoirAtlas, ReservoirAtlas);
cmdList.SetComputeTextureParam(HReservoirValidation, reservoirOcclusionValidation_Kernel, _ReservoirAtlasRadianceData_Inout, ReservoirAtlasRadianceData_B);
cmdList.SetComputeTextureParam(HReservoirValidation, reservoirOcclusionValidation_Kernel, _ShadowGuidanceMask_Output, ShadowGuidanceMask);
cmdList.SetComputeTextureParam(HReservoirValidation, reservoirOcclusionValidation_Kernel, _ProbeAmbientOcclusion, ProbeAmbientOcclusion_Filtered);
cmdList.SetComputeBufferParam(HReservoirValidation, reservoirOcclusionValidation_Kernel, _PointDistribution, PointDistributionBuffer);
cmdList.SetComputeBufferParam(HReservoirValidation, reservoirOcclusionValidation_Kernel, _RayCounter, RayCounter);
cmdList.SetComputeBufferParam(HReservoirValidation, reservoirOcclusionValidation_Kernel, _TracingCoords, IndirectCoordsOV);
cmdList.SetComputeIntParam(HReservoirValidation, _IndexXR, 0);
cmdList.DispatchCompute(HReservoirValidation, reservoirOcclusionValidation_Kernel, IndirectArgumentsOV, 0);
if (TextureXR.slices > 1)
{
cmdList.SetComputeIntParam(HReservoirValidation, _IndexXR, 1);
cmdList.DispatchCompute(HReservoirValidation, reservoirOcclusionValidation_Kernel, IndirectArgumentsOV, sizeof(uint) * 3);
}
// Temporal accumulation pass
int occlusionTemporalFilter_Kernel = HReservoirValidation.FindKernel("OcclusionTemporalFilter");
cmdList.SetComputeTextureParam(HReservoirValidation, occlusionTemporalFilter_Kernel, _ReprojectionWeights, ReprojectionWeights);
cmdList.SetComputeTextureParam(HReservoirValidation, occlusionTemporalFilter_Kernel, _ReprojectionCoords, ReprojectionCoord);
cmdList.SetComputeTextureParam(HReservoirValidation, occlusionTemporalFilter_Kernel, _ShadowGuidanceMask, ShadowGuidanceMask);
cmdList.SetComputeTextureParam(HReservoirValidation, occlusionTemporalFilter_Kernel, _SampleCount_History, ShadowGuidanceMask_SamplecountHistory);
cmdList.SetComputeTextureParam(HReservoirValidation, occlusionTemporalFilter_Kernel, _SampleCount_Output, ShadowGuidanceMask_Samplecount);
cmdList.SetComputeTextureParam(HReservoirValidation, occlusionTemporalFilter_Kernel, _ShadowGuidanceMask_History, ShadowGuidanceMask_History);
cmdList.SetComputeTextureParam(HReservoirValidation, occlusionTemporalFilter_Kernel, _ShadowGuidanceMask_Output, ShadowGuidanceMask_Accumulated);
cmdList.DispatchCompute(HReservoirValidation, occlusionTemporalFilter_Kernel, probeAtlasResX_8, probeAtlasResY_8, TextureXR.slices);
// Spatial filtering pass
int occlusionSpatialFilter_Kernel = HReservoirValidation.FindKernel("OcclusionSpatialFilter");
cmdList.SetComputeTextureParam(HReservoirValidation, occlusionSpatialFilter_Kernel, _SpatialWeightsPacked, SpatialWeightsPacked);
cmdList.SetComputeTextureParam(HReservoirValidation, occlusionSpatialFilter_Kernel, _SpatialOffsetsPacked, SpatialOffsetsPacked);
cmdList.SetComputeTextureParam(HReservoirValidation, occlusionSpatialFilter_Kernel, _SampleCount, ShadowGuidanceMask_Samplecount);
cmdList.SetComputeTextureParam(HReservoirValidation, occlusionSpatialFilter_Kernel, _ShadowGuidanceMask, ShadowGuidanceMask_Accumulated);
cmdList.SetComputeTextureParam(HReservoirValidation, occlusionSpatialFilter_Kernel, _ShadowGuidanceMask_Output, ShadowGuidanceMask_Filtered);
cmdList.SetComputeTextureParam(HReservoirValidation, occlusionSpatialFilter_Kernel, _ReservoirAtlasRadianceData_Inout, ReservoirAtlasRadianceData_A);
cmdList.DispatchCompute(HReservoirValidation, occlusionSpatialFilter_Kernel, probeAtlasResX_8, probeAtlasResY_8, TextureXR.slices);
}
// ---------------------------------------- ReSTIR SPATIAL REUSE ---------------------------------------- //
using (new ProfilingScope(cmdList, s_ReSTIRSpatialReuseProfilingSampler))
{
// Prepare spatial kernel
int probeAtlasSpatialReuse_Kernel = HReSTIR.FindKernel("ProbeAtlasSpatialReuse");
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ProbeDiffuse, ProbeDiffuse);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _SpatialWeightsPacked, SpatialWeightsPacked);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _SpatialOffsetsPacked, SpatialOffsetsPacked);
// 1st spatial disk pass
cmdList.SetComputeIntParam(HReSTIR, _PassNumber, 1);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRayData, ReservoirAtlasRayData_A);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRadianceData, ReservoirAtlasRadianceData_A);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRayData_Output, ReservoirAtlasRayData_B);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRadianceData_Output, ReservoirAtlasRadianceData_B);
cmdList.DispatchCompute(HReSTIR, probeAtlasSpatialReuse_Kernel, probeAtlasResX_8, probeAtlasResY_8, TextureXR.slices);
// 2nd spatial disk pass
cmdList.SetComputeIntParam(HReSTIR, _PassNumber, 2);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRayData, ReservoirAtlasRayData_B);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRadianceData, ReservoirAtlasRadianceData_B);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRayData_Output, ReservoirAtlasRayData_A);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRadianceData_Output, ReservoirAtlasRadianceData_A);
cmdList.DispatchCompute(HReSTIR, probeAtlasSpatialReuse_Kernel, probeAtlasResX_8, probeAtlasResY_8, TextureXR.slices);
// 3rd spatial disk pass
cmdList.SetComputeIntParam(HReSTIR, _PassNumber, 3);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRayData, ReservoirAtlasRayData_A);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRadianceData, ReservoirAtlasRadianceData_A);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRayData_Output, ReservoirAtlasRayData_B);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRadianceData_Output, ReservoirAtlasRadianceData_B);
cmdList.DispatchCompute(HReSTIR, probeAtlasSpatialReuse_Kernel, probeAtlasResX_8, probeAtlasResY_8, TextureXR.slices);
// 3rd spatial disk pass
cmdList.SetComputeIntParam(HReSTIR, _PassNumber, 2);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRayData, ReservoirAtlasRayData_B);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRadianceData, ReservoirAtlasRadianceData_B);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRayData_Output, ReservoirAtlasRayData_A);
cmdList.SetComputeTextureParam(HReSTIR, probeAtlasSpatialReuse_Kernel, _ReservoirAtlasRadianceData_Output, ReservoirAtlasRadianceData_A);
cmdList.DispatchCompute(HReSTIR, probeAtlasSpatialReuse_Kernel, probeAtlasResX_8, probeAtlasResY_8, TextureXR.slices);
}
// ---------------------------------------- PERSISTENT HISTORY UPDATE ---------------------------------------- //
using (new ProfilingScope(cmdList, s_PersistentHistoryUpdateProfilingSampler))
{
// Scroll history indirection array slice by slice
int historyIndirectionScroll_Kernel = HTemporalReprojection.FindKernel("HistoryIndirectionScroll");
cmdList.SetComputeTextureParam(HTemporalReprojection, historyIndirectionScroll_Kernel, _ReprojectionCoord, ReprojectionCoord);
cmdList.SetComputeTextureParam(HTemporalReprojection, historyIndirectionScroll_Kernel, _HistoryIndirection, HistoryIndirection);
// Scrolling cycle
for (int i = PersistentHistorySamples - 1; i > 0; i--)
{
cmdList.SetComputeIntParam(HTemporalReprojection, _HistoryArrayIndex, i);
cmdList.DispatchCompute(HTemporalReprojection, historyIndirectionScroll_Kernel, probeResX_8, probeResY_8, TextureXR.slices);
}
// Update history indirection coord buffer
int historyIndirectionUpdate_Kernel = HTemporalReprojection.FindKernel("HistoryIndirectionUpdate");
cmdList.SetComputeTextureParam(HTemporalReprojection, historyIndirectionUpdate_Kernel, _HistoryIndirection, HistoryIndirection);
cmdList.DispatchCompute(HTemporalReprojection, historyIndirectionUpdate_Kernel, probeResX_8, probeResY_8, TextureXR.slices);
// Update probe world position & normal history buffer
int historyProbeBuffersUpdate_Kernel = HTemporalReprojection.FindKernel("HistoryProbeBuffersUpdate");
cmdList.SetComputeTextureParam(HTemporalReprojection, historyProbeBuffersUpdate_Kernel, _ProbeNormalDepth, ProbeNormalDepth);
cmdList.SetComputeTextureParam(HTemporalReprojection, historyProbeBuffersUpdate_Kernel, _ProbeWorldPosNormal_HistoryOutput, ProbeWorldPosNormal_History);
cmdList.DispatchCompute(HTemporalReprojection, historyProbeBuffersUpdate_Kernel, probeResX_8, probeResY_8, TextureXR.slices);
// Update probe ambient occlusion history buffer
int probeAmbientOcclusionHistoryUpdate_Kernel = HProbeAmbientOcclusion.FindKernel("ProbeAmbientOcclusionHistoryUpdate");
cmdList.SetComputeTextureParam(HProbeAmbientOcclusion, probeAmbientOcclusionHistoryUpdate_Kernel, _ProbeAmbientOcclusion, ProbeAmbientOcclusion);
cmdList.SetComputeTextureParam(HProbeAmbientOcclusion, probeAmbientOcclusionHistoryUpdate_Kernel, _ProbeAmbientOcclusion_Output, ProbeAmbientOcclusion_History);
cmdList.DispatchCompute(HProbeAmbientOcclusion, probeAmbientOcclusionHistoryUpdate_Kernel, probeResX_8, probeResY_8, TextureXR.slices);
// Update reserovir history buffer
int reservoirHistoryUpdate_Kernel = HReSTIR.FindKernel("ReservoirHistoryUpdate");
cmdList.SetComputeTextureParam(HReSTIR, reservoirHistoryUpdate_Kernel, _ReservoirAtlas, ReservoirAtlas);
cmdList.SetComputeTextureParam(HReSTIR, reservoirHistoryUpdate_Kernel, _ReservoirAtlas_Output, ReservoirAtlas_History);
cmdList.DispatchCompute(HReSTIR, reservoirHistoryUpdate_Kernel, probeAtlasResX_8, probeAtlasResY_8, TextureXR.slices);
}
// ---------------------------------------- INTERPOLATION ---------------------------------------- //
using (new ProfilingScope(cmdList, s_InterpolationProfilingSampler))
{
// Spherical harmonics gather
int gatherSH_Kernel = HInterpolation.FindKernel("GatherSH");
cmdList.SetComputeTextureParam(HInterpolation, gatherSH_Kernel, _ShadowGuidanceMask, ShadowGuidanceMask_Accumulated);
cmdList.SetComputeTextureParam(HInterpolation, gatherSH_Kernel, _ReservoirAtlasRadianceData, ReservoirAtlasRadianceData_A);
cmdList.SetComputeTextureParam(HInterpolation, gatherSH_Kernel, _ReservoirAtlasRayData, ReservoirAtlasRayData_A);
cmdList.SetComputeTextureParam(HInterpolation, gatherSH_Kernel, _ProbeNormalDepth, ProbeNormalDepth);
cmdList.SetComputeTextureParam(HInterpolation, gatherSH_Kernel, _Temp, ShadowGuidanceMask_Accumulated);
cmdList.SetComputeTextureParam(HInterpolation, gatherSH_Kernel, _PackedSH_A_Output, PackedSH_A);
cmdList.SetComputeTextureParam(HInterpolation, gatherSH_Kernel, _PackedSH_B_Output, PackedSH_B);
cmdList.DispatchCompute(HInterpolation, gatherSH_Kernel, probeResX_8, probeResY_8, TextureXR.slices);
// Interpolation to the final resolution
int interpolation_Kernel = HInterpolation.FindKernel("Interpolation");
cmdList.SetComputeTextureParam(HInterpolation, interpolation_Kernel, _ProbeSSAO, ProbeSSAO);
cmdList.SetComputeTextureParam(HInterpolation, interpolation_Kernel, _PackedSH_A, PackedSH_A);
cmdList.SetComputeTextureParam(HInterpolation, interpolation_Kernel, _PackedSH_B, PackedSH_B);
cmdList.SetComputeTextureParam(HInterpolation, interpolation_Kernel, _GeometryNormal, GeometryNormal);
cmdList.SetComputeTextureParam(HInterpolation, interpolation_Kernel, _BentNormalsAO, BentNormalsAO_Interpolated);
cmdList.SetComputeTextureParam(HInterpolation, interpolation_Kernel, _Radiance_Output, Radiance_Interpolated);
cmdList.SetComputeTextureParam(HInterpolation, interpolation_Kernel, _ProbeNormalDepth, ProbeNormalDepth);
cmdList.SetComputeFloatParam(HInterpolation, _AO_Intensity, HResources.ScreenSpaceLightingData.OcclusionIntensity);
cmdList.DispatchCompute(HInterpolation, interpolation_Kernel, fullResX_8, fullResY_8, TextureXR.slices);
}
// ---------------------------------------- TEMPORAL DENOISER ---------------------------------------- //
using (new ProfilingScope(cmdList, s_TemporalDenoisingProfilingSampler))
{
int temporalDenoising_Kernel = HTemporalDenoiser.FindKernel("TemporalDenoising");
cmdList.SetComputeTextureParam(HTemporalDenoiser, temporalDenoising_Kernel, _GeometryNormal, GeometryNormal);
cmdList.SetComputeTextureParam(HTemporalDenoiser, temporalDenoising_Kernel, _NormalDepth_History, NormalDepth_History);
cmdList.SetComputeTextureParam(HTemporalDenoiser, temporalDenoising_Kernel, _Radiance, Radiance_Interpolated);
cmdList.SetComputeTextureParam(HTemporalDenoiser, temporalDenoising_Kernel, _Radiance_History, RadianceAccumulated_History);
cmdList.SetComputeTextureParam(HTemporalDenoiser, temporalDenoising_Kernel, _Radiance_Output, RadianceAccumulated);
cmdList.SetComputeTextureParam(HTemporalDenoiser, temporalDenoising_Kernel, _LuminanceDelta_Output, LuminanceDelta);
cmdList.SetComputeTextureParam(HTemporalDenoiser, temporalDenoising_Kernel, _LuminanceDelta_History, LuminanceDelta_History);
cmdList.DispatchCompute(HTemporalDenoiser, temporalDenoising_Kernel, fullResX_8, fullResY_8, TextureXR.slices);
}
// ---------------------------------------- SPATIAL CLEANUP ---------------------------------------- //
using (new ProfilingScope(cmdList, s_SpatialCleanupProfilingSampler))
{
int spatialCleanup_Kernel = HTemporalDenoiser.FindKernel("SpatialCleanup");
cmdList.SetComputeTextureParam(HTemporalDenoiser, spatialCleanup_Kernel, _GeometryNormal, GeometryNormal);
cmdList.SetComputeTextureParam(HTemporalDenoiser, spatialCleanup_Kernel, _Radiance, RadianceAccumulated);
cmdList.SetComputeTextureParam(HTemporalDenoiser, spatialCleanup_Kernel, _Radiance_HistoryOutput, RadianceAccumulated_History);
cmdList.SetComputeTextureParam(HTemporalDenoiser, spatialCleanup_Kernel, _NormalDepth_HistoryOutput, NormalDepth_History);
cmdList.DispatchCompute(HTemporalDenoiser, spatialCleanup_Kernel, fullResX_8, fullResY_8, TextureXR.slices);
}
// ---------------------------------------- COPY BUFFERS ---------------------------------------- //
using (new ProfilingScope(cmdList, s_CopyBuffersProfilingSampler))
{
int hCopyProbeBuffers_Kernel = HCopy.FindKernel("CopyProbeBuffers");
cmdList.SetComputeTextureParam(HCopy, hCopyProbeBuffers_Kernel, _ShadowGuidanceMask_Samplecount, ShadowGuidanceMask_Samplecount);
cmdList.SetComputeTextureParam(HCopy, hCopyProbeBuffers_Kernel, _ShadowGuidanceMask_SamplecountHistoryOutput, ShadowGuidanceMask_SamplecountHistory);
cmdList.DispatchCompute(HCopy, hCopyProbeBuffers_Kernel, probeResX_8, probeResY_8, TextureXR.slices);
int hCopyProbeAtlases_Kernel = HCopy.FindKernel("CopyProbeAtlases");
cmdList.SetComputeTextureParam(HCopy, hCopyProbeAtlases_Kernel, _ShadowGuidanceMask, ShadowGuidanceMask);
cmdList.SetComputeTextureParam(HCopy, hCopyProbeAtlases_Kernel, _ShadowGuidanceMask_CheckerboardHistoryOutput, ShadowGuidanceMask_CheckerboardHistory);
cmdList.SetComputeTextureParam(HCopy, hCopyProbeAtlases_Kernel, _ShadowGuidanceMask_Accumulated, ShadowGuidanceMask_Accumulated);
cmdList.SetComputeTextureParam(HCopy, hCopyProbeAtlases_Kernel, _ShadowGuidanceMask_HistoryOutput, ShadowGuidanceMask_History);
cmdList.DispatchCompute(HCopy, hCopyProbeAtlases_Kernel, probeAtlasResX_8, probeAtlasResY_8, TextureXR.slices);
int hCopyFullResBuffers_Kernel = HCopy.FindKernel("CopyFullResBuffers");
cmdList.SetComputeTextureParam(HCopy, hCopyFullResBuffers_Kernel, _GeometryNormal, GeometryNormal);
cmdList.SetComputeTextureParam(HCopy, hCopyFullResBuffers_Kernel, _NormalDepth_HistoryOutput, NormalDepth_History);
cmdList.DispatchCompute(HCopy, hCopyFullResBuffers_Kernel, fullResX_8, fullResY_8, TextureXR.slices);
}
// Final output
cmdList.SetGlobalTexture(g_HTraceBufferGI, RadianceAccumulated);
// ---------------------------------------- DEBUG (DON'T SHIP!) ---------------------------------------- //
using (new ProfilingScope(cmdList, s_DebugPassthroughProfilingSampler))
{
if (HResources.GeneralData.DebugModeWS != DebugModeWS.None)
{
int hDebugPassthrough_Kernel = HDebugPassthrough.FindKernel("DebugPassthrough");
cmdList.SetComputeTextureParam(HDebugPassthrough, hDebugPassthrough_Kernel, _InputA, RadianceAccumulated);
cmdList.SetComputeTextureParam(HDebugPassthrough, hDebugPassthrough_Kernel, _InputB, VoxelVisualizationRayDirections);
cmdList.SetComputeTextureParam(HDebugPassthrough, hDebugPassthrough_Kernel, _Output, DebugOutput);
cmdList.DispatchCompute(HDebugPassthrough, hDebugPassthrough_Kernel, fullResX_8, fullResY_8, TextureXR.slices);
}
}
// Disable visualization keywords by default
VoxelVisualization.EnableKeyword("VISUALIZE_OFF"); VoxelVisualization.DisableKeyword("VISUALIZE_LIGHTING"); VoxelVisualization.DisableKeyword("VISUALIZE_COLOR");
// Visualize voxels if requested
if (HResources.GeneralData.DebugModeWS == DebugModeWS.VoxelizedLighting || HResources.GeneralData.DebugModeWS == DebugModeWS.VoxelizedColor)
{
using (new ProfilingScope(ctx.cmd, s_VisualizeVoxelsProfilingSampler))
{
if (HResources.GeneralData.DebugModeWS == DebugModeWS.VoxelizedLighting)
{VoxelVisualization.EnableKeyword("VISUALIZE_LIGHTING"); VoxelVisualization.DisableKeyword("VISUALIZE_COLOR"); VoxelVisualization.DisableKeyword("VISUALIZE_OFF");}
if (HResources.GeneralData.DebugModeWS == DebugModeWS.VoxelizedColor)
{VoxelVisualization.EnableKeyword("VISUALIZE_COLOR"); VoxelVisualization.DisableKeyword("VISUALIZE_LIGHTING"); VoxelVisualization.DisableKeyword("VISUALIZE_OFF");}
if (HResources.GeneralData.Multibounce == Multibounce.None) { HTracingWorldSpace.DisableKeyword("MULTIBOUNCE_CACHE"); HTracingWorldSpace.DisableKeyword("MULTIBOUNCE_APV"); HTracingWorldSpace.EnableKeyword("MULTIBOUNCE_OFF"); }
if (HResources.GeneralData.Multibounce == Multibounce.IrradianceCache) { HTracingWorldSpace.DisableKeyword("MULTIBOUNCE_OFF"); HTracingWorldSpace.DisableKeyword("MULTIBOUNCE_APV"); HTracingWorldSpace.EnableKeyword("MULTIBOUNCE_CACHE"); }
if (HResources.GeneralData.Multibounce == Multibounce.AdaptiveProbeVolumes) { HTracingWorldSpace.DisableKeyword("MULTIBOUNCE_CACHE"); HTracingWorldSpace.DisableKeyword("MULTIBOUNCE_OFF"); HTracingWorldSpace.EnableKeyword("MULTIBOUNCE_APV"); }
// Calculate rays in camera frustum
var debugCameraFrustum = ComputeFrustumCorners(ctx.hdCamera.camera);
// Interpolate rays in vf shader
VoxelVisualizationMaterial.SetMatrix(_DebugCameraFrustum, debugCameraFrustum);
CoreUtils.DrawFullScreen(ctx.cmd, VoxelVisualizationMaterial, VoxelVisualizationRayDirections, shaderPassId: 0, properties: ctx.propertyBlock);
// Trace into voxels for debug
int voxelVisualization_Kernel = VoxelVisualization.FindKernel("VisualizeVoxels");
ctx.cmd.SetComputeTextureParam(VoxelVisualization, voxelVisualization_Kernel, _DebugRayDirection, VoxelVisualizationRayDirections);
ctx.cmd.SetComputeTextureParam(VoxelVisualization, voxelVisualization_Kernel, _Visualization_Output, DebugOutput);
cmdList.SetComputeIntParam(VoxelVisualization, _MultibounceMode, (int)HResources.GeneralData.Multibounce);
ctx.cmd.DispatchCompute(VoxelVisualization, voxelVisualization_Kernel, fullResX_8, fullResY_8, TextureXR.slices);
}
}
if (Time.frameCount % 2 == 0)
HFrameIndex++;
HashUpdateFrameIndex++;
if (HResources.GeneralData.DebugModeWS != DebugModeWS.None)
cmdList.SetGlobalTexture(g_HTraceBufferGI, DebugOutput);
}
protected override void Cleanup()
{
base.Cleanup();
HExtensions.HRelease(PointDistributionBuffer);
AllocateMainRT(true);
AllocateDepthPyramidRT(new Vector2Int(0,0) ,true);
AllocateSSAO_RT(true);
AllocateDebugRT(true);
AllocateIndirectionBuffers(new Vector2Int(0,0), true);
ReallocHashBuffers(true);
PrevScreenResolution = Vector2Int.zero;
VoxelizationRuntimeData.OnReallocTextures -= () => ReallocHashBuffers();
if (HResources.GeneralData != null)
HResources.GeneralData.OnRayCountChanged -= RayCountChanged;
}
// Using Cleanup is not ideal, because after launch it's called (again?), but he have to use it because
// otherwise we get "RTHandleSystem.Initialize should be called once..." error.
protected internal void Release()
{
}
}
}
Reference in New Issue View Git Blame Copy Permalink