using System.Collections;
using System.Collections.Generic;
using NUnit.Framework;
using NUnit.Framework.Interfaces;
using UnityEngine.Experimental.Rendering;
using UnityEngine.Rendering.RenderGraphModule;
using UnityEngine.TestTools;

namespace UnityEngine.Rendering.Universal.Tests
{
    // Verifies the real back buffer MSAA optimization end to end: URP requests a single-sampled back
    // buffer for frames where no camera renders MSAA directly into it, and keeps it multisampled
    // otherwise. Each scenario asserts:
    //   - the *requested* count (Screen.msaaSamples) settles to the expected value, both per frame and at
    //     the instant each camera renders (so a one-frame apply lag is caught),
    //   - the *current* back buffer count (Screen.currentBackbufferMSAASamples) - the actual applied count -
    //     agrees with the request at the instant each camera renders, and
    //   - that each on-screen camera actually rendered the way the scenario intends - directly to the back
    //     buffer, or through an intermediate - via UniversalResourceData.isActiveTargetBackBuffer probed
    //     after opaques. This makes the tests robust: a camera that is silently forced through an
    //     intermediate (e.g. by some default setting) is caught instead of masquerading as "direct".
    //
    // "Uses an intermediate" is forced directly by a ScriptableRenderPass with
    // requiresIntermediateTexture = true (injected per camera via beginCameraRendering), so the tests are
    // decoupled from how any specific URP feature happens to trigger an intermediate.
    //
    // The fixture is skipped where MSAA must be resolved explicitly (editor, desktop, Intel/AMD Mac): the
    // request is always 1 there with nothing to discriminate. The meaningful coverage runs on the
    // device/player jobs (Android/iOS/Metal) via the Foundation/PostPro testables.
    [TestFixture]
    class RealBackbufferMSAATests
    {
        const int k_AssetMsaaSampleCount = 4;
        // Downgrade hysteresis + one-frame apply lag + margin for frame-pacing jitter.
        const int k_SettleFrames = UniversalRenderPipeline.realBackbufferMSAADowngradeDelayFrames + 1 + 3;
        const int k_StabilityFrames = 8;
        // Upgrades skip the hysteresis, so they must apply promptly: 1 frame to set the request + 1 frame for
        // the backend to reallocate. Strict bound to catch a regression that delays re-enabling back buffer
        // MSAA when a camera needs it.
        const int k_UpgradeFrames = 3;

        RenderPipelineAsset m_PreviousQualityRenderPipelineAsset;
        int m_PreviousMsaaSamples;
        UniversalRenderPipelineAsset m_Asset;
        UniversalRendererData m_RendererData;

        readonly List<Camera> m_DisabledCameras = new();
        readonly List<Object> m_TestObjects = new();
        readonly HashSet<Camera> m_ProbeCameras = new();        // on-screen cameras whose target we verify
        readonly HashSet<Camera> m_IntermediateCameras = new(); // cameras expected to use an intermediate
        readonly ForceIntermediatePass m_ForceIntermediatePass = new();
        readonly ActiveTargetProbePass m_ProbePass = new();

        // Per-frame applied back buffer MSAA, dumped in the failure diagnostics so a transition or
        // reallocation lag is visible frame by frame, not just at the settled state.
        readonly List<int> m_CurrentBackbufferMsaaPerFrame = new();

