< Summary

Information
Class: Gravitas.CollisionHandling.MeshSurfaceBoundaryDomain2D
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/2D/Surfaces/MeshSurfaceBoundaryDomain2D.cs
Line coverage
100%
Covered lines: 104
Uncovered lines: 0
Coverable lines: 104
Total lines: 195
Line coverage: 100%
Branch coverage
100%
Covered branches: 84
Total branches: 84
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor()100%11100%
get_Spans()100%11100%
get_VertexBounds()100%11100%
Build(...)100%1010100%
Gather(...)100%3636100%
Offsets(...)100%44100%
Embed(...)100%11100%
Include(...)100%22100%
Classify(...)100%1010100%
ClassifyInterval(...)100%1818100%
.ctor(...)100%11100%
get_Zero()100%11100%
get_One()100%11100%
.ctor(...)100%11100%
Lower(...)100%22100%
Upper(...)100%22100%
CompareTo(...)100%11100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/2D/Surfaces/MeshSurfaceBoundaryDomain2D.cs

#LineLine coverage
 1//=======================================================================
 2// MeshSurfaceBoundaryDomain2D.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 System;
 9using FixedMathSharp;
 10using FixedMathSharp.Geometry;
 11using Gravitas.Colliders;
 12using SwiftCollections;
 13
 14namespace Gravitas.CollisionHandling;
 15
 16/// <summary>
 17/// Classifies original convex perimeters against explicitly supplied committed
 18/// members, preserving exact span provenance and ambiguous boundaries. The
 19/// dimensional surface owner manages declarations, endpoint fans and response.
 20/// </summary>
 21internal sealed partial class MeshSurfaceBoundaryDomain2D
 22{
 162223    private readonly SwiftList<BoundarySpan2D> _spans = new();
 162224    private readonly SwiftList<FixedBoundArea> _vertexBounds = new();
 162225    private readonly SwiftList<Coverage> _coverage = new();
 162226    private readonly SwiftList<Parameter> _cuts = new();
 324427    private readonly SwiftHashSet<int> _own = new(), _opposite = new();
 28
 29
 30
 18047131    internal ReadOnlySpan<BoundarySpan2D> Spans => _spans.AsReadOnlySpan();
 1310032    internal ReadOnlySpan<FixedBoundArea> VertexBounds => _vertexBounds.AsReadOnlySpan();
 33    internal Vector2d Origin { get; private set; }
 34    internal Fixed64 Rotation { get; private set; }
 35
 36    internal void Build(ReadOnlySpan<LSCollider2D> members, int sourceMember, bool mixed = false,
 37        Fixed64? lowerHeight = null, Fixed64? upperHeight = null)
 38    {
 2089139        foreach (LSCollider2D member in members)
 798840            if (member is not (LSAABBoxCollider2D or LSPolygonCollider2D))
 141                throw new ArgumentException("Boundary preparation requires committed AABB or convex polygon members.", n
 245742        LSCollider2D source = members[sourceMember];
 491443        Origin = source.Center; Rotation = source.ConvexRotation;
 245744        _spans.FastClear();
 245745        _vertexBounds.FastClear();
 245746        Span<Vector2d> points = stackalloc Vector2d[2];
 2444647        for (int first = 0; first < source.VertexCount; first++)
 48        {
 976649            int second = (first + 1) % source.VertexCount;
 1953250            Vector2d start = source.GetScaledLocalVertexUnchecked(first), end = source.GetScaledLocalVertexUnchecked(sec
 976651            points[0] = start;
 976652            _vertexBounds.Add(WideConvex2dRelations.GetBoundsClippedToDomain(Origin, Rotation, points.Slice(0, 1)));
 976653            points[1] = end;
 976654            FixedBoundArea bounds = WideConvex2dRelations.GetBoundsClippedToDomain(Origin, Rotation, points);
 976655            Vector2d inward = source.GetScaledLocalVertexUnchecked((first + 2) % source.VertexCount);
 976656            Gather(members, sourceMember, new FixedSegment2d(start, end), inward, bounds, mixed, lowerHeight, upperHeigh
 976657            Classify(sourceMember, first, second, start, end, bounds);
 58        }
 245759    }
 60
 61    private void Gather(ReadOnlySpan<LSCollider2D> members, int sourceMember, FixedSegment2d edge,
 62        Vector2d inward, FixedBoundArea bounds, bool mixed, Fixed64? lowerHeight, Fixed64? upperHeight)
 63    {
 1953264        _coverage.FastClear(); _cuts.FastClear();
 1953265        _cuts.Add(Parameter.Zero); _cuts.Add(Parameter.One);
 976666        LSCollider2D source = members[sourceMember];
 976667        Span<Vector2d> box = stackalloc Vector2d[4];
 8294068        for (int member = 0; member < members.Length; member++)
 69        {
 3170470            if (member == sourceMember) continue;
 2193871            LSCollider2D target = members[member];
 72            // Zero yaw shares the same exact chart in both paths. Nonzero mixed
 73            // quaternion coverage cannot use scalar-yaw bounds as a rejection proof.
 2193874            if ((!mixed || source.ConvexRotation == Fixed64.Zero && target.ConvexRotation == Fixed64.Zero)
 2193875                && !bounds.Intersects(target.Bounds)) continue;
 76            // Equal extrusions allow a planar proof to cover their entire
 77            // height. Different slabs retain their real step/side boundaries.
 945978            if (lowerHeight.HasValue)
 79            {
 889880                if (source.MixedBounds3D.Max.Y <= target.MixedBounds3D.Min.Y
 889881                    || source.MixedBounds3D.Min.Y >= target.MixedBounds3D.Max.Y) continue;
 870882                Fixed64 delta = target.MixedSlabCenterY - source.MixedSlabCenterY;
 870883                if (delta + target.MixedHalfThickness <= lowerHeight.Value
 952184                    || delta - target.MixedHalfThickness >= upperHeight!.Value) continue;
 85            }
 56186            else if (mixed && (source.MixedSlabCenterY != target.MixedSlabCenterY
 56187                || source.MixedHalfThickness != target.MixedHalfThickness)) continue;
 756888            ReadOnlySpan<Vector2d> vertices = Offsets(target, box);
 756889            if (!mixed)
 90            {
 639891                if (WideConvex2dRelations.TryGetEdgeCoverage(source.Center, source.ConvexRotation, edge, inward,
 639892                    target.Center, target.ConvexRotation, vertices, out RationalSegmentInterval interval, out int sides)
 637893                    Include(member, interval, sides);
 637894                continue;
 95            }
 96            // Mixed prisms use a normalized quaternion chart, whereas pure
 97            // 2D relations use scalar Sin/Cos. Reuse the actual prism frame;
 98            // a transient convex fan does not merge or round world geometry.
 117099            var face = new FixedTriangle(Embed(edge.Start), Embed(edge.End), Embed(inward));
 1170100            FixedQuaternion sourceRotation = FixedQuaternion.FromAxisAngle(Vector3d.Up, -source.ConvexRotation);
 1170101            FixedQuaternion targetRotation = FixedQuaternion.FromAxisAngle(Vector3d.Up, -target.ConvexRotation);
 6718102            for (int triangle = 1; triangle < vertices.Length - 1; triangle++)
 103                // Height bands classify actual extrusion overlap separately;
 104                // footprint incidence uses one common Y plane even for offset slabs.
 2189105                if (WideTriangleRelations.TryGetEdgeCoverage(face, new Vector3d(source.Center.X, Fixed64.Zero, source.Ce
 2189106                    new FixedTriangle(Embed(vertices[0]), Embed(vertices[triangle]), Embed(vertices[triangle + 1])),
 2189107                    new Vector3d(target.Center.X, Fixed64.Zero, target.Center.Y), targetRotation, out RationalSegmentInt
 1751108                    Include(member, interval, sides);
 109        }
 9766110        _cuts.SortInPlace();
 9766111    }
 112
 113    private static ReadOnlySpan<Vector2d> Offsets(LSCollider2D collider, Span<Vector2d> box)
 114    {
 8848115        if (collider is LSPolygonCollider2D polygon) return polygon.ScaledLocalVertices;
 88032116        for (int vertex = 0; vertex < 4; vertex++) box[vertex] = collider.GetScaledLocalVertexUnchecked(vertex);
 6288117        return box;
 118    }
 119
 10077120    private static Vector3d Embed(Vector2d point) => new(point.X, Fixed64.Zero, point.Y);
 121
 122    private void Include(int member, in RationalSegmentInterval interval, int sides)
 123    {
 16258124        var lower = Parameter.Lower(interval); var upper = Parameter.Upper(interval);
 125        // A shared endpoint does not fill either open half-neighborhood.
 13747126        if (lower.CompareTo(upper) == 0) return;
 2511127        _coverage.Add(new Coverage(member, sides, lower, upper));
 5022128        _cuts.Add(lower); _cuts.Add(upper);
 2511129    }
 130
 131    private void Classify(int sourceMember, int first, int second, Vector2d start, Vector2d end, FixedBoundArea bounds)
 132    {
 9766133        int edgeStart = _spans.Count;
 9766134        Parameter lower = _cuts[0];
 49108135        for (int cut = 1; cut < _cuts.Count; cut++)
 136        {
 14788137            Parameter upper = _cuts[cut];
 14788138            if (lower.CompareTo(upper) == 0) continue;
 10412139            SpanKind kind = ClassifyInterval(lower, upper, sourceMember, out int otherMember);
 10412140            if (_spans.Count > edgeStart)
 141            {
 646142                BoundarySpan2D previous = _spans[_spans.Count - 1];
 646143                if (previous.Kind == kind && previous.OtherMember == otherMember)
 144                {
 23145                    var merged = new RationalSegmentInterval(Parameter.Lower(previous.Interval).N,
 23146                        Parameter.Lower(previous.Interval).D, upper.N, upper.D);
 23147                    _spans[_spans.Count - 1] = new BoundarySpan2D(first, second, start, end, merged, kind, otherMember, 
 23148                    lower = upper;
 23149                    continue;
 150                }
 151            }
 10389152            var interval = new RationalSegmentInterval(lower.N, lower.D, upper.N, upper.D);
 10389153            _spans.Add(new BoundarySpan2D(first, second, start, end, interval, kind, otherMember, bounds));
 10389154            lower = upper;
 155        }
 9766156    }
 157
 158    private SpanKind ClassifyInterval(Parameter lower, Parameter upper, int sourceMember, out int otherMember)
 159    {
 41648160        _own.Clear(); _opposite.Clear(); _own.Add(sourceMember); otherMember = -1;
 27522161        foreach (Coverage coverage in _coverage.AsReadOnlySpan())
 162        {
 3349163            if (coverage.Lower.CompareTo(lower) > 0 || coverage.Upper.CompareTo(upper) < 0) continue;
 164            // A mixed convex fan contributes one member, including along
 165            // internal diagonals; duplicate triangles are not extra solids.
 2648166            if ((coverage.Sides & 1) != 0) _own.Add(coverage.Member);
 2549167            if ((coverage.Sides & 2) == 0) continue;
 5064168            _opposite.Add(coverage.Member); otherMember = coverage.Member;
 169        }
 12827170        if (_own.Count == 1 && _opposite.Count == 1) return SpanKind.Joined;
 7997171        otherMember = -1;
 7997172        return _own.Count == 1 && _opposite.Count == 0 ? SpanKind.Exposed : SpanKind.Ambiguous;
 173    }
 174
 175    private readonly struct Coverage
 176    {
 177        internal readonly int Member, Sides;
 178        internal readonly Parameter Lower, Upper;
 179        internal Coverage(int member, int sides, Parameter lower, Parameter upper)
 12555180        { Member = member; Sides = sides; Lower = lower; Upper = upper; }
 181    }
 182
 183    private readonly struct Parameter : IComparable<Parameter>
 184    {
 185        internal readonly Signed320 N, D;
 11642186        internal static Parameter Zero => new(default, Signed320.One);
 11642187        internal static Parameter One => new(Signed320.One, Signed320.One);
 107508188        private Parameter(Signed320 n, Signed320 d) { N = n; D = d; }
 8175189        internal static Parameter Lower(in RationalSegmentInterval interval) => interval.IsClipped
 8175190            ? new(interval.LowerNumerator, interval.LowerDenominator) : Zero;
 8129191        internal static Parameter Upper(in RationalSegmentInterval interval) => interval.IsClipped
 8129192            ? new(interval.UpperNumerator, interval.UpperDenominator) : One;
 46827193        public int CompareTo(Parameter other) => RationalSegmentInterval.CompareParameters(N, D, other.N, other.D);
 194    }
 195}