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

using XCEngine;
using XCEngine.Rendering;

namespace XCEngine.Rendering.Universal
{
    public class UniversalRenderPipelineAsset
        : RendererBackedRenderPipelineAsset
    {
        public UniversalShadowSettings shadows;
        public UniversalFinalColorSettings finalColor;

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

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

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

        protected override 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 override ScriptableRendererData
        CreateDefaultRendererData()
        {
            return UniversalDefaultRendererDataFactory
                .CreateDefaultRendererData();
        }

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

        protected override 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 base.ResolveRendererIndex(context);
        }

        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;
        }

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

            return finalColor;
        }
    }
}