        [OneTimeSetUp]
        public void OneTimeSetUp()
        {
            // Capture the global state we may mutate BEFORE any early-out. NUnit runs OneTimeTearDown even
            // when OneTimeSetUp calls Assert.Ignore, so these must already hold the real previous values -
            // otherwise teardown restores defaults (null pipeline / 0 samples) and clobbers the active URP
            // asset for the rest of the test session (silently dropping sibling graphics tests to BiRP).
            m_PreviousQualityRenderPipelineAsset = QualitySettings.renderPipeline;
            m_PreviousMsaaSamples = Screen.msaaSamples;

            if (GraphicsSettings.currentRenderPipeline is not UniversalRenderPipelineAsset)
                IgnoreWithLog("These tests only run when URP is the active render pipeline.");

            // No multisampled back buffer where MSAA is resolved explicitly (editor, desktop, Intel/AMD Mac),
            // so the request is always 1 and there is nothing to discriminate. Real coverage runs on the
            // device/player jobs (see fixture header).
            if (UniversalRenderer.PlatformRequiresExplicitMsaaResolve())
                IgnoreWithLog("Platform resolves MSAA explicitly (no multisampled back buffer); the real back buffer MSAA request is always 1, so there is nothing to test here.");

            // Under XR, URP renders into the XR-owned back buffer and never multisamples it directly, so the
            // optimization is inactive. A global gate (rather than URP's per-camera xr.enabled check) is enough
            // to skip the device XR and mock-XR jobs, where the fixture is meaningless.
            if (XRSystem.displayActive || XRGraphicsAutomatedTests.enabled)
                IgnoreWithLog("XR is active; URP renders into the XR-owned back buffer and never multisamples it directly, so there is nothing to test here.");

            // Frame isolation: only cameras a test creates should contribute to the per-frame back
            // buffer MSAA aggregation, so disable any cameras already present in the scene.
            foreach (var cam in Object.FindObjectsByType<Camera>(FindObjectsInactive.Exclude))
            {
                if (!cam.enabled)
                    continue;
                cam.enabled = false;
                m_DisabledCameras.Add(cam);
            }

            m_Asset = CreateAsset();
            m_RendererData = (UniversalRendererData)m_Asset.rendererDataList[0];
            QualitySettings.renderPipeline = m_Asset;

            RenderPipelineManager.beginCameraRendering += OnBeginCameraRendering;
        }

        [OneTimeTearDown]
        public void OneTimeTearDown()
        {
            RenderPipelineManager.beginCameraRendering -= OnBeginCameraRendering;
            QualitySettings.renderPipeline = m_PreviousQualityRenderPipelineAsset;

            // Don't leak the changed back buffer MSAA request into sibling fixtures in the same run.
            if (Screen.msaaSamples != m_PreviousMsaaSamples)
                Screen.SetMSAASamples(m_PreviousMsaaSamples);

            foreach (var cam in m_DisabledCameras)
            {
                if (cam != null)
                    cam.enabled = true;
            }
            m_DisabledCameras.Clear();

            if (m_RendererData != null)
                Object.DestroyImmediate(m_RendererData);
            if (m_Asset != null)
                Object.DestroyImmediate(m_Asset);
        }

        [SetUp]
        public void SetUp()
        {
            m_Asset.msaaSampleCount = k_AssetMsaaSampleCount;
        }

        [TearDown]
        public void TearDown()
        {
            if (TestContext.CurrentContext.Result.Outcome.Status == TestStatus.Failed)
                LogFailureDiagnostics();

            // Detach render textures from cameras before releasing them (releasing an RT still set as
            // Camera.targetTexture logs an error that would fail the test).
            foreach (var obj in m_TestObjects)
            {
                if (obj is GameObject go && go != null && go.TryGetComponent<Camera>(out var cam))
                    cam.targetTexture = null;
            }

            foreach (var obj in m_TestObjects)
            {
                if (obj != null)
                    Object.DestroyImmediate(obj);
            }
            m_TestObjects.Clear();
            m_ProbeCameras.Clear();
            m_IntermediateCameras.Clear();
            m_ProbePass.observedActiveTargetIsBackbuffer.Clear();
            m_ProbePass.observedCurrentBackbufferMsaa.Clear();
            m_ProbePass.observedRequestedMsaa.Clear();
            m_CurrentBackbufferMsaaPerFrame.Clear();
        }

        // Injects the per-camera passes: the active-target probe on every on-screen camera we verify, and
        // the force-intermediate pass on cameras the test marks as "uses an intermediate". Done via
        // beginCameraRendering + EnqueuePass so it doesn't depend on any URP feature.
        void OnBeginCameraRendering(ScriptableRenderContext context, Camera camera)
        {
            if (!camera.TryGetComponent<UniversalAdditionalCameraData>(out var data))
                return;

            if (m_IntermediateCameras.Contains(camera))
                data.scriptableRenderer.EnqueuePass(m_ForceIntermediatePass);
            if (m_ProbeCameras.Contains(camera))
                data.scriptableRenderer.EnqueuePass(m_ProbePass);
        }

