< Summary

Information
Class: Gravitas.CollisionHandling.MeshSurfaceBoundaryDomain
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/Mesh/Surfaces/MeshSurfaceBoundaryDomain.cs
Line coverage
100%
Covered lines: 92
Uncovered lines: 0
Coverable lines: 92
Total lines: 180
Line coverage: 100%
Branch coverage
100%
Covered branches: 60
Total branches: 60
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%
Build(...)100%22100%
RecoverCoordinate(...)100%11100%
Gather(...)100%1818100%
Classify(...)100%1212100%
ClassifyInterval(...)100%2424100%
.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/3D/Mesh/Surfaces/MeshSurfaceBoundaryDomain.cs

#LineLine coverage
 1//=======================================================================
 2// MeshSurfaceBoundaryDomain.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;
 13using SwiftCollections.Query;
 14
 15namespace Gravitas.CollisionHandling;
 16
 17/// <summary>
 18/// Classifies one surface's canonical perimeter against a bounded set of
 19/// committed members, without materializing or merging their world vertices.
 20/// This local span certificate does not establish endpoint fans or global
 21/// embedding; ambiguous coverage retains the original boundary.
 22/// </summary>
 23internal sealed partial class MeshSurfaceBoundaryDomain
 24{
 302125    private readonly SwiftList<BoundarySpan3D> _spans = new();
 302126    private readonly SwiftList<Coverage> _coverage = new();
 302127    private readonly SwiftList<Parameter> _cuts = new();
 302128    private readonly SwiftList<int> _triangles = new();
 604229    private readonly SwiftHashSet<(int Member, int Surface)> _own = new(), _opposite = new();
 30
 93495231    internal ReadOnlySpan<BoundarySpan3D> Spans => _spans.AsReadOnlySpan();
 32    internal int SourceMember { get; private set; }
 33    internal int SourceSurface { get; private set; }
 34    internal Vector3d Origin { get; private set; }
 35    internal FixedQuaternion Rotation { get; private set; }
 36
 37    /// <summary>Replaces prepared spans; member indices are caller-owned stable identities.</summary>
 38    internal void Build(ReadOnlySpan<PhysicsMesh> members, int sourceMember, int sourceTriangle)
 39    {
 156640        PhysicsMesh source = members[sourceMember];
 156641        int owner = source.GetManifoldSurfaceOwner(sourceTriangle);
 313242        SourceMember = sourceMember; SourceSurface = owner;
 313243        Origin = source.Origin; Rotation = source.Rotation;
 156644        ReadOnlySpan<int> edges = source.GetCanonicalSurfaceBoundaryVertexPairs(owner);
 156645        ReadOnlySpan<Vector3d> vertices = source.GeometryVertices;
 156646        Span<WideAxis3> fan = stackalloc WideAxis3[3];
 156647        _spans.FastClear();
 1567248        for (int edge = 0; edge < edges.Length; edge += 2)
 49        {
 1254050            int first = edges[edge], second = edges[edge + 1];
 627051            MeshSurfaceBoundaryTopology.GetIncidentFan(source, owner, first, second, true, fan);
 627052            Vector3d start = vertices[first];
 53            // The unnormalized fan ray is raw(inward) - raw(start), so this
 54            // wide sum recovers the original representable vertex exactly.
 627055            var inward = new Vector3d(RecoverCoordinate(start.X, fan[2].X),
 627056                RecoverCoordinate(start.Y, fan[2].Y), RecoverCoordinate(start.Z, fan[2].Z));
 627057            var face = new FixedTriangle(start, vertices[second], inward);
 627058            Gather(members, sourceMember, owner, face);
 627059            Classify(sourceMember, owner, first, second, face.A, face.B);
 60        }
 156661    }
 62
 63    private static Fixed64 RecoverCoordinate(Fixed64 start, Signed320 ray) =>
 1881064        Fixed64.GetSignedRawRatio(WideArithmetic.AddSigned320(Signed320.ExtendValue(Signed192.Raw(start)), ray),
 1881065            Signed192.Signed(1));
 66
 67    private void Gather(ReadOnlySpan<PhysicsMesh> members, int sourceMember, int owner, in FixedTriangle face)
 68    {
 1254069        _coverage.FastClear(); _cuts.FastClear();
 1254070        _cuts.Add(Parameter.Zero); _cuts.Add(Parameter.One);
 627071        PhysicsMesh source = members[sourceMember];
 627072        FixedBoundBox edgeBounds = new FixedSegment(face.A, face.B).Bounds;
 4683473        for (int member = 0; member < members.Length; member++)
 74        {
 1714775            PhysicsMesh target = members[member];
 76            // Use the existing local BVH, including when world endpoints cannot
 77            // be materialized. Exact coverage still decides every candidate.
 1714778            FixedBoundBox worldBounds = source.GeometryFrame.GetWorldBounds(edgeBounds.Min, edgeBounds.Max);
 1714779            target.GetTrianglesInWorldBounds(new FixedBoundVolume(worldBounds.Min, worldBounds.Max), _triangles);
 8466680            foreach (int triangle in _triangles.AsReadOnlySpan())
 81            {
 2518682                int surface = target.GetManifoldSurfaceOwner(triangle);
 2518683                if (member == sourceMember && surface == owner) continue;
 1053884                target.GetGeometryTriangleVertices(triangle, out Vector3d a, out Vector3d b, out Vector3d c);
 85                RationalSegmentInterval interval;
 86                int sides;
 1053887                if (source.GeometryFrame.IsRigid && target.GeometryFrame.IsRigid)
 88                {
 1015689                    if (!WideTriangleRelations.TryGetEdgeCoverage(face, source.Origin, source.Rotation,
 1219490                        new FixedTriangle(a, b, c), target.Origin, target.Rotation, out interval, out sides)) continue;
 91                }
 92                else
 93                {
 38294                    if (!WideTriangleRelations.TryGetEdgeCoverage(face, source.GeometryFrame,
 38295                        new FixedTriangle(a, b, c), target.GeometryFrame,
 38296                        out Signed832 lowerN, out Signed832 lowerD, out Signed832 upperN, out Signed832 upperD,
 38297                        out sides)) continue;
 28598                    interval = new RationalSegmentInterval(lowerN, lowerD, upperN, upperD);
 99                }
 16806100                var lower = Parameter.Lower(interval); var upper = Parameter.Upper(interval);
 101                // Closed point contacts do not fill an open half-neighborhood.
 8403102                if (lower.CompareTo(upper) == 0) continue;
 1998103                _coverage.Add(new Coverage(member, surface, sides, lower, upper));
 3996104                _cuts.Add(lower); _cuts.Add(upper);
 105            }
 106        }
 6270107        _cuts.SortInPlace();
 6270108    }
 109
 110    private void Classify(int sourceMember, int owner, int first, int second, Vector3d start, Vector3d end)
 111    {
 6270112        int edgeStart = _spans.Count;
 6270113        Parameter lower = _cuts[0];
 33072114        for (int cut = 1; cut < _cuts.Count; cut++)
 115        {
 10266116            Parameter upper = _cuts[cut];
 10266117            if (lower.CompareTo(upper) == 0) continue;
 6758118            SpanKind kind = ClassifyInterval(lower, upper, sourceMember, owner, out int otherMember, out int otherSurfac
 119            // Avoid artificial event endpoints at irrelevant triangle cuts.
 6758120            if (_spans.Count > edgeStart)
 121            {
 488122                BoundarySpan3D previous = _spans[_spans.Count - 1];
 488123                if (previous.Kind == kind && previous.OtherMember == otherMember && previous.OtherSurface == otherSurfac
 124                {
 148125                    var merged = new RationalSegmentInterval(Parameter.Lower(previous.Interval).N,
 148126                        Parameter.Lower(previous.Interval).D, upper.N, upper.D);
 148127                    _spans[_spans.Count - 1] = new BoundarySpan3D(first, second, start, end, merged, kind, otherMember, 
 148128                    lower = upper;
 148129                    continue;
 130                }
 131            }
 6610132            var interval = new RationalSegmentInterval(lower.N, lower.D, upper.N, upper.D);
 6610133            _spans.Add(new BoundarySpan3D(first, second, start, end, interval, kind, otherMember, otherSurface));
 6610134            lower = upper;
 135        }
 6270136    }
 137
 138    private SpanKind ClassifyInterval(Parameter lower, Parameter upper, int sourceMember, int owner,
 139        out int otherMember, out int otherSurface)
 140    {
 20274141        _own.Clear(); _opposite.Clear(); _own.Add((sourceMember, owner));
 13516142        otherMember = -1; otherSurface = -1;
 6758143        bool folded = false;
 26290144        foreach (Coverage coverage in _coverage.AsReadOnlySpan())
 145        {
 6387146            if (coverage.Lower.CompareTo(lower) > 0 || coverage.Upper.CompareTo(upper) < 0) continue;
 2015147            folded |= (coverage.Sides & 4) != 0;
 148            // Trusted patches partition their interiors. Count a patch's
 149            // filled side once even along authored internal diagonals.
 2171150            if ((coverage.Sides & 1) != 0) _own.Add((coverage.Member, coverage.Surface));
 2015151            if ((coverage.Sides & 2) == 0) continue;
 1795152            _opposite.Add((coverage.Member, coverage.Surface));
 3590153            otherMember = coverage.Member; otherSurface = coverage.Surface;
 154        }
 8481155        if (!folded && _own.Count == 1 && _opposite.Count == 1 && otherMember != sourceMember) return SpanKind.Joined;
 10070156        otherMember = -1; otherSurface = -1;
 5035157        return !folded && _own.Count == 1 && _opposite.Count == 0 ? SpanKind.Exposed : SpanKind.Ambiguous;
 158    }
 159
 160    private readonly struct Coverage
 161    {
 162        internal readonly int Member, Surface, Sides;
 163        internal readonly Parameter Lower, Upper;
 164        internal Coverage(int member, int surface, int sides, Parameter lower, Parameter upper)
 11988165        { Member = member; Surface = surface; Sides = sides; Lower = lower; Upper = upper; }
 166    }
 167
 168    private readonly struct Parameter : IComparable<Parameter>
 169    {
 170        internal readonly Signed832 N, D;
 7915171        internal static Parameter Zero => new(default, Signed832.ExtendValue(Signed192.One));
 7915172        internal static Parameter One => new(Signed832.ExtendValue(Signed192.One), Signed832.ExtendValue(Signed192.One))
 88926173        private Parameter(Signed832 n, Signed832 d) { N = n; D = d; }
 8699174        internal static Parameter Lower(in RationalSegmentInterval interval) => interval.IsClipped
 8699175            ? new(interval.WideLowerNumerator, interval.WideLowerDenominator) : Zero;
 8403176        internal static Parameter Upper(in RationalSegmentInterval interval) => interval.IsClipped
 8403177            ? new(interval.WideUpperNumerator, interval.WideUpperDenominator) : One;
 43488178        public int CompareTo(Parameter other) => WideTriangleRelations.CompareCoreParameters(N, D, other.N, other.D);
 179    }
 180}