< Summary

Information
Class: Gravitas.CollisionHandling.MeshHullSurfaceContacts
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/Mesh/MeshHullSurfaceContacts.cs
Line coverage
100%
Covered lines: 416
Uncovered lines: 0
Coverable lines: 416
Total lines: 684
Line coverage: 100%
Branch coverage
100%
Covered branches: 382
Total branches: 382
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%
.cctor()100%11100%
get_MovingPoints()100%22100%
get_MovingTriangles()100%44100%
get_MovingEdges()100%44100%
Release()100%11100%
Build(...)100%1414100%
BuildPart(...)100%2222100%
SetPatch(...)100%11100%
FillPatch(...)100%44100%
SetTriangle(...)100%22100%
FindPenetration(...)100%1414100%
AdmitAxis(...)100%11100%
AdmitScaledAxis(...)100%11100%
AdmitAxis(...)100%44100%
VisitFace(...)100%3636100%
MaySupplyFace(...)100%1212100%
CompleteFaceRegions(...)100%2828100%
IsReciprocalSpan(...)100%1010100%
RegionCount(...)100%22100%
SupportEdgeRegion(...)100%22100%
IntersectsSupport(...)100%11100%
IntersectsSupport(...)100%22100%
VisitFacePatch(...)100%22100%
Visit(...)100%22100%
BuildContacts(...)100%2424100%
FindGroup(...)100%1616100%
AddSample(...)100%22100%
Append(...)100%4848100%
FixedMathSharp.Geometry.IConvexHullContactDomain.GetEdgeIntervals(...)100%11100%
GetEdgeIntervals(...)100%11100%
GetEdgeIntervals(...)100%1010100%
MapBoundaryInterval(...)100%44100%
FixedMathSharp.Geometry.IConvexHullContactDomain.ContainsPoint(...)100%11100%
ContainsPoint(...)100%4242100%
ContainsPoint(...)100%3636100%
CompareBorrowedParameter(...)100%11100%
IsFaceNormal(...)100%11100%
SupportsJoinedFan(...)100%66100%
Supports(...)100%44100%
ComparePoints(...)100%66100%
CompareSamples(...)100%22100%
.ctor(...)100%11100%
.ctor(...)100%11100%
.ctor(...)100%11100%
.ctor(...)100%11100%
get_HasValue()100%22100%
get_Negate()100%22100%
get_Axis()100%22100%
get_Overlap()100%22100%
get_SquaredAxisLength()100%22100%
get_Denominator()100%22100%
ShouldReplace(...)100%44100%

File(s)

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