        // ---- Scenarios ----------------------------------------------------------------------------

        [UnityTest]
        public IEnumerator SingleCamera_DirectToBackbuffer_KeepsMSAA()
        {
            CreateScreenCamera(intermediate: false);
            yield return SettleAndAssert(needsRealBackbufferMSAA: true);
        }

        [UnityTest]
        public IEnumerator SingleCamera_DirectButCameraMSAADisabled_DisablesMSAA()
        {
            // Even when rendering directly to the back buffer, a camera with allowMSAA == false doesn't need
            // it multisampled - one of the per-camera checks the previous optimization lacked.
            var camera = CreateScreenCamera(intermediate: false);
            camera.allowMSAA = false;
            yield return SettleAndAssert(needsRealBackbufferMSAA: false);
        }

        [UnityTest]
        public IEnumerator SingleCamera_Intermediate_DisablesMSAA()
        {
            CreateScreenCamera(intermediate: true);
            yield return SettleAndAssert(needsRealBackbufferMSAA: false);
        }

        [UnityTest]
        public IEnumerator MultipleCameras_AllDirect_KeepsMSAA()
        {
            CreateScreenCamera(intermediate: false);
            CreateScreenCamera(intermediate: false);
            yield return SettleAndAssert(needsRealBackbufferMSAA: true);
        }

        [UnityTest]
        public IEnumerator MultipleCameras_AllIntermediate_DisablesMSAA()
        {
            CreateScreenCamera(intermediate: true);
            CreateScreenCamera(intermediate: true);
            yield return SettleAndAssert(needsRealBackbufferMSAA: false);
        }

        [UnityTest]
        public IEnumerator MultipleCameras_MixedDirectAndIntermediate_KeepsMSAA()
        {
            CreateScreenCamera(intermediate: true);   // resolves through an intermediate
            CreateScreenCamera(intermediate: false);  // renders direct -> vetoes, keeps MSAA on
            yield return SettleAndAssert(needsRealBackbufferMSAA: true);
        }

        [UnityTest]
        public IEnumerator CameraStack_BaseUsesIntermediate_DisablesMSAA()
        {
            // A base camera with a stack always composites through an intermediate, so the back buffer
            // only receives the resolved single-sampled result. Mark the base as intermediate so the
            // active-target probe expects (and confirms) the intermediate.
            var baseCamera = CreateScreenCamera(intermediate: true);
            var baseData = baseCamera.GetComponent<UniversalAdditionalCameraData>();

            var overlayGo = new GameObject("MSAA Test Overlay Camera");
            m_TestObjects.Add(overlayGo);
            var overlayCamera = overlayGo.AddComponent<Camera>();
            var overlayData = overlayGo.AddComponent<UniversalAdditionalCameraData>();
            overlayData.renderType = CameraRenderType.Overlay;
            overlayData.SetRenderer(0);

            Assume.That(baseData.TryAddCameraToStack(overlayCamera), "Could not add the overlay camera to the stack.");

            yield return SettleAndAssert(needsRealBackbufferMSAA: false);
        }

        [UnityTest]
        public IEnumerator SingleCamera_RenderTexture_DisablesMSAA()
        {
            CreateRenderTextureCamera();
            // Nothing renders to the real back buffer, so it doesn't need MSAA.
            yield return SettleAndAssert(needsRealBackbufferMSAA: false);
        }

        [UnityTest]
        public IEnumerator TileOnly_DirectCamera_KeepsMSAA()
        {
            // Tile-only must be set at renderer construction, so use a dedicated asset. Tile-only's whole
            // point is to keep rendering on-tile and avoid intermediates, so a direct camera should render
            // straight to the (multisampled) back buffer - the probe confirms no intermediate is added.
            var previousAsset = QualitySettings.renderPipeline;
            var tileOnlyAsset = CreateAsset(tileOnly: true);
            QualitySettings.renderPipeline = tileOnlyAsset;
            try
            {
                CreateScreenCamera(intermediate: false);

                // Let the renderer build, then confirm tile-only actually engaged on this platform.
                yield return null;
                var renderer = tileOnlyAsset.GetRenderer(0) as UniversalRenderer;
                if (renderer == null || !renderer.useTileOnlyMode)
                    Assert.Ignore("Tile-only mode is not active on this platform.");

                yield return SettleAndAssert(needsRealBackbufferMSAA: true);
            }
            finally
            {
                QualitySettings.renderPipeline = previousAsset;
                var rendererData = tileOnlyAsset.rendererDataList[0];
                Object.DestroyImmediate(tileOnlyAsset);
                if (rendererData != null)
                    Object.DestroyImmediate(rendererData);
            }
        }

