acdream/tests/AcDream.App.Tests/Rendering/ParticleRendererRouteTests.cs

using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using AcDream.App.Rendering;
using AcDream.App.Rendering.Gpu;
using AcDream.App.Rendering.Gpu.Vk;
using AcDream.App.Rendering.Wb;
using AcDream.App.Tests.Rendering.Gpu;
using AcDream.Content;
using AcDream.Core.Meshing;
using AcDream.Core.Vfx;
using Microsoft.Extensions.Logging.Abstractions;

namespace AcDream.App.Tests.Rendering;

/// <summary>
/// S4-c2 particle routing and production-dispatch pins. The pure table tests
/// remain narrow coverage; the two principal cases below call the actual
/// <see cref="ParticleRenderer.DeferToRetailAlphaQueue"/> dispatch that the
/// renderer's scene loop uses.
/// </summary>
public sealed class ParticleRendererRouteTests
{
    /// <summary>M1(d) pin 1: an Opaque-classified mesh-particle batch (mask
    /// 0x00) with a non-fully-opaque current alpha (top ColorArgb byte !=
    /// 0xFF, i.e. materialHasAlpha true) routes to ALPHA (Append) — retail's
    /// row 4 material-alpha fallback — not Immediate. Mutation check:
    /// reverting to the pre-fix code (which threw whenever the decision
    /// wasn't Append) would not distinguish this from pin 2 below at all
    /// (both would just throw); reverting ONLY the materialHasAlpha
    /// derivation to a hardcoded `false` makes this assertion fail because
    /// the decision becomes Immediate instead of Append.</summary>
    [Fact]
    public void OpaqueClassifiedMeshBatch_WithMaterialAlpha_DefersAndDrawsOnlyAtFlush()
    {
        var queue = new RetailAlphaQueue();
        var source = new RecordingSource();
        int reserveCount = 0;
        int immediateCount = 0;
        queue.BeginFrame();

        const uint colorArgbWithAlpha = 0x80FFFFFFu;
        RetailAlphaMeshDecision decision = ParticleRenderer.DeferToRetailAlphaQueue(
            ParticleSubmissionKind.Mesh,
            TranslucencyKind.Opaque,
            colorArgbWithAlpha,
            queue,
            source,
            reserveDeferred: () => reserveCount++,
            drawImmediate: (_, _, _, _) => immediateCount++,
            Matrix4x4.Identity,
            drawIndex: 7);

        Assert.Equal(RetailAlphaMeshAction.Append, decision.Action);
        Assert.Equal(RetailAlphaList.Alpha, decision.List);
        Assert.Equal(1, reserveCount);
        Assert.Equal(1, queue.AlphaCount);
        Assert.Equal(0, source.DrawCount);
        Assert.Equal(0, immediateCount);

        queue.EndFrame();

        Assert.Equal(1, source.DrawCount);
        Assert.Equal(0, immediateCount);
    }

