public HDRPVariantStripper() { // TODO: Grab correct configuration/quality asset. HDRenderPipeline hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline; if (hdPipeline != null) { m_CurrentHDRPAsset = hdPipeline.asset; } m_StripperFuncs = new Dictionary <string, VariantStrippingFunc>(); m_StripperFuncs.Add("HDRenderPipeline/Lit", LitShaderStripper); m_StripperFuncs.Add("HDRenderPipeline/LitTessellation", LitShaderStripper); m_StripperFuncs.Add("HDRenderPipeline/LayeredLit", LitShaderStripper); m_StripperFuncs.Add("HDRenderPipeline/LayeredLitTessellation", LitShaderStripper); m_Transparent = new ShaderKeyword("_SURFACE_TYPE_TRANSPARENT"); m_DebugDisplay = new ShaderKeyword("DEBUG_DISPLAY"); m_TileLighting = new ShaderKeyword("USE_FPTL_LIGHTLIST"); m_ClusterLighting = new ShaderKeyword("USE_CLUSTERED_LIGHTLIST"); m_FeatureSSS = new ShaderKeyword("_MATERIAL_FEATURE_SUBSURFACE_SCATTERING"); }
void FindDBufferNormalMaskRTIDs(HDRenderPipeline hdPipeline) { dbufferNormalMaskRTIDs = null; #if UNITY_2020_2_OR_NEWER // require alternate path if rendergraph is enabled #if !UNITY_2021_2_OR_NEWER var field_m_EnableRenderGraph = typeof(HDRenderPipeline).GetField("m_EnableRenderGraph", BindingFlags.NonPublic | BindingFlags.Instance); if (field_m_EnableRenderGraph != null && (bool)field_m_EnableRenderGraph.GetValue(hdPipeline) == true) #endif { var field_m_DBufferOutput = typeof(HDRenderPipeline).GetField("m_DBufferOutput", BindingFlags.NonPublic | BindingFlags.Instance); if (field_m_DBufferOutput != null) { var value_m_DBufferOutput = field_m_DBufferOutput.GetValue(hdPipeline); if (value_m_DBufferOutput != null) { var field_mrt = value_m_DBufferOutput.GetType().GetField("mrt", BindingFlags.Public | BindingFlags.Instance); if (field_mrt != null) { var value_mrt = field_mrt.GetValue(value_m_DBufferOutput) as TextureHandle[]; if (value_mrt != null) { dbufferNormalMaskRTIDs = new RenderTargetIdentifier[2]; #if !UNITY_2021_2_OR_NEWER cachedField_m_EnableRenderGraph = field_m_EnableRenderGraph; #endif cachedField_m_DBufferOutput_mrt = field_mrt; cachedValue_m_DBufferOutput = value_m_DBufferOutput; UpdateDBufferNormalMaskRTIDs(hdPipeline); } } } } return; } #endif #if !UNITY_2021_2_OR_NEWER var field_m_DbufferManager = typeof(HDRenderPipeline).GetField("m_DbufferManager", BindingFlags.NonPublic | BindingFlags.Instance); if (field_m_DbufferManager != null) { var value_m_DbufferManager = field_m_DbufferManager.GetValue(hdPipeline); if (value_m_DbufferManager != null) { var field_m_RTs = value_m_DbufferManager.GetType().GetField("m_RTs", BindingFlags.NonPublic | BindingFlags.Instance); if (field_m_RTs != null) { var value_m_RTs = field_m_RTs.GetValue(value_m_DbufferManager) as RTHandle[]; if (value_m_RTs != null) { dbufferNormalMaskRTIDs = new RenderTargetIdentifier[2]; dbufferNormalMaskRTIDs[0] = value_m_RTs[DBUFFER_NORMALS].nameID; dbufferNormalMaskRTIDs[1] = value_m_RTs[DBUFFER_MASK].nameID; } } } } #endif }
public override void OnInspectorGUI() { PropertyField(m_MaxShadowDistance, EditorGUIUtility.TrTextContent("Max Distance", "In Meter")); Rect firstLine = GUILayoutUtility.GetLastRect(); EditorGUILayout.Space(); EditorGUILayout.LabelField("Directional Light"); Rect shiftedRect = EditorGUILayout.GetControlRect(); shiftedRect.x += 20; shiftedRect.width -= 20; EditorGUI.BeginChangeCheck(); Unit unit = (Unit)EditorGUI.EnumPopup(shiftedRect, EditorGUIUtility.TrTextContent("Working Unit", "Except Max Distance which will be still in meter"), m_State.value); if (EditorGUI.EndChangeCheck()) { m_State.value = unit; (serializedObject.targetObject as HDShadowSettings).InitNormalized(m_State.value == Unit.Percent); } PropertyField(m_DirectionalTransmissionMultiplier, EditorGUIUtility.TrTextContent("Transmission Multiplier")); EditorGUI.BeginChangeCheck(); PropertyField(m_CascadeShadowSplitCount, EditorGUIUtility.TrTextContent("Cascade Count")); if (EditorGUI.EndChangeCheck()) { //fix newly activated cascade split not respecting ordering for (int i = 1; i < m_CascadeShadowSplitCount.value.intValue - 1; i++) { if (m_CascadeShadowSplits[i - 1].value.floatValue > m_CascadeShadowSplits[i].value.floatValue) { m_CascadeShadowSplits[i].value.floatValue = m_CascadeShadowSplits[i - 1].value.floatValue; } } } if (!m_CascadeShadowSplitCount.value.hasMultipleDifferentValues) { EditorGUI.indentLevel++; int cascadeCount = m_CascadeShadowSplitCount.value.intValue; for (int i = 0; i < cascadeCount - 1; i++) { PropertyField(m_CascadeShadowSplits[i], EditorGUIUtility.TrTextContent(string.Format("Split {0}", i + 1))); } if (HDRenderPipeline.s_UseCascadeBorders) { EditorGUILayout.Space(); for (int i = 0; i < cascadeCount; i++) { PropertyField(m_CascadeShadowBorders[i], EditorGUIUtility.TrTextContent(string.Format("Border {0}", i + 1))); } } EditorGUILayout.Space(); GUILayout.Label("Cascade splits"); ShadowCascadeGUI.DrawCascadeSplitGUI(m_CascadeShadowSplits, HDRenderPipeline.s_UseCascadeBorders ? m_CascadeShadowBorders : null, (uint)cascadeCount, blendLastCascade: true, useMetric: unit == Unit.Metric, baseMetric: m_MaxShadowDistance.value.floatValue); EditorGUI.indentLevel--; } HDRenderPipeline hdrp = UnityEngine.Rendering.RenderPipelineManager.currentPipeline as HDRenderPipeline; if (hdrp == null) { return; } Rect visualizeCascade = firstLine; visualizeCascade.y -= (EditorGUIUtility.singleLineHeight - 2); visualizeCascade.height -= 2; visualizeCascade.x += EditorGUIUtility.labelWidth + 20; visualizeCascade.width -= EditorGUIUtility.labelWidth + 20; bool currentCascadeValue = hdrp.showCascade; bool newCascadeValue = GUI.Toggle(visualizeCascade, currentCascadeValue, EditorGUIUtility.TrTextContent("Visualize Cascades"), EditorStyles.miniButton); if (currentCascadeValue ^ newCascadeValue) { hdrp.showCascade = newCascadeValue; } }
public void Init(HDRenderPipelineRayTracingResources rpRTResources, SharedRTManager sharedRTManager, HDRenderPipeline renderPipeline) { m_SharedRTManager = sharedRTManager; m_RenderPipeline = renderPipeline; m_ShadowDenoiser = rpRTResources.diffuseShadowDenoiserCS; m_BilateralFilterHSingleDirectionalKernel = m_ShadowDenoiser.FindKernel("BilateralFilterHSingleDirectional"); m_BilateralFilterVSingleDirectionalKernel = m_ShadowDenoiser.FindKernel("BilateralFilterVSingleDirectional"); m_BilateralFilterHColorDirectionalKernel = m_ShadowDenoiser.FindKernel("BilateralFilterHColorDirectional"); m_BilateralFilterVColorDirectionalKernel = m_ShadowDenoiser.FindKernel("BilateralFilterVColorDirectional"); m_BilateralFilterHSingleSphereKernel = m_ShadowDenoiser.FindKernel("BilateralFilterHSingleSphere"); m_BilateralFilterVSingleSphereKernel = m_ShadowDenoiser.FindKernel("BilateralFilterVSingleSphere"); }
public void Init(HDRenderPipelineRayTracingResources rpRTResources, SharedRTManager sharedRTManager, HDRenderPipeline renderPipeline) { m_ReflectionDenoiserCS = rpRTResources.reflectionDenoiserCS; m_ReflectionFilterMapping = rpRTResources.reflectionFilterMapping; m_SharedRTManager = sharedRTManager; m_RenderPipeline = renderPipeline; // Fetch all the kernels we shall be using s_TemporalAccumulationKernel = m_ReflectionDenoiserCS.FindKernel("TemporalAccumulation"); s_CopyHistoryKernel = m_ReflectionDenoiserCS.FindKernel("CopyHistory"); s_BilateralFilterHKernel = m_ReflectionDenoiserCS.FindKernel("BilateralFilterH"); s_BilateralFilterVKernel = m_ReflectionDenoiserCS.FindKernel("BilateralFilterV"); }
// Denoiser variant when history is stored in an array and the validation buffer is seperate public void DenoiseBuffer(CommandBuffer cmd, HDCamera hdCamera, RTHandle noisySignal, RTHandle historySignal, RTHandle validationHistory, RTHandle velocityBuffer, RTHandle outputSignal, int sliceIndex, Vector4 channelMask, RTHandle distanceSignal, RTHandle distanceHistorySignal, RTHandle outputDistanceSignal, Vector4 distanceChannelMask, bool singleChannel = true, float historyValidity = 1.0f) { // If we do not have a depth and normal history buffers, we can skip right away var historyDepthBuffer = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.Depth); var historyNormalBuffer = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.Normal); if (historyDepthBuffer == null || historyNormalBuffer == null) { HDUtils.BlitCameraTexture(cmd, noisySignal, historySignal); HDUtils.BlitCameraTexture(cmd, noisySignal, outputSignal); if (distanceSignal != null && distanceHistorySignal != null && outputDistanceSignal != null) { HDUtils.BlitCameraTexture(cmd, distanceSignal, distanceHistorySignal); HDUtils.BlitCameraTexture(cmd, distanceSignal, outputDistanceSignal); } return; } // Fetch texture dimensions int texWidth = hdCamera.actualWidth; int texHeight = hdCamera.actualHeight; // Evaluate the dispatch parameters int areaTileSize = 8; int numTilesX = (texWidth + (areaTileSize - 1)) / areaTileSize; int numTilesY = (texHeight + (areaTileSize - 1)) / areaTileSize; // Request the intermediate buffer we need RTHandle validationBuffer = m_RenderPipeline.GetRayTracingBuffer(InternalRayTracingBuffers.R0); // First of all we need to validate the history to know where we can or cannot use the history signal int m_KernelFilter = m_TemporalFilterCS.FindKernel("ValidateHistory"); var historyScale = new Vector2(hdCamera.actualWidth / (float)historySignal.rt.width, hdCamera.actualHeight / (float)historySignal.rt.height); cmd.SetComputeVectorParam(m_TemporalFilterCS, HDShaderIDs._RTHandleScaleHistory, historyScale); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer()); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._HistoryDepthTexture, historyDepthBuffer); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer()); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._HistoryNormalBufferTexture, historyNormalBuffer); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._ValidationBufferRW, validationBuffer); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._VelocityBuffer, velocityBuffer); cmd.SetComputeFloatParam(m_TemporalFilterCS, HDShaderIDs._HistoryValidity, historyValidity); cmd.SetComputeFloatParam(m_TemporalFilterCS, HDShaderIDs._PixelSpreadAngleTangent, HDRenderPipeline.GetPixelSpreadTangent(hdCamera.camera.fieldOfView, hdCamera.actualWidth, hdCamera.actualHeight)); cmd.DispatchCompute(m_TemporalFilterCS, m_KernelFilter, numTilesX, numTilesY, hdCamera.viewCount); // Now that we have validated our history, let's accumulate m_KernelFilter = m_TemporalFilterCS.FindKernel(singleChannel ? "TemporalAccumulationSingleArray" : "TemporalAccumulationColorArray"); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DenoiseInputTexture, noisySignal); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._HistoryBuffer, historySignal); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._HistoryValidityBuffer, validationHistory); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer()); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DenoiseOutputTextureRW, outputSignal); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._ValidationBuffer, validationBuffer); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._VelocityBuffer, velocityBuffer); cmd.SetComputeIntParam(m_TemporalFilterCS, HDShaderIDs._DenoisingHistorySlice, sliceIndex); cmd.SetComputeVectorParam(m_TemporalFilterCS, HDShaderIDs._DenoisingHistoryMask, channelMask); cmd.DispatchCompute(m_TemporalFilterCS, m_KernelFilter, numTilesX, numTilesY, hdCamera.viewCount); // Make sure to copy the new-accumulated signal in our history buffer m_KernelFilter = m_TemporalFilterCS.FindKernel(singleChannel ? "CopyHistorySingleArray" : "CopyHistoryColorArray"); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DenoiseInputTexture, outputSignal); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DenoiseOutputTextureRW, historySignal); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._ValidityOutputTextureRW, validationHistory); cmd.SetComputeIntParam(m_TemporalFilterCS, HDShaderIDs._DenoisingHistorySlice, sliceIndex); cmd.SetComputeVectorParam(m_TemporalFilterCS, HDShaderIDs._DenoisingHistoryMask, channelMask); cmd.DispatchCompute(m_TemporalFilterCS, m_KernelFilter, numTilesX, numTilesY, hdCamera.viewCount); if (distanceSignal != null && distanceHistorySignal != null && outputDistanceSignal != null) { // Now that we have validated our history, let's accumulate m_KernelFilter = m_TemporalFilterCS.FindKernel("TemporalAccumulationSingleArray"); // Bind the intput buffers cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DenoiseInputTexture, distanceSignal); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._HistoryBuffer, distanceHistorySignal); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._HistoryValidityBuffer, validationHistory); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer()); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._ValidationBuffer, validationBuffer); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._VelocityBuffer, velocityBuffer); // Bind the constant inputs cmd.SetComputeIntParam(m_TemporalFilterCS, HDShaderIDs._DenoisingHistorySlice, sliceIndex); cmd.SetComputeVectorParam(m_TemporalFilterCS, HDShaderIDs._DenoisingHistoryMask, distanceChannelMask); // Bind the output buffers cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DenoiseOutputTextureRW, outputDistanceSignal); // Dispatch the temporal accumulation cmd.DispatchCompute(m_TemporalFilterCS, m_KernelFilter, numTilesX, numTilesY, hdCamera.viewCount); // Make sure to copy the new-accumulated signal in our history buffer m_KernelFilter = m_TemporalFilterCS.FindKernel("CopyHistorySingleArrayNoValidity"); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DenoiseInputTexture, outputDistanceSignal); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DenoiseOutputTextureRW, distanceHistorySignal); cmd.SetComputeIntParam(m_TemporalFilterCS, HDShaderIDs._DenoisingHistorySlice, sliceIndex); cmd.SetComputeVectorParam(m_TemporalFilterCS, HDShaderIDs._DenoisingHistoryMask, distanceChannelMask); cmd.DispatchCompute(m_TemporalFilterCS, m_KernelFilter, numTilesX, numTilesY, hdCamera.viewCount); } }
public override void OnInspectorGUI() { PropertyField(m_MaxShadowDistance, EditorGUIUtility.TrTextContent("Max Distance", "In Meter")); Rect firstLine = GUILayoutUtility.GetLastRect(); EditorGUILayout.Space(); EditorGUILayout.LabelField("Directional Light"); Rect shiftedRect = EditorGUILayout.GetControlRect(); shiftedRect.x += 20; shiftedRect.width -= 20; EditorGUI.BeginChangeCheck(); Unit unit = (Unit)EditorGUI.EnumPopup(shiftedRect, EditorGUIUtility.TrTextContent("Working Unit", "Except Max Distance which will be still in meter"), m_State.value); if (EditorGUI.EndChangeCheck()) { m_State.value = unit; (serializedObject.targetObject as HDShadowSettings).InitNormalized(m_State.value == Unit.Percent); } PropertyField(m_DirectionalTransmissionMultiplier, EditorGUIUtility.TrTextContent("Transmission Multiplier")); EditorGUI.BeginChangeCheck(); PropertyField(m_CascadeShadowSplitCount, EditorGUIUtility.TrTextContent("Cascade Count")); if (EditorGUI.EndChangeCheck()) { //fix newly activated cascade split not respecting ordering for (int i = 1; i < m_CascadeShadowSplitCount.value.intValue - 1; i++) { if (m_CascadeShadowSplits[i - 1].value.floatValue > m_CascadeShadowSplits[i].value.floatValue) { m_CascadeShadowSplits[i].value.floatValue = m_CascadeShadowSplits[i - 1].value.floatValue; } } } if (!m_CascadeShadowSplitCount.value.hasMultipleDifferentValues) { int cascadeCount; using (new HDEditorUtils.IndentScope()) { cascadeCount = m_CascadeShadowSplitCount.value.intValue; Debug.Assert(cascadeCount <= 4); // If we add support for more than 4 cascades, then we should add new entries in the next line string[] cascadeOrder = { "first", "second", "third" }; for (int i = 0; i < cascadeCount - 1; i++) { string tooltipOverride = (unit == Unit.Metric) ? $"Distance from the Camera (in meters) to the {cascadeOrder[i]} cascade split." : $"Distance from the Camera (as a percentage of Max Distance) to the {cascadeOrder[i]} cascade split."; PropertyField(m_CascadeShadowSplits[i], EditorGUIUtility.TrTextContent(string.Format("Split {0}", i + 1), tooltipOverride)); } if (HDRenderPipeline.s_UseCascadeBorders) { EditorGUILayout.Space(); for (int i = 0; i < cascadeCount; i++) { PropertyField(m_CascadeShadowBorders[i], EditorGUIUtility.TrTextContent(string.Format("Border {0}", i + 1))); } } } EditorGUILayout.Space(); GUILayout.Label("Cascade splits"); DrawShadowCascades(cascadeCount, unit == Unit.Metric, m_MaxShadowDistance.value.floatValue); } HDRenderPipeline hdrp = UnityEngine.Rendering.RenderPipelineManager.currentPipeline as HDRenderPipeline; if (hdrp == null) { return; } Rect visualizeCascade = firstLine; visualizeCascade.y -= (EditorGUIUtility.singleLineHeight - 2); visualizeCascade.height -= 2; visualizeCascade.x += EditorGUIUtility.labelWidth + 20; visualizeCascade.width -= EditorGUIUtility.labelWidth + 20; bool currentCascadeValue = hdrp.showCascade; bool newCascadeValue = GUI.Toggle(visualizeCascade, currentCascadeValue, EditorGUIUtility.TrTextContent("Show Cascades"), EditorStyles.miniButton); if (currentCascadeValue ^ newCascadeValue) { hdrp.showCascade = newCascadeValue; } }
public void Init(HDRenderPipelineRayTracingResources rpRTResources, SharedRTManager sharedRTManager, HDRenderPipeline renderPipeline) { // Keep track of the resources m_TemporalFilterCS = rpRTResources.temporalFilterCS; // Keep track of the shared rt manager m_SharedRTManager = sharedRTManager; m_RenderPipeline = renderPipeline; }
public void DenoiseBuffer(CommandBuffer cmd, HDCamera hdCamera, RTHandle noisySignal, RTHandle outputSignal, float kernelSize, bool singleChannel = true, bool halfResolutionFilter = false) { // Fetch texture dimensions int texWidth = hdCamera.actualWidth; int texHeight = hdCamera.actualHeight; // Evaluate the dispatch parameters int areaTileSize = 8; int numTilesX = (texWidth + (areaTileSize - 1)) / areaTileSize; int numTilesY = (texHeight + (areaTileSize - 1)) / areaTileSize; int m_KernelFilter = m_SimpleDenoiserCS.FindKernel(singleChannel ? "BilateralFilterSingle" : "BilateralFilterColor"); cmd.SetGlobalTexture(HDShaderIDs._OwenScrambledRGTexture, m_OwenScrambleRGBA); cmd.SetComputeFloatParam(m_SimpleDenoiserCS, HDShaderIDs._DenoiserFilterRadius, kernelSize); cmd.SetComputeTextureParam(m_SimpleDenoiserCS, m_KernelFilter, HDShaderIDs._DenoiseInputTexture, noisySignal); cmd.SetComputeTextureParam(m_SimpleDenoiserCS, m_KernelFilter, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer()); cmd.SetComputeTextureParam(m_SimpleDenoiserCS, m_KernelFilter, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer()); cmd.SetComputeTextureParam(m_SimpleDenoiserCS, m_KernelFilter, HDShaderIDs._DenoiseOutputTextureRW, halfResolutionFilter ? m_IntermediateBuffer0 : outputSignal); cmd.SetComputeIntParam(m_SimpleDenoiserCS, HDShaderIDs._HalfResolutionFilter, halfResolutionFilter ? 1 : 0); cmd.SetComputeFloatParam(m_SimpleDenoiserCS, HDShaderIDs._PixelSpreadAngleTangent, HDRenderPipeline.GetPixelSpreadTangent(hdCamera.camera.fieldOfView, hdCamera.actualWidth, hdCamera.actualHeight)); cmd.DispatchCompute(m_SimpleDenoiserCS, m_KernelFilter, numTilesX, numTilesY, hdCamera.viewCount); if (halfResolutionFilter) { m_KernelFilter = m_SimpleDenoiserCS.FindKernel(singleChannel ? "GatherSingle" : "GatherColor"); cmd.SetComputeTextureParam(m_SimpleDenoiserCS, m_KernelFilter, HDShaderIDs._DenoiseInputTexture, m_IntermediateBuffer0); cmd.SetComputeTextureParam(m_SimpleDenoiserCS, m_KernelFilter, HDShaderIDs._DenoiseOutputTextureRW, outputSignal); cmd.DispatchCompute(m_SimpleDenoiserCS, m_KernelFilter, numTilesX, numTilesY, hdCamera.viewCount); } }
public void SetDebugView() { HDRenderPipeline hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline; hdPipeline.debugDisplaySettings.fullScreenDebugMode = fullScreenDebugMode; }
public void DenoiseBuffer(CommandBuffer cmd, HDCamera hdCamera, RTHandle noisySignal, RTHandle historySignal, RTHandle outputSignal, bool singleChannel = true, int slotIndex = -1, float historyValidity = 1.0f) { // If we do not have a depth and normal history buffers, we can skip right away var historyDepthBuffer = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.Depth); var historyNormalBuffer = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.Normal); if (historyDepthBuffer == null || historyNormalBuffer == null) { HDUtils.BlitCameraTexture(cmd, noisySignal, historySignal); HDUtils.BlitCameraTexture(cmd, noisySignal, outputSignal); return; } // Fetch texture dimensions int texWidth = hdCamera.actualWidth; int texHeight = hdCamera.actualHeight; // Evaluate the dispatch parameters int areaTileSize = 8; int numTilesX = (texWidth + (areaTileSize - 1)) / areaTileSize; int numTilesY = (texHeight + (areaTileSize - 1)) / areaTileSize; // First of all we need to validate the history to know where we can or cannot use the history signal int m_KernelFilter = m_TemporalFilterCS.FindKernel("ValidateHistory"); var historyScale = new Vector2(hdCamera.actualWidth / (float)historySignal.rt.width, hdCamera.actualHeight / (float)historySignal.rt.height); cmd.SetComputeVectorParam(m_TemporalFilterCS, HDShaderIDs._RTHandleScaleHistory, historyScale); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer()); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._HistoryDepthTexture, historyDepthBuffer); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer()); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._HistoryNormalBufferTexture, historyNormalBuffer); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._ValidationBufferRW, m_ValidationBuffer); cmd.SetComputeFloatParam(m_TemporalFilterCS, HDShaderIDs._HistoryValidity, historyValidity); cmd.SetComputeFloatParam(m_TemporalFilterCS, HDShaderIDs._PixelSpreadAngleTangent, HDRenderPipeline.GetPixelSpreadTangent(hdCamera.camera.fieldOfView, hdCamera.actualWidth, hdCamera.actualHeight)); cmd.DispatchCompute(m_TemporalFilterCS, m_KernelFilter, numTilesX, numTilesY, hdCamera.viewCount); // Now that we have validated our history, let's accumulate m_KernelFilter = m_TemporalFilterCS.FindKernel(singleChannel ? (slotIndex == -1 ? "TemporalAccumulationSingle" : "TemporalAccumulationSingleArray") : "TemporalAccumulationColor"); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DenoiseInputTexture, noisySignal); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._HistoryBuffer, historySignal); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer()); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DenoiseOutputTextureRW, outputSignal); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._ValidationBuffer, m_ValidationBuffer); cmd.SetComputeIntParam(m_TemporalFilterCS, HDShaderIDs._DenoisingHistorySlot, slotIndex); cmd.DispatchCompute(m_TemporalFilterCS, m_KernelFilter, numTilesX, numTilesY, hdCamera.viewCount); m_KernelFilter = m_TemporalFilterCS.FindKernel(singleChannel ? (slotIndex == -1 ? "CopyHistorySingle" : "CopyHistorySingleArray") : "CopyHistoryColor"); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DenoiseInputTexture, outputSignal); cmd.SetComputeTextureParam(m_TemporalFilterCS, m_KernelFilter, HDShaderIDs._DenoiseOutputTextureRW, historySignal); cmd.SetComputeIntParam(m_TemporalFilterCS, HDShaderIDs._DenoisingHistorySlot, slotIndex); cmd.DispatchCompute(m_TemporalFilterCS, m_KernelFilter, numTilesX, numTilesY, hdCamera.viewCount); }
public void Init(HDRenderPipelineRayTracingResources rpRTResources, SharedRTManager sharedRTManager, HDRenderPipeline renderPipeline) { m_SimpleDenoiserCS = rpRTResources.simpleDenoiserCS; m_SharedRTManager = sharedRTManager; m_RenderPipeline = renderPipeline; m_BilateralFilterHSingleKernel = m_SimpleDenoiserCS.FindKernel("BilateralFilterHSingle"); m_BilateralFilterVSingleKernel = m_SimpleDenoiserCS.FindKernel("BilateralFilterVSingle"); m_BilateralFilterHColorKernel = m_SimpleDenoiserCS.FindKernel("BilateralFilterHColor"); m_BilateralFilterVColorKernel = m_SimpleDenoiserCS.FindKernel("BilateralFilterVColor"); }
public void Init(RenderPipelineResources rpResources, SharedRTManager sharedRTManager, HDRenderPipeline renderPipeline) { // Keep track of the resources m_SSGIDenoiserCS = rpResources.shaders.ssGIDenoiserCS; // Keep track of the shared rt manager m_SharedRTManager = sharedRTManager; m_RenderPipeline = renderPipeline; // Fetch the kernels we are going to require m_SpatialFilterHalfKernel = m_SSGIDenoiserCS.FindKernel("SpatialFilterHalf"); m_SpatialFilterKernel = m_SSGIDenoiserCS.FindKernel("SpatialFilter"); // Fetch the kernels we are going to require m_TemporalFilterHalfKernel = m_SSGIDenoiserCS.FindKernel("TemporalFilterHalf"); m_TemporalFilterKernel = m_SSGIDenoiserCS.FindKernel("TemporalFilter"); m_CopyHistory = m_SSGIDenoiserCS.FindKernel("CopyHistory"); }
public void Init(RenderPipelineResources rpResources, HDRenderPipelineRayTracingResources rpRTResources, SharedRTManager sharedRTManager, HDRenderPipeline renderPipeline) { // Keep track of the resources m_SimpleDenoiserCS = rpRTResources.diffuseDenoiserCS; m_OwenScrambleRGBA = rpResources.textures.owenScrambledRGBATex; // Keep track of the shared rt manager m_SharedRTManager = sharedRTManager; m_RenderPipeline = renderPipeline; }
public void Init(HDRenderPipelineRayTracingResources rpRTResources, SharedRTManager sharedRTManager, HDRenderPipeline renderPipeline) { m_SimpleDenoiserCS = rpRTResources.simpleDenoiserCS; m_SharedRTManager = sharedRTManager; m_RenderPipeline = renderPipeline; }