        [UnityTest]
        public IEnumerator RenderRequest_DoesNotChangeBackbufferMSAA()
        {
            // Establish a converged state with an on-screen camera.
            CreateScreenCamera(intermediate: false);
            yield return TickFrames(k_SettleFrames);
            int requestedBefore = Screen.msaaSamples;

            // A camera that would render directly to the back buffer, but only ever via a render request
            // (disabled so it never participates in the normal frame loop).
            var go = new GameObject("MSAA Test Request Camera");
            m_TestObjects.Add(go);
            var requestCamera = go.AddComponent<Camera>();
            requestCamera.allowMSAA = true;
            requestCamera.enabled = false;
            var data = go.AddComponent<UniversalAdditionalCameraData>();
            data.SetRenderer(0);

            var rt = new RenderTexture(128, 128, 16);
            m_TestObjects.Add(rt);

            // SubmitRenderRequest renders synchronously, so the before/after read brackets exactly its effect.
            RenderPipeline.SubmitRenderRequest(requestCamera, new RenderPipeline.StandardRequest { destination = rt });

            Assert.AreEqual(requestedBefore, Screen.msaaSamples,
                "A render request must not change the real back buffer MSAA request.");
        }

        [UnityTest]
        public IEnumerator Transition_CameraMSAATogglesWithinSession_BackbufferFollows()
        {
            // Drives the real reallocation path the fresh-fixture scenarios never hit: transitions within one
            // continuous session (4 -> 1 -> 4). AssertStableForFrames adds the steady-state no-churn check.
            int multisampledCount = m_Asset.msaaSampleCount;
            var camera = CreateScreenCamera(intermediate: false);

            // Direct camera with MSAA -> the back buffer must be multisampled, and stay there.
            yield return SettleAndAssert(needsRealBackbufferMSAA: true);
            yield return AssertStableForFrames(multisampledCount, k_StabilityFrames);

            // Same camera still rendering directly, but MSAA off -> the back buffer must drop to single-sampled.
            int before = Screen.currentBackbufferMSAASamples;
            camera.allowMSAA = false;
            yield return SettleAndAssert(needsRealBackbufferMSAA: false);
            Assert.AreNotEqual(before, Screen.currentBackbufferMSAASamples, "Expected the back buffer MSAA to transition down when MSAA was disabled.");
            yield return AssertStableForFrames(1, k_StabilityFrames);

            // MSAA back on -> the back buffer must become multisampled again, and stay there.
            before = Screen.currentBackbufferMSAASamples;
            camera.allowMSAA = true;
            yield return SettleAndAssert(needsRealBackbufferMSAA: true);
            Assert.AreNotEqual(before, Screen.currentBackbufferMSAASamples, "Expected the back buffer MSAA to transition back up when MSAA was re-enabled.");
            yield return AssertStableForFrames(multisampledCount, k_StabilityFrames);
        }

        // ---- Helpers ------------------------------------------------------------------------------

        // Assert.Ignore writes its reason to the NUnit result XML, but not to the player log. On device/player
        // jobs the player log (TestRunnerLog.txt) is what's at hand, so mirror the skip reason and the caps
        // that drove it there first - this is how we confirm, from the device itself, why a platform skipped
        // (e.g. what supportsMultisampleAutoResolve / supportsMultisampledBackBuffer actually report on iOS).
        static void IgnoreWithLog(string reason)
        {
            Debug.Log($"[RealBackbufferMSAATests] Skipping fixture: {reason} " +
                $"(graphicsDeviceType={SystemInfo.graphicsDeviceType}, " +
                $"supportsMultisampleAutoResolve={SystemInfo.supportsMultisampleAutoResolve}, " +
                $"supportsMultisampledBackBuffer={SystemInfo.supportsMultisampledBackBuffer}, " +
                $"explicitMsaaResolve={UniversalRenderer.PlatformRequiresExplicitMsaaResolve()}, " +
                $"xrDisplayActive={XRSystem.displayActive}, xrAutomatedTests={XRGraphicsAutomatedTests.enabled})");
            Assert.Ignore(reason);
        }

