< Summary

Information
Class: Gravitas.CollisionHandling.MeshSurfaceBoundaryFan
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/Mesh/Surfaces/MeshSurfaceBoundaryFan.cs
Line coverage
100%
Covered lines: 89
Uncovered lines: 0
Coverable lines: 89
Total lines: 168
Line coverage: 100%
Branch coverage
100%
Covered branches: 72
Total branches: 72
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_RayCount()100%11100%
get_Rays()100%11100%
get_Owners()100%11100%
BuildEndpoint(...)100%88100%
BuildAtPoint(...)100%11100%
BuildAtAnchor(...)100%11100%
Build(...)100%3434100%
GetFan(...)100%1616100%
PointOnTriangle(...)100%22100%
SupportsTriangle(...)100%66100%
Supports(...)100%66100%
Supports(...)100%11100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/Mesh/Surfaces/MeshSurfaceBoundaryFan.cs

#LineLine coverage
 1//=======================================================================
 2// MeshSurfaceBoundaryFan.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>Collects exact incident sectors through certified positive-length surface joins.</summary>
 17internal sealed class MeshSurfaceBoundaryFan
 18{
 96619    private readonly MeshSurfaceBoundaryDomain _boundary = new();
 96620    private readonly SwiftList<(int Member, int Surface)> _owners = new();
 96621    private readonly SwiftHashSet<(int Member, int Surface)> _visited = new();
 96622    private readonly SwiftList<WideAxis3> _rays = new();
 23    private bool _trusted;
 24
 1125    internal int RayCount => _rays.Count;
 97726    internal ReadOnlySpan<WideAxis3> Rays => _rays.AsReadOnlySpan();
 120127    internal ReadOnlySpan<(int Member, int Surface)> Owners => _owners.AsReadOnlySpan();
 28    internal bool HasExposedBoundary { get; private set; }
 29
 30    internal bool BuildEndpoint(ReadOnlySpan<PhysicsMesh> members, MeshSurfaceBoundaryDomain source, int span, bool uppe
 31        ReadOnlySpan<MeshSurfaceBoundaryDomain> prepared = default)
 32    {
 12233        var edge = source.Spans[span];
 12234        Signed832 n = upper ? edge.Interval.WideUpperNumerator : edge.Interval.WideLowerNumerator;
 12235        Signed832 d = upper ? edge.Interval.WideUpperDenominator : edge.Interval.WideLowerDenominator;
 25036        if (!edge.Interval.IsClipped) { n = upper ? Signed832.ExtendValue(Signed192.Signed(1)) : default; d = Signed832.
 12237        return Build(members, source.SourceMember, source.SourceSurface,
 12238            new FixedSegment(edge.Start, edge.End), n, d, prepared);
 39    }
 40
 41    internal bool BuildAtPoint(ReadOnlySpan<PhysicsMesh> members, int sourceMember, int sourceSurface, Vector3d point,
 42        ReadOnlySpan<MeshSurfaceBoundaryDomain> prepared = default) =>
 91743        Build(members, sourceMember, sourceSurface, new FixedSegment(point, point), default, Signed832.ExtendValue(Signe
 44
 45    internal bool BuildAtAnchor(ReadOnlySpan<PhysicsMesh> members, int sourceMember, int sourceSurface,
 46        in FixedPointAnchor point, ReadOnlySpan<MeshSurfaceBoundaryDomain> prepared) =>
 4347        Build(members, sourceMember, sourceSurface, default, default, Signed832.ExtendValue(Signed192.Signed(1)),
 4348            prepared, RationalPoint3d.FromAnchor(point));
 49
 50    // The caller supplies an admitted point. Traverse only positive-length
 51    // certified joins incident to it; a point-only neighbor adds no sector.
 52    private bool Build(ReadOnlySpan<PhysicsMesh> members, int sourceMember, int sourceSurface,
 53        FixedSegment source, Signed832 n, Signed832 d, ReadOnlySpan<MeshSurfaceBoundaryDomain> prepared = default,
 54        RationalPoint3d? point = null)
 55    {
 541056        _trusted = false; HasExposedBoundary = false; _owners.FastClear(); _visited.Clear(); _rays.FastClear();
 108257        var first = (sourceMember, members[sourceMember].GetManifoldSurfaceOwner(sourceSurface));
 216458        _owners.Add(first); _visited.Add(first);
 108259        PhysicsMesh original = members[sourceMember];
 108260        Span<WideAxis3> fan = stackalloc WideAxis3[4];
 594661        for (int index = 0; index < _owners.Count; index++)
 62        {
 382263            var key = _owners[index]; PhysicsMesh mesh = members[key.Member];
 191164            MeshSurfaceBoundaryDomain boundary = _boundary;
 205665            if (prepared.IsEmpty) boundary.Build(members, key.Member, key.Surface);
 66            else
 67            {
 176668                MeshSurfaceBoundaryDomain? found = null;
 696369                foreach (var candidate in prepared)
 611870                    if (candidate.SourceMember == key.Member && candidate.SourceSurface == key.Surface) { found = candid
 177671                if (found == null) { HasExposedBoundary = true; continue; }
 176172                boundary = found;
 73            }
 2236674            foreach (var edge in boundary.Spans)
 75            {
 928676                int location = point.HasValue ? WideTriangleRelations.LocatePointOnFrameEdge(point.Value,
 928677                    new FixedSegment(edge.Start, edge.End), mesh.GeometryFrame, edge.Interval)
 928678                    : WideTriangleRelations.LocateEdgePoint(source, original.GeometryFrame, n, d,
 928679                        new FixedSegment(edge.Start, edge.End), mesh.GeometryFrame, edge.Interval);
 928680                if (location < 0) continue;
 353381                if (edge.Kind == SpanKind.Ambiguous) { _rays.FastClear(); return false; }
 524482                if (edge.Kind == SpanKind.Exposed) HasExposedBoundary = true;
 347983                var neighbor = (edge.OtherMember, edge.OtherSurface);
 430884                if (edge.Kind == SpanKind.Joined && _visited.Add(neighbor)) _owners.Add(neighbor);
 85            }
 188886            int count = GetFan(mesh, key.Surface, source, original, n, d, fan, point,
 188887                key.Member == sourceMember && key.Surface == first.Item2 ? sourceSurface : key.Surface);
 189288            if (count == 0) { _rays.FastClear(); return false; }
 89            // Each positive affine denominator is irrelevant to a ray's halfspace sign.
 1262490            for (int ray = 0; ray < count; ray++)
 442691                _rays.Add(mesh.GeometryFrame.GetWorldDirectionNumerators(fan[ray]));
 92        }
 106293        _trusted = true;
 106294        return true;
 95    }
 96
 97    private static int GetFan(PhysicsMesh mesh, int owner, FixedSegment source, PhysicsMesh original,
 98        Signed832 n, Signed832 d, Span<WideAxis3> fan, RationalPoint3d? point, int admittedTriangle)
 99    {
 1888100        ReadOnlySpan<int> edges = mesh.GetCanonicalSurfaceBoundaryVertexPairs(owner);
 1888101        ReadOnlySpan<Vector3d> vertices = mesh.GeometryVertices;
 9842102        for (int edge = 0; edge < edges.Length; edge += 2)
 103        {
 9654104            int first = edges[edge], second = edges[edge + 1];
 4827105            int location = point.HasValue ? WideTriangleRelations.LocatePointOnFrameEdge(point.Value,
 4827106                new FixedSegment(vertices[first], vertices[second]), mesh.GeometryFrame)
 4827107                : WideTriangleRelations.LocateEdgePoint(source, original.GeometryFrame, n, d,
 4827108                    new FixedSegment(vertices[first], vertices[second]), mesh.GeometryFrame);
 4827109            if (location < 0) continue;
 2802110            if (location == 2) (first, second) = (second, first);
 1794111            return MeshSurfaceBoundaryTopology.GetIncidentFan(mesh, owner, first, second, location == 1, fan);
 112        }
 94113        if (point.HasValue)
 114        {
 115            // An authored diagonal inside a certified coplanar owner is filled
 116            // surface, not a rim. Final anchor rounding can put the point on
 117            // either incident triangle; both still require exact finite proof.
 8118            bool admitted = PointOnTriangle(mesh, admittedTriangle, point.Value);
 119            // Prepared coplanar neighbors share this committed manifold owner.
 32120            foreach (int neighbor in mesh.GetCoplanarTriangleNeighbors(admittedTriangle))
 8121                if (!admitted)
 5122                    admitted = PointOnTriangle(mesh, neighbor, point.Value);
 10123            if (!admitted) return 0;
 124        }
 92125        mesh.GetGeometryTriangleVertices(owner, out Vector3d a, out Vector3d b, out Vector3d c);
 184126        fan[0] = MeshSurfaceBoundaryTopology.Ray(a, b); fan[1] = -fan[0];
 184127        fan[2] = MeshSurfaceBoundaryTopology.Ray(a, c); fan[3] = -fan[2];
 92128        return 4;
 129    }
 130
 131    private static bool PointOnTriangle(PhysicsMesh mesh, int triangle, in RationalPoint3d point)
 132    {
 183133        mesh.GetGeometryTriangleVertices(triangle, out var a, out var b, out var c);
 183134        FixedTriangle face = new(a, b, c);
 183135        var frame = mesh.GeometryFrame;
 183136        WideDirection3d normal = WideTriangleRelations.GetScaledTriangleLocalNormal(face, frame).Transform(frame.Geometr
 183137        return WideDirection3d.Dot(normal, WideTriangleRelations.GetScaledPointDifference(point,
 183138            frame.GetPoint(a), frame.RotationDenominator)).IsZero && WideTriangleRelations.ContainsProjection(face, fram
 139    }
 140
 141    internal static bool SupportsTriangle(PhysicsMesh mesh, int triangle, in RationalPoint3d point,
 142        in WideDirection3d direction)
 143    {
 144        // A rounded closest witness can land on a seam without remaining the
 145        // actual closest point. Finite incidence and the triangle normal cone
 146        // certify that the supplied point-to-core direction still owns it.
 171147        if (!PointOnTriangle(mesh, triangle, point)) return false;
 169148        mesh.GetGeometryTriangleVertices(triangle, out var a, out var b, out var c);
 169149        Span<Vector3d> vertices = stackalloc Vector3d[3] { a, b, c };
 1344150        foreach (Vector3d vertex in vertices)
 505151            if (WideDirection3d.Dot(direction, WideTriangleRelations.GetScaledPointDifference(
 505152                mesh.GeometryFrame.GetPoint(vertex), point,
 509153                WideArithmetic.TruncateSigned320By64(point.Denominator))).Sign > 0) return false;
 165154        return true;
 155    }
 156    /// <summary>Tests an exact world direction against every incident inward ray.</summary>
 157    internal bool Supports(in WideDirection3d direction)
 158    {
 73159        if (!_trusted) return false;
 671160        foreach (WideAxis3 ray in _rays.AsReadOnlySpan())
 338161            if (WideDirection3d.Dot(direction, ray).Sign > 0) return false;
 20162        return true;
 163    }
 164
 40165    internal bool Supports(Vector3d direction) => Supports(new WideDirection3d(
 40166        Signed320.ExtendValue(Signed192.Raw(direction.X)), Signed320.ExtendValue(Signed192.Raw(direction.Y)),
 40167        Signed320.ExtendValue(Signed192.Raw(direction.Z))));
 168}

Methods/Properties

.ctor()
get_RayCount()
get_Rays()
get_Owners()
BuildEndpoint(System.ReadOnlySpan`1<Gravitas.Colliders.PhysicsMesh>,Gravitas.CollisionHandling.MeshSurfaceBoundaryDomain,System.Int32,System.Boolean,System.ReadOnlySpan`1<Gravitas.CollisionHandling.MeshSurfaceBoundaryDomain>)
BuildAtPoint(System.ReadOnlySpan`1<Gravitas.Colliders.PhysicsMesh>,System.Int32,System.Int32,FixedMathSharp.Vector3d,System.ReadOnlySpan`1<Gravitas.CollisionHandling.MeshSurfaceBoundaryDomain>)
BuildAtAnchor(System.ReadOnlySpan`1<Gravitas.Colliders.PhysicsMesh>,System.Int32,System.Int32,FixedMathSharp.Geometry.FixedPointAnchor&,System.ReadOnlySpan`1<Gravitas.CollisionHandling.MeshSurfaceBoundaryDomain>)
Build(System.ReadOnlySpan`1<Gravitas.Colliders.PhysicsMesh>,System.Int32,System.Int32,FixedMathSharp.Geometry.FixedSegment,FixedMathSharp.Signed832,FixedMathSharp.Signed832,System.ReadOnlySpan`1<Gravitas.CollisionHandling.MeshSurfaceBoundaryDomain>,System.Nullable`1<FixedMathSharp.Geometry.RationalPoint3d>)
GetFan(Gravitas.Colliders.PhysicsMesh,System.Int32,FixedMathSharp.Geometry.FixedSegment,Gravitas.Colliders.PhysicsMesh,FixedMathSharp.Signed832,FixedMathSharp.Signed832,System.Span`1<FixedMathSharp.Geometry.WideAxis3>,System.Nullable`1<FixedMathSharp.Geometry.RationalPoint3d>,System.Int32)
PointOnTriangle(Gravitas.Colliders.PhysicsMesh,System.Int32,FixedMathSharp.Geometry.RationalPoint3d&)
SupportsTriangle(Gravitas.Colliders.PhysicsMesh,System.Int32,FixedMathSharp.Geometry.RationalPoint3d&,FixedMathSharp.Geometry.WideDirection3d&)
Supports(FixedMathSharp.Geometry.WideDirection3d&)
Supports(FixedMathSharp.Vector3d)