Added a scene transparent depth prepass.

Did a few enhancements to the samples.
Added TODOs to README.

Author: yahiaetman

CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+### Added
+- Added a Scene Transparent Depth PrePass.
+
+### Changed
+- Gradient Fog can now be used before or after the transparent pass.
+
+### Fixed
+- Fixed after image popping on leaving the volume by changing the default time scale to 0.
+- Fixed scene shifting on the screen to the left with the Glitch effect.
+- Removed some visual artifacts from Edge Detection by making the depth threshold relative to the center pixel depth.
+
 ## [1.0.0] - 2020-09-17
 ### Added
 - Added the main functionality for custom post-processing as renderer future for URP.

README.md

@@ -49,6 +49,12 @@ Other custom effects in samples but not used in screenshots:
 * It failed with **Single-Pass Instanced** on **Mock HMD Loader**.
 * The `SceneNormals` renderer feature uses the override material in the drawing settings so it doesn't copy the original materials' parameters (e.g. normal maps and alpha clipping) and doesn't respect custom vertex shaders. This should be solved in URP 10.0 with the release of the `DepthNormalsPass` made for the SSAO feature.
 
+## Features I hope to implement
+
+- [ ] Global settings for `CustomPostProcessRenderer` to be set from the renderer feature instead of the volume component.
+- [ ] A Volumetric Light Effect as a sample.
+- [ ] The ability to add the same renderer multiple times under the same injection point (not sure yet if it is a good idea).
+
 ## How To Install
 
 Follow the instructions from the Unity manual on [Installing from a Git URL](https://docs.unity3d.com/Manual/upm-ui-giturl.html) and insert the url:
@@ -231,6 +237,7 @@ We didn't explain some stuff here but you can see more in the samples:
 * Create temporary render targets inside the renderer (see [StreakEffect.cs](Samples~/Examples/Scripts/PostProcessing/StreakEffect.cs)).
 * Create persistent render targets inside the renderer (see [AfterImageEffect.cs](Samples~/Examples/Scripts/PostProcessing/AfterImageEffect.cs)).
 * Use a shader graph `Unlit shader` to create a post processing effect (see [GlitchEffect.cs](Samples~/Examples/Scripts/PostProcessing/GlitchEffect.cs)).
+* Use a renderer at multiple injection points (see [GradientFogEffect.cs](Samples~/Examples/Scripts/PostProcessing/GradientFogEffect.cs) and [GradientFog.shader](Samples~/Examples/Resources/Shaders/PostProcessing/GradientFog.shader)). 
 
 ## Issues & Pull Requests
 

Runtime/RenderFeatures/SceneTransparentDepth.cs

@@ -0,0 +1,130 @@
+using System;
+
+namespace UnityEngine.Rendering.Universal.PostProcessing
+{
+    /// <summary>
+    /// This renderer feature renders the depth of transparent objects to a texture named "_CameraTransparentDepthTexture"
+    /// </summary>
+    [Serializable]
+    public class SceneTransparentDepth : ScriptableRendererFeature
+    {
+        
+        /// <summary>
+        /// The render pass
+        /// </summary>
+        private TransparentDepthPass depthPass = null;
+
+        /// <summary>
+        /// The render target for the scene transparent depth
+        /// </summary>
+        private RenderTargetHandle sceneTransparentDepthTexture = default;
+
+        /// <summary>
+        /// Intializes the renderer feature resources
+        /// </summary>
+        public override void Create()
+        {
+            depthPass = new TransparentDepthPass(RenderPassEvent.AfterRenderingPrePasses, RenderQueueRange.transparent, -1);
+            sceneTransparentDepthTexture.Init("_CameraTransparentDepthTexture");
+        }
+
+        /// <summary>
+        /// Here you can inject one or multiple render passes in the renderer.
+        /// This method is called when setting up the renderer once per-camera.
+        /// </summary>
+        public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
+        {
+            depthPass.Setup(sceneTransparentDepthTexture);
+            renderer.EnqueuePass(depthPass);
+        }
+    }
+
+    /// <summary>
+    /// Render all transparent objects that have a 'DepthOnly' pass into the given depth buffer.
+    ///
+    /// You can use this pass to prime a depth buffer for subsequent rendering.
+    /// Use it as a z-prepass, or use it to generate a depth buffer.
+    /// 
+    /// Code mostly copied from "DepthOnlyPass.cs" from the Universal Render Pipeline
+    /// </summary>
+    public class TransparentDepthPass : ScriptableRenderPass
+    {
+        int kDepthBufferBits = 32;
+
+        private RenderTargetHandle destination;
+
+        FilteringSettings m_FilteringSettings;
+        const string m_ProfilerTag = "Transparent Depth Prepass";
+        ProfilingSampler m_ProfilingSampler = new ProfilingSampler(m_ProfilerTag);
+        ShaderTagId m_ShaderTagId = new ShaderTagId("DepthOnly");
+
+        /// <summary>
+        /// Create the TransparentDepthPass
+        /// </summary>
+        public TransparentDepthPass(RenderPassEvent evt, RenderQueueRange renderQueueRange, LayerMask layerMask)
+        {
+            m_FilteringSettings = new FilteringSettings(renderQueueRange, layerMask);
+            renderPassEvent = evt;
+        }
+
+        /// <summary>
+        /// Configure the pass
+        /// </summary>
+        public void Setup( RenderTargetHandle destination)
+        {
+            this.destination = destination;
+        }
+
+        public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
+        {
+            RenderTextureDescriptor descriptor = cameraTextureDescriptor;
+            descriptor.colorFormat = RenderTextureFormat.Depth;
+            descriptor.depthBufferBits = kDepthBufferBits;
+            descriptor.msaaSamples = 1;
+
+            cmd.GetTemporaryRT(destination.id, descriptor, FilterMode.Point);
+            ConfigureTarget(destination.Identifier());
+            ConfigureClear(ClearFlag.All, Color.black);
+        }
+
+        /// <inheritdoc/>
+        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
+        {
+            CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
+            using (new ProfilingScope(cmd, m_ProfilingSampler))
+            {
+                context.ExecuteCommandBuffer(cmd);
+                cmd.Clear();
+
+                var sortFlags = renderingData.cameraData.defaultOpaqueSortFlags;
+                var drawSettings = CreateDrawingSettings(m_ShaderTagId, ref renderingData, sortFlags);
+                drawSettings.perObjectData = PerObjectData.None;
+
+                ref CameraData cameraData = ref renderingData.cameraData;
+                Camera camera = cameraData.camera;
+                if (cameraData.isStereoEnabled)
+                    context.StartMultiEye(camera);
+                
+                m_FilteringSettings.layerMask = camera.cullingMask;
+
+                context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref m_FilteringSettings);
+
+            }
+            context.ExecuteCommandBuffer(cmd);
+            CommandBufferPool.Release(cmd);
+        }
+
+        /// <inheritdoc/>
+        public override void FrameCleanup(CommandBuffer cmd)
+        {
+            if (cmd == null)
+                throw new ArgumentNullException("cmd");
+
+            if (destination != RenderTargetHandle.CameraTarget)
+            {
+                cmd.ReleaseTemporaryRT(destination.id);
+                destination = RenderTargetHandle.CameraTarget;
+            }
+        }
+    }
+}

