< Summary

Information
Class: Gravitas.Colliders.ColliderCanonicalBounds2D
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/Colliders/Geometry/ColliderCanonicalBounds2D.cs
Line coverage
100%
Covered lines: 120
Uncovered lines: 0
Coverable lines: 120
Total lines: 232
Line coverage: 100%
Branch coverage
100%
Covered branches: 40
Total branches: 40
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Colliders/Geometry/ColliderCanonicalBounds2D.cs

#LineLine coverage
 1//=======================================================================
 2// ColliderCanonicalBounds2D.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using FixedMathSharp;
 9using FixedMathSharp.Geometry;
 10
 11namespace Gravitas.Colliders;
 12
 13/// <summary>
 14/// Contains methods for computing canonical bounds of 2D colliders,
 15/// including proxy radii and relative bounds, based on collider type and properties.
 16/// </summary>
 17internal static class ColliderCanonicalBounds2D
 18{
 19    // The caller supplies a compound leaf. Retain its authored local box until
 20    // the final mesh-relative transform; clipped world bounds lose boundary geometry.
 21    internal static void GetMixedRelativeBounds(LSCollider2D collider,
 22        Vector3d referenceOrigin, FixedQuaternion referenceRotation, out FixedBoundBox relativeBounds,
 23        out FixedOrientedBox orientedBounds)
 24    {
 50925        orientedBounds = default;
 26        Vector2d minimum, maximum;
 50927        Fixed64 rotation = collider.Rotation;
 50928        if (collider is LSCircleCollider2D circle)
 29        {
 430            minimum = -Vector2d.One * circle.ScaledRadius;
 431            maximum = -minimum;
 32        }
 50533        else if (collider is LSCapsuleCollider2D capsule)
 34        {
 35            // Admitted capsule reach bounds every local extent before world clipping.
 41836            FixedBoundArea bounds = FixedBoundArea.FromCenteredRotatedCapsuleClippedToDomain(
 41837                Vector2d.Zero, Fixed64.Zero, capsule.AxisLength, capsule.ScaledRadius);
 41838            minimum = bounds.Min;
 41839            maximum = bounds.Max;
 40        }
 41        else
 42        {
 8743            rotation = collider.ConvexRotation;
 8744            minimum = maximum = collider.GetScaledLocalVertexUnchecked(0);
 62445            for (int i = 1; i < collider.VertexCount; i++)
 46            {
 22547                Vector2d vertex = collider.GetScaledLocalVertexUnchecked(i);
 22548                minimum = new Vector2d(FixedMath.Min(minimum.X, vertex.X), FixedMath.Min(minimum.Y, vertex.Y));
 22549                maximum = new Vector2d(FixedMath.Max(maximum.X, vertex.X), FixedMath.Max(maximum.Y, vertex.Y));
 50            }
 51        }
 52        // Keep the enclosure centered on the canonical origin, avoiding another
 53        // rounded world-center transform for asymmetric authored polygons.
 50954        Vector2d negativeMinimum = -minimum;
 50955        Vector3d origin = new(collider.Center.X, collider.MixedSlabCenterY, collider.Center.Y);
 50956        FixedQuaternion orientation = FixedQuaternion.FromAxisAngle(Vector3d.Up, -rotation);
 50957        orientedBounds = new FixedOrientedBox(origin, orientation, new Vector3d(
 50958            FixedMath.Max(negativeMinimum.X, maximum.X), collider.MixedHalfThickness,
 50959            FixedMath.Max(negativeMinimum.Y, maximum.Y)));
 50960        relativeBounds = FixedBoundBox.FromRelativeRotatedBoundsClippedToDomain(
 50961            origin, orientation,
 50962            new Vector3d(minimum.X, -collider.MixedHalfThickness, minimum.Y),
 50963            new Vector3d(maximum.X, collider.MixedHalfThickness, maximum.Y), referenceOrigin, referenceRotation);
 50964    }
 65
 66    private static Fixed64 GetShapeCenteredProxyRadius(
 67        LSCollider2D collider)
 68    {
 1469        if (collider is LSCircleCollider2D circle)
 270            return circle.ScaledRadius;
 1271        if (collider is LSCapsuleCollider2D capsule)
 72        {
 173            FixedBoundArea localBounds =
 174                FixedBoundArea.FromCenteredCapsuleClippedToDomain(
 175                    Vector2d.Zero,
 176                    Vector2d.Forward,
 177                    capsule.AxisLength,
 178                    capsule.ScaledRadius);
 179            return localBounds.Max.Y;
 80        }
 1181        if (collider is LSPolygonCollider2D polygon)
 982            return polygon.GetCurrentGeometryReach();
 283        Fixed64 radius = Fixed64.Zero;
 1284        for (int index = 0; index < collider.VertexCount; index++)
 85        {
 586            if (!collider.GetScaledLocalVertexUnchecked(index)
 587                    .TryGetMagnitudeCeiling(out Fixed64 vertexRadius))
 88            {
 189                return Fixed64.MaxValue;
 90            }
 91
 492            radius = FixedMath.Max(radius, vertexRadius);
 93        }
 94
 195        return radius;
 96    }
 97
 98    internal static Fixed64 GetCompoundCenteredProxyRadius(LSCompoundCollider2D compound, out Fixed64 rotationalRadius)
 99    {
 1425100        Fixed64 radius = Fixed64.Zero;
 1425101        rotationalRadius = Fixed64.Zero;
 6406102        for (int index = 0; index < compound.PartCount; index++)
 103        {
 1778104            var part = compound.GetPartCollider(index);
 1778105            Vector2d offset = part.CanonicalCenter - compound.CanonicalCenter;
 1778106            radius = FixedMath.Max(radius, ColliderGeometryPolicy.Add(
 1778107                ColliderGeometryPolicy.Magnitude(offset), part.CanonicalCenteredProxyRadius));
 108            // Retain a separate all-angle enclosure for the frame's CCD proxy.
 1778109            rotationalRadius = FixedMath.Max(rotationalRadius, part.CanonicalPivotProxyRadius);
 110        }
 1425111        return radius;
 112    }
 113
 114    internal static Fixed64 GetCurrentCompoundCenteredProxyRadius(
 115        LSCompoundCollider2D compound)
 116    {
 14117        Fixed64 radius = Fixed64.Zero;
 54118        for (int index = 0; index < compound.PartCount; index++)
 119        {
 14120            LSCollider2D part = compound.GetPartCollider(index);
 14121            bool distanceResolved = part.TryGetCurrentScaledOffset(
 14122                    out Vector2d centerOffset)
 14123                & centerOffset.TryGetMagnitudeCeiling(
 14124                    out Fixed64 centerDistance);
 14125            bool radiusResolved = Fixed64.TryAdd(
 14126                centerDistance,
 14127                GetShapeCenteredProxyRadius(part),
 14128                out Fixed64 partRadius);
 14129            if (!(distanceResolved & radiusResolved))
 1130                return Fixed64.MaxValue;
 131
 13132            radius = FixedMath.Max(radius, partRadius);
 133        }
 134
 13135        return radius;
 136    }
 137
 138    internal static Fixed64 GetGroundProbeRadius(
 139        LSCollider2D collider)
 140    {
 39573141        if (collider is LSCircleCollider2D circle)
 12962142            return circle.ScaledRadius;
 26611143        if (collider is LSCapsuleCollider2D capsule)
 5655144            return capsule.ScaledRadius;
 20956145        if (collider is LSCompoundCollider2D compound)
 146        {
 1425147            GetCompoundRelativeBounds(compound, compound.CanonicalCenter,
 1425148                out Vector2d minimum, out Vector2d maximum);
 1425149            return GetMinimumAbsoluteExtent(minimum, maximum);
 150        }
 19531151        if (collider.VertexCount == 0)
 16152            return Fixed64.Zero;
 153
 19515154        GetConvexBoundsFromRelativeCenter(collider, Vector2d.Zero,
 19515155            out Vector2d convexMinimum, out Vector2d convexMaximum);
 19515156        return GetMinimumAbsoluteExtent(convexMinimum, convexMaximum);
 157    }
 158
 159    private static void GetCompoundRelativeBounds(LSCompoundCollider2D compound,
 160        Vector2d referenceCenter, out Vector2d minimum, out Vector2d maximum)
 161    {
 1425162        minimum = maximum = default;
 6406163        for (int index = 0; index < compound.PartCount; index++)
 164        {
 1778165            GetRelativeBounds(compound.GetPartCollider(index), referenceCenter,
 1778166                out Vector2d partMinimum, out Vector2d partMaximum);
 1778167            if (index == 0)
 168            {
 1425169                minimum = partMinimum;
 1425170                maximum = partMaximum;
 171            }
 172            else
 173            {
 353174                minimum = new Vector2d(FixedMath.Min(minimum.X, partMinimum.X), FixedMath.Min(minimum.Y, partMinimum.Y))
 353175                maximum = new Vector2d(FixedMath.Max(maximum.X, partMaximum.X), FixedMath.Max(maximum.Y, partMaximum.Y))
 176            }
 177        }
 1425178    }
 179
 180    private static void GetRelativeBounds(LSCollider2D collider, Vector2d referenceCenter,
 181        out Vector2d minimum, out Vector2d maximum)
 182    {
 183        // Called only during publication. Admitted part spacing and local reach
 184        // bound these relative coordinates, even at an absolute scalar face.
 1778185        Vector2d relativeCenter = collider.CanonicalCenter - referenceCenter;
 1778186        if (collider is LSCircleCollider2D circle)
 187        {
 425188            GetRoundBounds(relativeCenter, circle.ScaledRadius, circle.ScaledRadius, out minimum, out maximum);
 425189            return;
 190        }
 1353191        if (collider is LSCapsuleCollider2D capsule)
 192        {
 182193            FixedBoundArea centeredBounds = FixedBoundArea.FromCenteredRotatedCapsuleClippedToDomain(
 182194                Vector2d.Zero, capsule.Rotation, capsule.AxisLength, capsule.ScaledRadius);
 182195            GetRoundBounds(relativeCenter, centeredBounds.Max.X, centeredBounds.Max.Y, out minimum, out maximum);
 182196            return;
 197        }
 1171198        GetConvexBoundsFromRelativeCenter(collider, relativeCenter, out minimum, out maximum);
 1171199    }
 200
 201    private static void GetRoundBounds(Vector2d center, Fixed64 extentX, Fixed64 extentY,
 202        out Vector2d minimum, out Vector2d maximum)
 203    {
 607204        Vector2d extents = new(extentX, extentY);
 607205        minimum = center - extents;
 607206        maximum = center + extents;
 607207    }
 208
 209    private static void GetConvexBoundsFromRelativeCenter(LSCollider2D collider, Vector2d relativeCenter,
 210        out Vector2d minimum, out Vector2d maximum)
 211    {
 212        // Admission bounds the local rotated sums; retain the existing fused
 213        // transform rounding rather than project products independently.
 20686214        _ = Vector2d.TryTransformPoint(relativeCenter, collider.GetScaledLocalVertexUnchecked(0),
 20686215            collider.ConvexRotation, out minimum);
 20686216        maximum = minimum;
 166272217        for (int index = 1; index < collider.VertexCount; index++)
 218        {
 62450219            _ = Vector2d.TryTransformPoint(relativeCenter, collider.GetScaledLocalVertexUnchecked(index),
 62450220                collider.ConvexRotation, out Vector2d point);
 62450221            minimum = new Vector2d(FixedMath.Min(minimum.X, point.X), FixedMath.Min(minimum.Y, point.Y));
 62450222            maximum = new Vector2d(FixedMath.Max(maximum.X, point.X), FixedMath.Max(maximum.Y, point.Y));
 223        }
 20686224    }
 225
 226    private static Fixed64 GetMinimumAbsoluteExtent(
 227        Vector2d minimum,
 228        Vector2d maximum) =>
 20940229        FixedMath.Min(
 20940230            FixedMath.Max(minimum.X.Abs(), maximum.X.Abs()),
 20940231            FixedMath.Max(minimum.Y.Abs(), maximum.Y.Abs()));
 232}