refactor(srp): infer fullscreen stages from renderer pass queue

managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRenderer.cs

@@ -95,6 +95,12 @@ namespace XCEngine.Rendering.Universal
             ConfigureCameraFramePlan(context);
         }
 
+        internal void FinalizeCameraFramePlanInstance(
+            ScriptableRenderPipelinePlanningContext context)
+        {
+            FinalizeCameraFramePlan(context);
+        }
+
         internal bool RecordRendererInstance(
             RendererRecordingContext context)
         {
@@ -181,6 +187,18 @@ namespace XCEngine.Rendering.Universal
         {
         }
 
+        protected virtual void FinalizeCameraFramePlan(
+            ScriptableRenderPipelinePlanningContext context)
+        {
+            if (context == null)
+            {
+                return;
+            }
+
+            ApplyInferredFullscreenStageRequests(
+                context);
+        }
+
         private void BuildPassQueue(
             RenderingData renderingData)
         {
@@ -205,6 +223,111 @@ namespace XCEngine.Rendering.Universal
         protected virtual void ReleaseRuntimeResources()
         {
         }
+
+        protected virtual RenderingData CreatePlanningRenderingData(
+            ScriptableRenderPipelinePlanningContext context)
+        {
+            return context != null
+                ? new RenderingData(
+                    CameraFrameStage.MainScene,
+                    context.rendererIndex)
+                : null;
+        }
+
+        private void ApplyInferredFullscreenStageRequests(
+            ScriptableRenderPipelinePlanningContext context)
+        {
+            RenderingData planningData =
+                CreatePlanningRenderingData(context);
+            if (planningData == null)
+            {
+                return;
+            }
+
+            BuildPassQueue(planningData);
+
+            bool hasPostProcessPass =
+                HasQueuedPassForStage(
+                    CameraFrameStage.PostProcess);
+            bool hasFinalOutputPass =
+                HasQueuedPassForStage(
+                    CameraFrameStage.FinalOutput);
+            bool needsFinalOutputDependency =
+                context.HasFinalColorProcessing() ||
+                context.IsStageRequested(
+                    CameraFrameStage.FinalOutput) ||
+                hasFinalOutputPass;
+
+            if (hasPostProcessPass)
+            {
+                EnsureInferredPostProcessStage(
+                    context,
+                    needsFinalOutputDependency);
+            }
+
+            if (hasFinalOutputPass &&
+                !context.IsStageRequested(
+                    CameraFrameStage.FinalOutput))
+            {
+                context.RequestFullscreenStage(
+                    CameraFrameStage.FinalOutput,
+                    context.IsStageRequested(
+                        CameraFrameStage.PostProcess)
+                        ? CameraFrameColorSource.PostProcessColor
+                        : CameraFrameColorSource.MainSceneColor);
+            }
+        }
+
+        private bool HasQueuedPassForStage(
+            CameraFrameStage stage)
+        {
+            for (int i = 0; i < m_activePassQueue.Count; ++i)
+            {
+                ScriptableRenderPass renderPass =
+                    m_activePassQueue[i];
+                if (renderPass != null &&
+                    renderPass.SupportsStage(stage))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private static void EnsureInferredPostProcessStage(
+            ScriptableRenderPipelinePlanningContext context,
+            bool needsGraphManagedOutputColor)
+        {
+            if (!context.IsStageRequested(
+                    CameraFrameStage.PostProcess))
+            {
+                context.RequestFullscreenStage(
+                    CameraFrameStage.PostProcess,
+                    CameraFrameColorSource.MainSceneColor,
+                    needsGraphManagedOutputColor);
+                return;
+            }
+
+            CameraFrameColorSource source =
+                context.GetStageColorSource(
+                    CameraFrameStage.PostProcess);
+            if (!needsGraphManagedOutputColor ||
+                source ==
+                    CameraFrameColorSource.ExplicitSurface ||
+                context.UsesGraphManagedOutputColor(
+                    CameraFrameStage.PostProcess))
+            {
+                return;
+            }
+
+            context.ClearFullscreenStage(
+                CameraFrameStage.PostProcess);
+            context.RequestFullscreenStage(
+                CameraFrameStage.PostProcess,
+                source,
+                true);
+        }
     }
 }