Moved SSR to profile / volume

Author: Chman

PostProcessing/Editor/Effects/AmbientOcclusionEditor.cs

@@ -27,6 +27,12 @@ public override void OnEnable()
 
         public override void OnInspectorGUI()
         {
+            if (RuntimeUtilities.scriptableRenderPipelineActive)
+            {
+                EditorGUILayout.HelpBox("This effect doesn't work with scriptable render pipelines yet.", MessageType.Warning);
+                return;
+            }
+
             PropertyField(m_Mode);
             PropertyField(m_Intensity);
 

PostProcessing/Editor/Effects/ScreenSpaceReflectionsEditor.cs

@@ -0,0 +1,58 @@
+using UnityEngine;
+using UnityEngine.Rendering.PostProcessing;
+
+namespace UnityEditor.Rendering.PostProcessing
+{
+    [PostProcessEditor(typeof(ScreenSpaceReflections))]
+    public sealed class ScreenSpaceReflectionsEditor : PostProcessEffectEditor<ScreenSpaceReflections>
+    {
+        SerializedParameterOverride m_Preset;
+        SerializedParameterOverride m_MaximumIterationCount;
+        SerializedParameterOverride m_Thickness;
+        SerializedParameterOverride m_Resolution;
+        SerializedParameterOverride m_MaximumMarchDistance;
+        SerializedParameterOverride m_DistanceFade;
+        SerializedParameterOverride m_Attenuation;
+
+        public override void OnEnable()
+        {
+            m_Preset = FindParameterOverride(x => x.preset);
+            m_MaximumIterationCount = FindParameterOverride(x => x.maximumIterationCount);
+            m_Thickness = FindParameterOverride(x => x.thickness);
+            m_Resolution = FindParameterOverride(x => x.resolution);
+            m_MaximumMarchDistance = FindParameterOverride(x => x.maximumMarchDistance);
+            m_DistanceFade = FindParameterOverride(x => x.distanceFade);
+            m_Attenuation = FindParameterOverride(x => x.attenuation);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (RuntimeUtilities.scriptableRenderPipelineActive)
+            {
+                EditorGUILayout.HelpBox("This effect doesn't work with scriptable render pipelines yet.", MessageType.Warning);
+                return;
+            }
+
+            if (Camera.main.actualRenderingPath != RenderingPath.DeferredShading)
+                EditorGUILayout.HelpBox("This effect only works with the deferred rendering path.", MessageType.Warning);
+
+            if (!SystemInfo.supportsComputeShaders)
+                EditorGUILayout.HelpBox("This effect requires compute shader support.", MessageType.Warning);
+
+            PropertyField(m_Preset);
+
+            if (m_Preset.value.intValue == (int)ScreenSpaceReflectionPreset.Custom)
+            {
+                PropertyField(m_MaximumIterationCount);
+                PropertyField(m_Thickness);
+                PropertyField(m_Resolution);
+
+                EditorGUILayout.Space();
+            }
+
+            PropertyField(m_MaximumMarchDistance);
+            PropertyField(m_DistanceFade);
+            PropertyField(m_Attenuation);
+        }
+    }
+}

PostProcessing/Editor/Effects/ScreenSpaceReflectionsEditor.cs.meta

@@ -3,77 +3,83 @@
 
 namespace UnityEngine.Rendering.PostProcessing
 {
-    [Serializable]
-    public sealed class ScreenSpaceReflections
+    public enum ScreenSpaceReflectionPreset
     {
-        public enum Preset
-        {
-            Lower,
-            Low,
-            Medium,
-            High,
-            Higher,
-            Ultra,
-            Overkill,
-            Custom
-        }
+        Lower, Low, Medium, High, Higher, Ultra, Overkill, Custom
+    }
 
-        public enum Resolution
-        {
-            Downsampled,
-            FullSize,
-            Supersampled
-        }
+    public enum ScreenSpaceReflectionResolution
+    {
+        Downsampled,
+        FullSize,
+        Supersampled
+    }
 
-        [Tooltip("Enables screen-space reflections.")]
-        public bool enabled;
+    [Serializable]
+    public sealed class ScreenSpaceReflectionPresetParameter : ParameterOverride<ScreenSpaceReflectionPreset> {}
+
+    [Serializable]
+    public sealed class ScreenSpaceReflectionResolutionParameter : ParameterOverride<ScreenSpaceReflectionResolution> {}
 
+    [Serializable]
+    [PostProcess(typeof(ScreenSpaceReflectionsRenderer), "Unity/Screen-space reflections")]
+    public sealed class ScreenSpaceReflections : PostProcessEffectSettings
+    {
         [Tooltip("Choose a quality preset, or use \"Custom\" to fine tune it. Don't use a preset higher than \"Medium\" if you care about performances on consoles.")]
-        public Preset preset = Preset.Medium;
+        public ScreenSpaceReflectionPresetParameter preset = new ScreenSpaceReflectionPresetParameter { value = ScreenSpaceReflectionPreset.Medium };
 
         [Range(0, 256), Tooltip("Maximum iteration count.")]
-        public int maximumIterationCount;
+        public IntParameter maximumIterationCount = new IntParameter { value = 16 };
 
         [Tooltip("Changes the size of the SSR buffer. Downsample it to maximize performances or supersample it to get slow but higher quality results.")]
-        public Resolution resolution = Resolution.Downsampled;
+        public ScreenSpaceReflectionResolutionParameter resolution = new ScreenSpaceReflectionResolutionParameter { value = ScreenSpaceReflectionResolution.Downsampled };
 
         [Range(1f, 64f), Tooltip("Ray thickness. Lower values are more expensive but allow the effect to detect smaller details.")]
-        public float thickness = 8f;
+        public FloatParameter thickness = new FloatParameter { value = 8f };
 
         [Tooltip("Maximum distance to traverse after which it will stop drawing reflections.")]
-        public float maximumMarchDistance = 100f;
+        public FloatParameter maximumMarchDistance = new FloatParameter { value = 100f };
 
         [Range(0f, 1f), Tooltip("Fades reflections close to the near planes.")]
-        public float distanceFade = 0.5f;
+        public FloatParameter distanceFade = new FloatParameter { value = 0.5f };
 
         [Range(0f, 1f), Tooltip("Fades reflections close to the screen borders.")]
-        public float attenuation = 0.25f;
+        public FloatParameter attenuation = new FloatParameter { value = 0.25f };
+
+        public override bool IsEnabledAndSupported(PostProcessRenderContext context)
+        {
+            return enabled
+                && context.camera.actualRenderingPath == RenderingPath.DeferredShading
+                && SystemInfo.supportsMotionVectors
+                && SystemInfo.supportsComputeShaders
+                && SystemInfo.copyTextureSupport > CopyTextureSupport.None;
+        }
+    }
+
+    public sealed class ScreenSpaceReflectionsRenderer : PostProcessEffectRenderer<ScreenSpaceReflections>
+    {
+        RenderTexture m_Resolve;
+        RenderTexture m_History;
+        int[] m_MipIDs;
 
         class QualityPreset
         {
             public int maximumIterationCount;
             public float thickness;
-            public Resolution downsampling;
+            public ScreenSpaceReflectionResolution downsampling;
         }
 
         QualityPreset[] m_Presets =
         {
-            new QualityPreset { maximumIterationCount = 10, thickness = 32, downsampling = Resolution.Downsampled  }, // Lower
-            new QualityPreset { maximumIterationCount = 16, thickness = 32, downsampling = Resolution.Downsampled  }, // Low
-            new QualityPreset { maximumIterationCount = 32, thickness = 16, downsampling = Resolution.Downsampled  }, // Medium
-            new QualityPreset { maximumIterationCount = 48, thickness =  8, downsampling = Resolution.Downsampled  }, // High
-            new QualityPreset { maximumIterationCount = 16, thickness = 32, downsampling = Resolution.FullSize }, // Higher
-            new QualityPreset { maximumIterationCount = 48, thickness = 16, downsampling = Resolution.FullSize }, // Ultra
-            new QualityPreset { maximumIterationCount = 128, thickness = 12, downsampling = Resolution.Supersampled }, // Overkill
+            new QualityPreset { maximumIterationCount = 10, thickness = 32, downsampling = ScreenSpaceReflectionResolution.Downsampled  }, // Lower
+            new QualityPreset { maximumIterationCount = 16, thickness = 32, downsampling = ScreenSpaceReflectionResolution.Downsampled  }, // Low
+            new QualityPreset { maximumIterationCount = 32, thickness = 16, downsampling = ScreenSpaceReflectionResolution.Downsampled  }, // Medium
+            new QualityPreset { maximumIterationCount = 48, thickness =  8, downsampling = ScreenSpaceReflectionResolution.Downsampled  }, // High
+            new QualityPreset { maximumIterationCount = 16, thickness = 32, downsampling = ScreenSpaceReflectionResolution.FullSize }, // Higher
+            new QualityPreset { maximumIterationCount = 48, thickness = 16, downsampling = ScreenSpaceReflectionResolution.FullSize }, // Ultra
+            new QualityPreset { maximumIterationCount = 128, thickness = 12, downsampling = ScreenSpaceReflectionResolution.Supersampled }, // Overkill
         };
 
-        RenderTexture m_Test;
-        RenderTexture m_Resolve;
-        RenderTexture m_History;
-        int[] m_MipIDs;
-
-        bool m_ResetHistory = true;
-
         enum Pass
         {
             Test,
@@ -82,16 +88,7 @@ enum Pass
             Composite
         }
 
-        internal bool IsEnabledAndSupported(PostProcessRenderContext context)
-        {
-            return enabled
-                && context.camera.actualRenderingPath == RenderingPath.DeferredShading
-                && SystemInfo.supportsMotionVectors
-                && SystemInfo.supportsComputeShaders
-                && SystemInfo.copyTextureSupport > CopyTextureSupport.None;
-        }
-
-        internal DepthTextureMode GetCameraFlags()
+        public override DepthTextureMode GetCameraFlags()
         {
             return DepthTextureMode.Depth | DepthTextureMode.MotionVectors;
         }
@@ -115,28 +112,28 @@ internal void CheckRT(ref RenderTexture rt, int width, int height, RenderTexture
             }
         }
 
-        internal void Render(PostProcessRenderContext context)
+        public override void Render(PostProcessRenderContext context)
         {
             var cmd = context.command;
             cmd.BeginSample("Screen-space Reflections");
 
             // Get quality settings
-            if (preset != Preset.Custom)
+            if (settings.preset.value != ScreenSpaceReflectionPreset.Custom)
             {
-                int id = (int)preset;
-                maximumIterationCount = m_Presets[id].maximumIterationCount;
-                thickness = m_Presets[id].thickness;
-                resolution = m_Presets[id].downsampling;
+                int id = (int)settings.preset.value;
+                settings.maximumIterationCount.value = m_Presets[id].maximumIterationCount;
+                settings.thickness.value = m_Presets[id].thickness;
+                settings.resolution.value = m_Presets[id].downsampling;
             }
 
-            maximumMarchDistance = Mathf.Max(0f, maximumMarchDistance);
+            settings.maximumMarchDistance.value = Mathf.Max(0f, settings.maximumMarchDistance.value);
 
             // Square POT target
             int size = Mathf.ClosestPowerOfTwo(Mathf.Min(context.width, context.height));
 
-            if (resolution == Resolution.Downsampled)
+            if (settings.resolution.value == ScreenSpaceReflectionResolution.Downsampled)
                 size >>= 1;
-            else if (resolution == Resolution.Supersampled)
+            else if (settings.resolution.value == ScreenSpaceReflectionResolution.Supersampled)
                 size <<= 1;
 
             // The gaussian pyramid compute works in blocks of 8x8 so make sure the last lod has a
@@ -171,8 +168,8 @@ internal void Render(PostProcessRenderContext context)
             sheet.properties.SetMatrix(ShaderIDs.InverseViewMatrix, context.camera.worldToCameraMatrix.inverse);
             sheet.properties.SetMatrix(ShaderIDs.InverseProjectionMatrix, projectionMatrix.inverse);
             sheet.properties.SetMatrix(ShaderIDs.ScreenSpaceProjectionMatrix, screenSpaceProjectionMatrix);
-            sheet.properties.SetVector(ShaderIDs.Params, new Vector4(attenuation, distanceFade, maximumMarchDistance, lodCount));
-            sheet.properties.SetVector(ShaderIDs.Params2, new Vector4((float)context.width / (float)context.height, (float)size / (float)noiseTex.width, thickness, maximumIterationCount));
+            sheet.properties.SetVector(ShaderIDs.Params, new Vector4(settings.attenuation.value, settings.distanceFade.value, settings.maximumMarchDistance.value, lodCount));
+            sheet.properties.SetVector(ShaderIDs.Params2, new Vector4((float)context.width / (float)context.height, (float)size / (float)noiseTex.width, settings.thickness.value, settings.maximumIterationCount.value));
 
             cmd.GetTemporaryRT(ShaderIDs.Test, size, size, 0, FilterMode.Point, context.sourceFormat);
             cmd.BlitFullscreenTriangle(context.source, ShaderIDs.Test, sheet, (int)Pass.Test);
@@ -225,19 +222,12 @@ internal void Render(PostProcessRenderContext context)
             cmd.EndSample("Screen-space Reflections");
         }
 
-        internal void Release()
+        public override void Release()
         {
-            RuntimeUtilities.Destroy(m_Test);
             RuntimeUtilities.Destroy(m_Resolve);
             RuntimeUtilities.Destroy(m_History);
-            m_Test = null;
             m_Resolve = null;
             m_History = null;
         }
-
-        internal void ResetHistory()
-        {
-            m_ResetHistory = true;
-        }
     }
 }

