XCEngine/managed/GameScripts/RenderPipelineApiProbe.cs

using System;
using System.Reflection;
using XCEngine;
using XCEngine.Rendering;
using XCEngine.Rendering.Universal;

namespace Gameplay
{
    internal static class BuiltinShaderPaths
    {
        public const string ColorScalePostProcess =
            "builtin://shaders/color-scale-post-process";
    }

    internal static class ProbeFinalColorSettingsFactory
    {
        public static FinalColorSettings Create()
        {
            FinalColorSettings settings =
                FinalColorSettings.CreateDefault();
            settings.outputTransferMode =
                FinalColorOutputTransferMode.LinearToSRGB;
            settings.exposureMode =
                FinalColorExposureMode.Fixed;
            settings.exposureValue = 1.75f;
            settings.toneMappingMode =
                FinalColorToneMappingMode.ACES;
            settings.finalColorScale =
                new Vector4(0.90f, 1.10f, 1.20f, 1.0f);
            return settings;
        }
    }

    internal static class ProbeRuntimeVersionUtility
    {
        private static readonly MethodInfo s_getRuntimeResourceVersionMethod =
            typeof(ScriptableRenderPipelineAsset)
                .GetMethod(
                    "GetRuntimeResourceVersionInstance",
                    BindingFlags.Instance |
                    BindingFlags.NonPublic);

        public static int GetRuntimeResourceVersion(
            ScriptableRenderPipelineAsset asset)
        {
            if (asset == null ||
                s_getRuntimeResourceVersionMethod == null)
            {
                return 0;
            }

            object version =
                s_getRuntimeResourceVersionMethod.Invoke(
                    asset,
                    null);
            return version is int resolvedVersion
                ? resolvedVersion
                : 0;
        }
    }

    internal static class ProbeScriptableObjectFactory
    {
        public static T Create<T>()
            where T : ScriptableObject
        {
            T instance =
                ScriptableObject.CreateInstance<T>();
            if (instance != null)
            {
                return instance;
            }

            throw new InvalidOperationException(
                "Failed to create ScriptableObject probe instance: " +
                typeof(T).FullName);
        }

        public static ScriptableRendererData[] CreateRendererDataList(
            params ScriptableRendererData[] rendererData)
        {
            return Compact(rendererData);
        }

        public static ScriptableRendererFeature[] CreateRendererFeatureList(
            params ScriptableRendererFeature[] rendererFeatures)
        {
            return Compact(rendererFeatures);
        }

        private static T[] Compact<T>(
            params T[] items)
            where T : class
        {
            if (items == null ||
                items.Length == 0)
            {
                return Array.Empty<T>();
            }

            int validCount = 0;
            for (int i = 0; i < items.Length; ++i)
            {
                if (items[i] != null)
                {
                    validCount++;
                }
            }

            if (validCount == items.Length)
            {
                return items;
            }

            if (validCount == 0)
            {
                return Array.Empty<T>();
            }

            T[] compactItems = new T[validCount];
            int writeIndex = 0;
            for (int i = 0; i < items.Length; ++i)
            {
                if (items[i] == null)
                {
                    continue;
                }

                compactItems[writeIndex++] = items[i];
            }

            return compactItems;
        }
    }

    internal enum SceneInjectionKind
    {
        BeforeOpaque,
        AfterOpaque,
        BeforeSkybox,
        AfterSkybox,
        BeforeTransparent,
        AfterTransparent
    }

    internal enum ScenePhaseKind
    {
        Opaque,
        Skybox,
        Transparent
    }

    internal enum FullscreenPassKind
    {
        ColorScale,
        ShaderVector
    }

    internal sealed class SceneInjectionPass : ScriptableRenderPass
    {
        private readonly SceneInjectionKind m_injectionKind;

        public SceneInjectionPass(
            RenderPassEvent passEvent,
            SceneInjectionKind injectionKind)
        {
            renderPassEvent = passEvent;
            m_injectionKind = injectionKind;
        }

        protected override bool RecordRenderGraph(
            ScriptableRenderContext context,
            RenderingData renderingData)
        {
            return context != null &&
                   renderingData != null &&
                   renderingData.isMainSceneStage &&
                   RecordInjection(context);
        }

        private bool RecordInjection(
            ScriptableRenderContext context)
        {
            switch (m_injectionKind)
            {
                case SceneInjectionKind.BeforeOpaque:
                    return context.RecordBeforeOpaqueInjection();
                case SceneInjectionKind.AfterOpaque:
                    return context.RecordAfterOpaqueInjection();
                case SceneInjectionKind.BeforeSkybox:
                    return context.RecordBeforeSkyboxInjection();
                case SceneInjectionKind.AfterSkybox:
                    return context.RecordAfterSkyboxInjection();
                case SceneInjectionKind.BeforeTransparent:
                    return context.RecordBeforeTransparentInjection();
                case SceneInjectionKind.AfterTransparent:
                    return context.RecordAfterTransparentInjection();
                default:
                    return false;
            }
        }
    }

    internal sealed class ScenePhasePass : ScriptableRenderPass
    {
        private readonly ScenePhaseKind m_phaseKind;
        private readonly Action m_onRecorded;

        public ScenePhasePass(
            RenderPassEvent passEvent,
            ScenePhaseKind phaseKind,
            Action onRecorded = null)
        {
            renderPassEvent = passEvent;
            m_phaseKind = phaseKind;
            m_onRecorded = onRecorded;
        }

        protected override bool RecordRenderGraph(
            ScriptableRenderContext context,
            RenderingData renderingData)
        {
            bool recorded = context != null &&
                            renderingData != null &&
                            renderingData.isMainSceneStage &&
                            RecordPhase(context);
            if (recorded && m_onRecorded != null)
            {
                m_onRecorded();
            }

            return recorded;
        }

        private bool RecordPhase(
            ScriptableRenderContext context)
        {
            switch (m_phaseKind)
            {
                case ScenePhaseKind.Opaque:
                    return context.RecordOpaqueScenePhase();
                case ScenePhaseKind.Skybox:
                    return context.RecordSkyboxScenePhase();
                case ScenePhaseKind.Transparent:
                    return context.RecordTransparentScenePhase();
                default:
                    return false;
            }
        }
    }

    internal sealed class FullscreenPass : ScriptableRenderPass
    {
        private readonly FullscreenPassKind m_passKind;
        private readonly Vector4 m_vectorPayload;
        private readonly string m_shaderPath;
        private readonly string m_passName;

        public FullscreenPass(
            RenderPassEvent passEvent,
            Vector4 colorScale)
        {
            renderPassEvent = passEvent;
            m_passKind = FullscreenPassKind.ColorScale;
            m_vectorPayload = colorScale;
            m_shaderPath = string.Empty;
            m_passName = string.Empty;
        }

        public FullscreenPass(
            RenderPassEvent passEvent,
            string shaderPath,
            Vector4 vectorPayload,
            string passName = null)
        {
            renderPassEvent = passEvent;
            m_passKind = FullscreenPassKind.ShaderVector;
            m_vectorPayload = vectorPayload;
            m_shaderPath = shaderPath ?? string.Empty;
            m_passName = passName ?? string.Empty;
        }

        protected override bool RecordRenderGraph(
            ScriptableRenderContext context,
            RenderingData renderingData)
        {
            return context != null &&
                   renderingData != null &&
                   RecordFullscreen(context);
        }

        private bool RecordFullscreen(
            ScriptableRenderContext context)
        {
            switch (m_passKind)
            {
                case FullscreenPassKind.ColorScale:
                    return RecordColorScaleFullscreenPass(
                        context,
                        m_vectorPayload);
                case FullscreenPassKind.ShaderVector:
                    return RecordShaderVectorFullscreenPass(
                        context,
                        m_shaderPath,
                        m_vectorPayload,
                        m_passName);
                default:
                    return false;
            }
        }
    }

    internal sealed class DefaultSceneFeature : ScriptableRendererFeature
    {
        private readonly SceneInjectionPass m_beforeOpaquePass;
        private readonly ScenePhasePass m_opaquePass;
        private readonly SceneInjectionPass m_afterOpaquePass;
        private readonly SceneInjectionPass m_beforeSkyboxPass;
        private readonly ScenePhasePass m_skyboxPass;
        private readonly SceneInjectionPass m_afterSkyboxPass;
        private readonly SceneInjectionPass m_beforeTransparentPass;
        private readonly ScenePhasePass m_transparentPass;
        private readonly SceneInjectionPass m_afterTransparentPass;

        public DefaultSceneFeature(
            Action onOpaqueRecorded = null)
        {
            m_beforeOpaquePass =
                new SceneInjectionPass(
                    RenderPassEvent.BeforeRenderingOpaques,
                    SceneInjectionKind.BeforeOpaque);
            m_opaquePass =
                new ScenePhasePass(
                    RenderPassEvent.RenderOpaques,
                    ScenePhaseKind.Opaque,
                    onOpaqueRecorded);
            m_afterOpaquePass =
                new SceneInjectionPass(
                    RenderPassEvent.AfterRenderingOpaques,
                    SceneInjectionKind.AfterOpaque);
            m_beforeSkyboxPass =
                new SceneInjectionPass(
                    RenderPassEvent.BeforeRenderingSkybox,
                    SceneInjectionKind.BeforeSkybox);
            m_skyboxPass =
                new ScenePhasePass(
                    RenderPassEvent.RenderSkybox,
                    ScenePhaseKind.Skybox);
            m_afterSkyboxPass =
                new SceneInjectionPass(
                    RenderPassEvent.AfterRenderingSkybox,
                    SceneInjectionKind.AfterSkybox);
            m_beforeTransparentPass =
                new SceneInjectionPass(
                    RenderPassEvent.BeforeRenderingTransparents,
                    SceneInjectionKind.BeforeTransparent);
            m_transparentPass =
                new ScenePhasePass(
                    RenderPassEvent.RenderTransparents,
                    ScenePhaseKind.Transparent);
            m_afterTransparentPass =
                new SceneInjectionPass(
                    RenderPassEvent.AfterRenderingTransparents,
                    SceneInjectionKind.AfterTransparent);
        }

        public override void AddRenderPasses(
            ScriptableRenderer renderer,
            RenderingData renderingData)
        {
            if (renderer == null ||
                renderingData == null ||
                !renderingData.isMainSceneStage)
            {
                return;
            }

            renderer.EnqueuePass(m_beforeOpaquePass);
            renderer.EnqueuePass(m_opaquePass);
            renderer.EnqueuePass(m_afterOpaquePass);
            renderer.EnqueuePass(m_beforeSkyboxPass);
            renderer.EnqueuePass(m_skyboxPass);
            renderer.EnqueuePass(m_afterSkyboxPass);
            renderer.EnqueuePass(m_beforeTransparentPass);
            renderer.EnqueuePass(m_transparentPass);
            renderer.EnqueuePass(m_afterTransparentPass);
        }
    }

    internal sealed class FullscreenFeature : ScriptableRendererFeature
    {
        private readonly ScriptableRenderPass[] m_passes;

        public FullscreenFeature(
            params ScriptableRenderPass[] passes)
        {
            m_passes = passes ?? Array.Empty<ScriptableRenderPass>();
        }

        public override void AddRenderPasses(
            ScriptableRenderer renderer,
            RenderingData renderingData)
        {
            if (renderer == null ||
                renderingData == null)
            {
                return;
            }

            for (int i = 0; i < m_passes.Length; ++i)
            {
                ScriptableRenderPass renderPass = m_passes[i];
                if (renderPass == null ||
                    !renderPass.SupportsStage(renderingData.stage))
                {
                    continue;
                }

                renderer.EnqueuePass(renderPass);
            }
        }

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

            bool hasPostProcessPass = false;
            bool hasFinalOutputPass = false;
            for (int i = 0; i < m_passes.Length; ++i)
            {
                ScriptableRenderPass renderPass = m_passes[i];
                if (renderPass == null)
                {
                    continue;
                }

                if (renderPass.SupportsStage(
                        CameraFrameStage.PostProcess))
                {
                    hasPostProcessPass = true;
                }

                if (renderPass.SupportsStage(
                        CameraFrameStage.FinalOutput))
                {
                    hasFinalOutputPass = true;
                }
            }

            bool needsGraphManagedPostProcessOutput =
                context.HasFinalColorProcessing() ||
                context.IsStageRequested(
                    CameraFrameStage.FinalOutput) ||
                hasFinalOutputPass;