    /// <summary>M1(d) pin 2: the SAME Opaque-classified mesh-particle batch
    /// with a fully-opaque current alpha (top ColorArgb byte == 0xFF, i.e.
    /// materialHasAlpha false) draws immediately and never enters a list —
    /// retail's row 5 fallthrough. Mutation check: this is the EXACT case
    /// that threw before the fix (mask 0x00, materialHasAlpha false ->
    /// row 5 Immediate -> the old "rows 1/2/4/5 unreachable" guard fired);
    /// reverting the throw's removal reproduces
    /// <c>InvalidOperationException</c> here, which this test would report
    /// as a failure (an unhandled exception) rather than an assertion
    /// mismatch.</summary>
    [Fact]
    public void OpaqueClassifiedMeshBatch_WithNoMaterialAlpha_DrawsImmediateOnOpaqueDepthState()
    {
        var queue = new RetailAlphaQueue();
        var source = new RecordingSource();
        int reserveCount = 0;
        var immediate = new List<(ParticleSubmissionKind Kind, int Index, bool Opaque)>();
        queue.BeginFrame();

        const uint fullyOpaqueColorArgb = 0xFFFFFFFFu;
        RetailAlphaMeshDecision decision = ParticleRenderer.DeferToRetailAlphaQueue(
            ParticleSubmissionKind.Mesh,
            TranslucencyKind.Opaque,
            fullyOpaqueColorArgb,
            queue,
            source,
            reserveDeferred: () => reserveCount++,
            drawImmediate: (_, kind, index, opaque) => immediate.Add((kind, index, opaque)),
            Matrix4x4.Identity,
            drawIndex: 11);

        Assert.Equal(RetailAlphaMeshAction.Immediate, decision.Action);
        Assert.Equal(0, reserveCount);
        Assert.Equal(0, queue.PendingCount);
        Assert.Equal(
            [(ParticleSubmissionKind.Mesh, 11, true)],
            immediate);

        ParticleRenderer.MeshParticlePipelineState state =
            ParticleRenderer.ResolveMeshParticlePipelineState(
                TranslucencyKind.Opaque,
                opaqueDepthState: immediate[0].Opaque);
        Assert.Equal(GpuBlendMode.None, state.Blend);
        Assert.True(state.Depth.Test);
        Assert.True(state.Depth.Write);
        Assert.Equal(WorldDepthContract.WorldCompare, state.Depth.Compare);

        queue.EndFrame();
        Assert.Equal(0, source.PrepareCount);
        Assert.Equal(0, source.DrawCount);
    }

    /// <summary>
    /// M1 production fixed-state/binding pin. Executes the real private
    /// pipeline factory against the recording GPU device and the real
    /// <c>PipelineForMeshBlend</c> selector (not a restated expected-state
    /// helper). Mutation checks: making the opaque factory depth-write false
    /// fails the descriptor assertions; mapping the immediate opaque case to
    /// <c>_meshAlphaPipeline</c> fails the identity assertion.
    /// </summary>
    [Fact]
    public void ImmediateOpaqueMesh_UsesProductionParticleMeshOpaquePipelineDescription()
    {
        using var device = new RecordingGpuDevice();
        using var manager = new ObjectMeshManager(
            new VulkanMeshPipelineDevice(device.Retirement),
            device,
            new NullPreparedAssetSource(),
            NullLogger<ObjectMeshManager>.Instance);
        var adapter = (WbMeshAdapter)RuntimeHelpers.GetUninitializedObject(
            typeof(WbMeshAdapter));
        typeof(WbMeshAdapter).GetField(
            "_meshManager",
            BindingFlags.Instance | BindingFlags.NonPublic)!
            .SetValue(adapter, manager);
        var frames = new GpuDeviceFrameLifetime(device);
        var scope = new VulkanWorldPassScope(sampleCount: 1);
        using var renderer = new ParticleRenderer(
            device,
            frames,
            scope,
            new ParticleSystem(new EmitterDescRegistry(), new Random(42)),
            meshAdapter: adapter);
        MethodInfo select = typeof(ParticleRenderer).GetMethod(
            "PipelineForMeshBlend",
            BindingFlags.Instance | BindingFlags.NonPublic)!;

        var selected = (IGpuPipeline)select.Invoke(
            renderer,
            [TranslucencyKind.Opaque, true])!;

        Assert.Same(
            device.CreatedPipelines.Single(
                static pipeline => pipeline.Description.Name == "particle-mesh-opaque"),
            selected);
        GpuPipelineDescription description = selected.Description;
        Assert.Equal("particle_mesh", description.Shaders.Name);
        Assert.Equal(GpuBlendMode.None, description.Blend);
        Assert.True(description.Depth.Test);
        Assert.True(description.Depth.Write);
        Assert.Equal(WorldDepthContract.WorldCompare, description.Depth.Compare);
        Assert.Equal(GpuCullMode.None, description.Cull);
        Assert.Equal(GpuFrontFace.Clockwise, description.FrontFace);
        Assert.False(description.AlphaToCoverage);

    }