        // Ticks 'count' frames, recording the applied back buffer MSAA each one for the diagnostics timeline.
        IEnumerator TickFrames(int count)
        {
            for (int i = 0; i < count; i++)
            {
                yield return null;
                m_CurrentBackbufferMsaaPerFrame.Add(Screen.currentBackbufferMSAASamples);
            }
        }

        // Asserts the applied back buffer MSAA stays at 'expected' for 'count' frames - the steady-state
        // no-churn check. Observes the applied count, so it can't see a redundant SetMSAASamples(sameValue)
        // reallocation (no managed hook for that).
        IEnumerator AssertStableForFrames(int expected, int count)
        {
            int start = m_CurrentBackbufferMsaaPerFrame.Count;
            yield return TickFrames(count);
            for (int i = start; i < m_CurrentBackbufferMsaaPerFrame.Count; i++)
                Assert.AreEqual(expected, m_CurrentBackbufferMsaaPerFrame[i],
                    $"Back buffer MSAA churned at steady state (frame index {i} was {m_CurrentBackbufferMsaaPerFrame[i]}, expected a stable {expected}). " +
                    $"Current MSAA per ticked frame: [{string.Join(", ", m_CurrentBackbufferMsaaPerFrame)}]");
        }

        // Establishes an MSAA-on baseline the real way: a needing camera appears (back buffer goes
        // multisampled), then leaves - so the off-test measures a genuine downgrade, not an already-off state.
        IEnumerator EstablishMsaaOn()
        {
            int multisampledCount = m_Asset.msaaSampleCount;
            var go = new GameObject("MSAA Test Baseline Camera");
            m_TestObjects.Add(go);
            var camera = go.AddComponent<Camera>();
            camera.allowMSAA = true;
            camera.allowHDR = false;
            camera.allowDynamicResolution = false;
            camera.targetTexture = null;
            camera.rect = new Rect(0f, 0f, 1f, 1f);
            var data = go.AddComponent<UniversalAdditionalCameraData>();
            data.SetRenderer(0);
            data.renderPostProcessing = false;

            // Tick at least once with the camera present (even if the back buffer is already multisampled
            // from a prior test) so the helper actually drives the baseline and resets the downgrade clock,
            // making the following downgrade deterministic.
            for (int i = 0; i < k_SettleFrames; i++)
            {
                yield return null;
                m_CurrentBackbufferMsaaPerFrame.Add(Screen.currentBackbufferMSAASamples);
                if (Screen.currentBackbufferMSAASamples == multisampledCount)
                    break;
            }
            Assert.AreEqual(multisampledCount, Screen.currentBackbufferMSAASamples,
                "Failed to establish the MSAA-on baseline before measuring the downgrade.");

            Object.DestroyImmediate(go);
        }