            if (hasPostProcessPass)
            {
                if (!context.IsStageRequested(
                        CameraFrameStage.PostProcess))
                {
                    context.RequestFullscreenStage(
                        CameraFrameStage.PostProcess,
                        CameraFrameColorSource.MainSceneColor,
                        needsGraphManagedPostProcessOutput);
                }
                else if (needsGraphManagedPostProcessOutput &&
                         context.GetStageColorSource(
                             CameraFrameStage.PostProcess) !=
                             CameraFrameColorSource.ExplicitSurface &&
                         !context.UsesGraphManagedOutputColor(
                             CameraFrameStage.PostProcess))
                {
                    CameraFrameColorSource source =
                        context.GetStageColorSource(
                            CameraFrameStage.PostProcess);
                    context.ClearFullscreenStage(
                        CameraFrameStage.PostProcess);
                    context.RequestFullscreenStage(
                        CameraFrameStage.PostProcess,
                        source,
                        true);
                }
            }

            if (hasFinalOutputPass &&
                !context.IsStageRequested(
                    CameraFrameStage.FinalOutput))
            {
                context.RequestFullscreenStage(
                    CameraFrameStage.FinalOutput,
                    hasPostProcessPass
                        ? CameraFrameColorSource.PostProcessColor
                        : CameraFrameColorSource.MainSceneColor);
            }
        }
    }

    internal class ProbeSceneRenderer : ScriptableRenderer
    {
        public ProbeSceneRenderer(
            Action onOpaqueRecorded = null)
        {
            AddFeature(new DefaultSceneFeature(onOpaqueRecorded));
        }
    }

    internal class ProbePostProcessRenderer : ScriptableRenderer
    {
        public ProbePostProcessRenderer(
            Vector4 firstVectorPayload,
            Vector4 secondVectorPayload)
        {
            AddFeature(
                new FullscreenFeature(
                    new FullscreenPass(
                        RenderPassEvent.BeforeRenderingPostProcessing,
                        BuiltinShaderPaths.ColorScalePostProcess,
                        firstVectorPayload,
                        "ColorScale"),
                    new FullscreenPass(
                        RenderPassEvent.AfterRenderingPostProcessing,
                        BuiltinShaderPaths.ColorScalePostProcess,
                        secondVectorPayload,
                        "ColorScale")));
        }
    }

    internal class ProbeUniversalRenderer : ScriptableRenderer
    {
        public ProbeUniversalRenderer(
            Vector4 postProcessScale,
            Action onOpaqueRecorded)
        {
            AddFeature(new DefaultSceneFeature(onOpaqueRecorded));
            AddFeature(
                new FullscreenFeature(
                    new FullscreenPass(
                        RenderPassEvent.BeforeRenderingPostProcessing,
                        postProcessScale)));
        }
    }

    internal class ProbePlannedFullscreenRenderer : ScriptableRenderer
    {
        public ProbePlannedFullscreenRenderer()
        {
            AddFeature(
                new FullscreenFeature(
                    new FullscreenPass(
                        RenderPassEvent.BeforeRenderingPostProcessing,
                        new Vector4(1.05f, 1.0f, 0.95f, 1.0f)),
                    new FullscreenPass(
                        RenderPassEvent.BeforeRenderingFinalOutput,
                        new Vector4(1.05f, 1.0f, 0.95f, 1.0f))));
        }
    }

    internal static class ManagedFeaturePassOrderProbeState
    {
        public static string RecordedOrder = string.Empty;

        public static void Reset()
        {
            RecordedOrder = string.Empty;
        }

        public static void Append(
            string token)
        {
            if (string.IsNullOrEmpty(token))
            {
                return;
            }

            if (!string.IsNullOrEmpty(RecordedOrder))
            {
                RecordedOrder += ">";
            }

            RecordedOrder += token;
        }
    }

    internal sealed class ManagedFeaturePassOrderProbePass
        : ScriptableRenderPass
    {
        private readonly string m_token;

        public ManagedFeaturePassOrderProbePass(
            string token)
        {
            m_token = token ?? string.Empty;
            renderPassEvent = RenderPassEvent.RenderOpaques;
        }

        protected override bool RecordRenderGraph(
            ScriptableRenderContext context,
            RenderingData renderingData)
        {
            if (renderingData == null ||
                !renderingData.isMainSceneStage)
            {
                return false;
            }

            ManagedFeaturePassOrderProbeState.Append(m_token);
            return true;
        }
    }

    internal sealed class ManagedFeaturePassOrderBuiltinFeature
        : ScriptableRendererFeature
    {
        private readonly ManagedFeaturePassOrderProbePass m_pass =
            new ManagedFeaturePassOrderProbePass("Builtin");

        public override void AddRenderPasses(
            ScriptableRenderer renderer,
            RenderingData renderingData)
        {
            if (renderer == null ||
                renderingData == null ||
                !renderingData.isMainSceneStage)
            {
                return;
            }

            renderer.EnqueuePass(m_pass);
        }
    }

    internal sealed class ManagedFeaturePassOrderCustomFeature
        : ScriptableRendererFeature
    {
        private ManagedFeaturePassOrderProbePass m_pass;

        public string token = string.Empty;

        protected override int ComputeRuntimeStateHash()
        {
            int hash =
                base.ComputeRuntimeStateHash();
            hash =
                RuntimeStateHashUtility.Combine(
                    hash,
                    token ?? string.Empty);
            return hash;
        }

        public override void Create()
        {
            m_pass =
                new ManagedFeaturePassOrderProbePass(
                    token ?? string.Empty);
        }

        public override void AddRenderPasses(
            ScriptableRenderer renderer,
            RenderingData renderingData)
        {
            if (renderer == null ||
                renderingData == null ||
                !renderingData.isMainSceneStage)
            {
                return;
            }

            CreateInstance();
            if (m_pass != null)
            {
                renderer.EnqueuePass(m_pass);
            }
        }
    }

    internal sealed class ManagedFeaturePassOrderProbeRenderer
        : ScriptableRenderer
    {
        public ManagedFeaturePassOrderProbeRenderer()
        {
            AddFeature(
                new ManagedFeaturePassOrderBuiltinFeature());
        }
    }

    internal sealed class ManagedFeaturePassOrderProbeRendererData
        : ProbeRendererData
    {
        public ManagedFeaturePassOrderProbeRendererData()
            : base(false)
        {
            ManagedFeaturePassOrderCustomFeature customA =
                ProbeScriptableObjectFactory
                    .Create<ManagedFeaturePassOrderCustomFeature>();
            ManagedFeaturePassOrderCustomFeature customB =
                ProbeScriptableObjectFactory
                    .Create<ManagedFeaturePassOrderCustomFeature>();
            customA.token = "CustomA";
            customB.token = "CustomB";
            rendererFeatures =
                ProbeScriptableObjectFactory
                    .CreateRendererFeatureList(
                        customA,
                        customB);
        }

        protected override ScriptableRenderer CreateProbeRenderer()
        {
            return new ManagedFeaturePassOrderProbeRenderer();
        }
    }

    internal sealed class CameraDataObservationPass
        : ScriptableRenderPass
    {
        public static Vector4 ObservedViewRow0;
        public static Vector4 ObservedViewRow1;
        public static Vector4 ObservedViewRow2;
        public static Vector4 ObservedViewRow3;
        public static Vector4 ObservedProjectionRow0;
        public static Vector4 ObservedProjectionRow1;
        public static Vector4 ObservedProjectionRow2;
        public static Vector4 ObservedProjectionRow3;
        public static Vector4 ObservedViewProjectionRow0;
        public static Vector4 ObservedViewProjectionRow1;
        public static Vector4 ObservedViewProjectionRow2;
        public static Vector4 ObservedViewProjectionRow3;
        public static Vector3 ObservedWorldPosition;
        public static Vector4 ObservedClearColor;
        public static int ObservedClearFlags;
        public static bool ObservedPerspectiveProjection;
        public static float ObservedVerticalFovRadians;
        public static float ObservedOrthographicSize;
        public static float ObservedAspectRatio;
        public static float ObservedNearClipPlane;
        public static float ObservedFarClipPlane;
        public static int ObservedViewportWidth;
        public static int ObservedViewportHeight;
        public static bool ObservedMainDirectionalLightEnabled;
        public static bool ObservedMainDirectionalLightCastsShadows;
        public static Vector3 ObservedMainDirectionalLightDirection;
        public static Vector4 ObservedMainDirectionalLightColor;
        public static float ObservedMainDirectionalLightIntensity;
        public static bool ObservedHasMainDirectionalShadow;
        public static int ObservedAdditionalLightCount;
        public static bool ObservedShadowEnabled;
        public static Vector4 ObservedShadowViewProjectionRow0;
        public static Vector4 ObservedShadowViewProjectionRow1;
        public static Vector4 ObservedShadowViewProjectionRow2;
        public static Vector4 ObservedShadowViewProjectionRow3;
        public static float ObservedShadowOrthographicHalfExtent;
        public static float ObservedShadowNearClipPlane;
        public static float ObservedShadowFarClipPlane;
        public static int ObservedShadowMapWidth;
        public static int ObservedShadowMapHeight;
        public static float ObservedShadowWorldTexelSize;
        public static float ObservedShadowReceiverDepthBias;
        public static float ObservedShadowNormalBiasScale;
        public static float ObservedShadowStrength;
        public static float ObservedShadowDepthBiasFactor;
        public static int ObservedShadowDepthBiasUnits;
        public static int ObservedEnvironmentMode;
        public static Vector4 ObservedSkyboxTopColor;
        public static Vector4 ObservedSkyboxHorizonColor;
        public static Vector4 ObservedSkyboxBottomColor;
        public static int ObservedFinalColorOutputTransferMode;
        public static int ObservedFinalColorExposureMode;
        public static float ObservedFinalColorExposureValue;
        public static int ObservedFinalColorToneMappingMode;
        public static Vector4 ObservedFinalColorScale;
        public static bool ObservedFinalColorHasPipelineDefaults;
        public static bool ObservedFinalColorHasCameraOverrides;
        public static bool ObservedFinalColorRequiresProcessing;
        public static int RecordCallCount;

        public CameraDataObservationPass()
        {
            renderPassEvent = RenderPassEvent.RenderOpaques;
        }

        public static void Reset()
        {
            ObservedViewRow0 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedViewRow1 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedViewRow2 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedViewRow3 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedProjectionRow0 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedProjectionRow1 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedProjectionRow2 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedProjectionRow3 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedViewProjectionRow0 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedViewProjectionRow1 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedViewProjectionRow2 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedViewProjectionRow3 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedWorldPosition = new Vector3(0.0f, 0.0f, 0.0f);
            ObservedClearColor = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedClearFlags = 0;
            ObservedPerspectiveProjection = true;
            ObservedVerticalFovRadians = 0.0f;
            ObservedOrthographicSize = 0.0f;
            ObservedAspectRatio = 0.0f;
            ObservedNearClipPlane = 0.0f;
            ObservedFarClipPlane = 0.0f;
            ObservedViewportWidth = 0;
            ObservedViewportHeight = 0;
            ObservedMainDirectionalLightEnabled = false;
            ObservedMainDirectionalLightCastsShadows = false;
            ObservedMainDirectionalLightDirection =
                new Vector3(0.0f, 0.0f, 0.0f);
            ObservedMainDirectionalLightColor =
                new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedMainDirectionalLightIntensity = 0.0f;
            ObservedHasMainDirectionalShadow = false;
            ObservedAdditionalLightCount = 0;
            ObservedShadowEnabled = false;
            ObservedShadowViewProjectionRow0 =
                new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedShadowViewProjectionRow1 =
                new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedShadowViewProjectionRow2 =
                new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedShadowViewProjectionRow3 =
                new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedShadowOrthographicHalfExtent = 0.0f;
            ObservedShadowNearClipPlane = 0.0f;
            ObservedShadowFarClipPlane = 0.0f;
            ObservedShadowMapWidth = 0;
            ObservedShadowMapHeight = 0;
            ObservedShadowWorldTexelSize = 0.0f;
            ObservedShadowReceiverDepthBias = 0.0f;
            ObservedShadowNormalBiasScale = 0.0f;
            ObservedShadowStrength = 0.0f;
            ObservedShadowDepthBiasFactor = 0.0f;
            ObservedShadowDepthBiasUnits = 0;
            ObservedEnvironmentMode = 0;
            ObservedSkyboxTopColor =
                new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedSkyboxHorizonColor =
                new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedSkyboxBottomColor =
                new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedFinalColorOutputTransferMode = 0;
            ObservedFinalColorExposureMode = 0;
            ObservedFinalColorExposureValue = 0.0f;
            ObservedFinalColorToneMappingMode = 0;
            ObservedFinalColorScale =
                new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ObservedFinalColorHasPipelineDefaults = false;
            ObservedFinalColorHasCameraOverrides = false;
            ObservedFinalColorRequiresProcessing = false;
            RecordCallCount = 0;
        }

        protected override bool RecordRenderGraph(
            ScriptableRenderContext context,
            RenderingData renderingData)
        {
            if (context == null ||
                renderingData == null ||
                !renderingData.isMainSceneStage)
            {
                return false;
            }

            CameraData cameraData = renderingData.cameraData;
            LightingData lightingData = renderingData.lightingData;
            ShadowData shadowData = renderingData.shadowData;
            EnvironmentData environmentData =
                renderingData.environmentData;
            FinalColorData finalColorData =
                renderingData.finalColorData;
            if (cameraData == null)
            {
                return false;
            }

            ObservedViewRow0 = cameraData.view.GetRow(0);
            ObservedViewRow1 = cameraData.view.GetRow(1);
            ObservedViewRow2 = cameraData.view.GetRow(2);
            ObservedViewRow3 = cameraData.view.GetRow(3);
            ObservedProjectionRow0 =
                cameraData.projection.GetRow(0);
            ObservedProjectionRow1 =
                cameraData.projection.GetRow(1);
            ObservedProjectionRow2 =
                cameraData.projection.GetRow(2);
            ObservedProjectionRow3 =
                cameraData.projection.GetRow(3);
            ObservedViewProjectionRow0 =
                cameraData.viewProjection.GetRow(0);
            ObservedViewProjectionRow1 =
                cameraData.viewProjection.GetRow(1);
            ObservedViewProjectionRow2 =
                cameraData.viewProjection.GetRow(2);
            ObservedViewProjectionRow3 =
                cameraData.viewProjection.GetRow(3);
            ObservedWorldPosition = cameraData.worldPosition;
            ObservedClearColor = new Vector4(
                cameraData.clearColor.r,
                cameraData.clearColor.g,
                cameraData.clearColor.b,
                cameraData.clearColor.a);
            ObservedClearFlags = (int)cameraData.clearFlags;
            ObservedPerspectiveProjection =
                cameraData.perspectiveProjection;
            ObservedVerticalFovRadians =
                cameraData.verticalFovRadians;
            ObservedOrthographicSize =
                cameraData.orthographicSize;
            ObservedAspectRatio =
                cameraData.aspectRatio;
            ObservedNearClipPlane =
                cameraData.nearClipPlane;
            ObservedFarClipPlane =
                cameraData.farClipPlane;
            ObservedViewportWidth =
                cameraData.viewportWidth;
            ObservedViewportHeight =
                cameraData.viewportHeight;
            if (lightingData != null &&
                lightingData.mainDirectionalLight != null)
            {
                ObservedMainDirectionalLightEnabled =
                    lightingData.mainDirectionalLight.enabled;
                ObservedMainDirectionalLightCastsShadows =
                    lightingData.mainDirectionalLight.castsShadows;
                ObservedMainDirectionalLightDirection =
                    lightingData.mainDirectionalLight.direction;
                ObservedMainDirectionalLightColor = new Vector4(
                    lightingData.mainDirectionalLight.color.r,
                    lightingData.mainDirectionalLight.color.g,
                    lightingData.mainDirectionalLight.color.b,
                    lightingData.mainDirectionalLight.color.a);
                ObservedMainDirectionalLightIntensity =
                    lightingData.mainDirectionalLight.intensity;
                ObservedHasMainDirectionalShadow =
                    lightingData.hasMainDirectionalShadow;
                ObservedAdditionalLightCount =
                    lightingData.additionalLightCount;
            }
            if (shadowData != null &&
                shadowData.mainDirectionalShadow != null)
            {
                DirectionalShadowData mainDirectionalShadow =
                    shadowData.mainDirectionalShadow;
                ObservedShadowEnabled =
                    mainDirectionalShadow.enabled;
                ObservedShadowViewProjectionRow0 =
                    mainDirectionalShadow.viewProjection.GetRow(0);
                ObservedShadowViewProjectionRow1 =
                    mainDirectionalShadow.viewProjection.GetRow(1);
                ObservedShadowViewProjectionRow2 =
                    mainDirectionalShadow.viewProjection.GetRow(2);
                ObservedShadowViewProjectionRow3 =
                    mainDirectionalShadow.viewProjection.GetRow(3);
                ObservedShadowOrthographicHalfExtent =
                    mainDirectionalShadow.orthographicHalfExtent;
                ObservedShadowNearClipPlane =
                    mainDirectionalShadow.nearClipPlane;
                ObservedShadowFarClipPlane =
                    mainDirectionalShadow.farClipPlane;
                ObservedShadowMapWidth =
                    mainDirectionalShadow.mapWidth;
                ObservedShadowMapHeight =
                    mainDirectionalShadow.mapHeight;
                ObservedShadowWorldTexelSize =
                    mainDirectionalShadow.worldTexelSize;
                ObservedShadowReceiverDepthBias =
                    mainDirectionalShadow.receiverDepthBias;
                ObservedShadowNormalBiasScale =
                    mainDirectionalShadow.normalBiasScale;
                ObservedShadowStrength =
                    mainDirectionalShadow.shadowStrength;
                ObservedShadowDepthBiasFactor =
                    mainDirectionalShadow.depthBiasFactor;
                ObservedShadowDepthBiasUnits =
                    mainDirectionalShadow.depthBiasUnits;
            }
            if (environmentData != null)
            {
                ObservedEnvironmentMode =
                    (int)environmentData.mode;
                ObservedSkyboxTopColor = new Vector4(
                    environmentData.skyboxTopColor.r,
                    environmentData.skyboxTopColor.g,
                    environmentData.skyboxTopColor.b,
                    environmentData.skyboxTopColor.a);
                ObservedSkyboxHorizonColor = new Vector4(
                    environmentData.skyboxHorizonColor.r,
                    environmentData.skyboxHorizonColor.g,
                    environmentData.skyboxHorizonColor.b,
                    environmentData.skyboxHorizonColor.a);
                ObservedSkyboxBottomColor = new Vector4(
                    environmentData.skyboxBottomColor.r,
                    environmentData.skyboxBottomColor.g,
                    environmentData.skyboxBottomColor.b,
                    environmentData.skyboxBottomColor.a);
            }
            if (finalColorData != null)
            {
                ObservedFinalColorOutputTransferMode =
                    (int)finalColorData.settings.outputTransferMode;
                ObservedFinalColorExposureMode =
                    (int)finalColorData.settings.exposureMode;
                ObservedFinalColorExposureValue =
                    finalColorData.settings.exposureValue;
                ObservedFinalColorToneMappingMode =
                    (int)finalColorData.settings.toneMappingMode;
                ObservedFinalColorScale =
                    finalColorData.settings.finalColorScale;
                ObservedFinalColorHasPipelineDefaults =
                    finalColorData.hasPipelineDefaults;
                ObservedFinalColorHasCameraOverrides =
                    finalColorData.hasCameraOverrides;
                ObservedFinalColorRequiresProcessing =
                    finalColorData.requiresProcessing;
            }
            RecordCallCount++;
            return context.RecordScene();
        }
    }

    internal sealed class CameraDataObservationFeature
        : ScriptableRendererFeature
    {
        private readonly CameraDataObservationPass m_pass =
            new CameraDataObservationPass();

        public override void AddRenderPasses(
            ScriptableRenderer renderer,
            RenderingData renderingData)
        {
            if (renderer == null ||
                renderingData == null ||
                !renderingData.isMainSceneStage)
            {
                return;
            }

            renderer.EnqueuePass(m_pass);
        }
    }

    internal class CameraDataObservationRenderer
        : ScriptableRenderer
    {
        public CameraDataObservationRenderer()
        {
            AddFeature(new CameraDataObservationFeature());
        }
    }

    internal sealed class StageColorObservationPass
        : ScriptableRenderPass
    {
        public static int ObservedMainSceneSource;
        public static bool ObservedMainSceneUsesGraphManagedOutputColor;
        public static int ObservedPostProcessSource;
        public static bool ObservedPostProcessUsesGraphManagedOutputColor;
        public static int ObservedFinalOutputSource;
        public static bool ObservedFinalOutputUsesGraphManagedOutputColor;
        public static int MainSceneRecordCallCount;
        public static int PostProcessRecordCallCount;
        public static int FinalOutputRecordCallCount;

        public StageColorObservationPass(
            RenderPassEvent passEvent)
        {
            renderPassEvent = passEvent;
        }

        public static void Reset()
        {
            ObservedMainSceneSource = 0;
            ObservedMainSceneUsesGraphManagedOutputColor = false;
            ObservedPostProcessSource = 0;
            ObservedPostProcessUsesGraphManagedOutputColor = false;
            ObservedFinalOutputSource = 0;
            ObservedFinalOutputUsesGraphManagedOutputColor = false;
            MainSceneRecordCallCount = 0;
            PostProcessRecordCallCount = 0;
            FinalOutputRecordCallCount = 0;
        }

        protected override bool RecordRenderGraph(
            ScriptableRenderContext context,
            RenderingData renderingData)
        {
            if (context == null ||
                renderingData == null)
            {
                return false;
            }

            StageColorData stageColorData =
                renderingData.stageColorData;
            if (stageColorData == null)
            {
                return false;
            }

            if (renderingData.isMainSceneStage)
            {
                ObservedMainSceneSource =
                    (int)stageColorData.source;
                ObservedMainSceneUsesGraphManagedOutputColor =
                    stageColorData.usesGraphManagedOutputColor;
                MainSceneRecordCallCount++;
                return true;
            }

            if (renderingData.isPostProcessStage)
            {
                ObservedPostProcessSource =
                    (int)stageColorData.source;
                ObservedPostProcessUsesGraphManagedOutputColor =
                    stageColorData.usesGraphManagedOutputColor;
                PostProcessRecordCallCount++;
                return true;
            }

            if (renderingData.isFinalOutputStage)
            {
                ObservedFinalOutputSource =
                    (int)stageColorData.source;
                ObservedFinalOutputUsesGraphManagedOutputColor =
                    stageColorData.usesGraphManagedOutputColor;
                FinalOutputRecordCallCount++;
                return true;
            }

            return false;
        }
    }

    internal class StageColorObservationRenderer
        : ScriptableRenderer
    {
        public StageColorObservationRenderer()
        {
            AddFeature(
                new FullscreenFeature(
                    new StageColorObservationPass(
                        RenderPassEvent.RenderOpaques),
                    new StageColorObservationPass(
                        RenderPassEvent.BeforeRenderingPostProcessing),
                    new StageColorObservationPass(
                        RenderPassEvent.BeforeRenderingFinalOutput)));
        }
    }

    internal abstract class ProbeRendererData
        : UniversalRendererData
    {
        protected ProbeRendererData()
        {
        }

        protected ProbeRendererData(
            bool initializeDefaultRendererFeatures)
            : base(initializeDefaultRendererFeatures)
        {
        }

        protected sealed override ScriptableRenderer CreateRenderer()
        {
            return CreateProbeRenderer();
        }

        protected abstract ScriptableRenderer CreateProbeRenderer();
    }

    internal sealed class ManagedRenderPipelineProbeRendererData
        : ProbeRendererData
    {
        protected override ScriptableRenderer CreateProbeRenderer()
        {
            return new ManagedRenderPipelineProbe();
        }
    }

    internal sealed class ManagedPostProcessRenderPipelineProbeRendererData
        : ProbeRendererData
    {
        protected override ScriptableRenderer CreateProbeRenderer()
        {
            return new ManagedPostProcessRenderPipelineProbe();
        }
    }

    internal sealed class ManagedUniversalRenderPipelineProbeRendererData
        : ProbeRendererData
    {
        public Vector4 postProcessScale =
            new Vector4(1.03f, 0.98f, 0.94f, 1.0f);

        protected override ScriptableRenderer CreateProbeRenderer()
        {
            return new ManagedUniversalRenderPipelineProbe(
                postProcessScale);
        }
    }

    internal sealed class ManagedRendererReuseProbeRendererData
        : ProbeRendererData
    {
        public static int CreateRendererCallCount;
        public static int SetupRendererCallCount;

        protected override ScriptableRenderer CreateProbeRenderer()
        {
            CreateRendererCallCount++;
            return new ManagedRenderPipelineProbe();
        }

        protected override void SetupRenderer(
            ScriptableRenderer renderer)
        {
            SetupRendererCallCount++;
            base.SetupRenderer(renderer);
        }
    }

    internal static class ManagedRendererInvalidationProbeState
    {
        public static int CreatePipelineCallCount;
        public static int DisposePipelineCallCount;
        public static int CreateRendererCallCount;
        public static int SetupRendererCallCount;
        public static int CreateFeatureCallCount;
        public static int DisposeRendererCallCount;
        public static int DisposeFeatureCallCount;
        public static int InvalidateRendererCallCount;

        public static void Reset()
        {
            CreatePipelineCallCount = 0;
            DisposePipelineCallCount = 0;
            CreateRendererCallCount = 0;
            SetupRendererCallCount = 0;
            CreateFeatureCallCount = 0;
            DisposeRendererCallCount = 0;
            DisposeFeatureCallCount = 0;
            InvalidateRendererCallCount = 0;
        }
    }

    internal sealed class ManagedRendererInvalidationProbePipeline
        : RendererBackedRenderPipeline
    {
        public ManagedRendererInvalidationProbePipeline(
            RendererBackedRenderPipelineAsset asset)
            : base(asset)
        {
            ManagedRendererInvalidationProbeState
                .CreatePipelineCallCount++;
        }

        protected override void Dispose(
            bool disposing)
        {
            if (disposing)
            {
                ManagedRendererInvalidationProbeState
                    .DisposePipelineCallCount++;
            }

            base.Dispose(disposing);
        }
    }

    internal sealed class ManagedRendererInvalidationProbeFeature
        : ScriptableRendererFeature
    {
        protected override void ReleaseRuntimeResources()
        {
            ManagedRendererInvalidationProbeState.DisposeFeatureCallCount++;
        }
    }

    internal sealed class ManagedRendererInvalidationProbeRenderer
        : ProbeSceneRenderer
    {
        protected override void ReleaseRuntimeResources()
        {
            ManagedRendererInvalidationProbeState.DisposeRendererCallCount++;
        }
    }

    internal sealed class ManagedRendererInvalidationProbeRendererData
        : ProbeRendererData
    {
        public ManagedRendererInvalidationProbeRendererData()
            : base(false)
        {
            ManagedRendererInvalidationProbeState.CreateFeatureCallCount++;
            rendererFeatures =
                ProbeScriptableObjectFactory
                    .CreateRendererFeatureList(
                        ProbeScriptableObjectFactory
                            .Create<ManagedRendererInvalidationProbeFeature>());
        }

        protected override ScriptableRenderer CreateProbeRenderer()
        {
            ManagedRendererInvalidationProbeState.CreateRendererCallCount++;
            return new ManagedRendererInvalidationProbeRenderer();
        }

        protected override void SetupRenderer(
            ScriptableRenderer renderer)
        {
            ManagedRendererInvalidationProbeState.SetupRendererCallCount++;
            base.SetupRenderer(renderer);
        }

        public void InvalidateForTest()
        {
            ManagedRendererInvalidationProbeState.InvalidateRendererCallCount++;
            SetDirty();
        }
    }

    internal static class ManagedPersistentFeatureProbeState
    {
        public static int CreateRendererCallCount;
        public static int CreateFeatureRuntimeCallCount;
        public static int DisposeRendererCallCount;
        public static int DisposeFeatureCallCount;
        public static int InvalidateRendererCallCount;

        public static void Reset()
        {
            CreateRendererCallCount = 0;
            CreateFeatureRuntimeCallCount = 0;
            DisposeRendererCallCount = 0;
            DisposeFeatureCallCount = 0;
            InvalidateRendererCallCount = 0;
        }
    }

    internal sealed class ManagedPersistentFeatureProbeRendererFeature
        : ScriptableRendererFeature
    {
        public override void Create()
        {
            ManagedPersistentFeatureProbeState
                .CreateFeatureRuntimeCallCount++;
        }

        protected override void ReleaseRuntimeResources()
        {
            ManagedPersistentFeatureProbeState
                .DisposeFeatureCallCount++;
        }
    }

    internal sealed class ManagedPersistentFeatureProbeRenderer
        : ProbeSceneRenderer
    {
        protected override void ReleaseRuntimeResources()
        {
            ManagedPersistentFeatureProbeState
                .DisposeRendererCallCount++;
        }
    }

    internal sealed class ManagedPersistentFeatureProbeRendererData
        : ProbeRendererData
    {
        private readonly ManagedPersistentFeatureProbeRendererFeature m_feature;

        public ManagedPersistentFeatureProbeRendererData()
            : base(false)
        {
            m_feature =
                ProbeScriptableObjectFactory
                    .Create<ManagedPersistentFeatureProbeRendererFeature>();
            rendererFeatures =
                ProbeScriptableObjectFactory
                    .CreateRendererFeatureList(
                        m_feature);
        }

        protected override ScriptableRenderer CreateProbeRenderer()
        {
            ManagedPersistentFeatureProbeState
                .CreateRendererCallCount++;
            return new ManagedPersistentFeatureProbeRenderer();
        }

        public void InvalidateForTest()
        {
            ManagedPersistentFeatureProbeState
                .InvalidateRendererCallCount++;
            SetDirty();
        }
    }

    internal sealed class ManagedPlannedFullscreenRenderPipelineProbeRendererData
        : ProbeRendererData
    {
        protected override ScriptableRenderer CreateProbeRenderer()
        {
            return new ManagedPlannedFullscreenRenderPipelineProbe();
        }
    }

    internal sealed class ManagedFeaturePlannedPostProcessRendererFeature
        : ScriptableRendererFeature
    {
        public override void ConfigureCameraFramePlan(
            ScriptableRenderPipelinePlanningContext context)
        {
            if (context == null ||
                context.IsStageRequested(CameraFrameStage.PostProcess))
            {
                return;
            }

            context.RequestFullscreenStage(
                CameraFrameStage.PostProcess,
                CameraFrameColorSource.MainSceneColor);
        }
    }

    internal sealed class ManagedFeaturePlannedPostProcessRendererData
        : ProbeRendererData
    {
        public ManagedFeaturePlannedPostProcessRendererData()
            : base(false)
        {
            rendererFeatures =
                ProbeScriptableObjectFactory
                    .CreateRendererFeatureList(
                        ProbeScriptableObjectFactory
                            .Create<ManagedFeaturePlannedPostProcessRendererFeature>());
        }

        protected override ScriptableRenderer CreateProbeRenderer()
        {
            return new ProbeSceneRenderer();
        }
    }

    internal sealed class ManagedRenderContextCameraDataProbeRendererData
        : ProbeRendererData
    {
        protected override ScriptableRenderer CreateProbeRenderer()
        {
            return new ManagedRenderContextCameraDataProbe();
        }
    }

    internal sealed class ManagedRenderContextStageColorDataProbeRendererData
        : ProbeRendererData
    {
        protected override ScriptableRenderer CreateProbeRenderer()
        {
            return new ManagedRenderContextStageColorDataProbe();
        }
    }

    internal static class ManagedLifecycleProbeState
    {
        public static int CreatePipelineCallCount;
        public static int CreateRendererCallCount;
        public static int SetupRendererCallCount;
        public static int CreateFeatureCallCount;
        public static int ReleaseRendererDataRuntimeResourcesCallCount;
        public static int DisposePipelineCallCount;
        public static int ReleaseAssetRuntimeResourcesCallCount;
        public static int DisposeRendererCallCount;
        public static int DisposeFeatureCallCount;

        public static void Reset()
        {
            CreatePipelineCallCount = 0;
            CreateRendererCallCount = 0;
            SetupRendererCallCount = 0;
            CreateFeatureCallCount = 0;
            ReleaseRendererDataRuntimeResourcesCallCount = 0;
            DisposePipelineCallCount = 0;
            ReleaseAssetRuntimeResourcesCallCount = 0;
            DisposeRendererCallCount = 0;
            DisposeFeatureCallCount = 0;
        }
    }

    internal sealed class ManagedLifecycleProbeRendererFeature
        : ScriptableRendererFeature
    {
        protected override void ReleaseRuntimeResources()
        {
            ManagedLifecycleProbeState.DisposeFeatureCallCount++;
        }
    }

    internal sealed class ManagedLifecycleProbeRenderer
        : ScriptableRenderer
    {
        protected override bool SupportsRendererRecording(
            RendererRecordingContext context)
        {
            return context != null &&
                   context.stage == CameraFrameStage.MainScene;
        }

        protected override bool RecordRenderer(
            RendererRecordingContext context)
        {
            return context != null;
        }

        protected override void ReleaseRuntimeResources()
        {
            ManagedLifecycleProbeState.DisposeRendererCallCount++;
        }
    }

    internal sealed class ManagedLifecycleProbeRendererData
        : ProbeRendererData
    {
        public ManagedLifecycleProbeRendererData()
            : base(false)
        {
            ManagedLifecycleProbeState.CreateFeatureCallCount++;
            rendererFeatures =
                ProbeScriptableObjectFactory
                    .CreateRendererFeatureList(
                        ProbeScriptableObjectFactory
                            .Create<ManagedLifecycleProbeRendererFeature>());
        }

        protected override ScriptableRenderer CreateProbeRenderer()
        {
            ManagedLifecycleProbeState.CreateRendererCallCount++;
            return new ManagedLifecycleProbeRenderer();
        }

        protected override void SetupRenderer(
            ScriptableRenderer renderer)
        {
            ManagedLifecycleProbeState.SetupRendererCallCount++;
            base.SetupRenderer(renderer);
        }

        protected override void ReleaseRuntimeResources()
        {
            ManagedLifecycleProbeState.ReleaseRendererDataRuntimeResourcesCallCount++;
        }
    }

    internal sealed class ManagedPipelineDisposeProbe
        : ScriptableRenderPipeline
    {
        protected override bool SupportsStageRenderGraph(
            CameraFrameStage stage)
        {
            return stage == CameraFrameStage.MainScene;
        }

        protected override bool RecordStageRenderGraph(
            ScriptableRenderContext context)
        {
            return context != null;
        }

        protected override void Dispose(
            bool disposing)
        {
            if (disposing)
            {
                ManagedLifecycleProbeState.DisposePipelineCallCount++;
            }
        }
    }

    public sealed class LegacyRenderPipelineApiProbeAsset : RenderPipelineAsset
    {
    }

    public sealed class RenderPipelineApiProbeAsset : ScriptableRenderPipelineAsset
    {
    }

    public sealed class ManagedPipelineDisposeProbeAsset
        : ScriptableRenderPipelineAsset
    {
        protected override ScriptableRenderPipeline CreatePipeline()
        {
            ManagedLifecycleProbeState.CreatePipelineCallCount++;
            return new ManagedPipelineDisposeProbe();
        }
    }

    public sealed class ManagedUniversalLifecycleProbeAsset
        : UniversalRenderPipelineAsset
    {
        public ManagedUniversalLifecycleProbeAsset()
        {
            rendererDataList =
                ProbeScriptableObjectFactory
                    .CreateRendererDataList(
                        ProbeScriptableObjectFactory
                            .Create<ManagedLifecycleProbeRendererData>());
        }

        protected override ScriptableRenderPipeline CreatePipeline()
        {
            ManagedLifecycleProbeState.CreatePipelineCallCount++;
            return base.CreatePipeline();
        }

        protected override void ReleaseRuntimeResources()
        {
            ManagedLifecycleProbeState.ReleaseAssetRuntimeResourcesCallCount++;
            ReleaseRendererDataRuntimeResources();
        }
    }

    public sealed class ManagedRenderPipelineProbeAsset
        : UniversalRenderPipelineAsset
    {
        public static int CreatePipelineCallCount;

        public ManagedRenderPipelineProbeAsset()
        {
            rendererDataList =
                ProbeScriptableObjectFactory
                    .CreateRendererDataList(
                        ProbeScriptableObjectFactory
                            .Create<ManagedRenderPipelineProbeRendererData>());
        }

        protected override ScriptableRenderPipeline CreatePipeline()
        {
            CreatePipelineCallCount++;
            return base.CreatePipeline();
        }
    }

    public sealed class ManagedPostProcessRenderPipelineProbeAsset
        : UniversalRenderPipelineAsset
    {
        public ManagedPostProcessRenderPipelineProbeAsset()
        {
            rendererDataList =
                ProbeScriptableObjectFactory
                    .CreateRendererDataList(
                        ProbeScriptableObjectFactory
                            .Create<ManagedPostProcessRenderPipelineProbeRendererData>());
        }
    }

    public sealed class ManagedUniversalRenderPipelineProbeAsset
        : UniversalRenderPipelineAsset
    {
        public static int CreatePipelineCallCount;
        public Vector4 postProcessScale = new Vector4(1.03f, 0.98f, 0.94f, 1.0f);

        public ManagedUniversalRenderPipelineProbeAsset()
        {
            rendererDataList = CreateRendererDataList();
        }

        protected override ScriptableRenderPipeline CreatePipeline()
        {
            CreatePipelineCallCount++;
            rendererDataList = CreateRendererDataList();
            return base.CreatePipeline();
        }

        private ScriptableRendererData[] CreateRendererDataList()
        {
            ManagedUniversalRenderPipelineProbeRendererData rendererData =
                ProbeScriptableObjectFactory
                    .Create<ManagedUniversalRenderPipelineProbeRendererData>();
            rendererData.postProcessScale =
                postProcessScale;
            return ProbeScriptableObjectFactory
                .CreateRendererDataList(
                    rendererData);
        }
    }

    public sealed class ManagedRendererReuseProbeAsset
        : UniversalRenderPipelineAsset
    {
        public ManagedRendererReuseProbeAsset()
        {
            ManagedRendererReuseProbeRendererData.CreateRendererCallCount = 0;
            ManagedRendererReuseProbeRendererData.SetupRendererCallCount = 0;
            rendererDataList =
                ProbeScriptableObjectFactory
                    .CreateRendererDataList(
                        ProbeScriptableObjectFactory
                            .Create<ManagedRendererReuseProbeRendererData>());
        }
    }

    public sealed class ManagedRendererInvalidationProbeAsset
        : UniversalRenderPipelineAsset
    {
        private readonly ManagedRendererInvalidationProbeRendererData
            m_rendererData;

        public ManagedRendererInvalidationProbeAsset()
        {
            ManagedRendererInvalidationProbeState.Reset();
            m_rendererData =
                ProbeScriptableObjectFactory
                    .Create<ManagedRendererInvalidationProbeRendererData>();
            rendererDataList =
                ProbeScriptableObjectFactory
                    .CreateRendererDataList(
                        m_rendererData);
        }

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

        public void InvalidateDefaultRendererForTest()
        {
            if (m_rendererData == null)
            {
                return;
            }

            m_rendererData.InvalidateForTest();
        }
    }

    public sealed class ManagedPersistentFeatureProbeAsset
        : UniversalRenderPipelineAsset
    {
        private readonly ManagedPersistentFeatureProbeRendererData
            m_rendererData;

        public ManagedPersistentFeatureProbeAsset()
        {
            ManagedPersistentFeatureProbeState.Reset();
            m_rendererData =
                ProbeScriptableObjectFactory
                    .Create<ManagedPersistentFeatureProbeRendererData>();
            rendererDataList =
                ProbeScriptableObjectFactory
                    .CreateRendererDataList(
                        m_rendererData);
        }

        public void InvalidateDefaultRendererForTest()
        {
            if (m_rendererData == null)
            {
                return;
            }

            m_rendererData.InvalidateForTest();
        }
    }

    public sealed class ManagedFeaturePassOrderProbeAsset
        : UniversalRenderPipelineAsset
    {
        public ManagedFeaturePassOrderProbeAsset()
        {
            ManagedFeaturePassOrderProbeState.Reset();
            rendererDataList =
                ProbeScriptableObjectFactory
                    .CreateRendererDataList(
                        ProbeScriptableObjectFactory
                            .Create<ManagedFeaturePassOrderProbeRendererData>());
        }
    }

    internal static class ManagedAssetInvalidationProbeState
    {
        public static int CreatePipelineCallCount;
        public static int DisposePipelineCallCount;
        public static int InvalidateAssetCallCount;
        public static int LastCreatedSupportedStage;

        public static void Reset()
        {
            CreatePipelineCallCount = 0;
            DisposePipelineCallCount = 0;
            InvalidateAssetCallCount = 0;
            LastCreatedSupportedStage =
                (int)CameraFrameStage.MainScene;
        }
    }

    internal sealed class ManagedAssetInvalidationProbePipeline
        : ScriptableRenderPipeline
    {
        private readonly CameraFrameStage m_supportedStage;

        public ManagedAssetInvalidationProbePipeline(
            CameraFrameStage supportedStage)
        {
            m_supportedStage = supportedStage;
            ManagedAssetInvalidationProbeState
                .LastCreatedSupportedStage =
                (int)supportedStage;
        }

        protected override bool SupportsStageRenderGraph(
            CameraFrameStage stage)
        {
            return stage == m_supportedStage;
        }

        protected override void Dispose(
            bool disposing)
        {
            if (disposing)
            {
                ManagedAssetInvalidationProbeState
                    .DisposePipelineCallCount++;
            }
        }
    }

    public sealed class ManagedAssetInvalidationProbeAsset
        : ScriptableRenderPipelineAsset
    {
        private CameraFrameStage m_supportedStage =
            CameraFrameStage.MainScene;

        public ManagedAssetInvalidationProbeAsset()
        {
            ManagedAssetInvalidationProbeState.Reset();
        }

        protected override ScriptableRenderPipeline CreatePipeline()
        {
            ManagedAssetInvalidationProbeState
                .CreatePipelineCallCount++;
            return new ManagedAssetInvalidationProbePipeline(
                m_supportedStage);
        }

        public void InvalidatePipelineForTest(
            CameraFrameStage supportedStage)
        {
            if (m_supportedStage == supportedStage)
            {
                return;
            }

            m_supportedStage = supportedStage;
            ManagedAssetInvalidationProbeState
                .InvalidateAssetCallCount++;
            SetDirty();
        }
    }

    public sealed class ManagedPlannedFullscreenRenderPipelineProbeAsset
        : UniversalRenderPipelineAsset
    {
        public ManagedPlannedFullscreenRenderPipelineProbeAsset()
        {
            rendererDataList =
                ProbeScriptableObjectFactory
                    .CreateRendererDataList(
                        ProbeScriptableObjectFactory
                            .Create<ManagedPlannedFullscreenRenderPipelineProbeRendererData>());
        }
    }

    public sealed class ManagedFeaturePlannedPostProcessProbeAsset
        : UniversalRenderPipelineAsset
    {
        public ManagedFeaturePlannedPostProcessProbeAsset()
        {
            rendererDataList =
                ProbeScriptableObjectFactory
                    .CreateRendererDataList(
                        ProbeScriptableObjectFactory
                            .Create<ManagedFeaturePlannedPostProcessRendererData>());
        }
    }

    public sealed class ManagedClearedPostProcessRenderPipelineProbeAsset
        : UniversalRenderPipelineAsset
    {
        public ManagedClearedPostProcessRenderPipelineProbeAsset()
        {
            rendererDataList =
                ProbeScriptableObjectFactory
                    .CreateRendererDataList(
                        ProbeScriptableObjectFactory
                            .Create<ManagedPlannedFullscreenRenderPipelineProbeRendererData>());
        }

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

            context.ClearFullscreenStage(
                CameraFrameStage.PostProcess);
            context.RequestFullscreenStage(
                CameraFrameStage.FinalOutput,
                CameraFrameColorSource.MainSceneColor);
        }

        protected override FinalColorSettings GetDefaultFinalColorSettings()
        {
            return ProbeFinalColorSettingsFactory.Create();
        }
    }

    internal sealed class ManagedCameraRequestConfiguredRendererData
        : UniversalRendererData
    {
        protected override ScriptableRenderer CreateRenderer()
        {
            return new ProbeSceneRenderer();
        }

        protected override void ConfigureCameraRenderRequest(
            CameraRenderRequestContext context)
        {
            if (HasDirectionalShadow(context))
            {
                ClearDirectionalShadow(context);
            }
        }
    }

    public sealed class ManagedCameraRequestConfiguredRenderPipelineProbeAsset
        : UniversalRenderPipelineAsset
    {
        public ManagedCameraRequestConfiguredRenderPipelineProbeAsset()
        {
            rendererDataList =
                ProbeScriptableObjectFactory
                    .CreateRendererDataList(
                        ProbeScriptableObjectFactory
                            .Create<ManagedCameraRequestConfiguredRendererData>());
        }
    }

    public sealed class ManagedRenderContextCameraDataProbeAsset
        : UniversalRenderPipelineAsset
    {
        public ManagedRenderContextCameraDataProbeAsset()
        {
            rendererDataList =
                ProbeScriptableObjectFactory
                    .CreateRendererDataList(
                        ProbeScriptableObjectFactory
                            .Create<ManagedRenderContextCameraDataProbeRendererData>());
        }
    }

    public sealed class ManagedFinalColorRenderPipelineProbeAsset
        : UniversalRenderPipelineAsset
    {
        public ManagedFinalColorRenderPipelineProbeAsset()
        {
            rendererDataList =
                ProbeScriptableObjectFactory
                    .CreateRendererDataList(
                        ProbeScriptableObjectFactory
                            .Create<ManagedRenderPipelineProbeRendererData>());
        }

        protected override FinalColorSettings GetDefaultFinalColorSettings()
        {
            return ProbeFinalColorSettingsFactory.Create();
        }
    }

    public sealed class ManagedRenderContextFinalColorDataProbeAsset
        : UniversalRenderPipelineAsset
    {
        public ManagedRenderContextFinalColorDataProbeAsset()
        {
            rendererDataList =
                ProbeScriptableObjectFactory
                    .CreateRendererDataList(
                        ProbeScriptableObjectFactory
                            .Create<ManagedRenderContextCameraDataProbeRendererData>());
        }

        protected override FinalColorSettings GetDefaultFinalColorSettings()
        {
            return ProbeFinalColorSettingsFactory.Create();
        }
    }

    public sealed class ManagedRenderContextStageColorDataProbeAsset
        : UniversalRenderPipelineAsset
    {
        public ManagedRenderContextStageColorDataProbeAsset()
        {
            rendererDataList =
                ProbeScriptableObjectFactory
                    .CreateRendererDataList(
                        ProbeScriptableObjectFactory
                            .Create<ManagedRenderContextStageColorDataProbeRendererData>());
        }
    }

    internal sealed class ManagedRenderPipelineProbe
        : ProbeSceneRenderer
    {
        public static int SupportsStageCallCount;
        public static int RecordStageCallCount;

        protected override bool SupportsRendererRecording(
            RendererRecordingContext context)
        {
            SupportsStageCallCount++;
            return base.SupportsRendererRecording(context);
        }

        protected override bool RecordRenderer(
            RendererRecordingContext context)
        {
            RecordStageCallCount++;
            return base.RecordRenderer(context);
        }
    }

    internal sealed class ManagedPostProcessRenderPipelineProbe
        : ProbePostProcessRenderer
    {
        public ManagedPostProcessRenderPipelineProbe()
            : base(
                new Vector4(1.10f, 0.95f, 0.90f, 1.0f),
                new Vector4(0.95f, 1.05f, 1.10f, 1.0f))
        {
        }
    }

    internal sealed class ManagedUniversalRenderPipelineProbe
        : ProbeUniversalRenderer
    {
        public static int SupportsMainSceneCallCount;
        public static int SupportsPostProcessCallCount;
        public static int RecordMainSceneCallCount;
        public static int RecordSceneCallCount;
        public static int RecordPostProcessCallCount;
        public static Vector4 LastPostProcessScale;

        private readonly Vector4 m_postProcessScale;

        public ManagedUniversalRenderPipelineProbe(
            Vector4 postProcessScale)
            : base(
                postProcessScale,
                OnOpaqueRecorded)
        {
            m_postProcessScale = postProcessScale;
        }

        protected override bool SupportsRendererRecording(
            RendererRecordingContext context)
        {
            if (context == null)
            {
                return false;
            }

            if (context.stage == CameraFrameStage.MainScene)
            {
                SupportsMainSceneCallCount++;
            }
            else if (context.stage == CameraFrameStage.PostProcess)
            {
                SupportsPostProcessCallCount++;
            }

            return base.SupportsRendererRecording(context);
        }

        protected override bool RecordRenderer(
            RendererRecordingContext context)
        {
            if (context == null)
            {
                return false;
            }

            if (context.stage == CameraFrameStage.MainScene)
            {
                RecordMainSceneCallCount++;
            }
            else if (context.stage == CameraFrameStage.PostProcess)
            {
                RecordPostProcessCallCount++;
                LastPostProcessScale = m_postProcessScale;
            }

            return base.RecordRenderer(context);
        }

        private static void OnOpaqueRecorded()
        {
            RecordSceneCallCount++;
        }
    }

    internal sealed class ManagedPlannedFullscreenRenderPipelineProbe
        : ProbePlannedFullscreenRenderer
    {
    }

    internal sealed class ManagedRenderContextCameraDataProbe
        : CameraDataObservationRenderer
    {
    }

    internal sealed class ManagedRenderContextStageColorDataProbe
        : StageColorObservationRenderer
    {
    }

    public sealed class ManagedRendererReuseObservationProbe
        : MonoBehaviour
    {
        public int ObservedCreateRendererCallCount;
        public int ObservedSetupRendererCallCount;

        public void Start()
        {
            ObservedCreateRendererCallCount =
                ManagedRendererReuseProbeRendererData
                    .CreateRendererCallCount;
            ObservedSetupRendererCallCount =
                ManagedRendererReuseProbeRendererData
                    .SetupRendererCallCount;
        }
    }

    public sealed class ManagedRendererInvalidationRuntimeSelectionProbe
        : MonoBehaviour
    {
        public void Start()
        {
            GraphicsSettings.renderPipelineAsset =
                ProbeScriptableObjectFactory
                    .Create<ManagedRendererInvalidationProbeAsset>();
        }
    }

    public sealed class ManagedRendererInvalidationObservationProbe
        : MonoBehaviour
    {
        public int ObservedCreatePipelineCallCount;
        public int ObservedDisposePipelineCallCount;
        public int ObservedCreateRendererCallCount;
        public int ObservedSetupRendererCallCount;
        public int ObservedCreateFeatureCallCount;
        public int ObservedDisposeRendererCallCount;
        public int ObservedDisposeFeatureCallCount;
        public int ObservedInvalidateRendererCallCount;
        public int ObservedRuntimeResourceVersionBeforeInvalidation;
        public int ObservedRuntimeResourceVersionAfterInvalidation;

        private bool m_requestedInvalidation;

        public void Update()
        {
            ManagedRendererInvalidationProbeAsset selectedAsset =
                GraphicsSettings.renderPipelineAsset
                    as ManagedRendererInvalidationProbeAsset;
            if (!m_requestedInvalidation &&
                selectedAsset != null &&
                ManagedRendererInvalidationProbeState
                    .CreateRendererCallCount > 0)
            {
                ObservedRuntimeResourceVersionBeforeInvalidation =
                    ProbeRuntimeVersionUtility
                        .GetRuntimeResourceVersion(
                            selectedAsset);
                selectedAsset.InvalidateDefaultRendererForTest();
                ObservedRuntimeResourceVersionAfterInvalidation =
                    ProbeRuntimeVersionUtility
                        .GetRuntimeResourceVersion(
                            selectedAsset);
                m_requestedInvalidation = true;
            }

            ObservedCreatePipelineCallCount =
                ManagedRendererInvalidationProbeState
                    .CreatePipelineCallCount;
            ObservedDisposePipelineCallCount =
                ManagedRendererInvalidationProbeState
                    .DisposePipelineCallCount;
            ObservedCreateRendererCallCount =
                ManagedRendererInvalidationProbeState.CreateRendererCallCount;
            ObservedSetupRendererCallCount =
                ManagedRendererInvalidationProbeState.SetupRendererCallCount;
            ObservedCreateFeatureCallCount =
                ManagedRendererInvalidationProbeState.CreateFeatureCallCount;
            ObservedDisposeRendererCallCount =
                ManagedRendererInvalidationProbeState.DisposeRendererCallCount;
            ObservedDisposeFeatureCallCount =
                ManagedRendererInvalidationProbeState.DisposeFeatureCallCount;
            ObservedInvalidateRendererCallCount =
                ManagedRendererInvalidationProbeState.InvalidateRendererCallCount;
        }
    }

    public sealed class ManagedPersistentFeatureRuntimeSelectionProbe
        : MonoBehaviour
    {
        public void Start()
        {
            GraphicsSettings.renderPipelineAsset =
                ProbeScriptableObjectFactory
                    .Create<ManagedPersistentFeatureProbeAsset>();
        }
    }

    public sealed class ManagedPersistentFeatureObservationProbe
        : MonoBehaviour
    {
        public int ObservedCreateRendererCallCount;
        public int ObservedCreateFeatureRuntimeCallCount;
        public int ObservedDisposeRendererCallCount;
        public int ObservedDisposeFeatureCallCount;
        public int ObservedInvalidateRendererCallCount;

        private bool m_requestedInvalidation;

        public void Update()
        {
            ManagedPersistentFeatureProbeAsset selectedAsset =
                GraphicsSettings.renderPipelineAsset
                    as ManagedPersistentFeatureProbeAsset;
            if (!m_requestedInvalidation &&
                selectedAsset != null &&
                ManagedPersistentFeatureProbeState
                    .CreateFeatureRuntimeCallCount > 0)
            {
                selectedAsset.InvalidateDefaultRendererForTest();
                m_requestedInvalidation = true;
            }

            ObservedCreateRendererCallCount =
                ManagedPersistentFeatureProbeState
                    .CreateRendererCallCount;
            ObservedCreateFeatureRuntimeCallCount =
                ManagedPersistentFeatureProbeState
                    .CreateFeatureRuntimeCallCount;
            ObservedDisposeRendererCallCount =
                ManagedPersistentFeatureProbeState
                    .DisposeRendererCallCount;
            ObservedDisposeFeatureCallCount =
                ManagedPersistentFeatureProbeState
                    .DisposeFeatureCallCount;
            ObservedInvalidateRendererCallCount =
                ManagedPersistentFeatureProbeState
                    .InvalidateRendererCallCount;
        }
    }

    public sealed class ManagedFeaturePassOrderRuntimeSelectionProbe
        : MonoBehaviour
    {
        public void Start()
        {
            GraphicsSettings.renderPipelineAsset =
                ProbeScriptableObjectFactory
                    .Create<ManagedFeaturePassOrderProbeAsset>();
        }
    }

    public sealed class ManagedFeaturePassOrderObservationProbe
        : MonoBehaviour
    {
        public string ObservedOrder = string.Empty;

        public void Update()
        {
            ObservedOrder =
                ManagedFeaturePassOrderProbeState.RecordedOrder ??
                string.Empty;
        }
    }

    public sealed class ManagedAssetInvalidationRuntimeSelectionProbe
        : MonoBehaviour
    {
        public void Start()
        {
            GraphicsSettings.renderPipelineAsset =
                ProbeScriptableObjectFactory
                    .Create<ManagedAssetInvalidationProbeAsset>();
        }
    }

    public sealed class ManagedAssetInvalidationObservationProbe
        : MonoBehaviour
    {
        public int ObservedCreatePipelineCallCount;
        public int ObservedDisposePipelineCallCount;
        public int ObservedInvalidateAssetCallCount;
        public int ObservedLastCreatedSupportedStage;

        private bool m_requestedInvalidation;

        public void Update()
        {
            ManagedAssetInvalidationProbeAsset selectedAsset =
                GraphicsSettings.renderPipelineAsset
                    as ManagedAssetInvalidationProbeAsset;
            if (!m_requestedInvalidation &&
                selectedAsset != null &&
                ManagedAssetInvalidationProbeState
                    .CreatePipelineCallCount > 0)
            {
                selectedAsset.InvalidatePipelineForTest(
                    CameraFrameStage.PostProcess);
                m_requestedInvalidation = true;
            }

            ObservedCreatePipelineCallCount =
                ManagedAssetInvalidationProbeState
                    .CreatePipelineCallCount;
            ObservedDisposePipelineCallCount =
                ManagedAssetInvalidationProbeState
                    .DisposePipelineCallCount;
            ObservedInvalidateAssetCallCount =
                ManagedAssetInvalidationProbeState
                    .InvalidateAssetCallCount;
            ObservedLastCreatedSupportedStage =
                ManagedAssetInvalidationProbeState
                    .LastCreatedSupportedStage;
        }
    }

    public sealed class RenderPipelineApiProbe : MonoBehaviour
    {
        public bool InitialAssetWasNull;
        public bool SelectionRoundTripSucceeded;
        public bool SelectionReferencePreserved;
        public string SelectedPipelineAssetTypeName = string.Empty;

        public void Start()
        {
            InitialAssetWasNull = GraphicsSettings.renderPipelineAsset == null;

            RenderPipelineApiProbeAsset selectedAssetInstance =
                new RenderPipelineApiProbeAsset();
            GraphicsSettings.renderPipelineAsset = selectedAssetInstance;
            ScriptableRenderPipelineAsset selectedAsset =
                GraphicsSettings.renderPipelineAsset;
            SelectionRoundTripSucceeded =
                selectedAsset is RenderPipelineApiProbeAsset;
            SelectionReferencePreserved =
                object.ReferenceEquals(
                    selectedAsset,
                    selectedAssetInstance);
            SelectedPipelineAssetTypeName = selectedAsset != null
                ? selectedAsset.GetType().FullName ?? string.Empty
                : string.Empty;
        }
    }

    public sealed class ManagedRenderPipelineRuntimeSelectionProbe : MonoBehaviour
    {
        public void Start()
        {
            ManagedRenderPipelineProbeAsset.CreatePipelineCallCount = 0;
            ManagedRenderPipelineProbe.SupportsStageCallCount = 0;
            ManagedRenderPipelineProbe.RecordStageCallCount = 0;
            ManagedRendererReuseProbeRendererData.CreateRendererCallCount = 0;
            ManagedRendererReuseProbeRendererData.SetupRendererCallCount = 0;
            GraphicsSettings.renderPipelineAsset =
                ProbeScriptableObjectFactory
                    .Create<ManagedRenderPipelineProbeAsset>();
        }
    }

    public sealed class ManagedRenderPipelineCreateCountObservationProbe
        : MonoBehaviour
    {
        public int ObservedCreatePipelineCallCount;

        public void Start()
        {
            ManagedRenderPipelineProbeAsset.CreatePipelineCallCount = 0;
        }

        public void Update()
        {
            ObservedCreatePipelineCallCount =
                ManagedRenderPipelineProbeAsset.CreatePipelineCallCount;
        }
    }

    public sealed class ManagedLifecycleObservationProbe
        : MonoBehaviour
    {
        public int ObservedCreatePipelineCallCount;
        public int ObservedCreateRendererCallCount;
        public int ObservedSetupRendererCallCount;
        public int ObservedCreateFeatureCallCount;
        public int ObservedReleaseRendererDataRuntimeResourcesCallCount;
        public int ObservedDisposePipelineCallCount;
        public int ObservedReleaseAssetRuntimeResourcesCallCount;
        public int ObservedDisposeRendererCallCount;
        public int ObservedDisposeFeatureCallCount;

        public void Start()
        {
            ManagedLifecycleProbeState.Reset();
        }

        public void Update()
        {
            ObservedCreatePipelineCallCount =
                ManagedLifecycleProbeState.CreatePipelineCallCount;
            ObservedCreateRendererCallCount =
                ManagedLifecycleProbeState.CreateRendererCallCount;
            ObservedSetupRendererCallCount =
                ManagedLifecycleProbeState.SetupRendererCallCount;
            ObservedCreateFeatureCallCount =
                ManagedLifecycleProbeState.CreateFeatureCallCount;
            ObservedReleaseRendererDataRuntimeResourcesCallCount =
                ManagedLifecycleProbeState
                    .ReleaseRendererDataRuntimeResourcesCallCount;
            ObservedDisposePipelineCallCount =
                ManagedLifecycleProbeState.DisposePipelineCallCount;
            ObservedReleaseAssetRuntimeResourcesCallCount =
                ManagedLifecycleProbeState.ReleaseAssetRuntimeResourcesCallCount;
            ObservedDisposeRendererCallCount =
                ManagedLifecycleProbeState.DisposeRendererCallCount;
            ObservedDisposeFeatureCallCount =
                ManagedLifecycleProbeState.DisposeFeatureCallCount;
        }
    }

    public sealed class ManagedUniversalLifecycleRuntimeSelectionProbe
        : MonoBehaviour
    {
        public int ObservedCreatePipelineCallCount;
        public int ObservedCreateRendererCallCount;
        public int ObservedSetupRendererCallCount;
        public int ObservedCreateFeatureCallCount;
        public int ObservedReleaseRendererDataRuntimeResourcesCallCount;
        public int ObservedDisposePipelineCallCount;
        public int ObservedReleaseAssetRuntimeResourcesCallCount;
        public int ObservedDisposeRendererCallCount;
        public int ObservedDisposeFeatureCallCount;

        public void Start()
        {
            ManagedLifecycleProbeState.Reset();
            GraphicsSettings.renderPipelineAsset =
                ProbeScriptableObjectFactory
                    .Create<ManagedUniversalLifecycleProbeAsset>();
        }

        public void Update()
        {
            ObservedCreatePipelineCallCount =
                ManagedLifecycleProbeState.CreatePipelineCallCount;
            ObservedCreateRendererCallCount =
                ManagedLifecycleProbeState.CreateRendererCallCount;
            ObservedSetupRendererCallCount =
                ManagedLifecycleProbeState.SetupRendererCallCount;
            ObservedCreateFeatureCallCount =
                ManagedLifecycleProbeState.CreateFeatureCallCount;
            ObservedReleaseRendererDataRuntimeResourcesCallCount =
                ManagedLifecycleProbeState
                    .ReleaseRendererDataRuntimeResourcesCallCount;
            ObservedDisposePipelineCallCount =
                ManagedLifecycleProbeState.DisposePipelineCallCount;
            ObservedReleaseAssetRuntimeResourcesCallCount =
                ManagedLifecycleProbeState.ReleaseAssetRuntimeResourcesCallCount;
            ObservedDisposeRendererCallCount =
                ManagedLifecycleProbeState.DisposeRendererCallCount;
            ObservedDisposeFeatureCallCount =
                ManagedLifecycleProbeState.DisposeFeatureCallCount;
        }
    }

    public sealed class ScriptCoreUniversalRenderPipelineSelectionProbe
        : MonoBehaviour
    {
        public bool SelectionRoundTripSucceeded;
        public string SelectedPipelineAssetTypeName = string.Empty;
        public string SelectedRendererDataTypeName = string.Empty;

        public void Start()
        {
            UniversalRenderPipelineAsset asset =
                ScriptableObject
                    .CreateInstance<UniversalRenderPipelineAsset>();
            UniversalRendererData rendererData =
                ScriptableObject
                    .CreateInstance<UniversalRendererData>();
            if (asset != null &&
                rendererData != null)
            {
                asset.rendererDataList =
                    new ScriptableRendererData[]
                    {
                        rendererData
                    };
            }

            GraphicsSettings.renderPipelineAsset = asset;

            UniversalRenderPipelineAsset selectedAsset =
                GraphicsSettings.renderPipelineAsset as UniversalRenderPipelineAsset;
            ScriptableRendererData selectedRendererData = null;
            if (selectedAsset != null &&
                selectedAsset.rendererDataList != null &&
                selectedAsset.rendererDataList.Length > 0)
            {
                int rendererIndex =
                    selectedAsset.defaultRendererIndex;
                if (rendererIndex < 0 ||
                    rendererIndex >= selectedAsset.rendererDataList.Length)
                {
                    rendererIndex = 0;
                }

                selectedRendererData =
                    selectedAsset.rendererDataList[rendererIndex];
            }

            SelectionRoundTripSucceeded =
                selectedAsset != null;
            SelectedPipelineAssetTypeName =
                selectedAsset != null
                    ? selectedAsset.GetType().FullName ?? string.Empty
                    : string.Empty;
            SelectedRendererDataTypeName = selectedRendererData != null
                ? selectedRendererData.GetType().FullName ?? string.Empty
                : string.Empty;
        }
    }

    public sealed class ScriptCoreUniversalRenderPipelineRuntimeSelectionProbe
        : MonoBehaviour
    {
        public void Start()
        {
            UniversalRenderPipelineAsset asset =
                ScriptableObject
                    .CreateInstance<UniversalRenderPipelineAsset>();
            UniversalRendererData rendererData =
                ScriptableObject
                    .CreateInstance<UniversalRendererData>();
            if (asset == null ||
                rendererData == null)
            {
                return;
            }

            asset.rendererDataList =
                new ScriptableRendererData[]
                {
                    rendererData
                };
            GraphicsSettings.renderPipelineAsset = asset;
        }
    }

    public sealed class ScriptCoreConfiguredUniversalRenderPipelineRuntimeSelectionProbe
        : MonoBehaviour
    {
        public void Start()
        {
            UniversalRenderPipelineAsset asset =
                ScriptableObject
                    .CreateInstance<UniversalRenderPipelineAsset>();
            UniversalRendererData rendererData =
                ScriptableObject
                    .CreateInstance<UniversalRendererData>();
            if (asset == null ||
                rendererData == null)
            {
                return;
            }

            rendererData.mainScene =
                UniversalMainSceneData.CreateOpaqueOnly();
            asset.rendererDataList =
                new ScriptableRendererData[]
                {
                    rendererData
                };
            GraphicsSettings.renderPipelineAsset = asset;
        }
    }

    public sealed class ScriptCoreUniversalPostProcessRendererFeatureRuntimeSelectionProbe
        : MonoBehaviour
    {
        public void Start()
        {
            UniversalRenderPipelineAsset asset =
                ScriptableObject
                    .CreateInstance<UniversalRenderPipelineAsset>();
            UniversalRendererData rendererData =
                ScriptableObject
                    .CreateInstance<UniversalRendererData>();
            ColorScalePostProcessRendererFeature colorScaleFeature =
                ScriptableObject
                    .CreateInstance<ColorScalePostProcessRendererFeature>();
            if (asset == null ||
                rendererData == null ||
                colorScaleFeature == null)
            {
                return;
            }

            colorScaleFeature.colorScale = new Vector4(
                1.08f,
                0.96f,
                0.92f,
                1.0f);
            rendererData.rendererFeatures =
                new ScriptableRendererFeature[]
                {
                    colorScaleFeature
                };
            asset.rendererDataList =
                new ScriptableRendererData[]
                {
                    rendererData
                };
            GraphicsSettings.renderPipelineAsset = asset;
        }
    }

    public sealed class ScriptCoreUniversalShadowlessRendererFeatureRuntimeSelectionProbe
        : MonoBehaviour
    {
        public void Start()
        {
            UniversalRenderPipelineAsset asset =
                ScriptableObject
                    .CreateInstance<UniversalRenderPipelineAsset>();
            UniversalRendererData rendererData =
                ScriptableObject
                    .CreateInstance<UniversalRendererData>();
            DisableDirectionalShadowRendererFeature shadowlessFeature =
                ScriptableObject
                    .CreateInstance<DisableDirectionalShadowRendererFeature>();
            if (asset == null ||
                rendererData == null ||
                shadowlessFeature == null)
            {
                return;
            }

            rendererData.rendererFeatures =
                new ScriptableRendererFeature[]
                {
                    shadowlessFeature
                };
            asset.rendererDataList =
                new ScriptableRendererData[]
                {
                    rendererData
                };
            GraphicsSettings.renderPipelineAsset = asset;
        }
    }

    public sealed class ProjectConfiguredRenderPipelineGetterProbe
        : MonoBehaviour
    {
        public bool ObservedAssetWasNull = true;
        public string ObservedPipelineAssetTypeName = string.Empty;

        public void Start()
        {
            ScriptableRenderPipelineAsset asset =
                GraphicsSettings.renderPipelineAsset;
            ObservedAssetWasNull = asset == null;
            ObservedPipelineAssetTypeName = asset != null
                ? asset.GetType().FullName ?? string.Empty
                : string.Empty;
        }
    }

    public sealed class ManagedUniversalRenderPipelineRuntimeSelectionProbe
        : MonoBehaviour
    {
        public int ObservedCreatePipelineCallCount;
        public int ObservedSupportsMainSceneCallCount;
        public int ObservedSupportsPostProcessCallCount;
        public int ObservedRecordMainSceneCallCount;
        public int ObservedRecordSceneCallCount;
        public int ObservedRecordPostProcessCallCount;
        public Vector4 ObservedPostProcessScale;

        public void Start()
        {
            ManagedUniversalRenderPipelineProbeAsset.CreatePipelineCallCount = 0;
            ManagedUniversalRenderPipelineProbe.SupportsMainSceneCallCount = 0;
            ManagedUniversalRenderPipelineProbe.SupportsPostProcessCallCount = 0;
            ManagedUniversalRenderPipelineProbe.RecordMainSceneCallCount = 0;
            ManagedUniversalRenderPipelineProbe.RecordSceneCallCount = 0;
            ManagedUniversalRenderPipelineProbe.RecordPostProcessCallCount = 0;
            ManagedUniversalRenderPipelineProbe.LastPostProcessScale =
                new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            ManagedUniversalRenderPipelineProbeAsset asset =
                ProbeScriptableObjectFactory
                    .Create<ManagedUniversalRenderPipelineProbeAsset>();
            asset.postProcessScale =
                new Vector4(1.11f, 0.97f, 0.93f, 1.0f);
            GraphicsSettings.renderPipelineAsset =
                asset;
        }

        public void Update()
        {
            ObservedCreatePipelineCallCount =
                ManagedUniversalRenderPipelineProbeAsset.CreatePipelineCallCount;
            ObservedSupportsMainSceneCallCount =
                ManagedUniversalRenderPipelineProbe.SupportsMainSceneCallCount;
            ObservedSupportsPostProcessCallCount =
                ManagedUniversalRenderPipelineProbe.SupportsPostProcessCallCount;
            ObservedRecordMainSceneCallCount =
                ManagedUniversalRenderPipelineProbe.RecordMainSceneCallCount;
            ObservedRecordSceneCallCount =
                ManagedUniversalRenderPipelineProbe.RecordSceneCallCount;
            ObservedRecordPostProcessCallCount =
                ManagedUniversalRenderPipelineProbe.RecordPostProcessCallCount;
            ObservedPostProcessScale =
                ManagedUniversalRenderPipelineProbe.LastPostProcessScale;
        }
    }

    public sealed class ManagedRenderContextCameraDataRuntimeSelectionProbe
        : MonoBehaviour
    {
        public Vector4 ObservedViewRow0;
        public Vector4 ObservedViewRow1;
        public Vector4 ObservedViewRow2;
        public Vector4 ObservedViewRow3;
        public Vector4 ObservedProjectionRow0;
        public Vector4 ObservedProjectionRow1;
        public Vector4 ObservedProjectionRow2;
        public Vector4 ObservedProjectionRow3;
        public Vector4 ObservedViewProjectionRow0;
        public Vector4 ObservedViewProjectionRow1;
        public Vector4 ObservedViewProjectionRow2;
        public Vector4 ObservedViewProjectionRow3;
        public Vector3 ObservedWorldPosition;
        public Vector4 ObservedClearColor;
        public int ObservedClearFlags;
        public bool ObservedPerspectiveProjection;
        public float ObservedVerticalFovRadians;
        public float ObservedOrthographicSize;
        public float ObservedAspectRatio;
        public float ObservedNearClipPlane;
        public float ObservedFarClipPlane;
        public int ObservedViewportWidth;
        public int ObservedViewportHeight;
        public int ObservedRecordCallCount;

        public void Start()
        {
            CameraDataObservationPass.Reset();
            GraphicsSettings.renderPipelineAsset =
                ProbeScriptableObjectFactory
                    .Create<ManagedRenderContextCameraDataProbeAsset>();
        }

        public void Update()
        {
            ObservedViewRow0 =
                CameraDataObservationPass.ObservedViewRow0;
            ObservedViewRow1 =
                CameraDataObservationPass.ObservedViewRow1;
            ObservedViewRow2 =
                CameraDataObservationPass.ObservedViewRow2;
            ObservedViewRow3 =
                CameraDataObservationPass.ObservedViewRow3;
            ObservedProjectionRow0 =
                CameraDataObservationPass.ObservedProjectionRow0;
            ObservedProjectionRow1 =
                CameraDataObservationPass.ObservedProjectionRow1;
            ObservedProjectionRow2 =
                CameraDataObservationPass.ObservedProjectionRow2;
            ObservedProjectionRow3 =
                CameraDataObservationPass.ObservedProjectionRow3;
            ObservedViewProjectionRow0 =
                CameraDataObservationPass.ObservedViewProjectionRow0;
            ObservedViewProjectionRow1 =
                CameraDataObservationPass.ObservedViewProjectionRow1;
            ObservedViewProjectionRow2 =
                CameraDataObservationPass.ObservedViewProjectionRow2;
            ObservedViewProjectionRow3 =
                CameraDataObservationPass.ObservedViewProjectionRow3;
            ObservedWorldPosition =
                CameraDataObservationPass.ObservedWorldPosition;
            ObservedClearColor =
                CameraDataObservationPass.ObservedClearColor;
            ObservedClearFlags =
                CameraDataObservationPass.ObservedClearFlags;
            ObservedPerspectiveProjection =
                CameraDataObservationPass.ObservedPerspectiveProjection;
            ObservedVerticalFovRadians =
                CameraDataObservationPass.ObservedVerticalFovRadians;
            ObservedOrthographicSize =
                CameraDataObservationPass.ObservedOrthographicSize;
            ObservedAspectRatio =
                CameraDataObservationPass.ObservedAspectRatio;
            ObservedNearClipPlane =
                CameraDataObservationPass.ObservedNearClipPlane;
            ObservedFarClipPlane =
                CameraDataObservationPass.ObservedFarClipPlane;
            ObservedViewportWidth =
                CameraDataObservationPass.ObservedViewportWidth;
            ObservedViewportHeight =
                CameraDataObservationPass.ObservedViewportHeight;
            ObservedRecordCallCount =
                CameraDataObservationPass.RecordCallCount;
        }
    }

    public sealed class ManagedRenderContextLightingDataRuntimeSelectionProbe
        : MonoBehaviour
    {
        public bool ObservedMainDirectionalLightEnabled;
        public bool ObservedMainDirectionalLightCastsShadows;
        public Vector3 ObservedMainDirectionalLightDirection;
        public Vector4 ObservedMainDirectionalLightColor;
        public float ObservedMainDirectionalLightIntensity;
        public bool ObservedHasMainDirectionalShadow;
        public int ObservedAdditionalLightCount;
        public int ObservedRecordCallCount;

        public void Start()
        {
            CameraDataObservationPass.Reset();
            GraphicsSettings.renderPipelineAsset =
                ProbeScriptableObjectFactory
                    .Create<ManagedRenderContextCameraDataProbeAsset>();
        }

        public void Update()
        {
            ObservedMainDirectionalLightEnabled =
                CameraDataObservationPass
                    .ObservedMainDirectionalLightEnabled;
            ObservedMainDirectionalLightCastsShadows =
                CameraDataObservationPass
                    .ObservedMainDirectionalLightCastsShadows;
            ObservedMainDirectionalLightDirection =
                CameraDataObservationPass
                    .ObservedMainDirectionalLightDirection;
            ObservedMainDirectionalLightColor =
                CameraDataObservationPass
                    .ObservedMainDirectionalLightColor;
            ObservedMainDirectionalLightIntensity =
                CameraDataObservationPass
                    .ObservedMainDirectionalLightIntensity;
            ObservedHasMainDirectionalShadow =
                CameraDataObservationPass
                    .ObservedHasMainDirectionalShadow;
            ObservedAdditionalLightCount =
                CameraDataObservationPass
                    .ObservedAdditionalLightCount;
            ObservedRecordCallCount =
                CameraDataObservationPass.RecordCallCount;
        }
    }

    public sealed class ManagedRenderContextEnvironmentDataRuntimeSelectionProbe
        : MonoBehaviour
    {
        public int ObservedEnvironmentMode;
        public Vector4 ObservedSkyboxTopColor;
        public Vector4 ObservedSkyboxHorizonColor;
        public Vector4 ObservedSkyboxBottomColor;
        public int ObservedRecordCallCount;

        public void Start()
        {
            CameraDataObservationPass.Reset();
            GraphicsSettings.renderPipelineAsset =
                ProbeScriptableObjectFactory
                    .Create<ManagedRenderContextCameraDataProbeAsset>();
        }

        public void Update()
        {
            ObservedEnvironmentMode =
                CameraDataObservationPass.ObservedEnvironmentMode;
            ObservedSkyboxTopColor =
                CameraDataObservationPass.ObservedSkyboxTopColor;
            ObservedSkyboxHorizonColor =
                CameraDataObservationPass.ObservedSkyboxHorizonColor;
            ObservedSkyboxBottomColor =
                CameraDataObservationPass.ObservedSkyboxBottomColor;
            ObservedRecordCallCount =
                CameraDataObservationPass.RecordCallCount;
        }
    }

    public sealed class ManagedRenderContextShadowDataRuntimeSelectionProbe
        : MonoBehaviour
    {
        public bool ObservedShadowEnabled;
        public Vector4 ObservedShadowViewProjectionRow0;
        public Vector4 ObservedShadowViewProjectionRow1;
        public Vector4 ObservedShadowViewProjectionRow2;
        public Vector4 ObservedShadowViewProjectionRow3;
        public float ObservedShadowOrthographicHalfExtent;
        public float ObservedShadowNearClipPlane;
        public float ObservedShadowFarClipPlane;
        public int ObservedShadowMapWidth;
        public int ObservedShadowMapHeight;
        public float ObservedShadowWorldTexelSize;
        public float ObservedShadowReceiverDepthBias;
        public float ObservedShadowNormalBiasScale;
        public float ObservedShadowStrength;
        public float ObservedShadowDepthBiasFactor;
        public int ObservedShadowDepthBiasUnits;
        public int ObservedRecordCallCount;

        public void Start()
        {
            CameraDataObservationPass.Reset();
            GraphicsSettings.renderPipelineAsset =
                ProbeScriptableObjectFactory
                    .Create<ManagedRenderContextCameraDataProbeAsset>();
        }

        public void Update()
        {
            ObservedShadowEnabled =
                CameraDataObservationPass.ObservedShadowEnabled;
            ObservedShadowViewProjectionRow0 =
                CameraDataObservationPass
                    .ObservedShadowViewProjectionRow0;
            ObservedShadowViewProjectionRow1 =
                CameraDataObservationPass
                    .ObservedShadowViewProjectionRow1;
            ObservedShadowViewProjectionRow2 =
                CameraDataObservationPass
                    .ObservedShadowViewProjectionRow2;
            ObservedShadowViewProjectionRow3 =
                CameraDataObservationPass
                    .ObservedShadowViewProjectionRow3;
            ObservedShadowOrthographicHalfExtent =
                CameraDataObservationPass
                    .ObservedShadowOrthographicHalfExtent;
            ObservedShadowNearClipPlane =
                CameraDataObservationPass
                    .ObservedShadowNearClipPlane;
            ObservedShadowFarClipPlane =
                CameraDataObservationPass
                    .ObservedShadowFarClipPlane;
            ObservedShadowMapWidth =
                CameraDataObservationPass
                    .ObservedShadowMapWidth;
            ObservedShadowMapHeight =
                CameraDataObservationPass
                    .ObservedShadowMapHeight;
            ObservedShadowWorldTexelSize =
                CameraDataObservationPass
                    .ObservedShadowWorldTexelSize;
            ObservedShadowReceiverDepthBias =
                CameraDataObservationPass
                    .ObservedShadowReceiverDepthBias;
            ObservedShadowNormalBiasScale =
                CameraDataObservationPass
                    .ObservedShadowNormalBiasScale;
            ObservedShadowStrength =
                CameraDataObservationPass
                    .ObservedShadowStrength;
            ObservedShadowDepthBiasFactor =
                CameraDataObservationPass
                    .ObservedShadowDepthBiasFactor;
            ObservedShadowDepthBiasUnits =
                CameraDataObservationPass
                    .ObservedShadowDepthBiasUnits;
            ObservedRecordCallCount =
                CameraDataObservationPass.RecordCallCount;
        }
    }

    public sealed class ManagedRenderContextFinalColorDataRuntimeSelectionProbe
        : MonoBehaviour
    {
        public int ObservedFinalColorOutputTransferMode;
        public int ObservedFinalColorExposureMode;
        public float ObservedFinalColorExposureValue;
        public int ObservedFinalColorToneMappingMode;
        public Vector4 ObservedFinalColorScale;
        public bool ObservedFinalColorHasPipelineDefaults;
        public bool ObservedFinalColorHasCameraOverrides;
        public bool ObservedFinalColorRequiresProcessing;
        public int ObservedRecordCallCount;

        public void Start()
        {
            CameraDataObservationPass.Reset();
            GraphicsSettings.renderPipelineAsset =
                ProbeScriptableObjectFactory
                    .Create<ManagedRenderContextFinalColorDataProbeAsset>();
        }

        public void Update()
        {
            ObservedFinalColorOutputTransferMode =
                CameraDataObservationPass
                    .ObservedFinalColorOutputTransferMode;
            ObservedFinalColorExposureMode =
                CameraDataObservationPass
                    .ObservedFinalColorExposureMode;
            ObservedFinalColorExposureValue =
                CameraDataObservationPass
                    .ObservedFinalColorExposureValue;
            ObservedFinalColorToneMappingMode =
                CameraDataObservationPass
                    .ObservedFinalColorToneMappingMode;
            ObservedFinalColorScale =
                CameraDataObservationPass
                    .ObservedFinalColorScale;
            ObservedFinalColorHasPipelineDefaults =
                CameraDataObservationPass
                    .ObservedFinalColorHasPipelineDefaults;
            ObservedFinalColorHasCameraOverrides =
                CameraDataObservationPass
                    .ObservedFinalColorHasCameraOverrides;
            ObservedFinalColorRequiresProcessing =
                CameraDataObservationPass
                    .ObservedFinalColorRequiresProcessing;
            ObservedRecordCallCount =
                CameraDataObservationPass.RecordCallCount;
        }
    }

    public sealed class ManagedRenderContextStageColorDataRuntimeSelectionProbe
        : MonoBehaviour
    {
        public int ObservedMainSceneSource;
        public bool ObservedMainSceneUsesGraphManagedOutputColor;
        public int ObservedPostProcessSource;
        public bool ObservedPostProcessUsesGraphManagedOutputColor;
        public int ObservedFinalOutputSource;
        public bool ObservedFinalOutputUsesGraphManagedOutputColor;
        public int ObservedMainSceneRecordCallCount;
        public int ObservedPostProcessRecordCallCount;
        public int ObservedFinalOutputRecordCallCount;

        public void Start()
        {
            StageColorObservationPass.Reset();
            GraphicsSettings.renderPipelineAsset =
                ProbeScriptableObjectFactory
                    .Create<ManagedRenderContextStageColorDataProbeAsset>();
        }

        public void Update()
        {
            ObservedMainSceneSource =
                StageColorObservationPass.ObservedMainSceneSource;
            ObservedMainSceneUsesGraphManagedOutputColor =
                StageColorObservationPass
                    .ObservedMainSceneUsesGraphManagedOutputColor;
            ObservedPostProcessSource =
                StageColorObservationPass.ObservedPostProcessSource;
            ObservedPostProcessUsesGraphManagedOutputColor =
                StageColorObservationPass
                    .ObservedPostProcessUsesGraphManagedOutputColor;
            ObservedFinalOutputSource =
                StageColorObservationPass.ObservedFinalOutputSource;
            ObservedFinalOutputUsesGraphManagedOutputColor =
                StageColorObservationPass
                    .ObservedFinalOutputUsesGraphManagedOutputColor;
            ObservedMainSceneRecordCallCount =
                StageColorObservationPass.MainSceneRecordCallCount;
            ObservedPostProcessRecordCallCount =
                StageColorObservationPass.PostProcessRecordCallCount;
            ObservedFinalOutputRecordCallCount =
                StageColorObservationPass.FinalOutputRecordCallCount;
        }
    }
}