    /// <summary>A billboard submission always carries the alpha-family mask
    /// (0x02) regardless of the (unused) mesh parameters, and therefore
    /// always satisfies row 3 (Append, ALPHA) under the fixed default delay
    /// mask — never Immediate, never CLIP. Mutation check: swapping
    /// <see cref="RetailAlphaMeshRouter.MaskAlphaFamily"/> for
    /// <see cref="RetailAlphaMeshRouter.MaskClipMap"/> in the billboard
    /// branch would route this to the CLIP list instead of ALPHA.</summary>
    [Fact]
    public void Billboard_AlwaysRoutesToAlphaAppend()
    {
        RetailAlphaMeshDecision decision = ParticleRenderer.RouteParticleSubmission(
            ParticleSubmissionKind.Billboard, default, default);

        Assert.Equal(RetailAlphaMeshAction.Append, decision.Action);
        Assert.Equal(RetailAlphaList.Alpha, decision.List);
    }

    [Fact]
    public void ProductionDispatch_WarmedAppendAndImmediatePathsDoNotAllocate()
    {
        var queue = new RetailAlphaQueue();
        var sink = new NoAllocParticleSink();
        ParticleRenderer.ReserveDeferredParticleDraw reserve = sink.Reserve;
        ParticleRenderer.DrawImmediateParticle immediate = sink.DrawImmediate;

        for (int i = 0; i < 64; i++)
            RunPair(queue, sink, reserve, immediate);

        long before = GC.GetAllocatedBytesForCurrentThread();
        for (int i = 0; i < 1_000; i++)
            RunPair(queue, sink, reserve, immediate);
        long allocated = GC.GetAllocatedBytesForCurrentThread() - before;

        Assert.Equal(0, allocated);
    }

    private static void RunPair(
        RetailAlphaQueue queue,
        NoAllocParticleSink sink,
        ParticleRenderer.ReserveDeferredParticleDraw reserve,
        ParticleRenderer.DrawImmediateParticle immediate)
    {
        queue.BeginFrame();
        ParticleRenderer.DeferToRetailAlphaQueue(
            ParticleSubmissionKind.Mesh,
            TranslucencyKind.Opaque,
            0x80FFFFFFu,
            queue,
            sink,
            reserve,
            immediate,
            Matrix4x4.Identity,
            drawIndex: 0);
        ParticleRenderer.DeferToRetailAlphaQueue(
            ParticleSubmissionKind.Mesh,
            TranslucencyKind.Opaque,
            0xFFFFFFFFu,
            queue,
            sink,
            reserve,
            immediate,
            Matrix4x4.Identity,
            drawIndex: 1);
        queue.EndFrame();
    }

    private sealed class RecordingSource : IRetailAlphaDrawSource
    {
        public int PrepareCount { get; private set; }
        public int DrawCount { get; private set; }

        public void PrepareAlphaDraws(ReadOnlySpan<int> tokens) => PrepareCount++;

        public void DrawPreparedAlphaBatch(int firstPreparedDraw, int drawCount) =>
            DrawCount += drawCount;

        public void ResetAlphaSubmissions()
        {
        }
    }

    private sealed class NoAllocParticleSink : IRetailAlphaDrawSource
    {
        private int _nextToken;

        public int Reserve() => _nextToken++;

        public void DrawImmediate(
            Matrix4x4 viewProjection,
            ParticleSubmissionKind kind,
            int drawIndex,
            bool opaqueDepthState)
        {
        }

        public void PrepareAlphaDraws(ReadOnlySpan<int> tokens)
        {
        }

        public void DrawPreparedAlphaBatch(int firstPreparedDraw, int drawCount)
        {
        }

        public void ResetAlphaSubmissions() => _nextToken = 0;
    }

    private sealed class NullPreparedAssetSource : IPreparedAssetSource
    {
        public PreparedAssetSourceStats Stats => default;

        public CacheStats DecodedTextureCacheStats => default;

        public PreparedAssetPresence Probe(
            AcDream.Content.Pak.PakAssetType type,
            uint sourceFileId) =>
            PreparedAssetPresence.Missing;

        public PreparedAssetReadResult Read(
            in PreparedAssetRequest request,
            CancellationToken cancellationToken = default) =>
            PreparedAssetReadResult.Missing;

        public void Dispose()
        {
        }
    }
}