        IEnumerator SettleAndAssert(bool needsRealBackbufferMSAA)
        {
            // The fixture only runs where the platform supports a multisampled back buffer (see
            // OneTimeSetUp), so a camera that needs it keeps the asset's sample count; otherwise it's 1.
            int expectedRequest = needsRealBackbufferMSAA ? m_Asset.msaaSampleCount : 1;

            // Arrange the opposite baseline (asserted), so each test measures a real transition rather
            // than an incidental steady state.
            if (needsRealBackbufferMSAA)
            {
                // Off baseline via the cameras' off form - allowMSAA=false still renders direct, so routing
                // is unchanged - then enable MSAA and require the upgrade within its tight bound.
                foreach (var camera in m_ProbeCameras)
                    camera.allowMSAA = false;
                yield return TickFrames(k_SettleFrames);
                Assert.AreEqual(1, Screen.currentBackbufferMSAASamples,
                    "Failed to establish the MSAA-off baseline before measuring the upgrade.");

                foreach (var camera in m_ProbeCameras)
                    camera.allowMSAA = true;
                yield return TickFrames(k_UpgradeFrames);
            }
            else
            {
                yield return EstablishMsaaOn();
                yield return TickFrames(k_SettleFrames);
            }

            // What the optimization decided to request.
            Assert.AreEqual(expectedRequest, Screen.msaaSamples,
                $"Requested real back buffer MSAA should be {expectedRequest} (needs={needsRealBackbufferMSAA}).");

            foreach (var camera in m_ProbeCameras)
            {
                // Confirm the camera actually rendered the way the scenario intends, so a camera silently
                // forced through an intermediate can't pass as "direct" (or vice versa).
                bool expectedDirect = !m_IntermediateCameras.Contains(camera);
                Assert.IsTrue(m_ProbePass.observedActiveTargetIsBackbuffer.TryGetValue(camera, out bool renderedDirect),
                    $"Camera '{camera.name}' did not render, so its back buffer usage couldn't be probed.");
                Assert.AreEqual(expectedDirect, renderedDirect,
                    $"Camera '{camera.name}' should render {(expectedDirect ? "directly to the back buffer (no intermediate)" : "through an intermediate")}.");

                // Confirm the request is already settled to the expected count at the instant the camera
                // renders - not just by teardown - so a one-frame apply lag would be caught.
                Assert.IsTrue(m_ProbePass.observedRequestedMsaa.TryGetValue(camera, out int requestedAtRender),
                    $"Camera '{camera.name}' did not render, so its requested back buffer MSAA couldn't be probed.");
                Assert.AreEqual(expectedRequest, requestedAtRender,
                    $"Camera '{camera.name}' requested back buffer MSAA at render time should be {expectedRequest}.");

                // The actual applied count must match the request once settled (SettleFrames absorbs the
                // one-frame apply lag), so any remaining disagreement is a real bug.
                Assert.IsTrue(m_ProbePass.observedCurrentBackbufferMsaa.TryGetValue(camera, out int currentAtRender),
                    $"Camera '{camera.name}' did not render, so its current back buffer MSAA couldn't be probed.");
                Assert.AreEqual(expectedRequest, currentAtRender,
                    $"Camera '{camera.name}' current back buffer MSAA at render time should be {expectedRequest}.");
            }
        }

        // On any failure in this fixture, dump the captured back buffer MSAA state so CI logs explain why
        // without needing a device repro: the platform/caps, the requested vs current counts, and per camera
        // how it actually rendered (direct vs intermediate) and the current back buffer MSAA seen at render time.
        void LogFailureDiagnostics()
        {
            var sb = new System.Text.StringBuilder();
            sb.AppendLine($"[RealBackbufferMSAATests] '{TestContext.CurrentContext.Test.Name}' failed. Captured state:");
            sb.AppendLine($"  graphicsDeviceType={SystemInfo.graphicsDeviceType}, supportsMultisampledBackBuffer={SystemInfo.supportsMultisampledBackBuffer}, explicitMsaaResolve={UniversalRenderer.PlatformRequiresExplicitMsaaResolve()}");
            sb.AppendLine($"  asset.msaaSampleCount={m_Asset.msaaSampleCount}, Screen.msaaSamples(requested)={Screen.msaaSamples}, Screen.currentBackbufferMSAASamples(in teardown)={Screen.currentBackbufferMSAASamples}");
            foreach (var camera in m_ProbeCameras)
            {
                string rendered = m_ProbePass.observedActiveTargetIsBackbuffer.TryGetValue(camera, out bool isBackbuffer)
                    ? (isBackbuffer ? "direct" : "intermediate") : "<not rendered>";
                string current = m_ProbePass.observedCurrentBackbufferMsaa.TryGetValue(camera, out int currentMsaa)
                    ? currentMsaa.ToString() : "<not rendered>";
                string requestedAtProbe = m_ProbePass.observedRequestedMsaa.TryGetValue(camera, out int reqMsaa)
                    ? reqMsaa.ToString() : "<not rendered>";
                sb.AppendLine($"  camera '{camera.name}': expectedIntermediate={m_IntermediateCameras.Contains(camera)}, rendered={rendered}, requestedMSAA(at render time)={requestedAtProbe}, currentBackbufferMSAA(at render time)={current}");
            }
            sb.AppendLine($"  current back buffer MSAA per ticked frame: [{string.Join(", ", m_CurrentBackbufferMsaaPerFrame)}]");
            Debug.Log(sb.ToString());
        }