Runtime/RenderFeatures/SceneTransparentDepth.cs.meta

@@ -83,7 +83,7 @@
         // Normal similarity is calculated using a dot product
         float normalSame = smoothstep(_Threshold.x, _Threshold.y, dot(center.xyz, neighborhood.xyz));
         // Depth similarity is calculated using absolute difference
-        float depthSame = smoothstep(_Threshold.w, _Threshold.z, abs(center.w - neighborhood.w));
+        float depthSame = smoothstep(_Threshold.w * center.w, _Threshold.z * center.w, abs(center.w - neighborhood.w));
         // Combine normal and depth sameness to get edge factor
         float edge = 1 - normalSame * depthSame;
 

Samples~/Examples/Resources/Shaders/PostProcessing/EdgeDetection.shader

@@ -3,6 +3,10 @@
     HLSLINCLUDE
     #include "Packages/com.yetman.render-pipelines.universal.postprocess/ShaderLibrary/Core.hlsl"
     #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"
+    
+    #if AFTER_TRANSPARENT_ON
+    #include "Packages/com.yetman.render-pipelines.universal.postprocess/ShaderLibrary/DeclareTransparentDepthTexture.hlsl"
+    #endif
 
     TEXTURE2D_X(_MainTex);
 
@@ -32,6 +36,20 @@
         uint2 positionSS = uv * _ScreenSize.xy;
 
         float depth = LoadSceneDepth(positionSS);
+
+        #if AFTER_TRANSPARENT_ON
+        // If the fog is applied after the transparent pass,
+        // the depth is sampled from both the opaque and transparent depth textures
+        // and the nearest depth is selected.
+        // TODO: This can be optimized to read from one texture if the scene transparent depth includes the opaque depth 
+        float transparentDepth = LoadSceneTransparentDepth(positionSS);
+            #if UNITY_REVERSED_Z
+                depth = max(depth, transparentDepth);
+            #else
+                depth = min(depth, transparentDepth);
+            #endif
+        #endif
+
         float deviceDepth = ConvertZBufferToDeviceDepth(depth);
         float3 viewPos = ComputeViewSpacePosition(uv, deviceDepth, unity_CameraInvProjection);
         float distance = length(viewPos);