PostProcessing/Runtime/Effects/ScreenSpaceReflections.cs

@@ -29,7 +29,6 @@ public enum Antialiasing
         public TemporalAntialiasing temporalAntialiasing;
         public SubpixelMorphologicalAntialiasing subpixelMorphologicalAntialiasing;
         public FastApproximateAntialiasing fastApproximateAntialiasing;
-        public ScreenSpaceReflections screenSpaceReflections;
         public Fog fog;
         public Dithering dithering;
 
@@ -138,7 +137,6 @@ public void Init(PostProcessResources resources)
         {
             if (resources != null) m_Resources = resources;
 
-            RuntimeUtilities.CreateIfNull(ref screenSpaceReflections);
             RuntimeUtilities.CreateIfNull(ref temporalAntialiasing);
             RuntimeUtilities.CreateIfNull(ref subpixelMorphologicalAntialiasing);
             RuntimeUtilities.CreateIfNull(ref fastApproximateAntialiasing);
@@ -226,7 +224,6 @@ void OnDisable()
             }
 
             temporalAntialiasing.Release();
-            screenSpaceReflections.Release();
             m_LogHistogram.Release();
 
             foreach (var bundle in m_Bundles.Values)
@@ -279,19 +276,23 @@ void OnPreCull()
 
             SetupContext(context);
 
