< Summary

Information
Class: Gravitas.CollisionHandling.MeshSurfaceConnectivity
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/Mesh/Surfaces/MeshSurfaceConnectivity.cs
Line coverage
100%
Covered lines: 164
Uncovered lines: 0
Coverable lines: 164
Total lines: 376
Line coverage: 100%
Branch coverage
100%
Covered branches: 104
Total branches: 104
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_RegionCount()100%11100%
get_TriangleIndices()100%11100%
IsCompleteSingleRegion(...)100%88100%
Build(...)100%11100%
BuildCapsule(...)100%11100%
BuildCapsule(...)100%11100%
BuildSlab(...)100%11100%
BuildSlab(...)100%11100%
Build(...)100%11100%
Build(...)100%11100%
BuildGraph(...)100%1212100%
OrderRegions(...)100%66100%
BuildSlabSupport(...)100%11100%
BuildHullSupport(...)100%11100%
BuildSupport(...)100%1010100%
GetRegionOrdinal(...)100%22100%
JoinAdmittedFeatures(...)100%3636100%
FindBoundaryMinima(...)100%22100%
KeepBoundaryPoint(...)100%1212100%
CompareRegions(...)100%22100%
Minimum(...)100%11100%
Find(...)100%44100%
Union(...)100%22100%
.ctor(...)100%11100%
ContainsPoint(...)100%11100%
IntersectsSegment(...)100%11100%
FindEdgeRegion(...)100%11100%
.ctor(...)100%11100%
ContainsPoint(...)100%11100%
IntersectsSegment(...)100%22100%
FindEdgeRegion(...)100%11100%
.ctor(...)100%11100%
ContainsPoint(...)100%11100%
IntersectsSegment(...)100%11100%
TryGetFirstSegmentPoint(...)100%11100%
.ctor(...)100%11100%
ContainsPoint(...)100%11100%
IntersectsSegment(...)100%11100%
TryGetFirstSegmentPoint(...)100%11100%
.ctor(...)100%11100%
ContainsPoint(...)100%22100%
IntersectsSegment(...)100%22100%
TryGetFirstSegmentPoint(...)100%22100%

File(s)

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