@@ -52,6 +70,8 @@
         Pass
         {
             HLSLPROGRAM
+            #pragma multi_compile_local_fragment __ AFTER_TRANSPARENT_ON
+
             #pragma vertex FullScreenTrianglePostProcessVertexProgram
             #pragma fragment GradientFogFragmentProgram
             ENDHLSL

Samples~/Examples/Resources/Shaders/PostProcessing/Glitch.shadergraph

@@ -17,7 +17,7 @@ public class AfterImageEffect : VolumeComponent
         public ColorParameter blend = new ColorParameter(Color.black, false, false, true);
 
         [Tooltip("A scale for the time to convergence.")]
-        public MinFloatParameter timeScale = new MinFloatParameter(1, 0);
+        public MinFloatParameter timeScale = new MinFloatParameter(0, 0);
     }
 
     // Define the renderer for the custom post processing effect
@@ -80,8 +80,8 @@ public override bool Setup(ref RenderingData renderingData, CustomPostProcessInj
             var stack = VolumeManager.instance.stack;
             // Get the corresponding volume component
             m_VolumeComponent = stack.GetComponent<AfterImageEffect>();
-            // if blend value > 0, then we need to render this effect. 
-            bool requireRendering = m_VolumeComponent.blend.value != Color.black;
+            // if blend value and time scale > 0, then we need to render this effect. 
+            bool requireRendering = m_VolumeComponent.blend.value != Color.black && m_VolumeComponent.timeScale.value > 0;
             // if we don't need to execute this frame, we need to make sure that the history is invalidated
             // this solves an artifact where a very old history is used due to the effect being disabled for many frames   
             if(!requireRendering){
@@ -131,7 +131,7 @@ public override void Render(CommandBuffer cmd, RenderTargetIdentifier source, Re
             // set material properties
             if(m_Material != null){
                 Color blend = m_VolumeComponent.blend.value;
-                float power = Time.deltaTime / m_VolumeComponent.timeScale.value;
+                float power = Time.deltaTime / Mathf.Max(Mathf.Epsilon, m_VolumeComponent.timeScale.value);
                 // The amound of blending should depend on the delta time to make fading time frame-rate independent. 
                 blend.r = Mathf.Pow(blend.r, power);
                 blend.g = Mathf.Pow(blend.g, power);

Samples~/Examples/Resources/Shaders/PostProcessing/GradientFog.shader

@@ -29,7 +29,8 @@ public class GradientFogEffect : VolumeComponent
     }
 
     // Define the renderer for the custom post processing effect
-    [CustomPostProcess("Gradient Fog", CustomPostProcessInjectionPoint.AfterOpaqueAndSky)]
+    // This effect can be used after the opaque/sky pass or after the transparent pass
+    [CustomPostProcess("Gradient Fog", CustomPostProcessInjectionPoint.AfterOpaqueAndSky | CustomPostProcessInjectionPoint.BeforePostProcess)]
     public class GradientFogEffectRenderer : CustomPostProcessRenderer
     {
         // A variable to hold a reference to the corresponding volume component (you can define as many as you like)
@@ -79,6 +80,12 @@ public override void Render(CommandBuffer cmd, RenderTargetIdentifier source, Re
                 m_Material.SetVector(ShaderIDs.ColorRange, new Vector2(m_VolumeComponent.nearColorDistance.value, m_VolumeComponent.farColorDistance.value));
                 m_Material.SetColor(ShaderIDs.NearFogColor, m_VolumeComponent.nearFogColor.value);
                 m_Material.SetColor(ShaderIDs.FarFogColor, m_VolumeComponent.farFogColor.value);
+                // Checks whether the renderer is called before transparent or not to pick the proper shader features
+                if(injectionPoint == CustomPostProcessInjectionPoint.AfterOpaqueAndSky){
+                    m_Material.DisableKeyword("AFTER_TRANSPARENT_ON");
+                } else {
+                    m_Material.EnableKeyword("AFTER_TRANSPARENT_ON");
+                }
             }
             // set source texture
             cmd.SetGlobalTexture(ShaderIDs.Input, source);

Samples~/Examples/Scripts/PostProcessing/AfterImageEffect.cs

@@ -0,0 +1,17 @@
+#ifndef YETMAN_POSTPROCESS_TRANSPARENT_DECLARE_DEPTH_TEXTURE_INCLUDED
+#define YETMAN_POSTPROCESS_TRANSPARENT_DECLARE_DEPTH_TEXTURE_INCLUDED
+#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+
+TEXTURE2D_X_FLOAT(_CameraTransparentDepthTexture);
+SAMPLER(sampler_CameraTransparentDepthTexture);
+
+float SampleSceneTransparentDepth(float2 uv)
+{
+    return SAMPLE_TEXTURE2D_X(_CameraTransparentDepthTexture, sampler_CameraTransparentDepthTexture, UnityStereoTransformScreenSpaceTex(uv)).r;
+}
+
+float LoadSceneTransparentDepth(uint2 uv)
+{
+    return LOAD_TEXTURE2D_X(_CameraTransparentDepthTexture, uv).r;
+}
+#endif