+            context.command = m_LegacyCmdBufferOpaque;
+            UpdateSettingsIfNeeded(context);
+
             // Lighting & opaque-only effects
             var aoBundle = GetBundle<AmbientOcclusion>();
             var aoSettings = aoBundle.CastSettings<AmbientOcclusion>();
             var aoRenderer = aoBundle.CastRenderer<AmbientOcclusionRenderer>();
 
-            int opaqueOnlyEffects = 0;
-            bool hasCustomOpaqueOnlyEffects = HasOpaqueOnlyEffects(context);
             bool aoSupported = aoSettings.IsEnabledAndSupported(context);
             bool aoAmbientOnly = aoRenderer.IsAmbientOnly(context);
             bool isAmbientOcclusionDeferred = aoSupported && aoAmbientOnly;
             bool isAmbientOcclusionOpaque = aoSupported && !aoAmbientOnly;
-            bool isScreenSpaceReflectionsActive = screenSpaceReflections.IsEnabledAndSupported(context);
-            bool isFogActive = fog.IsEnabledAndSupported(context);
+
+            var ssrBundle = GetBundle<ScreenSpaceReflections>();
+            var ssrSettings = ssrBundle.settings;
+            var ssrRenderer = ssrBundle.renderer;
+            bool isScreenSpaceReflectionsActive = ssrSettings.IsEnabledAndSupported(context);
 
             // Ambient-only AO is a special case and has to be done in separate command buffers
             if (isAmbientOcclusionDeferred)
