角色挥剑时突然消失：骨骼动画不能沿用绑定姿态 Bounds

readonly record struct Bounds3(Vector3 Min, Vector3 Max)
{
    public bool Intersects(Bounds3 other) =>
        Min.X <= other.Max.X && Max.X >= other.Min.X &&
        Min.Y <= other.Max.Y && Max.Y >= other.Min.Y &&
        Min.Z <= other.Max.Z && Max.Z >= other.Min.Z;
}

readonly record struct BoneLocalBounds(int Bone, Bounds3 Bounds);

enum CommitResult
{
    Committed,
    StaleRevision,
    MissingBone,
    NonFiniteMatrix
}

sealed class SkinnedBoundsOwner
{
    private readonly BoneLocalBounds[] boneBounds;

    public int ActiveRevision { get; private set; }
    public Bounds3 ActiveBounds { get; private set; }

    public SkinnedBoundsOwner(Bounds3 bindPoseBounds, params BoneLocalBounds[] localBounds)
    {
        if (localBounds.Length == 0)
            throw new ArgumentException("At least one bone bound is required.", nameof(localBounds));
        if (localBounds.Any(item => !IsValid(item.Bounds)))
            throw new ArgumentException("Bone bounds must be finite and ordered.", nameof(localBounds));

        boneBounds = localBounds.ToArray();
        ActiveBounds = bindPoseBounds;
    }

    public CommitResult TryCommit(int revision, IReadOnlyDictionary<int, Matrix4x4> palette)
    {
        if (revision <= ActiveRevision)
            return CommitResult.StaleRevision;

        foreach (var item in boneBounds)
        {
            if (!palette.ContainsKey(item.Bone))
                return CommitResult.MissingBone;
            if (!IsFinite(palette[item.Bone]))
                return CommitResult.NonFiniteMatrix;
        }

        var candidate = Transform(boneBounds[0].Bounds, palette[boneBounds[0].Bone]);
        for (var i = 1; i < boneBounds.Length; i++)
        {
            var item = boneBounds[i];
            candidate = Union(candidate, Transform(item.Bounds, palette[item.Bone]));
        }

        ActiveBounds = candidate;
        ActiveRevision = revision;
        return CommitResult.Committed;
    }

    private static Bounds3 Transform(Bounds3 bounds, Matrix4x4 matrix)
    {
        var min = new Vector3(float.PositiveInfinity);
        var max = new Vector3(float.NegativeInfinity);
        foreach (var corner in Corners(bounds))
        {
            var point = Vector3.Transform(corner, matrix);
            min = Vector3.Min(min, point);
            max = Vector3.Max(max, point);
        }
        return new Bounds3(min, max);
    }

    private static IEnumerable<Vector3> Corners(Bounds3 bounds)
    {
        for (var mask = 0; mask < 8; mask++)
        {
            yield return new Vector3(
                (mask & 1) == 0 ? bounds.Min.X : bounds.Max.X,
                (mask & 2) == 0 ? bounds.Min.Y : bounds.Max.Y,
                (mask & 4) == 0 ? bounds.Min.Z : bounds.Max.Z);
        }
    }

    private static Bounds3 Union(Bounds3 a, Bounds3 b) =>
        new(Vector3.Min(a.Min, b.Min), Vector3.Max(a.Max, b.Max));

    private static bool IsValid(Bounds3 bounds) =>
        IsFinite(bounds.Min) && IsFinite(bounds.Max) &&
        bounds.Min.X <= bounds.Max.X && bounds.Min.Y <= bounds.Max.Y && bounds.Min.Z <= bounds.Max.Z;

    private static bool IsFinite(Vector3 value) =>
        float.IsFinite(value.X) && float.IsFinite(value.Y) && float.IsFinite(value.Z);

    private static bool IsFinite(Matrix4x4 value) =>
        float.IsFinite(value.M11) && float.IsFinite(value.M12) && float.IsFinite(value.M13) && float.IsFinite(value.M14) &&
        float.IsFinite(value.M21) && float.IsFinite(value.M22) && float.IsFinite(value.M23) && float.IsFinite(value.M24) &&
        float.IsFinite(value.M31) && float.IsFinite(value.M32) && float.IsFinite(value.M33) && float.IsFinite(value.M34) &&
        float.IsFinite(value.M41) && float.IsFinite(value.M42) && float.IsFinite(value.M43) && float.IsFinite(value.M44);
}

private static void MissingBonePreserves()
{
    var owner = CreateOwner();
    owner.TryCommit(4, ValidPalette());
    var before = owner.ActiveBounds;
    var incomplete = new Dictionary<int, Matrix4x4> { [0] = Matrix4x4.Identity };

    Check.Equal(CommitResult.MissingBone, owner.TryCommit(5, incomplete), "missing bone");
    Check.Equal(before, owner.ActiveBounds, "missing active bounds");
    Check.Equal(4, owner.ActiveRevision, "missing active revision");
}

dotnet build "$LAB_ROOT/SkinnedBoundsLab.csproj" -c Release --no-restore --nologo
dotnet run --project "$LAB_ROOT/SkinnedBoundsLab.csproj" -c Release --no-build

RESULT bind_visible=False commit=Committed revision=7 min_x=-0.50 max_x=2.50 animated_visible=True
TESTS passed=8 failed=0 skipped=0 elapsed_ms=41