First Commit

Assets/Scripts/RenderPasses/ScreenFadeFeature.cs

@@ -0,0 +1,176 @@
+using Golems.RenderFeatures;
+using UnityEngine;
+using UnityEngine.Rendering;
+using Golems.Attributes;
+using RogueUtils.Data;
+using UnityEngine.Rendering.Universal;
+using static Golems.ScriptableRenderPassHelper;
+
+namespace Golems
+{
+    public class ScreenFadeFeature : SourceToDestinationBlitRenderFeature
+    {
+        [Header("Screen fade things")]
+        //
+        // This is the fade colour used to fade the screen.
+        // It is up to whatever is setting this to correctly set the alpha.
+        //
+        [SerializeField] 
+        private ColorVariable m_TargetFadeColour = default;
+
+        public bool IsEnabled
+        {
+            get
+            {
+                return m_IsEnabled;;
+            }
+            set
+            {
+                m_IsEnabled = value;
+            }
+        }
+        
+        [SerializeField] 
+        private bool m_IsEnabled = false;
+
+
+        private ScreenFadePass m_Pass = default;
+        
+        public override void Create()
+        {
+            m_Pass = new ScreenFadePass(m_TargetFadeColour);
+
+            DoCreate();
+            
+
+        }
+
+        private void DebugSetEnabledState(bool state)
+        {
+            m_IsEnabled = state;
+        }
+        private bool DebugGetEnabledState()
+        {
+            return m_IsEnabled;
+        }
+        
+        public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
+        {
+            if (IsSourceAndDestinationSame() && !m_IsEnabled)
+            {
+                //
+                // Can skip this pass as the source and destination are the same and the fade
+                // is not enabled.
+                //
+                return;
+            }
+
+            m_Pass.Setup(m_IsEnabled, m_WhenToInsert, renderer.cameraColorTarget,
+                m_SourceTextureSourceType, m_SourceNamedTemporaryNameHash,
+                m_DestinationTextureSourceType, m_DestinationNamedTemporaryNameHash,
+                m_TempCopyNamedTemporaryNameHash);
+            renderer.EnqueuePass(m_Pass);
+        }
+    }
+
+    public class ScreenFadePass : SourceToDestinationBlitRenderPass
+    {
+        private const string k_ProfilerIdent = "ScreenFadePass";
+        private const string k_ScreenFaderCompositeShader = "Hidden/ScreenFaderComposite";
+        private const string k_FadeColour = "_FadeColour";
+
+        private static readonly int k_FadeColourId = Shader.PropertyToID(k_FadeColour);
+
+        private Material m_ScreenFaderCompositeMaterial = default;
+
+        private readonly Color m_FadeColour;
+
+        private bool m_IsEnabled;
+        
+        public ScreenFadePass(ColorVariable colourVariable)
+        {
+            CreateMaterial(k_ScreenFaderCompositeShader, out m_ScreenFaderCompositeMaterial);
+            m_FadeColour = Color.white;
+        }
+        
+        public void Setup(bool isEnabled, RenderPassEvent whenToRender, RenderTargetIdentifier cameraColourTargetIdentifier,
+            RenderFeatures.TextureSourceType sourceSourceType, int tempSourceTextureHash,
+            RenderFeatures.TextureSourceType destinationSourceType, int tempDestinationTextureHash,
+            int sameSourceDestTextureHash)
+        {
+            m_IsEnabled = isEnabled;
+            DoSetup(whenToRender, cameraColourTargetIdentifier,
+                sourceSourceType, tempSourceTextureHash,
+                destinationSourceType, tempDestinationTextureHash,
+                sameSourceDestTextureHash);
+        }
+
+        public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
+        {
+            DoOnCameraSetup(cmd, ref renderingData);
+        }
+        
+        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
+        {
+#if UNITY_EDITOR
+            if (m_ScreenFaderCompositeMaterial == null)
+            {
+                //
+                // In Editor the material will get destroyed on scene change
+                //
+                CreateMaterial(k_ScreenFaderCompositeShader, out m_ScreenFaderCompositeMaterial);
+                if (m_ScreenFaderCompositeMaterial == null)
+                {
+                    return;
+                }
+            }
+#endif
+            if (!m_GoodToExecute)
+            {
+                return;
+            }
+
+            //
+            // Set up all the shader parameters here! 
+            //
+            var fadeColour = m_FadeColour;
+
+            bool doCopyOnly = fadeColour.a == 0.0f || !m_IsEnabled;
+            if (doCopyOnly)
+            {
+                //
+                // Nothing to blend
+                //
+                if (!m_SourceAndDestinationSame)
+                {
+                    //
+                    // Copy the source to the destination
+                    //
+                    var copyCmd = CommandBufferPool.Get(k_ProfilerIdent);
+                    copyCmd.Blit(m_SourceTargetIdentifier, m_DestinationTargetIdentifier);
+                    context.ExecuteCommandBuffer(copyCmd);
+                    CommandBufferPool.Release(copyCmd);
+                }
+                return;
+            }
+            m_ScreenFaderCompositeMaterial.SetColor(k_FadeColourId, fadeColour);
+
+            var cmd = CommandBufferPool.Get(k_ProfilerIdent);
+            
+            if (m_SourceAndDestinationSame)
+            {
+                // Blit the Camera into the screen copy texture using the the fader shader
+                cmd.Blit(m_SourceTargetIdentifier, m_TempCopyTargetIdentifier, m_ScreenFaderCompositeMaterial);
+                // blit back into the camera texture
+                cmd.Blit(m_TempCopyTargetIdentifier, m_DestinationTargetIdentifier);
+            }
+            else
+            {
+                cmd.Blit(m_SourceTargetIdentifier, m_DestinationTargetIdentifier, m_ScreenFaderCompositeMaterial);
+            }
+            
+            context.ExecuteCommandBuffer(cmd);
+            CommandBufferPool.Release(cmd);
+        }
+    }
+}