Merge branch 'ssr' into v2

Author: Chman

PostProcessing/Editor/PostProcessLayerEditor.cs

@@ -5,11 +5,13 @@
 using UnityEngine.Rendering.PostProcessing;
 using UnityEditorInternal;
 using System.IO;
+using ScreenSpaceReflections = UnityEngine.Rendering.PostProcessing.ScreenSpaceReflections;
 
 namespace UnityEditor.Rendering.PostProcessing
 {
     using SerializedBundleRef = PostProcessLayer.SerializedBundleRef;
     using EXRFlags = Texture2D.EXRFlags;
+    using SSRPreset = UnityEngine.Rendering.PostProcessing.ScreenSpaceReflections.Preset;
 
     [CanEditMultipleObjects, CustomEditor(typeof(PostProcessLayer))]
     public sealed class PostProcessLayerEditor : BaseEditor<PostProcessLayer>
@@ -65,6 +67,15 @@ void OnEnable()
             m_FxaaMobileOptimized = FindProperty(x => x.fastApproximateAntialiasing.mobileOptimized);
             m_FxaaKeepAlpha = FindProperty(x => x.fastApproximateAntialiasing.keepAlpha);
 
+            m_SSREnabled = FindProperty(x => x.screenSpaceReflections.enabled);
+            m_SSRPreset = FindProperty(x => x.screenSpaceReflections.preset);
+            m_SSRMaximumIterationCount = FindProperty(x => x.screenSpaceReflections.maximumIterationCount);
+            m_SSRResolution = FindProperty(x => x.screenSpaceReflections.resolution);
+            m_SSRThickness = FindProperty(x => x.screenSpaceReflections.thickness);
+            m_SSRMaximumMarchDistance = FindProperty(x => x.screenSpaceReflections.maximumMarchDistance);
+            m_SSRDistanceFade = FindProperty(x => x.screenSpaceReflections.distanceFade);
+            m_SSRAttenuation = FindProperty(x => x.screenSpaceReflections.attenuation);
+
             m_FogEnabled = FindProperty(x => x.fog.enabled);
             m_FogExcludeSkybox = FindProperty(x => x.fog.excludeSkybox);
 

PostProcessing/Runtime/Effects/Dithering.cs

@@ -10,7 +10,7 @@ public sealed class Dithering
 
         internal void Render(PostProcessRenderContext context)
         {
-            var blueNoise = context.resources.blueNoise;
+            var blueNoise = context.resources.blueNoise64;
             Assert.IsTrue(blueNoise != null && blueNoise.Length > 0);
 
         #if POSTFX_DEBUG_STATIC_DITHERING // Used by QA for automated testing

PostProcessing/Runtime/Effects/ScreenSpaceReflections.cs

@@ -0,0 +1,243 @@
+using System;
+using UnityEngine.Assertions;
+
+namespace UnityEngine.Rendering.PostProcessing
+{
+    [Serializable]
+    public sealed class ScreenSpaceReflections
+    {
+        public enum Preset
+        {
+            Lower,
+            Low,
+            Medium,
+            High,
+            Higher,
+            Ultra,
+            Overkill,
+            Custom
+        }
+
+        public enum Resolution
+        {
+            Downsampled,
+            FullSize,
+            Supersampled
+        }
+
+        [Tooltip("Enables screen-space reflections.")]
+        public bool enabled;
+
+        [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;
+
+        [Range(0, 256), Tooltip("Maximum iteration count.")]
+        public int maximumIterationCount;
+
+        [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;
+
+        [Range(1f, 64f), Tooltip("Ray thickness. Lower values are more expensive but allow the effect to detect smaller details.")]
+        public float thickness = 8f;
+
+        [Tooltip("Maximum distance to traverse after which it will stop drawing reflections.")]
+        public float maximumMarchDistance = 100f;
+
+        [Range(0f, 1f), Tooltip("Fades reflections close to the near planes.")]
+        public float distanceFade = 0.5f;
+
+        [Range(0f, 1f), Tooltip("Fades reflections close to the screen borders.")]
+        public float attenuation = 0.25f;
+
+        class QualityPreset
+        {
+            public int maximumIterationCount;
+            public float thickness;
+            public Resolution 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
+        };
+
+        RenderTexture m_Test;
+        RenderTexture m_Resolve;
+        RenderTexture m_History;
+        int[] m_MipIDs;
+
+        bool m_ResetHistory = true;
+
+        enum Pass
+        {
+            Test,
+            Resolve,
+            Reproject,
+            Composite
+        }
+
+        internal bool IsEnabledAndSupported(PostProcessRenderContext context)
+        {
+            return enabled
+                && context.camera.actualRenderingPath == RenderingPath.DeferredShading
+                && SystemInfo.supportsMotionVectors
+                && SystemInfo.supportsComputeShaders
+                && SystemInfo.copyTextureSupport > CopyTextureSupport.None;
+        }
+
+        internal DepthTextureMode GetCameraFlags()
+        {
+            return DepthTextureMode.Depth | DepthTextureMode.MotionVectors;
+        }
+
+        internal void CheckRT(ref RenderTexture rt, int width, int height, RenderTextureFormat format, FilterMode filterMode, bool useMipMap)
+        {
+            if (rt == null || !rt.IsCreated() || rt.width != width || rt.height != height)
+            {
+                if (rt != null)
+                    rt.Release();
+
+                rt = new RenderTexture(width, height, 0, format)
+                {
+                    filterMode = filterMode,
+                    useMipMap = useMipMap,
+                    autoGenerateMips = false,
+                    hideFlags = HideFlags.HideAndDontSave
+                };
+
+                rt.Create();
+            }
+        }
+
+        internal void Render(PostProcessRenderContext context)
+        {
+            var cmd = context.command;
+            cmd.BeginSample("Screen-space Reflections");
+
+            // Get quality settings
+            if (preset != Preset.Custom)
+            {
+                int id = (int)preset;
+                maximumIterationCount = m_Presets[id].maximumIterationCount;
+                thickness = m_Presets[id].thickness;
+                resolution = m_Presets[id].downsampling;
+            }
+
+            maximumMarchDistance = Mathf.Max(0f, maximumMarchDistance);
+
+            // Square POT target
+            int size = Mathf.ClosestPowerOfTwo(Mathf.Min(context.width, context.height));
+
+            if (resolution == Resolution.Downsampled)
+                size >>= 1;
+            else if (resolution == Resolution.Supersampled)
+                size <<= 1;
+
+            // The gaussian pyramid compute works in blocks of 8x8 so make sure the last lod has a
+            // minimum size of 8x8
+            const int kMaxLods = 12;
+            int lodCount = Mathf.FloorToInt(Mathf.Log(size, 2f) - 3f);
+            lodCount = Mathf.Min(lodCount, kMaxLods);
+
+            CheckRT(ref m_Resolve, size, size, context.sourceFormat, FilterMode.Trilinear, true);
+            CheckRT(ref m_History, size, size, context.sourceFormat, FilterMode.Bilinear, false);
+
+            if (m_ResetHistory)
+            {
+                context.command.BlitFullscreenTriangle(context.source, m_History);
+                m_ResetHistory = false;
+            }
+
+            var noiseTex = context.resources.blueNoise256[0];
+            var sheet = context.propertySheets.Get(context.resources.shaders.screenSpaceReflections);
+            sheet.properties.SetTexture(ShaderIDs.Noise, noiseTex);
+
+            var screenSpaceProjectionMatrix = new Matrix4x4();
+            screenSpaceProjectionMatrix.SetRow(0, new Vector4(size * 0.5f, 0f, 0f, size * 0.5f));
+            screenSpaceProjectionMatrix.SetRow(1, new Vector4(0f, size * 0.5f, 0f, size * 0.5f));
+            screenSpaceProjectionMatrix.SetRow(2, new Vector4(0f, 0f, 1f, 0f));
+            screenSpaceProjectionMatrix.SetRow(3, new Vector4(0f, 0f, 0f, 1f));
+
+            var projectionMatrix = GL.GetGPUProjectionMatrix(context.camera.projectionMatrix, false);
+            screenSpaceProjectionMatrix *= projectionMatrix;
+
+            sheet.properties.SetMatrix(ShaderIDs.ViewMatrix, context.camera.worldToCameraMatrix);
+            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));
+
+            cmd.GetTemporaryRT(ShaderIDs.Test, size, size, 0, FilterMode.Point, context.sourceFormat);
+            cmd.BlitFullscreenTriangle(context.source, ShaderIDs.Test, sheet, (int)Pass.Test);
+
+            cmd.GetTemporaryRT(ShaderIDs.SSRResolveTemp, size, size, 0, FilterMode.Bilinear, context.sourceFormat);
+            cmd.BlitFullscreenTriangle(context.source, ShaderIDs.SSRResolveTemp, sheet, (int)Pass.Resolve);
+
+            sheet.properties.SetTexture(ShaderIDs.History, m_History);
+            cmd.BlitFullscreenTriangle(ShaderIDs.SSRResolveTemp, m_Resolve, sheet, (int)Pass.Reproject);
+
+            cmd.ReleaseTemporaryRT(ShaderIDs.Test);
+            cmd.ReleaseTemporaryRT(ShaderIDs.SSRResolveTemp);
+
+            cmd.CopyTexture(m_Resolve, 0, 0, m_History, 0, 0);
+
+            // Pre-cache mipmaps ids
+            if (m_MipIDs == null || m_MipIDs.Length == 0)
+            {
+                m_MipIDs = new int[kMaxLods];
+
+                for (int i = 0; i < kMaxLods; i++)
+                    m_MipIDs[i] = Shader.PropertyToID("_SSRGaussianMip" + i);
+            }
+
+            var compute = context.resources.computeShaders.gaussianDownsample;
+            int kernel = compute.FindKernel("KMain");
+
+            var last = new RenderTargetIdentifier(m_Resolve);
+
+            for (int i = 0; i < lodCount; i++)
+            {
+                size >>= 1;
+                Assert.IsTrue(size > 0);
+
+                cmd.GetTemporaryRT(m_MipIDs[i], size, size, 0, FilterMode.Bilinear, context.sourceFormat, RenderTextureReadWrite.Default, 1, true);
+                cmd.SetComputeTextureParam(compute, kernel, "_Source", last);
+                cmd.SetComputeTextureParam(compute, kernel, "_Result", m_MipIDs[i]);
+                cmd.SetComputeVectorParam(compute, "_Size", new Vector4(size, size, 1f / size, 1f / size));
+                cmd.DispatchCompute(compute, kernel, size / 8, size / 8, 1);
+                cmd.CopyTexture(m_MipIDs[i], 0, 0, m_Resolve, 0, i + 1);
+
+                last = m_MipIDs[i];
+            }
+
+            for (int i = 0; i < lodCount; i++)
+                cmd.ReleaseTemporaryRT(m_MipIDs[i]);
+
+            sheet.properties.SetTexture(ShaderIDs.Resolve, m_Resolve);
+            cmd.BlitFullscreenTriangle(context.source, context.destination, sheet, (int)Pass.Composite);
+            cmd.EndSample("Screen-space Reflections");
+        }
+
+        internal 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.meta

@@ -29,6 +29,7 @@ public enum Antialiasing
         public TemporalAntialiasing temporalAntialiasing;
         public SubpixelMorphologicalAntialiasing subpixelMorphologicalAntialiasing;
         public FastApproximateAntialiasing fastApproximateAntialiasing;
+        public ScreenSpaceReflections screenSpaceReflections;
         public Fog fog;
         public Dithering dithering;
 
@@ -137,8 +138,8 @@ void OnEnable()
         public void Init(PostProcessResources resources)
         {
             if (resources != null) m_Resources = resources;
-            
-            RuntimeUtilities.CreateIfNull(ref debugLayer);
+
+            RuntimeUtilities.CreateIfNull(ref screenSpaceReflections);
             RuntimeUtilities.CreateIfNull(ref temporalAntialiasing);
             RuntimeUtilities.CreateIfNull(ref subpixelMorphologicalAntialiasing);
             RuntimeUtilities.CreateIfNull(ref fastApproximateAntialiasing);
@@ -226,6 +227,7 @@ void OnDisable()
             }
 
             temporalAntialiasing.Release();
+            screenSpaceReflections.Release();
             m_LogHistogram.Release();
 
             foreach (var bundle in m_Bundles.Values)
@@ -270,7 +272,7 @@ void OnPreCull()
             context.Reset();
             context.camera = m_Camera;
             context.sourceFormat = sourceFormat;
-            
+
             m_LegacyCmdBufferBeforeReflections.Clear();
             m_LegacyCmdBufferBeforeLighting.Clear();
             m_LegacyCmdBufferOpaque.Clear();
@@ -289,6 +291,7 @@ void OnPreCull()
             bool aoAmbientOnly = aoRenderer.IsAmbientOnly(context);
             bool isAmbientOcclusionDeferred = aoSupported && aoAmbientOnly;
             bool isAmbientOcclusionOpaque = aoSupported && !aoAmbientOnly;
+            bool isScreenSpaceReflectionsActive = screenSpaceReflections.IsEnabledAndSupported(context);
             bool isFogActive = fog.IsEnabledAndSupported(context);
 
             // Ambient-only AO is a special case and has to be done in separate command buffers
@@ -310,6 +313,7 @@ void OnPreCull()
                 aoRenderer.Get().RenderAfterOpaque(context);
             }
 
+            opaqueOnlyEffects += isScreenSpaceReflectionsActive ? 1 : 0;
             opaqueOnlyEffects += isFogActive ? 1 : 0;
             opaqueOnlyEffects += hasCustomOpaqueOnlyEffects ? 1 : 0;
 
@@ -337,7 +341,14 @@ void OnPreCull()
                 }
                 else context.destination = cameraTarget;
 
-                // TODO: Insert SSR here
+                if (isScreenSpaceReflectionsActive)
+                {
+                    screenSpaceReflections.Render(context);
+                    opaqueOnlyEffects--;
+                    var prevSource = context.source;
+                    context.source = context.destination;
+                    context.destination = opaqueOnlyEffects == 1 ? cameraTarget : prevSource;
+                }
 
                 if (isFogActive)
                 {
@@ -373,14 +384,14 @@ void OnPreCull()
         }
 
         void OnPostRender()
-         {
-             // Unused in scriptable render pipelines
-             if (RuntimeUtilities.scriptableRenderPipelineActive)
-                 return;
- 
-             if (m_CurrentContext.IsTemporalAntialiasingActive())
-                 m_Camera.ResetProjectionMatrix();
-         }
+        {
+            // Unused in scriptable render pipelines
+            if (RuntimeUtilities.scriptableRenderPipelineActive)
+                return;
+
+            if (m_CurrentContext.IsTemporalAntialiasingActive())
+                m_Camera.ResetProjectionMatrix();
+        }
 
         PostProcessBundle GetBundle<T>()
             where T : PostProcessEffectSettings
@@ -451,6 +462,7 @@ public void ResetHistory()
                 bundle.Value.ResetHistory();
 
             temporalAntialiasing.ResetHistory();
+            screenSpaceReflections.ResetHistory();
         }
 
         public bool HasOpaqueOnlyEffects(PostProcessRenderContext context)