acdream/src/AcDream.Core/Physics/ShadowShapeBuilder.cs

using System;
using System.Collections.Generic;
using System.Numerics;
using DatReaderWriter.DBObjs;
using DatReaderWriter.Enums;
using DatReaderWriter.Types;

namespace AcDream.Core.Physics;

/// <summary>
/// Pure-function builder that translates a <see cref="Setup"/> into a list of
/// <see cref="ShadowShape"/>s suitable for registration via
/// <see cref="ShadowObjectRegistry.RegisterMultiPart"/>.
///
/// <para>
/// Walks (1) every CylSphere → Cylinder shape, (2) every Sphere ONLY when no
/// CylSpheres are present (matches retail and the existing landblock-static
/// convention at GameWindow.cs:6034), and (3) every Part whose GfxObj has a
/// non-null PhysicsBSP → per-part BSP shape, with local transforms from
/// PlacementFrames[Resting | Default | first available].
/// </para>
///
/// <para>
/// Retail anchor: <c>CPhysicsObj::FindObjCollisions</c> calls
/// <c>CPartArray::FindObjCollisions</c> which iterates parts; each part's
/// <c>find_obj_collisions</c> tests CylSpheres + GfxObj BSP. We emit one
/// ShadowShape per part contribution so the existing FindObjCollisions
/// iteration loop in <see cref="Transition"/> tests each part independently.
/// </para>
/// </summary>
public static class ShadowShapeBuilder
{
    /// <summary>
    /// Build the shape list for a Setup.
    /// </summary>
    /// <param name="setup">The Setup to walk.</param>
    /// <param name="entScale">The entity's overall scale factor; multiplies
    /// every radius, height, and local offset.</param>
    /// <param name="hasPhysicsBsp">Predicate: does the GfxObj with this id
    /// have a non-null PhysicsBSP? Production: <c>id => cache.GetGfxObj(id)?.BSP?.Root is not null</c>.</param>
    /// <param name="partPoseOverride">#175: per-part pose override for the
    /// BSP part shapes — the entity's motion-table DEFAULT-STATE pose (the
    /// closed pose for doors). Retail collision tests each part's LIVE
    /// <c>CPhysicsPart</c> pose, which for an idle entity is the motion
    /// table's default state, NOT the Setup's placement frame — the two
    /// differ on e.g. the Facility Hub double door (Setup 0x02000C9D:
    /// placement poses the panels AJAR at yaw −150°/−30°, y −0.44 m; the
    /// closed pose is straight). Null / short lists fall back to the
    /// placement frame per part (entities with no motion table, and the
    /// CylSphere/Sphere shapes, are unaffected — retail poses those from
    /// the setup too).</param>
    public static IReadOnlyList<ShadowShape> FromSetup(
        Setup setup,
        float entScale,
        Func<uint, bool> hasPhysicsBsp,
        IReadOnlyList<Frame>? partPoseOverride = null)
    {
        if (setup is null) throw new ArgumentNullException(nameof(setup));
        if (hasPhysicsBsp is null) throw new ArgumentNullException(nameof(hasPhysicsBsp));

        var result = new List<ShadowShape>();

        // 1. CylSpheres — each becomes a Cylinder shape.
        foreach (var cyl in setup.CylSpheres)
        {
            if (cyl.Radius <= 0f) continue;
            float baseHeight = cyl.Height > 0f ? cyl.Height : cyl.Radius * 4f;
            result.Add(new ShadowShape(
                GfxObjId:      0u,
                LocalPosition: new Vector3(cyl.Origin.X, cyl.Origin.Y, cyl.Origin.Z) * entScale,
                LocalRotation: Quaternion.Identity,
                Scale:         entScale,
                CollisionType: ShadowCollisionType.Cylinder,
                Radius:        cyl.Radius * entScale,
                CylHeight:     baseHeight * entScale));
        }

        // 2. Spheres — only when no CylSpheres (matches landblock-static convention
        //    at GameWindow.cs:6034). Each becomes a true Sphere (no height clamping).
        //    Retail anchor: CSphere::intersects_sphere @ 0x00537A80 uses 3-D distance
        //    for the overlap check, unlike CCylSphere which clips to [low_pt, high_pt].
        if (setup.CylSpheres.Count == 0)
        {
            foreach (var sph in setup.Spheres)
            {
                if (sph.Radius <= 0f) continue;
                result.Add(new ShadowShape(
                    GfxObjId:      0u,
                    LocalPosition: new Vector3(sph.Origin.X, sph.Origin.Y, sph.Origin.Z) * entScale,
                    LocalRotation: Quaternion.Identity,
                    Scale:         entScale,
                    CollisionType: ShadowCollisionType.Sphere,
                    Radius:        sph.Radius * entScale,
                    CylHeight:     0f));
            }
        }

        // 3. Parts — one BSP shape per part with a non-null PhysicsBSP.
        // Pose priority per part: partPoseOverride (the motion-table
        // default-state pose, #175) → placement frame → identity.
        AnimationFrame? placementFrame = ResolvePlacementFrame(setup);
        for (int i = 0; i < setup.Parts.Count; i++)
        {
            uint gfxId = (uint)setup.Parts[i];
            if (!hasPhysicsBsp(gfxId)) continue;

            Frame partFrame;
            if (partPoseOverride is not null && i < partPoseOverride.Count)
                partFrame = partPoseOverride[i];
            else if (placementFrame is not null && i < placementFrame.Frames.Count)
                partFrame = placementFrame.Frames[i];
            else
                partFrame = new Frame { Origin = Vector3.Zero, Orientation = Quaternion.Identity };

            // BSP radius default; caller substitutes the real BoundingSphere.Radius
            // at registration time when available. Loose-but-safe broadphase value.
            float bspRadius = 2f * entScale;

            result.Add(new ShadowShape(
                GfxObjId:      gfxId,
                LocalPosition: new Vector3(partFrame.Origin.X, partFrame.Origin.Y, partFrame.Origin.Z) * entScale,
                LocalRotation: partFrame.Orientation,
                Scale:         entScale,
                CollisionType: ShadowCollisionType.BSP,
                Radius:        bspRadius,
                CylHeight:     0f));
        }

        return result;
    }

    /// <summary>Resolve the placement frame in priority Resting → Default →
    /// first available. Mirrors <c>SetupMesh.Flatten</c>'s convention.</summary>
    private static AnimationFrame? ResolvePlacementFrame(Setup setup)
    {
        if (setup.PlacementFrames.TryGetValue(Placement.Resting, out var resting)) return resting;
        if (setup.PlacementFrames.TryGetValue(Placement.Default, out var def))     return def;
        foreach (var kvp in setup.PlacementFrames) return kvp.Value;
        return null;
    }
}