        Camera CreateScreenCamera(bool intermediate)
        {
            var go = new GameObject("MSAA Test Screen Camera");
            m_TestObjects.Add(go);
            var camera = go.AddComponent<Camera>();
            // Pin every camera setting that would otherwise push the camera through an intermediate, so a
            // "direct" camera is direct because the test says so, not because of defaults.
            camera.allowMSAA = true;
            camera.allowHDR = false;
            camera.allowDynamicResolution = false;
            camera.targetTexture = null;
            camera.rect = new Rect(0f, 0f, 1f, 1f);
            var data = go.AddComponent<UniversalAdditionalCameraData>();
            data.SetRenderer(0);
            data.renderPostProcessing = false;
            m_ProbeCameras.Add(camera);
            if (intermediate)
                m_IntermediateCameras.Add(camera);
            return camera;
        }

        Camera CreateRenderTextureCamera()
        {
            var rt = new RenderTexture(128, 128, 16) { antiAliasing = k_AssetMsaaSampleCount };
            m_TestObjects.Add(rt);
            var go = new GameObject("MSAA Test RenderTexture Camera");
            m_TestObjects.Add(go);
            var camera = go.AddComponent<Camera>();
            camera.allowMSAA = true;
            camera.targetTexture = rt;
            var data = go.AddComponent<UniversalAdditionalCameraData>();
            data.SetRenderer(0);
            return camera;
        }

        UniversalRenderPipelineAsset CreateAsset(bool tileOnly = false)
        {
            var rendererData = ScriptableObject.CreateInstance<UniversalRendererData>();
            rendererData.renderingMode = RenderingMode.Forward;
            rendererData.tileOnlyMode = tileOnly;

            var instance = ScriptableObject.CreateInstance<UniversalRenderPipelineAsset>();
            instance.m_RendererDataList[0] = rendererData;
            // Pin every setting that feeds RequiresIntermediateColorTexture, rather than trusting fresh-asset
            // defaults: any of these flipping on would push a "direct" camera through an intermediate and
            // silently invalidate the test. With these off, the direct-vs-intermediate distinction is
            // controlled solely by the force-intermediate pass.
            instance.msaaSampleCount = k_AssetMsaaSampleCount;
            instance.supportsHDR = false;
            instance.supportsCameraOpaqueTexture = false;
            instance.supportsCameraDepthTexture = false;
            instance.renderScale = 1.0f;
            return instance;
        }

        // A no-op pass that only declares it needs an intermediate texture, forcing URP to render the
        // camera through an intermediate attachment (decoupled from any specific URP feature).
        class ForceIntermediatePass : ScriptableRenderPass
        {
            public ForceIntermediatePass()
            {
                requiresIntermediateTexture = true;
            }

            public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
            {
            }
        }

        // Records, per camera, whether the active render target after opaques is the back buffer (direct)
        // or an intermediate. Read back by the test to verify each camera rendered as intended.
        class ActiveTargetProbePass : ScriptableRenderPass
        {
            public readonly Dictionary<Camera, bool> observedActiveTargetIsBackbuffer = new();
            public readonly Dictionary<Camera, int> observedCurrentBackbufferMsaa = new();
            public readonly Dictionary<Camera, int> observedRequestedMsaa = new();

            public ActiveTargetProbePass()
            {
                renderPassEvent = RenderPassEvent.AfterRenderingOpaques;
            }

            public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
            {
                var cameraData = frameData.Get<UniversalCameraData>();
                var resourceData = frameData.Get<UniversalResourceData>();
                observedActiveTargetIsBackbuffer[cameraData.camera] = resourceData.isActiveTargetBackBuffer;
                // Capture applied and requested counts at the same instant the camera renders, so a failure
                // shows whether they disagree mid-render rather than just by teardown.
                observedCurrentBackbufferMsaa[cameraData.camera] = Screen.currentBackbufferMSAASamples;
                observedRequestedMsaa[cameraData.camera] = Screen.msaaSamples;
            }
        }
    }
}