@@ -311,7 +312,10 @@ void OnPreCull()
                 context.command = m_LegacyCmdBufferOpaque;
                 aoRenderer.Get().RenderAfterOpaque(context);
             }
-
+            
+            bool isFogActive = fog.IsEnabledAndSupported(context);
+            bool hasCustomOpaqueOnlyEffects = HasOpaqueOnlyEffects(context);
+            int opaqueOnlyEffects = 0;
             opaqueOnlyEffects += isScreenSpaceReflectionsActive ? 1 : 0;
             opaqueOnlyEffects += isFogActive ? 1 : 0;
             opaqueOnlyEffects += hasCustomOpaqueOnlyEffects ? 1 : 0;
@@ -342,7 +346,7 @@ void OnPreCull()
 
                 if (isScreenSpaceReflectionsActive)
                 {
-                    screenSpaceReflections.Render(context);
+                    ssrRenderer.Render(context);
                     opaqueOnlyEffects--;
                     var prevSource = context.source;
                     context.source = context.destination;
@@ -461,7 +465,6 @@ public void ResetHistory()
                 bundle.Value.ResetHistory();
 
             temporalAntialiasing.ResetHistory();
-            screenSpaceReflections.ResetHistory();
         }
 
         public bool HasOpaqueOnlyEffects(PostProcessRenderContext context)