#LineLine coverage
 1//=======================================================================
 2// MeshHullSurfaceContacts.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;
 14using SwiftCollections.Query;
 15
 16namespace Gravitas.CollisionHandling;
 17
 18/// <summary>Admits native mesh supports against a declared surface's retained finite features.</summary>
 19internal sealed class MeshHullSurfaceContacts : IConvexHullContactDomain, IScaledConvexHullContactDomain
 20{
 14421    private MeshJoinedSurfaceRegions<WideDirection3d> _joined = new();
 14422    private readonly SwiftList<Vector3d> _points = new();
 43223    private readonly SwiftList<int> _vertices = new(), _triangles = new(), _edges = new();
 14424    private readonly SwiftList<Vector3d> _facePoints = new();
 28825    private readonly SwiftList<int> _faceTriangles = new(), _faceEdges = new();
 14426    private readonly SwiftList<RationalSegmentInterval> _intervals = new();
 14427    private readonly SwiftList<int> _supportCandidates = new();
 14428    private readonly SwiftList<int> _supportTriangles = new();
 14429    private readonly RationalSegmentInterval[] _supportClip = new RationalSegmentInterval[1];
 28830    private readonly SwiftList<Sample> _samples = new(), _pool = new();
 14431    private readonly SwiftList<ResponseGroup> _groups = new();
 14432    private readonly SwiftList<(int Member, int Triangle, NativePenetration Penetration)> _admitted = new();
 14433    private readonly SwiftHashSet<int> _overlappingMembers = new();
 14434    private readonly SwiftList<Vector3d> _movingPoints = new();
 28835    private readonly SwiftList<int> _movingTriangles = new(), _movingEdges = new();
 14436    private readonly SwiftHashSet<int> _movingOwners = new();
 37    private readonly PointSpanPenetrationAdmission _admit;
 38    private readonly ScaledHullPenetrationAdmission _admitScaled;
 139    private static readonly RationalSegmentInterval[] FullInterval = { default };
 240    private static readonly int[] TriangleIndices = { 0, 1, 2 }, TriangleEdges = { 0, 1, 1, 2, 2, 0 };
 141    private static readonly IComparer<Sample> PointComparer = Comparer<Sample>.Create(CompareSamples);
 42    private PhysicsMesh _movingMesh = null!;
 43    private Vector3d _movingCenter;
 44    private FixedBoundVolume _supportBounds;
 45    private NativePenetration _supportPenetration;
 46    private bool _supportQuery, _movingPatch;
 28847    private int _member, _group, _movingFeature = -1, _sampleRegion = -1;
 5151848    private ReadOnlySpan<Vector3d> MovingPoints => _movingFeature < 0 ? _movingMesh.GeometryVertices : _movingPoints.AsR
 5151849    private ReadOnlySpan<int> MovingTriangles => _movingFeature < 0 ? _movingMesh.Triangles
 5151850        : _movingPatch ? _movingTriangles.AsReadOnlySpan() : TriangleIndices;
 5151851    private ReadOnlySpan<int> MovingEdges => _movingFeature < 0 ? _movingMesh.ConvexSatEdgeVertexPairs
 5151852        : _movingPatch ? _movingEdges.AsReadOnlySpan() : TriangleEdges;
 53
 57654    internal MeshHullSurfaceContacts() { _admit = AdmitAxis; _admitScaled = AdmitScaledAxis; }
 55
 56    internal void Release()
 73057    { _joined = null!; _movingMesh = null!; _samples.FastClear(); _groups.FastClear(); }
 58
 59    internal void Build(ReadOnlySpan<(LSMeshCollider Collider, int Triangle)> sources, LSMeshCollider mover,
 60        ReadOnlySpan<PhysicsMesh> meshes, SwiftDictionary<(PhysicsMesh, int), MeshSurfaceBoundaryDomain> boundaries)
 61    {
 2331562        _movingMesh = mover.Mesh; _movingCenter = mover.Center; _samples.FastClear(); _groups.FastClear(); _overlappingM
 466363        FixedBoundBox supportBounds = FixedBoundBox.FromCenterAndScopeClippedToDomain(mover.Center,
 466364            Vector3d.One * (mover.CanonicalCenteredProxyRadius * Fixed64.Two));
 466365        _supportBounds = new(supportBounds.Min, supportBounds.Max);
 466366        _joined ??= new();
 466367        _joined.Prepare(sources, meshes, boundaries);
 2627068        for (int member = 0; member < _joined.Inputs.Count; member++)
 69        {
 1694470            var input = _joined.Members[member]; var mesh = input.Collider.Mesh;
 847271            mesh.GetGeometryTriangleVertices(input.Triangle, out Vector3d a, out Vector3d b, out Vector3d c);
 847272            input.Frame = WideTriangleRelations.GetScaledTriangleLocalNormal(new FixedTriangle(a, b, c),
 847273                mesh.GeometryFrame).Transform(mesh.GeometryFrame.GeometryBasis);
 74        }
 466375        var bounds = new FixedBoundVolume(mover.BoundsMin, mover.BoundsMax);
 466376        _movingPatch = false;
 466377        if (mover.Mode == MeshColliderMode.Convex && _movingMesh.IsClosedSurface)
 587478        { _movingFeature = -1; BuildPart(bounds); }
 79        else
 80        {
 172681            _movingOwners.Clear();
 4430682            for (int triangle = 0; triangle < _movingMesh.TriangleCount; triangle++)
 83            {
 2042784                int owner = _movingMesh.GetManifoldSurfaceOwner(triangle);
 2042785                ReadOnlySpan<int> corners = _movingMesh.GetConvexCoplanarPatchCornerVertexIndices(triangle);
 2042786                _movingPatch = !corners.IsEmpty;
 2042787                if (_movingPatch)
 88                {
 2038089                    if (!_movingOwners.Add(owner)) continue;
 1019090                    _movingFeature = owner;
 1019091                    FillPatch(_movingMesh, corners, _movingPoints, _movingTriangles, _movingEdges);
 92                }
 93                else
 94                {
 4795                    _movingFeature = triangle;
 4796                    _movingMesh.GetGeometryTriangleVertices(triangle, out var a, out var b, out var c);
 18897                    _movingPoints.FastClear(); _movingPoints.Add(a); _movingPoints.Add(b); _movingPoints.Add(c);
 98                }
 1023799                BuildPart(bounds);
 100            }
 101        }
 4663102        _joined.Commit();
 4663103    }
 104
 105    private void BuildPart(FixedBoundVolume bounds)
 106    {
 26348107        _admitted.FastClear(); _joined.PrepareResponseComponents();
 74024108        for (_member = 0; _member < _joined.Inputs.Count; _member++)
 109        {
 23838110            var member = _joined.Members[_member];
 23838111            member.Admitted.FastClear();
 23838112            ReadOnlySpan<int> corners = _movingFeature < 0 || _movingPatch
 23838113                ? member.Collider.Mesh.GetConvexCoplanarPatchCornerVertexIndices(member.Triangle) : default;
 23838114            if (!corners.IsEmpty)
 115            {
 23743116                SetPatch(corners);
 23743117                if (FindPenetration(out var penetration, filtered: false))
 22756118                { member.Admitted.Add(member.Triangle); _admitted.Add((_member, -1, penetration)); }
 119            }
 120            else
 121            {
 95122                member.Collider.GetTrianglesInBounds(bounds, _joined.Candidates);
 620123                foreach (int triangle in _joined.Candidates.AsReadOnlySpan())
 124                {
 215125                    if (member.Collider.Mesh.GetManifoldSurfaceOwner(triangle) != member.Owner) continue;
 213126                    SetTriangle(triangle);
 213127                    if (FindPenetration(out var penetration, filtered: false))
 162128                    { member.Admitted.Add(triangle); _admitted.Add((_member, triangle, penetration)); }
 129                }
 130            }
 23838131            if (member.Admitted.Count > 0)
 22832132            { _joined.AddAdmittedMember(_member); _overlappingMembers.Add(member.Collider.Id); }
 133        }
 49266134        foreach (var admitted in _admitted.AsReadOnlySpan())
 135        {
 11459136            _member = admitted.Member;
 22918137            var member = _joined.Members[_member]; PhysicsMesh mesh = member.Collider.Mesh;
 22837138            if (admitted.Triangle < 0) SetPatch(mesh.GetConvexCoplanarPatchCornerVertexIndices(member.Triangle));
 81139            else SetTriangle(admitted.Triangle);
 11459140            BuildContacts(admitted.Penetration);
 141        }
 13174142    }
 143
 144    private void SetPatch(ReadOnlySpan<int> corners)
 145    {
 70242146        _vertices.FastClear(); _vertices.AddRange(corners);
 35121147        FillPatch(_joined.Members[_member].Collider.Mesh, corners, _points, _triangles, _edges);
 35121148    }
 149
 150    internal static void FillPatch(PhysicsMesh mesh, ReadOnlySpan<int> corners, SwiftList<Vector3d> points,
 151        SwiftList<int> triangles, SwiftList<int> edges)
 152    {
 207027153        points.FastClear(); triangles.FastClear(); edges.FastClear();
 690090154        for (int index = 0; index < corners.Length; index++)
 155        {
 276036156            points.Add(mesh.GeometryVertices[corners[index]]);
 552072157            edges.Add(index); edges.Add((index + 1) % corners.Length);
 276036158            if (index < 2) continue;
 414054159            triangles.Add(0); triangles.Add(index - 1); triangles.Add(index);
 160        }
 69009161    }
 162
 163    private void SetTriangle(int triangle)
 164    {
 294165        PhysicsMesh mesh = _joined.Members[_member].Collider.Mesh;
 1176166        _vertices.FastClear(); _points.FastClear(); _triangles.FastClear(); _edges.FastClear();
 2352167        foreach (int vertex in mesh.GetWeldedTriangleVertexIndices(triangle))
 1764168        { _vertices.Add(vertex); _points.Add(mesh.GeometryVertices[vertex]); }
 588169        _triangles.AddRange(TriangleIndices); _edges.AddRange(TriangleEdges);
 294170    }
 171
 172    private bool FindPenetration(out NativePenetration best, bool filtered)
 173    {
 24385174        PhysicsMesh target = _joined.Members[_member].Collider.Mesh;
 24385175        if (!_movingMesh.GeometryFrame.IsRigid || !target.GeometryFrame.IsRigid)
 176        {
 88177            bool overlaps = WideOrientedBox.TryGetConvexHullPenetration(_movingMesh.GeometryFrame,
 88178                MovingPoints, MovingTriangles, MovingEdges, target.GeometryFrame,
 88179                _points.AsReadOnlySpan(), _triangles.AsReadOnlySpan(), _edges.AsReadOnlySpan(),
 88180                out WideScaledHullPenetration scaled, skipParallelDirections: true,
 88181                admission: filtered ? _admitScaled : null, planarPair: _movingFeature >= 0);
 88182            best = new NativePenetration(scaled);
 88183            return overlaps;
 184        }
 24297185        bool rigidOverlap = _movingFeature >= 0 && !_movingPatch
 24297186        ? WideTriangleRelations.TryGetPenetration(new(_movingPoints[0], _movingPoints[1], _movingPoints[2]),
 24297187            _movingMesh.Origin, _movingMesh.Rotation, new(_points[0], _points[1], _points[2]),
 24297188            target.Origin, target.Rotation,
 24297189            out var rigid, filtered ? _admit : null)
 24297190        : WideOrientedBox.TryGetConvexHullPenetration(_movingMesh.Origin, _movingMesh.Rotation,
 24297191            MovingPoints, MovingTriangles, MovingEdges,
 24297192            target.Origin, target.Rotation,
 24297193            _points.AsReadOnlySpan(), _triangles.AsReadOnlySpan(), _edges.AsReadOnlySpan(),
 24297194            out rigid, skipParallelDirections: true, admission: filtered ? _admit : null, planarPair: _movingPatch);
 24297195        best = new NativePenetration(rigid);
 24297196        return rigidOverlap;
 197    }
 198
 2123199    private bool AdmitAxis(in WidePointSpanPenetration candidate) => AdmitAxis(new NativePenetration(candidate));
 206200    private bool AdmitScaledAxis(in WideScaledHullPenetration candidate) => AdmitAxis(new NativePenetration(candidate));
 12329201    private bool AdmitAxis(in NativePenetration candidate) => IsFaceNormal(candidate.Axis)
 12329202        ? FindGroup(candidate) < _groups.Count || VisitFace(candidate, admissionOnly: true) > 0
 12329203        : Visit(candidate, admissionOnly: true) > 0;
 204
 205    private int VisitFace(in NativePenetration penetration, bool admissionOnly)
 206    {
 58257207        int source = _member, component = _joined.FindResponseComponent(source), count = 0;
 19419208        int firstSample = _samples.Count;
 19419209        if (!admissionOnly)
 210        {
 9698211            _supportPenetration = penetration;
 38792212            _joined.Parents.FastClear(); _joined.Roots.FastClear(); _joined.RegionByRoot.FastClear(); _joined.NodeMember
 213        }
 19419214        Span<Vector3d> points = stackalloc Vector3d[3];
 215        // A plane's support may project onto a member with no initial overlap.
 216        // Its genuine overlap carrier owns response; finite suppliers own anchors.
 80508217        for (int member = 0; member < _joined.Inputs.Count; member++)
 218        {
 30544219            if (_joined.FindResponseComponent(member) != component
 30544220                || !MaySupplyFace(_joined.Members[member].Collider, penetration.Axis))
 18794221            { if (!admissionOnly) _joined.AddRegions(member, 0); continue; }
 22414222            _member = member;
 44828223            var supplier = _joined.Members[member]; var mesh = supplier.Collider.Mesh;
 22414224            ReadOnlySpan<int> corners = mesh.GetConvexCoplanarPatchCornerVertexIndices(supplier.Triangle);
 22414225            if (!corners.IsEmpty)
 226            {
 22376227                FillPatch(mesh, corners, _facePoints, _faceTriangles, _faceEdges);
 22376228                _sampleRegion = admissionOnly ? -1 : _joined.Parents.Count;
 22376229                int supplied = VisitFacePatch(mesh, _facePoints.AsReadOnlySpan(), _faceTriangles.AsReadOnlySpan(),
 22376230                    _faceEdges.AsReadOnlySpan(), penetration, admissionOnly);
 22376231                count += supplied;
 34639232                if (!admissionOnly) _joined.AddRegions(member, supplied > 0 ? 1 : 0);
 41768233                if (admissionOnly && count > 0) { _member = source; return count; }
 234                continue;
 235            }
 38236            supplier.Collider.GetTrianglesInBounds(_supportBounds, _supportCandidates);
 38237            _supportTriangles.FastClear();
 1341238            foreach (int triangle in _supportCandidates.AsReadOnlySpan())
 239            {
 639240                if (mesh.GetManifoldSurfaceOwner(triangle) != supplier.Owner) continue;
 637241                mesh.GetGeometryTriangleVertices(triangle, out points[0], out points[1], out points[2]);
 637242                int supplied = VisitFacePatch(mesh, points, TriangleIndices, TriangleEdges, penetration, admissionOnly: 
 637243                count += supplied;
 698244                if (supplied > 0) _supportTriangles.Add(triangle);
 663245                if (admissionOnly && count > 0) { _member = source; return count; }
 246            }
 25247            if (admissionOnly) continue;
 13248            supplier.Connectivity.BuildHullSupport(mesh, supplier.Triangle, this, _supportTriangles.AsReadOnlySpan());
 13249            _joined.AddRegions(member);
 122250            foreach (int triangle in _supportTriangles.AsReadOnlySpan())
 251            {
 48252                _sampleRegion = supplier.Offset + supplier.Connectivity.GetRegionOrdinal(triangle);
 48253                mesh.GetGeometryTriangleVertices(triangle, out points[0], out points[1], out points[2]);
 48254                VisitFacePatch(mesh, points, TriangleIndices, TriangleEdges, penetration, admissionOnly: false);
 255            }
 256        }
 19408257        if (!admissionOnly) CompleteFaceRegions(firstSample);
 9710258        _sampleRegion = -1;
 9710259        _member = source;
 9710260        return count;
 261    }
 262
 263    private bool MaySupplyFace(LSMeshCollider supplier, in WideDirection3d normal)
 264    {
 265        // Plane projection preserves coordinates whose exact normal component
 266        // is zero. Cull only strict separation there, including remote suppliers.
 195444267        for (int coordinate = 0; coordinate < 3; coordinate++)
 268        {
 75308269            if (!(coordinate == 0 ? normal.X : coordinate == 1 ? normal.Y : normal.Z).IsZero) continue;
 52876270            if (supplier.BoundsMax[coordinate] < _movingMesh.Bounds.Min[coordinate]
 60936271                || supplier.BoundsMin[coordinate] > _movingMesh.Bounds.Max[coordinate]) return false;
 272        }
 22414273        return true;
 274    }
 275
 276    private void CompleteFaceRegions(int firstSample)
 277    {
 54612278        for (_member = 0; _member < _joined.Inputs.Count; _member++)
 279        {
 17608280            var member = _joined.Members[_member];
 17608281            if (RegionCount(_member) == 0) continue;
 118732282            for (int span = 0; span < member.Boundary.Spans.Length; span++)
 283            {
 48114284                if (!member.JoinedSpans[span]) continue;
 9422285                var edge = member.Boundary.Spans[span];
 9422286                int other = _joined.MemberBySurface[(_joined.Meshes[edge.OtherMember], edge.OtherSurface)];
 9422287                if (other <= _member || RegionCount(other) == 0
 9422288                    || !IntersectsSupport(new FixedSegment(edge.Start, edge.End), edge.Interval)) continue;
 1512289                int first = SupportEdgeRegion(_member, edge.First, edge.Second);
 1512290                var neighbor = _joined.Members[other];
 3024291                int saved = _member; _member = other;
 15152292                foreach (var reciprocal in neighbor.Boundary.Spans)
 293                {
 6064294                    if (reciprocal.Kind != SpanKind.Joined
 6064295                        || reciprocal.OtherMember != member.Boundary.SourceMember || reciprocal.OtherSurface != member.O
 6064296                        || !IsReciprocalSpan(edge, member.Collider.Mesh, reciprocal, neighbor.Collider.Mesh)) continue;
 1512297                    int second = SupportEdgeRegion(other, reciprocal.First, reciprocal.Second);
 298                    System.Diagnostics.Debug.Assert(first >= 0 && second >= 0);
 1512299                    _joined.Union(member.Offset + first, neighbor.Offset + second);
 300                }
 1512301                _member = saved;
 302            }
 303        }
 9698304        _joined.CompleteRegions();
 9698305        ResponseGroup response = _groups[_group];
 19540306        for (int region = 1; region < _joined.Roots.Count; region++) _groups.Add(response);
 83374307        for (int index = firstSample; index < _samples.Count; index++)
 308        {
 31989309            Sample sample = _samples[index];
 31989310            _samples[index] = new(_group + _joined.RegionByRoot[_joined.Find(sample.Group)], sample.Member, sample.Point
 311        }
 9698312    }
 313
 314    private static bool IsReciprocalSpan(in BoundarySpan3D source, PhysicsMesh sourceMesh,
 315        in BoundarySpan3D target, PhysicsMesh targetMesh)
 316    {
 317        // Trusted reciprocal spans are positive maximal runs after collinear
 318        // reduction and equal-class merging. Both exact ends identify the same
 319        // window; matching owners alone could cross-link separated U-shaped arms.
 1516320        Signed832 one = Signed832.ExtendValue(Signed192.One);
 1516321        Signed832 lowerN = source.Interval.IsClipped ? source.Interval.WideLowerNumerator : default;
 1516322        Signed832 lowerD = source.Interval.IsClipped ? source.Interval.WideLowerDenominator : one;
 1516323        Signed832 upperN = source.Interval.IsClipped ? source.Interval.WideUpperNumerator : one;
 1516324        Signed832 upperD = source.Interval.IsClipped ? source.Interval.WideUpperDenominator : one;
 1516325        var edge = new FixedSegment(source.Start, source.End);
 1516326        var other = new FixedSegment(target.Start, target.End);
 1516327        return WideTriangleRelations.LocateEdgePoint(edge, sourceMesh.GeometryFrame, lowerN, lowerD,
 1516328                other, targetMesh.GeometryFrame, target.Interval) >= 0
 1516329            && WideTriangleRelations.LocateEdgePoint(edge, sourceMesh.GeometryFrame, upperN, upperD,
 1516330                other, targetMesh.GeometryFrame, target.Interval) >= 0;
 331    }
 332
 25303333    private int RegionCount(int member) => (member + 1 < _joined.Inputs.Count
 25303334        ? _joined.Members[member + 1].Offset : _joined.Parents.Count) - _joined.Members[member].Offset;
 335
 336    private int SupportEdgeRegion(int index, int first, int second)
 337    {
 6040338        if (RegionCount(index) == 1) return 0;
 8339        var member = _joined.Members[index];
 8340        return MeshSurfaceBoundaryTopology.FindSupportEdgeRegion(member.Collider.Mesh, member.Owner,
 8341            first, second, member.Connectivity, this);
 342    }
 343
 169344    internal bool IntersectsSupport(FixedSegment segment) => IntersectsSupport(segment, default);
 345
 346    private bool IntersectsSupport(FixedSegment segment, in RationalSegmentInterval clip)
 347    {
 1725348        Span<Vector3d> points = stackalloc Vector3d[2] { segment.Start, segment.End };
 1725349        var mesh = _joined.Members[_member].Collider.Mesh;
 3450350        _supportQuery = true; _supportClip[0] = clip;
 1725351        bool intersects = _supportPenetration.IsScaled
 1725352            ? WideOrientedBox.VisitConvexHullContacts(_movingMesh.GeometryFrame, _movingMesh.Origin,
 1725353                MovingPoints, MovingTriangles, MovingEdges, mesh.GeometryFrame, mesh.Origin,
 1725354                points, ReadOnlySpan<int>.Empty, TriangleEdges.AsSpan(0, 2), _supportPenetration.Scaled,
 1725355                this, static (owner, contact) => owner.AddSample(contact), this, admissionOnly: true) > 0
 1725356            : WideOrientedBox.VisitConvexHullContacts(_movingMesh.Origin, _movingMesh.Rotation,
 1725357            MovingPoints, MovingTriangles, MovingEdges,
 1725358            mesh.Origin, mesh.Rotation, points, ReadOnlySpan<int>.Empty, TriangleEdges.AsSpan(0, 2), _supportPenetration
 1725359            this, static (owner, contact) => owner.AddSample(contact), this, admissionOnly: true) > 0;
 1725360        _supportQuery = false;
 1725361        return intersects;
 362    }
 363
 364    private int VisitFacePatch(PhysicsMesh mesh, ReadOnlySpan<Vector3d> points, ReadOnlySpan<int> triangles,
 23061365        ReadOnlySpan<int> edges, in NativePenetration penetration, bool admissionOnly) => penetration.IsScaled
 23061366        ? WideOrientedBox.VisitConvexHullContacts(_movingMesh.GeometryFrame, _movingMesh.Origin,
 23061367            MovingPoints, MovingTriangles, MovingEdges, mesh.GeometryFrame, mesh.Origin,
 23061368            points, triangles, edges, penetration.Scaled,
 23061369            this, static (owner, contact) => owner.AddSample(contact), admissionOnly: admissionOnly)
 23061370        : WideOrientedBox.VisitConvexHullContacts(_movingMesh.Origin, _movingMesh.Rotation,
 23061371            MovingPoints, MovingTriangles, MovingEdges,
 23061372            mesh.Origin, mesh.Rotation, points, triangles, edges, penetration.Rigid,
 23061373            this, static (owner, contact) => owner.AddSample(contact), admissionOnly: admissionOnly);
 374
 2502375    private int Visit(in NativePenetration penetration, bool admissionOnly) => penetration.IsScaled
 2502376        ? WideOrientedBox.VisitConvexHullContacts(_movingMesh.GeometryFrame, _movingMesh.Origin,
 2502377            MovingPoints, MovingTriangles, MovingEdges, _joined.Members[_member].Collider.Mesh.GeometryFrame,
 2502378            _joined.Members[_member].Collider.Mesh.Origin, _points.AsReadOnlySpan(), _triangles.AsReadOnlySpan(),
 2502379            _edges.AsReadOnlySpan(), penetration.Scaled, this, static (owner, contact) => owner.AddSample(contact), this
 2502380        : WideOrientedBox.VisitConvexHullContacts(_movingMesh.Origin, _movingMesh.Rotation,
 2502381            MovingPoints, MovingTriangles, MovingEdges,
 2502382            _joined.Members[_member].Collider.Mesh.Origin, _joined.Members[_member].Collider.Mesh.Rotation,
 2502383            _points.AsReadOnlySpan(), _triangles.AsReadOnlySpan(), _edges.AsReadOnlySpan(), penetration.Rigid,
 2502384            this, static (owner, contact) => owner.AddSample(contact), this, admissionOnly);
 385
 386    private void BuildContacts(NativePenetration penetration)
 387    {
 388        // An already collected plane group is also its exact finite admission certificate.
 12890389        if ((_movingFeature < 0 || _movingPatch) && IsFaceNormal(penetration.Axis) && FindGroup(penetration) < _groups.C
 390        // Native triangle contacts historically orient by centroids. Response
 391        // admission must rank the actual signed pushes instead of that legacy orientation.
 10028392        if (_movingFeature >= 0 && !_movingPatch || !AdmitAxis(penetration))
 393        {
 394            // Admission changes response ranking, never the already proved overlap.
 429395            bool overlaps = FindPenetration(out penetration, filtered: true);
 396            System.Diagnostics.Debug.Assert(overlaps);
 433397            if (!penetration.HasValue) return;
 398        }
 10024399        int component = _joined.FindResponseComponent(_member);
 10024400        WideDirection3d axis = penetration.Negate ? -penetration.Axis : penetration.Axis;
 10024401        _group = FindGroup(penetration);
 10024402        bool face = IsFaceNormal(axis);
 19822403        if (_group == _groups.Count) _groups.Add(new(component, axis, penetration, _movingFeature, _joined.GetResponseMe
 442404        else if (face) return; // The first accepted plane already collected every supplier.
 19506405        if (face) VisitFace(penetration, admissionOnly: false);
 110406        else Visit(penetration, admissionOnly: false);
 110407    }
 408
 409    private int FindGroup(in NativePenetration penetration)
 410    {
 30895411        int component = _joined.FindResponseComponent(_member);
 30895412        WideDirection3d axis = penetration.Negate ? -penetration.Axis : penetration.Axis;
 30895413        int group = 0;
 93565414        for (; group < _groups.Count; group++)
 415        {
 33208416            ResponseGroup existing = _groups[group];
 33208417            if (existing.Component == component && existing.Feature == _movingFeature && WideDirection3d.AreParallel(axi
 33208418                && WideDirection3d.Dot(axis, existing.Axis).Sign > 0
 33208419                && !existing.Penetration.ShouldReplace(penetration)
 33208420                && !penetration.ShouldReplace(existing.Penetration)) break;
 421        }
 30895422        return group;
 423    }
 424
 425    private void AddSample(FixedContactAnchors contact)
 426    {
 427        // Rank final points in one translated world chart without narrowing an absolute world position.
 32138428        bool represented = contact.SecondAnchor.TryGetPointInFrame(_movingCenter, out Vector3d point);
 429        System.Diagnostics.Debug.Assert(represented);
 32138430        _samples.Add(new(_sampleRegion < 0 ? _group : _sampleRegion, _member, point, contact));
 32138431    }
 432
 433    internal bool Append(LSMeshCollider collider, LSMeshCollider mover, ContactManifold manifold, bool reverse)
 434    {
 5955435        Span<int> chosen = stackalloc int[ContactManifold.MaxContactsPerGroup];
 37042436        for (int group = 0; group < _groups.Count; group++)
 437        {
 12566438            ResponseGroup response = _groups[group];
 12566439            if (_joined.Members[response.Carrier].Collider != collider) continue;
 9862440            _pool.FastClear();
 282728441            foreach (Sample sample in _samples.AsReadOnlySpan()) if (sample.Group == group) _pool.Add(sample);
 9862442            _pool.SortInPlace(PointComparer);
 9862443            int unique = 0;
 84158444            foreach (Sample sample in _pool.AsReadOnlySpan())
 445            {
 32217446                if (unique > 0 && ComparePoints(sample, _pool[unique - 1]) == 0) continue;
 26765447                _pool[unique++] = sample;
 448            }
 9862449            ReadOnlySpan<Sample> pool = _pool.AsReadOnlySpan()[..unique];
 9862450            int count = Math.Min(pool.Length, chosen.Length);
 9862451            if (response.Penetration.IsScaled)
 452            {
 298453                for (int slot = 0; slot < count; slot++)
 92454                    chosen[slot] = slot == 0 ? 0 : MeshPlaneSampleReduction.ChooseNext(pool, chosen[..slot], response.Ax
 57455                if (count > 2 && WidePlaneMetrics.GetAreaSign(response.Axis,
 59456                    pool[chosen[0]].Point, pool[chosen[1]].Point, pool[chosen[2]].Point) == 0) count = 2;
 457            }
 458            else
 459            {
 9805460                var metrics = new WidePlaneMetrics(response.Penetration.Rigid.Axis);
 70212461                for (int slot = 0; slot < count; slot++)
 25301462                    chosen[slot] = slot == 0 ? 0 : MeshPlaneSampleReduction.ChooseNext(pool, chosen[..slot], metrics, Po
 10479463                if (count > 2 && metrics.GetAreaSquared(pool[chosen[0]].Point, pool[chosen[1]].Point, pool[chosen[2]].Po
 464            }
 69158465            for (int slot = 0; slot < count; slot++)
 466            {
 49434467                Sample sample = pool[chosen[slot]]; var supplier = _joined.Members[sample.Member];
 24717468                FixedContactAnchors contact = sample.Contact;
 24717469                int movingSurface = response.Feature < 0 ? 0 : _movingMesh.GetCanonicalSurfaceOrdinal(response.Feature) 
 24717470                var key = new ContactGroupKey(0, 0, supplier.Collider.Mesh.GetCanonicalSurfaceOrdinal(supplier.Owner) + 
 24717471                    movingSurface, group, sourceIdA: supplier.Collider.Id + 1,
 24717472                    sourceOrderA: ((IPhysicsColliderRegistryItem)supplier.Collider).ReplayOrder + 1);
 24717473                manifold.AddContact(new ContactAnchor(reverse ? contact.FirstAnchor : contact.SecondAnchor),
 24717474                    new ContactAnchor(reverse ? contact.SecondAnchor : contact.FirstAnchor), contact.Depth,
 24717475                    reverse ? contact.Normal : -contact.Normal, reverse ? mover.Material : supplier.Collider.Material,
 24717476                    reverse ? supplier.Collider.Material : mover.Material, contact.DepthIsClamped,
 24717477                    group: reverse ? key.Remap(0, 0, true) : key);
 478            }
 479        }
 5955480        return _overlappingMembers.Contains(collider.Id);
 481    }
 482
 483    ReadOnlySpan<RationalSegmentInterval> IConvexHullContactDomain.GetEdgeIntervals(bool first, int start, int end,
 14424484        in WideAxis3 normal) => GetEdgeIntervals(first, start, end);
 485
 486    public ReadOnlySpan<RationalSegmentInterval> GetEdgeIntervals(bool first, int start, int end,
 775487        in WideDirection3d normal) => GetEdgeIntervals(first, start, end);
 488
 489    private ReadOnlySpan<RationalSegmentInterval> GetEdgeIntervals(bool first, int start, int end)
 490    {
 26906491        if (first) return FullInterval;
 5145492        if (_supportQuery) return _supportClip;
 1839493        var member = _joined.Members[_member];
 494        // Face visitation uses the filled supplier directly; only nonface
 495        // candidates and the support-query branch above borrow this domain.
 1839496        _intervals.FastClear();
 20220497        for (int span = 0; span < member.Boundary.Spans.Length; span++)
 498        {
 8271499            var edge = member.Boundary.Spans[span];
 8271500            if (member.JoinedSpans[span]) continue;
 6603501            RationalSegmentInterval interval = member.GetRetainedInterval(ref span);
 7330502            if (MapBoundaryInterval(edge, interval, start, end, out var mapped)) _intervals.Add(mapped);
 503        }
 1839504        return _intervals.AsReadOnlySpan();
 505    }
 506
 507    private bool MapBoundaryInterval(in BoundarySpan3D edge, in RationalSegmentInterval interval,
 508        int start, int end, out RationalSegmentInterval mapped)
 509    {
 15328510        if (edge.First == _vertices[start] && edge.Second == _vertices[end])
 1032511        { mapped = interval; return true; }
 512        // Canonical perimeters merge authored collinear subedges. Remap their
 513        // cuts before witness selection; matching only vertex IDs loses real rims.
 514        // Authored coordinates can be large even when scaled reach is small;
 515        // the interval owner retains full products before reducing these bounds.
 14812516        return interval.TryMapToSegment(new FixedSegment(edge.Start, edge.End),
 14812517            new FixedSegment(_points[start], _points[end]), out mapped);
 518    }
 519
 520    bool IConvexHullContactDomain.ContainsPoint(bool first, int start, int end, in Signed832 numerator,
 7559521        in Signed832 denominator, in WideAxis3 normal) => ContainsPoint(first, start, end, numerator, denominator, new W
 522
 523    public bool ContainsPoint(bool first, int start, int end, in Signed832 numerator, in Signed832 denominator, in WideD
 524    {
 10480525        if (first) return true;
 4816526        if (_supportQuery)
 527        {
 1593528            var clip = _supportClip[0];
 2741529            if (!clip.IsClipped) return true;
 445530            Signed832 n = start == end ? (start == 0 ? default : denominator) : numerator;
 445531            return WideTriangleRelations.CompareCoreParameters(n, denominator,
 445532                clip.WideLowerNumerator, clip.WideLowerDenominator) >= 0
 445533                && WideTriangleRelations.CompareCoreParameters(n, denominator,
 445534                clip.WideUpperNumerator, clip.WideUpperDenominator) <= 0;
 535        }
 3223536        var member = _joined.Members[_member];
 6446537        int a = _vertices[start], b = _vertices[end];
 3223538        if (start == end || numerator.IsZero || WideArithmetic.SubtractSigned832(denominator, numerator).IsZero)
 539        {
 630540            int vertex = start == end || numerator.IsZero ? a : b;
 630541            return SupportsJoinedFan(_joined.Fan.BuildAtPoint(_joined.Meshes.AsReadOnlySpan(), member.Boundary.SourceMem
 630542                member.Owner, member.Collider.Mesh.GeometryVertices[vertex], _joined.PreparedBoundaries.AsReadOnlySpan()
 543        }
 25618544        for (int span = 0; span < member.Boundary.Spans.Length; span++)
 545        {
 10825546            var edge = member.Boundary.Spans[span];
 10825547            if (member.JoinedSpans[span] || !MapBoundaryInterval(edge, edge.Interval, start, end, out var mapped)) conti
 2324548            Signed832 lowerN = mapped.WideLowerNumerator, lowerD = mapped.WideLowerDenominator;
 2324549            Signed832 upperN = mapped.WideUpperNumerator, upperD = mapped.WideUpperDenominator;
 2016550            if (!mapped.IsClipped) { lowerN = default; lowerD = upperN = upperD = Signed832.ExtendValue(Signed192.Signed
 1162551            int lower = WideTriangleRelations.CompareCoreParameters(numerator, denominator, lowerN, lowerD);
 1162552            int upper = WideTriangleRelations.CompareCoreParameters(numerator, denominator, upperN, upperD);
 1162553            if (lower < 0 || upper > 0) continue;
 1184554            if (lower > 0 && upper < 0) return true;
 34555            int coordinate = edge.Start.X != edge.End.X ? 0 : edge.Start.Y != edge.End.Y ? 1 : 2;
 34556            bool reverse = (_points[start][coordinate] > _points[end][coordinate]) != (edge.Start[coordinate] > edge.End
 34557            return SupportsJoinedFan(_joined.Fan.BuildEndpoint(_joined.Meshes.AsReadOnlySpan(), member.Boundary, span, (
 34558                _joined.PreparedBoundaries.AsReadOnlySpan()), normal);
 559        }
 1984560        return false;
 561    }
 562
 563    public bool ContainsPoint(bool first, int start, int end, scoped ContactQuadratic numerator,
 564        scoped ContactQuadratic denominator, in WideDirection3d normal)
 565    {
 360566        if (first) return true;
 120567        if (_supportQuery)
 568        {
 2569            var clip = _supportClip[0];
 2570            return !clip.IsClipped || clip.Contains(numerator, denominator, ReadOnlySpan<ulong>.Empty);
 571        }
 118572        var member = _joined.Members[_member];
 236573        int a = _vertices[start], b = _vertices[end];
 118574        bool atStart = numerator.Signs[0] == 0;
 118575        bool atEnd = CompareBorrowedParameter(numerator, denominator, Signed832.ExtendValue(Signed192.One),
 118576            Signed832.ExtendValue(Signed192.One)) == 0;
 577        // Borrowed ratios come only from the native edge/edge fallback;
 578        // point/face witnesses use the compact overload above.
 118579        if (atStart || atEnd)
 580        {
 21581            int vertex = atStart ? a : b;
 21582            return SupportsJoinedFan(_joined.Fan.BuildAtPoint(_joined.Meshes.AsReadOnlySpan(), member.Boundary.SourceMem
 21583                member.Owner, member.Collider.Mesh.GeometryVertices[vertex], _joined.PreparedBoundaries.AsReadOnlySpan()
 584        }
 97585        Signed832 one = Signed832.ExtendValue(Signed192.One);
 916586        for (int span = 0; span < member.Boundary.Spans.Length; span++)
 587        {
 394588            var edge = member.Boundary.Spans[span];
 394589            if (member.JoinedSpans[span] || !MapBoundaryInterval(edge, edge.Interval, start, end, out var mapped)) conti
 39590            int lower = CompareBorrowedParameter(numerator, denominator,
 39591                mapped.IsClipped ? mapped.WideLowerNumerator : default, mapped.IsClipped ? mapped.WideLowerDenominator :
 39592            int upper = CompareBorrowedParameter(numerator, denominator,
 39593                mapped.IsClipped ? mapped.WideUpperNumerator : one, mapped.IsClipped ? mapped.WideUpperDenominator : one
 39594            if (lower < 0 || upper > 0) continue;
 57595            if (lower > 0 && upper < 0) return true;
 9596            int coordinate = edge.Start.X != edge.End.X ? 0 : edge.Start.Y != edge.End.Y ? 1 : 2;
 9597            bool reverse = (_points[start][coordinate] > _points[end][coordinate]) != (edge.Start[coordinate] > edge.End
 9598            return SupportsJoinedFan(_joined.Fan.BuildEndpoint(_joined.Meshes.AsReadOnlySpan(), member.Boundary, span,
 9599                (upper == 0) != reverse, _joined.PreparedBoundaries.AsReadOnlySpan()), normal);
 600        }
 64601        return false;
 602    }
 603
 604    private static int CompareBorrowedParameter(scoped ContactQuadratic numerator, scoped ContactQuadratic denominator,
 605        Signed832 otherN, Signed832 otherD)
 606    {
 392607        Span<ulong> values = stackalloc ulong[52]; Span<int> signs = stackalloc int[4];
 392608        var n = ContactQuadratic.At(values, signs, 0, 13); var d = ContactQuadratic.At(values, signs, 1, 13);
 392609        n.Set(otherN); d.Set(otherD);
 196610        return ContactQuadratic.CompareRatios(numerator, denominator, ReadOnlySpan<ulong>.Empty,
 196611            n, d, ReadOnlySpan<ulong>.Empty);
 612    }
 613
 614    private bool IsFaceNormal(in WideDirection3d normal)
 615    {
 33784616        return WideDirection3d.AreParallel(normal, _joined.Members[_member].Frame);
 617    }
 618
 619    private bool SupportsJoinedFan(bool built, in WideDirection3d normal)
 620    {
 621        // Failed or ineligible neighbor certificates preserve the native feature.
 703622        if (!built) return true;
 3568623        foreach (var owner in _joined.Fan.Owners)
 1102624            if (!_joined.MemberBySurface.ContainsKey((_joined.Meshes[owner.Member], owner.Surface))) return true;
 683625        return Supports(_joined.Fan.Rays, normal);
 626    }
 627
 628    private bool Supports(ReadOnlySpan<WideAxis3> rays, in WideDirection3d normal)
 629    {
 683630        WideDirection3d inward = -normal;
 5021631        foreach (WideAxis3 ray in rays)
 632        {
 2444633            if (WideDirection3d.Dot(inward, ray).Sign > 0) return false;
 634        }
 272635        return true;
 636    }
 637
 638    private static int ComparePoints(Sample a, Sample b)
 639    {
 63520640        int order = a.Point.X.CompareTo(b.Point.X);
 98599641        if (order == 0) order = a.Point.Y.CompareTo(b.Point.Y);
 98500642        if (order == 0) order = a.Point.Z.CompareTo(b.Point.Z);
 63520643        return order != 0 ? order : a.Contact.FirstAnchor.CompareLocalFeature(b.Contact.FirstAnchor);
 644    }
 645    private static int CompareSamples(Sample a, Sample b)
 82330646    { int order = ComparePoints(a, b); return order != 0 ? order : a.Member.CompareTo(b.Member); }
 647    private readonly struct Sample : IPlaneContactSample
 648    {
 649        internal readonly int Group, Member;
 650        internal readonly FixedContactAnchors Contact;
 651        public Vector3d Point { get; }
 652        internal Sample(int group, int member, Vector3d point, FixedContactAnchors contact)
 320635653        { Group = group; Member = member; Point = point; Contact = contact; }
 654    }
 655    private readonly struct ResponseGroup
 656    {
 657        internal readonly int Component, Feature, Carrier;
 658        internal readonly WideDirection3d Axis;
 659        internal readonly NativePenetration Penetration;
 660        internal ResponseGroup(int component, WideDirection3d axis, NativePenetration penetration, int feature, int carr
 58788661        { Component = component; Axis = axis; Penetration = penetration; Feature = feature; Carrier = carrier; }
 662    }
 663
 664    private readonly struct NativePenetration
 665    {
 666        internal readonly WidePointSpanPenetration Rigid;
 667        internal readonly WideScaledHullPenetration Scaled;
 668        internal readonly bool IsScaled;
 79260669        internal NativePenetration(WidePointSpanPenetration value) { this = default; Rigid = value; }
 1176670        internal NativePenetration(WideScaledHullPenetration value) { this = default; Scaled = value; IsScaled = true; }
 429671        internal bool HasValue => IsScaled ? Scaled.HasValue : Rigid.HasValue;
 40919672        internal bool Negate => IsScaled ? Scaled.Negate : Rigid.Negate;
 95153673        internal WideDirection3d Axis => IsScaled ? Scaled.Axis : new WideDirection3d(Rigid.Axis);
 52674        private Signed832 Overlap => IsScaled ? Scaled.Overlap : Signed832.ExtendValue(Rigid.ExactOverlap);
 52675        private Signed832 SquaredAxisLength => IsScaled ? Scaled.SquaredAxisLength : Signed832.ExtendValue(Rigid.ExactSq
 52676        private Signed576 Denominator => IsScaled ? Scaled.CommonDenominator : Signed576.ExtendValue(Rigid.ExactCommonDe
 677        // Group comparison sees only successful SAT results or constructed
 678        // admission candidates; a filtered empty result is rejected earlier.
 3754679        internal bool ShouldReplace(in NativePenetration candidate) => !IsScaled && !candidate.IsScaled
 3754680            ? Rigid.ShouldReplace(candidate.Rigid.ExactOverlap, candidate.Rigid.ExactSquaredAxisLength, candidate.Rigid.
 3754681            : WideArithmetic.CompareNonNegativeNormalizedDepths(candidate.Overlap, candidate.SquaredAxisLength, candidat
 3754682                Overlap, SquaredAxisLength, Denominator) < 0;
 683    }
 684}

Methods/Properties

.ctor()
.cctor()
get_MovingPoints()
get_MovingTriangles()
get_MovingEdges()
Release()
Build(System.ReadOnlySpan`1<System.ValueTuple`2<Gravitas.Colliders.LSMeshCollider,System.Int32>>,Gravitas.Colliders.LSMeshCollider,System.ReadOnlySpan`1<Gravitas.Colliders.PhysicsMesh>,SwiftCollections.SwiftDictionary`2<System.ValueTuple`2<Gravitas.Colliders.PhysicsMesh,System.Int32>,Gravitas.CollisionHandling.MeshSurfaceBoundaryDomain>)
BuildPart(SwiftCollections.Query.FixedBoundVolume)
SetPatch(System.ReadOnlySpan`1<System.Int32>)
FillPatch(Gravitas.Colliders.PhysicsMesh,System.ReadOnlySpan`1<System.Int32>,SwiftCollections.SwiftList`1<FixedMathSharp.Vector3d>,SwiftCollections.SwiftList`1<System.Int32>,SwiftCollections.SwiftList`1<System.Int32>)
SetTriangle(System.Int32)
FindPenetration(Gravitas.CollisionHandling.MeshHullSurfaceContacts/NativePenetration&,System.Boolean)
AdmitAxis(FixedMathSharp.Geometry.WidePointSpanPenetration&)
AdmitScaledAxis(FixedMathSharp.Geometry.WideScaledHullPenetration&)
AdmitAxis(Gravitas.CollisionHandling.MeshHullSurfaceContacts/NativePenetration&)
VisitFace(Gravitas.CollisionHandling.MeshHullSurfaceContacts/NativePenetration&,System.Boolean)
MaySupplyFace(Gravitas.Colliders.LSMeshCollider,FixedMathSharp.Geometry.WideDirection3d&)
CompleteFaceRegions(System.Int32)
IsReciprocalSpan(Gravitas.CollisionHandling.BoundarySpan3D&,Gravitas.Colliders.PhysicsMesh,Gravitas.CollisionHandling.BoundarySpan3D&,Gravitas.Colliders.PhysicsMesh)
RegionCount(System.Int32)
SupportEdgeRegion(System.Int32,System.Int32,System.Int32)
IntersectsSupport(FixedMathSharp.Geometry.FixedSegment)
IntersectsSupport(FixedMathSharp.Geometry.FixedSegment,FixedMathSharp.Geometry.RationalSegmentInterval&)
VisitFacePatch(Gravitas.Colliders.PhysicsMesh,System.ReadOnlySpan`1<FixedMathSharp.Vector3d>,System.ReadOnlySpan`1<System.Int32>,System.ReadOnlySpan`1<System.Int32>,Gravitas.CollisionHandling.MeshHullSurfaceContacts/NativePenetration&,System.Boolean)
Visit(Gravitas.CollisionHandling.MeshHullSurfaceContacts/NativePenetration&,System.Boolean)
BuildContacts(Gravitas.CollisionHandling.MeshHullSurfaceContacts/NativePenetration)
FindGroup(Gravitas.CollisionHandling.MeshHullSurfaceContacts/NativePenetration&)
AddSample(FixedMathSharp.Geometry.FixedContactAnchors)
Append(Gravitas.Colliders.LSMeshCollider,Gravitas.Colliders.LSMeshCollider,Gravitas.CollisionHandling.ContactManifold,System.Boolean)
FixedMathSharp.Geometry.IConvexHullContactDomain.GetEdgeIntervals(System.Runtime.InteropServices.InAttribute))
GetEdgeIntervals(System.Boolean,System.Int32,System.Int32,FixedMathSharp.Geometry.WideDirection3d&)
GetEdgeIntervals(System.Boolean,System.Int32,System.Int32)
MapBoundaryInterval(Gravitas.CollisionHandling.BoundarySpan3D&,FixedMathSharp.Geometry.RationalSegmentInterval&,System.Int32,System.Int32,FixedMathSharp.Geometry.RationalSegmentInterval&)
FixedMathSharp.Geometry.IConvexHullContactDomain.ContainsPoint(System.Runtime.InteropServices.InAttribute))
ContainsPoint(System.Boolean,System.Int32,System.Int32,FixedMathSharp.Signed832&,FixedMathSharp.Signed832&,FixedMathSharp.Geometry.WideDirection3d&)
ContainsPoint(System.Boolean,System.Int32,System.Int32,FixedMathSharp.Geometry.ContactQuadratic,FixedMathSharp.Geometry.ContactQuadratic,FixedMathSharp.Geometry.WideDirection3d&)
CompareBorrowedParameter(FixedMathSharp.Geometry.ContactQuadratic,FixedMathSharp.Geometry.ContactQuadratic,FixedMathSharp.Signed832,FixedMathSharp.Signed832)
IsFaceNormal(FixedMathSharp.Geometry.WideDirection3d&)
SupportsJoinedFan(System.Boolean,FixedMathSharp.Geometry.WideDirection3d&)
Supports(System.ReadOnlySpan`1<FixedMathSharp.Geometry.WideAxis3>,FixedMathSharp.Geometry.WideDirection3d&)
ComparePoints(Gravitas.CollisionHandling.MeshHullSurfaceContacts/Sample,Gravitas.CollisionHandling.MeshHullSurfaceContacts/Sample)
CompareSamples(Gravitas.CollisionHandling.MeshHullSurfaceContacts/Sample,Gravitas.CollisionHandling.MeshHullSurfaceContacts/Sample)
.ctor(System.Int32,System.Int32,FixedMathSharp.Vector3d,FixedMathSharp.Geometry.FixedContactAnchors)
.ctor(System.Int32,FixedMathSharp.Geometry.WideDirection3d,Gravitas.CollisionHandling.MeshHullSurfaceContacts/NativePenetration,System.Int32,System.Int32)
.ctor(FixedMathSharp.Geometry.WidePointSpanPenetration)
.ctor(FixedMathSharp.Geometry.WideScaledHullPenetration)
get_HasValue()
get_Negate()
get_Axis()
get_Overlap()
get_SquaredAxisLength()
get_Denominator()
ShouldReplace(Gravitas.CollisionHandling.MeshHullSurfaceContacts/NativePenetration&)