#LineLine coverage
 1//=======================================================================
 2// MeshSurfaceConnectivity.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 System.Collections.Generic;
 10using FixedMathSharp;
 11using FixedMathSharp.Geometry;
 12using Gravitas.Colliders;
 13using SwiftCollections;
 14
 15namespace Gravitas.CollisionHandling;
 16
 17/// <summary>Retains exact admitted connectivity for one prepared mesh surface.</summary>
 18internal sealed class MeshSurfaceConnectivity
 19{
 2157220    private readonly SwiftDictionary<int, int> _nodeByTriangle = new();
 2157221    private readonly SwiftList<int> _triangles = new();
 2157222    private readonly SwiftList<int> _parents = new();
 2157223    private readonly SwiftList<int> _regionByRoot = new();
 2157224    private readonly SwiftList<int> _roots = new();
 2157225    private readonly SwiftHashSet<int> _visitedVertices = new();
 26    private readonly IComparer<int> _regionComparer;
 2157227    private ulong[] _minimumValues = Array.Empty<ulong>();
 2157228    private int[] _minimumSigns = Array.Empty<int>();
 2157229    private bool[] _hasMinimum = Array.Empty<bool>();
 2157230    private int[] _boundaryRanks = Array.Empty<int>();
 31    private bool _ordersSupport;
 32
 13760033    internal int RegionCount => _roots.Count;
 34
 11146235    internal ReadOnlySpan<int> TriangleIndices => _triangles.AsReadOnlySpan();
 36
 37    internal bool IsCompleteSingleRegion(PhysicsMesh mesh)
 38    {
 577039        if (RegionCount != 1) return false;
 40        // Prepared connected owners record every shared-edge neighbor. A
 41        // nonempty admitted subset closed under them contains the whole owner.
 2483742        foreach (int triangle in TriangleIndices)
 4026743            foreach (int neighbor in mesh.GetCoplanarTriangleNeighbors(triangle))
 1875044                if (GetRegionOrdinal(neighbor) != 0) return false;
 48945        return true;
 46    }
 47
 4314448    internal MeshSurfaceConnectivity() => _regionComparer = Comparer<int>.Create(CompareRegions);
 49
 50    internal void Build(PhysicsMesh mesh, int surfaceTriangle, Vector3d coneCenter,
 51        FixedQuaternion coneRotation, Fixed64 height, Fixed64 radius, ReadOnlySpan<int> admittedTriangles)
 52    {
 51853        mesh.GetGeometryTriangleVertices(surfaceTriangle, out Vector3d a, out Vector3d b, out Vector3d c);
 51854        var frame = new ConePlaneRayFrame(new FixedTriangle(a, b, c), mesh.GeometryFrame,
 51855            coneCenter, coneRotation, height, radius);
 51856        Build(mesh, surfaceTriangle, frame, admittedTriangles);
 51857    }
 58
 59    internal void BuildCapsule(PhysicsMesh mesh, int surfaceTriangle, Vector3d capsuleCenter,
 60        FixedQuaternion capsuleRotation, Fixed64 coreLength, Fixed64 radius, ReadOnlySpan<int> admittedTriangles)
 61    {
 16162        var frame = new CapsuleFiniteSectionFrame(mesh.GeometryFrame, capsuleCenter, capsuleRotation, coreLength, radius
 16163        Build(mesh, surfaceTriangle, new CapsuleSection(frame), admittedTriangles);
 16164    }
 65
 66    internal void BuildCapsule(PhysicsMesh mesh, int surfaceTriangle, in CapsuleFiniteSectionFrame frame,
 2605967        ReadOnlySpan<int> admittedTriangles) => Build(mesh, surfaceTriangle, new CapsuleSection(frame), admittedTriangle
 68
 69    internal void BuildSlab(PhysicsMesh mesh, int surfaceTriangle, in FiniteSlabSectionFrame frame,
 70        LSCollider2D? embedded, ReadOnlySpan<int> admittedTriangles) =>
 249271        Build(mesh, surfaceTriangle, new SlabSection(frame, embedded), admittedTriangles);
 72
 73    internal void BuildSlab(PhysicsMesh mesh, int surfaceTriangle, in FiniteSlabSectionFrame frame,
 74        ReadOnlyMemory<Vector2d> offsets, ReadOnlySpan<int> admittedTriangles) =>
 1897775        Build(mesh, surfaceTriangle, new SlabSection(frame, null, offsets), admittedTriangles);
 76
 77    internal void Build(PhysicsMesh mesh, int surfaceTriangle, in ConePlaneRayFrame frame, ReadOnlySpan<int> admittedTri
 1241078        Build(mesh, surfaceTriangle, new ConeSection(frame), admittedTriangles);
 79
 80    /// <remarks>
 81    /// The input contains every exactly admitted triangle, without duplicates.
 82    /// Only the seed's prepared surface owner is consumed. Preparation alone
 83    /// never establishes connectivity: every join needs finite shape admission.
 84    /// </remarks>
 85    private void Build<TSection>(PhysicsMesh mesh, int surfaceTriangle, in TSection section, ReadOnlySpan<int> admittedT
 86        where TSection : struct, ISection
 87    {
 6009988        BuildGraph(mesh, surfaceTriangle, section, admittedTriangles);
 6009989        _ordersSupport = false;
 6009990        OrderRegions(mesh, surfaceTriangle, section);
 6009991    }
 92
 93    private void BuildGraph<TSection>(PhysicsMesh mesh, int surfaceTriangle, in TSection section, ReadOnlySpan<int> admi
 94        where TSection : struct, IAdmission
 95    {
 18050196        _nodeByTriangle.Clear(); _triangles.FastClear(); _parents.FastClear();
 12033497        _regionByRoot.FastClear(); _roots.FastClear();
 6016798        _visitedVertices.Clear();
 6576699        if (admittedTriangles.IsEmpty) return;
 54568100        int owner = mesh.GetManifoldSurfaceOwner(surfaceTriangle);
 54568101        _nodeByTriangle.EnsureCapacity(admittedTriangles.Length);
 54568102        _triangles.EnsureCapacity(admittedTriangles.Length);
 54568103        _parents.EnsureCapacity(admittedTriangles.Length);
 54568104        _regionByRoot.EnsureCapacity(admittedTriangles.Length);
 54568105        _roots.EnsureCapacity(admittedTriangles.Length);
 54568106        _visitedVertices.EnsureCapacity(admittedTriangles.Length * 3);
 281482107        foreach (int triangle in admittedTriangles)
 108        {
 86173109            if (mesh.GetManifoldSurfaceOwner(triangle) != owner) continue;
 86167110            int node = _triangles.Count;
 172334111            _nodeByTriangle.Add(triangle, node); _triangles.Add(triangle);
 172334112            _parents.Add(node); _regionByRoot.Add(-1);
 113        }
 54570114        if (_triangles.Count == 0) return;
 54566115        JoinAdmittedFeatures(mesh, section);
 281466116        for (int node = 0; node < _triangles.Count; node++)
 117        {
 86167118            int root = Find(node);
 86167119            if (_regionByRoot[root] < 0)
 120            {
 55945121                _regionByRoot[root] = _roots.Count;
 55945122                _roots.Add(root);
 123            }
 124        }
 54566125    }
 126
 127    private void OrderRegions<TSection>(PhysicsMesh mesh, int surfaceTriangle, in TSection section)
 128        where TSection : struct, ISection
 129    {
 130        // If a connected section misses the true domain boundary it is the
 131        // whole convex shape section, hence the only region. Otherwise exact
 132        // minima on exposed segments order regions independently of authored
 133        // diagonals, discovery order and collinear perimeter subdivision.
 60099134        if (_roots.Count > 1)
 135        {
 136            // One region always has ordinal zero. Its exact boundary extrema
 137            // cannot affect ordering, so neither retain nor evaluate them.
 466138            if (_minimumValues.Length < _roots.Count * FiniteSectionPoint.StorageWords)
 139            {
 61140                Array.Resize(ref _minimumValues, _roots.Count * FiniteSectionPoint.StorageWords);
 61141                Array.Resize(ref _minimumSigns, _roots.Count * FiniteSectionPoint.SignCount);
 61142                Array.Resize(ref _hasMinimum, _roots.Count);
 143            }
 466144            Array.Clear(_hasMinimum, 0, _roots.Count);
 466145            FindBoundaryMinima(mesh, surfaceTriangle, section);
 146#if DEBUG
 147            for (int region = 0; region < _roots.Count; region++)
 148                System.Diagnostics.Debug.Assert(_hasMinimum[region]);
 149#endif
 466150            _roots.SortInPlace(_regionComparer);
 151        }
 231892152        for (int region = 0; region < _roots.Count; region++)
 55847153            _regionByRoot[_roots[region]] = region;
 60099154    }
 155
 156    internal void BuildSlabSupport(PhysicsMesh mesh, int surfaceTriangle, MeshSlabFaceRegions faces,
 157        LSCollider2D? embedded, ReadOnlySpan<int> admittedTriangles) =>
 55158        BuildSupport(mesh, surfaceTriangle, new SlabSupport(faces, embedded), admittedTriangles);
 159
 160    internal void BuildHullSupport(PhysicsMesh mesh, int surfaceTriangle, MeshHullSurfaceContacts faces,
 161        ReadOnlySpan<int> admittedTriangles) =>
 13162        BuildSupport(mesh, surfaceTriangle, new HullSupport(faces), admittedTriangles);
 163
 164    private void BuildSupport<TSupport>(PhysicsMesh mesh, int surfaceTriangle, in TSupport support,
 165        ReadOnlySpan<int> admittedTriangles) where TSupport : struct, ISupport
 166    {
 68167        BuildGraph(mesh, surfaceTriangle, support, admittedTriangles);
 68168        _ordersSupport = true;
 68169        if (_roots.Count > 1)
 170        {
 58171            if (_boundaryRanks.Length < _parents.Count) Array.Resize(ref _boundaryRanks, _parents.Count);
 30172            Array.Fill(_boundaryRanks, int.MaxValue, 0, _parents.Count);
 30173            ReadOnlySpan<int> edges = mesh.GetCanonicalSurfaceBoundaryVertexPairs(surfaceTriangle);
 30174            int owner = mesh.GetManifoldSurfaceOwner(surfaceTriangle);
 540175            for (int edge = 0; edge < edges.Length; edge += 2)
 176            {
 240177                int region = support.FindEdgeRegion(mesh, owner, edges[edge], edges[edge + 1], this);
 356178                if (region >= 0) _boundaryRanks[_roots[region]] = Math.Min(_boundaryRanks[_roots[region]], edge / 2);
 179            }
 180            // A convex support footprint meets a straight boundary span in one
 181            // interval: distinct connected regions have distinct boundary ranks.
 182#if DEBUG
 183            foreach (int root in _roots.AsReadOnlySpan()) System.Diagnostics.Debug.Assert(_boundaryRanks[root] != int.Ma
 184#endif
 30185            _roots.SortInPlace(_regionComparer);
 186        }
 430187        for (int region = 0; region < _roots.Count; region++) _regionByRoot[_roots[region]] = region;
 68188    }
 189
 142084190    internal int GetRegionOrdinal(int triangleIndex) => _nodeByTriangle.TryGetValue(triangleIndex, out int node)
 142084191        ? _regionByRoot[Find(node)] : -1;
 192
 193    private void JoinAdmittedFeatures<TSection>(PhysicsMesh mesh, in TSection section) where TSection : struct, IAdmissi
 194    {
 54566195        int components = _triangles.Count;
 99137196        if (components == 1) return;
 197        // Exact admitted joins are transitive. Once every node is connected,
 198        // further feature tests cannot change the single region or its ordinal.
 9995199        ReadOnlySpan<Vector3d> vertices = mesh.GeometryVertices;
 41900200        for (int node = 0; node < _triangles.Count; node++)
 201        {
 20454202            int triangle = _triangles[node];
 20454203            ReadOnlySpan<int> welded = mesh.GetWeldedTriangleVertexIndices(triangle);
 104488204            foreach (int neighbor in mesh.GetCoplanarTriangleNeighbors(triangle))
 205            {
 36002206                if (!_nodeByTriangle.TryGetValue(neighbor, out int other) || other <= node) continue;
 25298207                ReadOnlySpan<int> adjacent = mesh.GetWeldedTriangleVertexIndices(neighbor);
 50596208                int first = -1, second = -1;
 202384209                foreach (int vertex in welded)
 75894210                    if (adjacent.IndexOf(vertex) >= 0)
 211                    {
 75894212                        if (first < 0) first = vertex;
 25298213                        else second = vertex;
 214                    }
 215                System.Diagnostics.Debug.Assert(first >= 0 && second >= 0);
 25298216                if (section.IntersectsSegment(new FixedSegment(vertices[first], vertices[second]))
 33722217                    && Union(node, other) && --components == 1) return;
 218            }
 93143219            foreach (int vertex in welded)
 220            {
 221                // Each welded star is traversed once, even when an admitted
 222                // center belongs to every face of a large planar fan.
 35079223                if (!_visitedVertices.Add(vertex) || !section.ContainsPoint(vertices[vertex])) continue;
 41649224                foreach (int incident in mesh.GetWeldedVertexTriangleIndices(vertex))
 16330225                    if (_nodeByTriangle.TryGetValue(incident, out int other)
 17405226                        && Union(node, other) && --components == 1) return;
 227            }
 228        }
 496229    }
 230
 231    private void FindBoundaryMinima<TSection>(PhysicsMesh mesh, int surfaceTriangle, in TSection section) where TSection
 232    {
 466233        Span<ulong> values = stackalloc ulong[FiniteSectionPoint.StorageWords];
 466234        Span<int> signs = stackalloc int[FiniteSectionPoint.SignCount];
 466235        var point = new FiniteSectionPoint(values, signs);
 466236        ReadOnlySpan<int> pairs = mesh.GetManifoldSurfaceBoundaryVertexPairs(surfaceTriangle);
 466237        ReadOnlySpan<Vector3d> vertices = mesh.GeometryVertices;
 238        // Multiple regions require a certified patch with a true perimeter.
 239        // A declined owner contains only its single convex triangle section.
 240        System.Diagnostics.Debug.Assert(!pairs.IsEmpty);
 32042241        for (int edge = 0; edge < pairs.Length; edge += 2) KeepBoundaryPoint(mesh, pairs[edge], pairs[edge + 1], section
 466242    }
 243
 244    private void KeepBoundaryPoint<TSection>(PhysicsMesh mesh, int first, int second, in TSection section,
 245        FiniteSectionPoint point, ReadOnlySpan<Vector3d> vertices) where TSection : struct, ISection
 246    {
 15771247        if (!section.TryGetFirstSegmentPoint(new FixedSegment(vertices[first], vertices[second]), point)) return;
 24621248        foreach (int triangle in mesh.GetWeldedVertexTriangleIndices(first))
 249        {
 9826250            if (!_nodeByTriangle.TryGetValue(triangle, out int node)
 9826251                || mesh.GetWeldedTriangleVertexIndices(triangle).IndexOf(second) < 0) continue;
 4969252            int region = _regionByRoot[Find(node)];
 4969253            FiniteSectionPoint minimum = Minimum(region);
 4969254            if (!_hasMinimum[region] || FiniteSectionPoint.CompareLexicographic(point, minimum) < 0)
 255            {
 3798256                point.CopyTo(minimum); _hasMinimum[region] = true;
 257            }
 1899258            break; // A trusted exposed edge has one owner on this surface.
 259        }
 3070260    }
 261
 2118262    private int CompareRegions(int first, int second) => _ordersSupport ? _boundaryRanks[first].CompareTo(_boundaryRanks
 2118263        : FiniteSectionPoint.CompareLexicographic(Minimum(_regionByRoot[first]), Minimum(_regionByRoot[second]));
 264
 9145265    private FiniteSectionPoint Minimum(int region) => new(_minimumValues.AsSpan(region * FiniteSectionPoint.StorageWords
 9145266        _minimumSigns.AsSpan(region * FiniteSectionPoint.SignCount, FiniteSectionPoint.SignCount));
 267
 268    private int Find(int node)
 269    {
 310006270        int root = node;
 507918271        while (_parents[root] != root) root = _parents[root];
 408962272        while (_parents[node] != node)
 273        {
 296868274            int next = _parents[node]; _parents[node] = root; node = next;
 275        }
 310006276        return root;
 277    }
 278
 279    private bool Union(int first, int second)
 280    {
 82358281        first = Find(first); second = Find(second);
 52136282        if (first == second) return false;
 30222283        _parents[Math.Max(first, second)] = Math.Min(first, second);
 30222284        return true;
 285    }
 286
 287    // Constrained value-type calls share the graph without delegates, boxing,
 288    // or storing both shape frames in every operation.
 289    private interface IAdmission
 290    {
 291        bool ContainsPoint(Vector3d point);
 292        bool IntersectsSegment(FixedSegment segment);
 293    }
 294
 295    private interface ISection : IAdmission
 296    {
 297        bool TryGetFirstSegmentPoint(FixedSegment segment, FiniteSectionPoint point);
 298    }
 299
 300    private interface ISupport : IAdmission
 301    {
 302        int FindEdgeRegion(PhysicsMesh mesh, int owner, int first, int second, MeshSurfaceConnectivity connectivity);
 303    }
 304
 305    private readonly struct HullSupport : ISupport
 306    {
 307        private readonly MeshHullSurfaceContacts faces;
 13308        internal HullSupport(MeshHullSurfaceContacts faces) => this.faces = faces;
 64309        public bool ContainsPoint(Vector3d point) => IntersectsSegment(new FixedSegment(point, point));
 89310        public bool IntersectsSegment(FixedSegment segment) => faces.IntersectsSupport(segment);
 311        public int FindEdgeRegion(PhysicsMesh mesh, int owner, int first, int second, MeshSurfaceConnectivity connectivi
 48312            MeshSurfaceBoundaryTopology.FindSupportEdgeRegion(mesh, owner, first, second, connectivity, faces);
 313    }
 314
 315    private readonly struct SlabSupport : ISupport
 316    {
 317        private readonly MeshSlabFaceRegions faces;
 318        private readonly LSCollider2D? embedded;
 319        internal SlabSupport(MeshSlabFaceRegions faces, LSCollider2D? embedded)
 165320        { this.faces = faces; this.embedded = embedded; }
 201321        public bool ContainsPoint(Vector3d point) => IntersectsSegment(new FixedSegment(point, point));
 322        public bool IntersectsSegment(FixedSegment segment)
 323        {
 261324            Span<Vector2d> box = stackalloc Vector2d[4];
 261325            return faces.IntersectsSupport(segment, faces.PrismOffsets.IsEmpty
 261326                ? CollisionDetectionMixed.GetConvexPrismOffsets(embedded, box) : faces.PrismOffsets.Span);
 327        }
 328        public int FindEdgeRegion(PhysicsMesh mesh, int owner, int first, int second, MeshSurfaceConnectivity connectivi
 192329            MeshSurfaceBoundaryTopology.FindSupportEdgeRegion(mesh, owner, first, second, connectivity, faces, embedded)
 330    }
 331
 332    private readonly struct ConeSection : ISection
 333    {
 334        private readonly ConePlaneRayFrame frame;
 12410335        internal ConeSection(ConePlaneRayFrame frame) => this.frame = frame;
 11144336        public bool ContainsPoint(Vector3d point) => frame.ContainsPoint(point);
 12023337        public bool IntersectsSegment(FixedSegment segment) => frame.IntersectsSegment(segment);
 338        public bool TryGetFirstSegmentPoint(FixedSegment segment, FiniteSectionPoint point) =>
 558339            FiniteSectionPoint.TryGetFirstSegmentPoint(segment, frame.Finite, point);
 340    }
 341
 342    private readonly struct CapsuleSection : ISection
 343    {
 344        private readonly CapsuleFiniteSectionFrame frame;
 26220345        internal CapsuleSection(CapsuleFiniteSectionFrame frame) => this.frame = frame;
 10784346        public bool ContainsPoint(Vector3d point) => frame.ContainsPoint(point);
 10287347        public bool IntersectsSegment(FixedSegment segment) => frame.IntersectsSegment(segment);
 348        public bool TryGetFirstSegmentPoint(FixedSegment segment, FiniteSectionPoint point) =>
 9188349            FiniteSectionPoint.TryGetFirstSegmentPoint(segment, frame, point);
 350    }
 351
 352    private readonly struct SlabSection : ISection
 353    {
 354        private readonly FiniteSlabSectionFrame frame;
 355        private readonly LSCollider2D? embedded;
 356        private readonly ReadOnlyMemory<Vector2d> offsets;
 357        internal SlabSection(in FiniteSlabSectionFrame frame, LSCollider2D? embedded, ReadOnlyMemory<Vector2d> offsets =
 85876358        { this.frame = frame; this.embedded = embedded; this.offsets = offsets; }
 359        public bool ContainsPoint(Vector3d point)
 360        {
 1860361            Span<Vector2d> box = stackalloc Vector2d[4];
 1860362            return frame.ContainsPoint(point, offsets.IsEmpty ? CollisionDetectionMixed.GetConvexPrismOffsets(embedded, 
 363        }
 364        public bool IntersectsSegment(FixedSegment segment)
 365        {
 2903366            Span<Vector2d> box = stackalloc Vector2d[4];
 2903367            return frame.IntersectsSegment(segment, offsets.IsEmpty ? CollisionDetectionMixed.GetConvexPrismOffsets(embe
 368        }
 369        public bool TryGetFirstSegmentPoint(FixedSegment segment, FiniteSectionPoint point)
 370        {
 624371            Span<Vector2d> box = stackalloc Vector2d[4];
 624372            return FiniteSectionPoint.TryGetFirstSegmentPoint(segment, frame,
 624373                offsets.IsEmpty ? CollisionDetectionMixed.GetConvexPrismOffsets(embedded, box) : offsets.Span, point);
 374        }
 375    }
 376}

Methods/Properties

.ctor()
get_RegionCount()
get_TriangleIndices()
IsCompleteSingleRegion(Gravitas.Colliders.PhysicsMesh)
Build(Gravitas.Colliders.PhysicsMesh,System.Int32,FixedMathSharp.Vector3d,FixedMathSharp.FixedQuaternion,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,System.ReadOnlySpan`1<System.Int32>)
BuildCapsule(Gravitas.Colliders.PhysicsMesh,System.Int32,FixedMathSharp.Vector3d,FixedMathSharp.FixedQuaternion,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,System.ReadOnlySpan`1<System.Int32>)
BuildCapsule(Gravitas.Colliders.PhysicsMesh,System.Int32,FixedMathSharp.Geometry.CapsuleFiniteSectionFrame&,System.ReadOnlySpan`1<System.Int32>)
BuildSlab(Gravitas.Colliders.PhysicsMesh,System.Int32,FixedMathSharp.Geometry.FiniteSlabSectionFrame&,Gravitas.Colliders.LSCollider2D,System.ReadOnlySpan`1<System.Int32>)
BuildSlab(Gravitas.Colliders.PhysicsMesh,System.Int32,FixedMathSharp.Geometry.FiniteSlabSectionFrame&,System.ReadOnlyMemory`1<FixedMathSharp.Vector2d>,System.ReadOnlySpan`1<System.Int32>)
Build(Gravitas.Colliders.PhysicsMesh,System.Int32,FixedMathSharp.Geometry.ConePlaneRayFrame&,System.ReadOnlySpan`1<System.Int32>)
Build(Gravitas.Colliders.PhysicsMesh,System.Int32,TSection&,System.ReadOnlySpan`1<System.Int32>)
BuildGraph(Gravitas.Colliders.PhysicsMesh,System.Int32,TSection&,System.ReadOnlySpan`1<System.Int32>)
OrderRegions(Gravitas.Colliders.PhysicsMesh,System.Int32,TSection&)
BuildSlabSupport(Gravitas.Colliders.PhysicsMesh,System.Int32,Gravitas.CollisionHandling.MeshSlabFaceRegions,Gravitas.Colliders.LSCollider2D,System.ReadOnlySpan`1<System.Int32>)
BuildHullSupport(Gravitas.Colliders.PhysicsMesh,System.Int32,Gravitas.CollisionHandling.MeshHullSurfaceContacts,System.ReadOnlySpan`1<System.Int32>)
BuildSupport(Gravitas.Colliders.PhysicsMesh,System.Int32,TSupport&,System.ReadOnlySpan`1<System.Int32>)
GetRegionOrdinal(System.Int32)
JoinAdmittedFeatures(Gravitas.Colliders.PhysicsMesh,TSection&)
FindBoundaryMinima(Gravitas.Colliders.PhysicsMesh,System.Int32,TSection&)
KeepBoundaryPoint(Gravitas.Colliders.PhysicsMesh,System.Int32,System.Int32,TSection&,FixedMathSharp.Geometry.FiniteSectionPoint,System.ReadOnlySpan`1<FixedMathSharp.Vector3d>)
CompareRegions(System.Int32,System.Int32)
Minimum(System.Int32)
Find(System.Int32)
Union(System.Int32,System.Int32)
.ctor(Gravitas.CollisionHandling.MeshHullSurfaceContacts)
ContainsPoint(FixedMathSharp.Vector3d)
IntersectsSegment(FixedMathSharp.Geometry.FixedSegment)
FindEdgeRegion(Gravitas.Colliders.PhysicsMesh,System.Int32,System.Int32,System.Int32,Gravitas.CollisionHandling.MeshSurfaceConnectivity)
.ctor(Gravitas.CollisionHandling.MeshSlabFaceRegions,Gravitas.Colliders.LSCollider2D)
ContainsPoint(FixedMathSharp.Vector3d)
IntersectsSegment(FixedMathSharp.Geometry.FixedSegment)
FindEdgeRegion(Gravitas.Colliders.PhysicsMesh,System.Int32,System.Int32,System.Int32,Gravitas.CollisionHandling.MeshSurfaceConnectivity)
.ctor(FixedMathSharp.Geometry.ConePlaneRayFrame)
ContainsPoint(FixedMathSharp.Vector3d)
IntersectsSegment(FixedMathSharp.Geometry.FixedSegment)
TryGetFirstSegmentPoint(FixedMathSharp.Geometry.FixedSegment,FixedMathSharp.Geometry.FiniteSectionPoint)
.ctor(FixedMathSharp.Geometry.CapsuleFiniteSectionFrame)
ContainsPoint(FixedMathSharp.Vector3d)
IntersectsSegment(FixedMathSharp.Geometry.FixedSegment)
TryGetFirstSegmentPoint(FixedMathSharp.Geometry.FixedSegment,FixedMathSharp.Geometry.FiniteSectionPoint)
.ctor(FixedMathSharp.Geometry.FiniteSlabSectionFrame&,Gravitas.Colliders.LSCollider2D,System.ReadOnlyMemory`1<FixedMathSharp.Vector2d>)
ContainsPoint(FixedMathSharp.Vector3d)
IntersectsSegment(FixedMathSharp.Geometry.FixedSegment)
TryGetFirstSegmentPoint(FixedMathSharp.Geometry.FixedSegment,FixedMathSharp.Geometry.FiniteSectionPoint)