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

using System;
using XCEngine;
using XCEngine.Rendering;

namespace XCEngine.Rendering.Universal
{
    public class UniversalRenderPipelineAsset
        : ScriptableRenderPipelineAsset
    {
        public ScriptableRendererData[] rendererDataList =
            Array.Empty<ScriptableRendererData>();
        public int defaultRendererIndex = 0;
        public UniversalShadowSettings shadows;
        public UniversalFinalColorSettings finalColor;
        private readonly ScriptableRendererDataCollection
            m_rendererDataCollection;
        private int m_rendererDataRuntimeStateHash;
        private bool m_rendererDataRuntimeStateHashResolved;

        public UniversalRenderPipelineAsset()
        {
            m_rendererDataCollection =
                new ScriptableRendererDataCollection();
            shadows =
                UniversalShadowSettings.CreateDefault();
            finalColor =
                UniversalFinalColorSettings.CreateDefault();
            ResetRendererDataToDefault();
        }

        protected override ScriptableRenderPipeline CreatePipeline()
        {
            return new UniversalRenderPipeline(this);
        }

        protected override FinalColorSettings
            GetDefaultFinalColorSettings()
        {
            return GetFinalColorSettingsInstance().settings;
        }

        protected virtual void ConfigureRendererCameraRequest(
            RendererCameraRequestContext context)
        {
            if (context == null)
            {
                return;
            }

            FinalColorSettings resolvedFinalColorSettings =
                GetFinalColorSettingsInstance().settings;
            bool hasCameraFinalColorOverrides = false;

            Camera camera = context.camera;
            if (camera != null &&
                camera.hasFinalColorOverrides)
            {
                FinalColorOverrideSettings overrideSettings =
                    camera.GetFinalColorOverrideSettings();
                if (overrideSettings.HasOverrides())
                {
                    overrideSettings.ApplyTo(
                        ref resolvedFinalColorSettings);
                    hasCameraFinalColorOverrides = true;
                }
            }

            context.SetResolvedFinalColorPolicy(
                resolvedFinalColorSettings,
                true,
                hasCameraFinalColorOverrides);

            context.clearFlags =
                ResolveRequestClearFlags(context);

            UniversalShadowSettings shadowSettings =
                GetShadowSettingsInstance();
            if (!shadowSettings.supportsMainLightShadows)
            {
                if (context.hasDirectionalShadow)
                {
                    context.ClearDirectionalShadow();
                }
                return;
            }

            DirectionalShadowPlanningSettings desiredPlanningSettings =
                shadowSettings.mainLightPlanningSettings;
            if (!context.directionalShadowPlanningSettings
                     .Equals(desiredPlanningSettings))
            {
                context.directionalShadowPlanningSettings =
                    desiredPlanningSettings;
            }
        }

        protected virtual ScriptableRendererData
        CreateDefaultRendererData()
        {
            return UniversalDefaultRendererDataFactory
                .CreateDefaultRendererData();
        }

        protected virtual ScriptableRendererDataComposition
        CreateDefaultRendererDataComposition()
        {
            return UniversalDefaultRendererDataFactory
                .CreateDefaultRendererDataComposition();
        }

        protected virtual int ResolveRendererIndex(
            CameraRenderRequestContext context)
        {
            Camera camera =
                context != null
                    ? context.camera
                    : null;
            if (camera != null)
            {
                UniversalAdditionalCameraData additionalCameraData =
                    camera.GetComponent<UniversalAdditionalCameraData>();
                if (additionalCameraData != null &&
                    additionalCameraData.hasRendererOverride)
                {
                    return additionalCameraData.rendererIndex;
                }
            }

            return ResolveSelectedRendererIndex();
        }

        private static RenderClearFlags ResolveRequestClearFlags(
            RendererCameraRequestContext context)
        {
            Camera camera =
                context != null
                    ? context.camera
                    : null;
            if (camera == null)
            {
                return RenderClearFlags.All;
            }

            switch (camera.clearMode)
            {
                case CameraClearMode.ColorAndDepth:
                    return RenderClearFlags.All;
                case CameraClearMode.DepthOnly:
                    return RenderClearFlags.Depth;
                case CameraClearMode.None:
                    return RenderClearFlags.None;
                case CameraClearMode.Auto:
                default:
                    if (camera.stackType ==
                        CameraStackType.Overlay)
                    {
                        return context.renderedRequestCount == 0
                            ? RenderClearFlags.All
                            : RenderClearFlags.Depth;
                    }

                    return context.renderedBaseCameraCount == 0
                        ? RenderClearFlags.All
                        : RenderClearFlags.Depth;
            }
        }

        private UniversalShadowSettings GetShadowSettingsInstance()
        {
            if (shadows == null)
            {
                shadows =
                    UniversalShadowSettings.CreateDefault();
            }

            return shadows;
        }

        protected override void ConfigureCameraRenderRequest(
            CameraRenderRequestContext context)
        {
            ApplyResolvedRendererIndex(
                context,
                ResolveRendererIndex(context));

            ConfigureRendererCameraRequest(
                new RendererCameraRequestContext(context));

            ApplyResolvedRendererIndex(
                context,
                context != null
                    ? context.rendererIndex
                    : -1);

            ScriptableRendererData resolvedRendererData =
                ResolveRendererData(context);
            if (resolvedRendererData != null)
            {
                resolvedRendererData
                    .ConfigureCameraRenderRequestInstance(
                        context);
            }
        }

        protected override void ConfigureCameraFramePlan(
            ScriptableRenderPipelinePlanningContext context)
        {
            if (UsesExplicitCameraFrameStagePlanning() &&
                context != null)
            {
                context.ClearShadowCasterStage();
                context.ClearDepthOnlyStage();
                context.ClearFullscreenStage(
                    CameraFrameStage.PostProcess);
                context.ClearFullscreenStage(
                    CameraFrameStage.FinalOutput);
            }

            ScriptableRendererData resolvedRendererData =
                ResolveRendererData(context);
            if (resolvedRendererData != null)
            {
                resolvedRendererData
                    .ConfigureCameraFramePlanInstance(
                        context);
            }
        }

        protected override bool ConfigureDirectionalShadowExecutionState(
            DirectionalShadowExecutionContext context)
        {
            ScriptableRendererData resolvedRendererData =
                ResolveRendererData(context);
            return resolvedRendererData != null &&
                   resolvedRendererData
                       .ConfigureDirectionalShadowExecutionStateInstance(
                           context);
        }

        protected override bool ConfigureRenderSceneSetup(
            RenderSceneSetupContext context)
        {
            ScriptableRendererData resolvedRendererData =
                ResolveRendererData(context);
            return resolvedRendererData != null &&
                   resolvedRendererData
                       .ConfigureRenderSceneSetupInstance(
                           context);
        }

        protected override void ReleaseRuntimeResources()
        {
            m_rendererDataCollection.ReleaseRuntimeResources(
                ref rendererDataList,
                ref defaultRendererIndex,
                CreateDefaultRendererData);
        }

        protected override void SynchronizeRuntimeResourceVersion()
        {
            m_rendererDataCollection.Synchronize(
                ref rendererDataList,
                ref defaultRendererIndex,
                ref m_rendererDataRuntimeStateHash,
                ref m_rendererDataRuntimeStateHashResolved,
                CreateDefaultRendererData,
                SetDirty);
        }

        protected virtual bool UsesExplicitCameraFrameStagePlanning()
        {
            return UsesExplicitFullscreenStagePlanning();
        }

        protected virtual bool UsesExplicitFullscreenStagePlanning()
        {
            return true;
        }

        private UniversalFinalColorSettings
            GetFinalColorSettingsInstance()
        {
            if (finalColor == null)
            {
                finalColor =
                    UniversalFinalColorSettings.CreateDefault();
            }

            return finalColor;
        }

        protected void ResetRendererDataToDefault()
        {
            ScriptableRendererDataComposition composition =
                CreateDefaultRendererDataComposition();
            rendererDataList = composition.rendererDataList;
            defaultRendererIndex =
                composition.defaultRendererIndex;
        }

        internal ScriptableRendererData GetDefaultRendererData()
        {
            return m_rendererDataCollection.GetDefaultRendererData(
                ref rendererDataList,
                ref defaultRendererIndex,
                CreateDefaultRendererData);
        }

        internal ScriptableRenderer GetDefaultRenderer()
        {
            return ResolveSelectedRenderer();
        }

        internal ScriptableRendererData ResolveSelectedRendererData()
        {
            return GetDefaultRendererData();
        }

        internal ScriptableRenderer ResolveSelectedRenderer()
        {
            ScriptableRendererData rendererData =
                ResolveSelectedRendererData();
            return rendererData != null
                ? rendererData.GetRendererInstance()
                : null;
        }

        internal ScriptableRendererData GetRendererData(
            int rendererIndex)
        {
            return m_rendererDataCollection.GetRendererData(
                ref rendererDataList,
                ref defaultRendererIndex,
                rendererIndex,
                CreateDefaultRendererData);
        }

        internal ScriptableRenderer ResolveRenderer(
            int rendererIndex)
        {
            ScriptableRendererData rendererData =
                GetRendererData(rendererIndex);
            return rendererData != null
                ? rendererData.GetRendererInstance()
                : null;
        }

        private int ResolveSelectedRendererIndex()
        {
            return m_rendererDataCollection
                .ResolveDefaultRendererIndex(
                    ref rendererDataList,
                    ref defaultRendererIndex,
                    CreateDefaultRendererData);
        }

        private ScriptableRendererData ResolveRendererData(
            CameraRenderRequestContext context)
        {
            return GetRendererData(
                context != null
                    ? context.rendererIndex
                    : -1);
        }

        private ScriptableRendererData ResolveRendererData(
            ScriptableRenderPipelinePlanningContext context)
        {
            return GetRendererData(
                context != null
                    ? context.rendererIndex
                    : -1);
        }

        private ScriptableRendererData ResolveRendererData(
            RenderSceneSetupContext context)
        {
            return GetRendererData(
                context != null
                    ? context.rendererIndex
                    : -1);
        }

        private ScriptableRendererData ResolveRendererData(
            DirectionalShadowExecutionContext context)
        {
            return GetRendererData(
                context != null
                    ? context.rendererIndex
                    : -1);
        }

        private void ApplyResolvedRendererIndex(
            CameraRenderRequestContext context,
            int rendererIndex)
        {
            if (context == null)
            {
                return;
            }

            context.rendererIndex =
                m_rendererDataCollection
                    .ResolveRendererIndexWithFallback(
                        ref rendererDataList,
                        ref defaultRendererIndex,
                        rendererIndex,
                        CreateDefaultRendererData);
        }
    }
}