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

using XCEngine;
using XCEngine.Rendering;

namespace XCEngine.Rendering.Universal
{
    public sealed class UniversalRenderer : ScriptableRenderer
    {
        private readonly UniversalRendererData m_rendererData;
        private readonly BuiltinFinalColorPass m_builtinFinalColorPass =
            new BuiltinFinalColorPass();
        private readonly DrawObjectsPass m_drawOpaqueObjectsPass =
            new DrawObjectsPass(
                RenderPassEvent.RenderOpaques,
                SceneRenderPhase.Opaque,
                RendererListDesc.CreateDefault(
                    RendererListType.Opaque));
        private readonly DrawSkyboxPass m_drawSkyboxPass =
            new DrawSkyboxPass();
        private readonly DrawObjectsPass m_drawTransparentObjectsPass =
            new DrawObjectsPass(
                RenderPassEvent.RenderTransparents,
                SceneRenderPhase.Transparent,
                RendererListDesc.CreateDefault(
                    RendererListType.Transparent));

        public UniversalRenderer(
            UniversalRendererData rendererData)
        {
            m_rendererData =
                rendererData ?? new UniversalRendererData();
        }

        protected override void ConfigureCameraFramePlan(
            ScriptableRenderPipelinePlanningContext context)
        {
            if (context == null)
            {
                return;
            }

            ConfigureShadowCasterStage(context);
        }

        protected override void FinalizeCameraFramePlan(
            ScriptableRenderPipelinePlanningContext context)
        {
            if (context == null)
            {
                return;
            }

            base.FinalizeCameraFramePlan(context);
            ConfigureFinalOutputStage(context);
        }

        protected override void AddRenderPasses(
            RenderingData renderingData)
        {
            if (renderingData == null)
            {
                return;
            }

            UniversalMainSceneData mainScene =
                m_rendererData.GetMainSceneInstance();

            if (mainScene.renderOpaque)
            {
                EnqueueOpaquePasses(mainScene);
            }

            if (mainScene.renderSkybox)
            {
                EnqueueSkyboxPasses(mainScene);
            }

            if (mainScene.renderTransparent)
            {
                EnqueueTransparentPasses(mainScene);
            }

            EnqueueFinalOutputPasses(renderingData);
        }

        private void EnqueueOpaquePasses(
            UniversalMainSceneData mainScene)
        {
            m_drawOpaqueObjectsPass.Configure(
                mainScene.opaquePassEvent,
                SceneRenderPhase.Opaque,
                mainScene.opaqueRendererListDesc,
                mainScene.opaqueDrawingSettings);
            EnqueuePass(m_drawOpaqueObjectsPass);
        }

        private void EnqueueSkyboxPasses(
            UniversalMainSceneData mainScene)
        {
            m_drawSkyboxPass.Configure(
                mainScene.skyboxPassEvent);
            EnqueuePass(m_drawSkyboxPass);
        }

        private void EnqueueTransparentPasses(
            UniversalMainSceneData mainScene)
        {
            m_drawTransparentObjectsPass.Configure(
                mainScene.transparentPassEvent,
                SceneRenderPhase.Transparent,
                mainScene.transparentRendererListDesc,
                mainScene.transparentDrawingSettings);
            EnqueuePass(m_drawTransparentObjectsPass);
        }

        private static void ConfigureShadowCasterStage(
            ScriptableRenderPipelinePlanningContext context)
        {
            if (context.IsStageRequested(
                    CameraFrameStage.ShadowCaster))
            {
                context.RequestShadowCasterStage();
                return;
            }

            context.ClearShadowCasterStage();
        }

        private static void ConfigureFinalOutputStage(
            ScriptableRenderPipelinePlanningContext context)
        {
            if (!context.HasFinalColorProcessing())
            {
                return;
            }

            context.ClearFullscreenStage(
                CameraFrameStage.FinalOutput);

            CameraFrameColorSource finalOutputSource =
                CameraFrameColorSource.MainSceneColor;
            if (context.IsStageRequested(
                    CameraFrameStage.PostProcess))
            {
                CameraFrameColorSource postProcessSource =
                    context.GetStageColorSource(
                        CameraFrameStage.PostProcess);
                if (postProcessSource !=
                    CameraFrameColorSource.ExplicitSurface)
                {
                    if (!context.UsesGraphManagedOutputColor(
                            CameraFrameStage.PostProcess))
                    {
                        context.ClearFullscreenStage(
                            CameraFrameStage.PostProcess);
                        context.RequestFullscreenStage(
                            CameraFrameStage.PostProcess,
                            postProcessSource,
                            true);
                    }

                    finalOutputSource =
                        CameraFrameColorSource.PostProcessColor;
                }
            }

            context.RequestFullscreenStage(
                CameraFrameStage.FinalOutput,
                finalOutputSource);
        }

        private void EnqueueFinalOutputPasses(
            RenderingData renderingData)
        {
            if (renderingData == null)
            {
                return;
            }

            if (!renderingData.isFinalOutputStage &&
                !renderingData.finalColorData.requiresProcessing)
            {
                return;
            }

            EnqueuePass(m_builtinFinalColorPass);
        }
    }
}