< Summary

Line coverage
100%
Covered lines: 382
Uncovered lines: 0
Coverable lines: 382
Total lines: 687
Line coverage: 100%
Branch coverage
100%
Covered branches: 322
Total branches: 322
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
File 1: .ctor()100%11100%
File 1: .cctor()100%11100%
File 1: get_SelectionWords()100%11100%
File 1: get_Orientation()100%11100%
File 1: get_Frame()100%11100%
File 1: Prepare(...)100%11100%
File 1: PrepareFrame(...)100%2222100%
File 1: ContainsSection(...)100%44100%
File 1: Build(...)100%3636100%
File 1: IntersectsSupport(...)100%22100%
File 1: VisitTriangle(...)100%44100%
File 1: VisitPlane(...)100%22100%
File 1: AdmitPoint(...)100%2424100%
File 1: AppendContacts(...)100%88100%
File 1: ReduceSamples(...)100%2222100%
File 1: BorrowPeak()100%11100%
File 1: ComparePoints(...)100%66100%
File 1: .ctor(...)100%11100%
File 1: WithRegion(...)100%11100%
File 2: .ctor()100%11100%
File 2: get_SourceId()100%22100%
File 2: get_SourceOrder()100%22100%
File 2: ReleaseJoined()100%11100%
File 2: BuildJoined(...)100%44100%
File 2: BuildJoined(...)100%4646100%
File 2: TryUseConvexSupport(...)100%1212100%
File 2: AdmitConvexSupport(...)100%66100%
File 2: CertifyCompleteSupports()100%1616100%
File 2: ContainsSupportPoint(...)100%44100%
File 2: GatherJoinedBoundary(...)100%1010100%
File 2: CanReachSupport(...)100%1616100%
File 2: SelectJoinedMember(...)100%11100%
File 2: JoinSupportSpans()100%1212100%
File 2: JoinAtSupportPoint(...)100%2626100%
File 2: AppendJoinedContacts(...)100%1212100%
File 2: get_JoinedBoundary()100%22100%
File 2: IsJoinedSpan(...)100%11100%
File 2: GetRetainedInterval(...)100%11100%
File 2: GetJoinedCornerFan(...)100%11100%
File 2: TryGetContinuousFamily(...)100%1212100%
File 2: IsSameContinuousFamily(...)100%44100%
File 2: IntersectsContinuousBoundary(...)100%66100%

File(s)

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

#LineLine coverage
 1//=======================================================================
 2// MeshSlabFaceRegions.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 Gravitas.Materials;
 14using SwiftCollections;
 15
 16namespace Gravitas.CollisionHandling;
 17
 18/// <summary>Clips physical slab supports to the filled finite mesh owner.</summary>
 19/// <content>Native support charts and the shared finite sample reduction.</content>
 20internal sealed partial class MeshSlabFaceRegions
 21{
 1033222    private ulong[] _values = new ulong[FiniteSlabRaySelection.StorageWords];
 1033223    private sbyte[] _signs = new sbyte[FiniteSlabRaySelection.SignCount];
 1033224    private FiniteSlabRaySelectionMetadata[] _peaks = new FiniteSlabRaySelectionMetadata[1];
 2066425    private readonly SwiftList<Sample> _events = new(), _pool = new();
 2066426    private readonly SwiftList<int> _ownerTriangles = new(), _admitted = new();
 1033227    private readonly SwiftHashSet<int> _visitedTriangles = new();
 28    private readonly FiniteSlabRayCandidateVisitor _visitor;
 129    private static readonly IComparer<Sample> PointComparer = Comparer<Sample>.Create(ComparePoints);
 30    private FiniteSlabRayFrame _frame;
 1033231    private int _fieldWords = FiniteSlabPolynomial.Words;
 20257332    private int SelectionWords => FiniteSlabRaySelection.GetStorageWords(_fieldWords);
 33    private int _region, _orientation, _supportDimension;
 34    private bool _intrinsicOnly, _usesSupportGraph, _hasPlaneSamples;
 35
 2066436    internal MeshSlabFaceRegions() => _visitor = AdmitPoint;
 37    internal int RegionCount { get; private set; }
 114238    internal int Orientation => _orientation;
 1102939    internal ref readonly FiniteSlabRayFrame Frame => ref _frame;
 40
 41    internal void Prepare(in FiniteSlabRayFrame frame, ReadOnlySpan<Vector2d> prismOffsets, bool coveredSection)
 42    {
 249243        _member = -1;
 249244        PrismOffsets = default;
 249245        PrepareFrame(frame, prismOffsets, coveredSection);
 249246    }
 47
 48    private void PrepareFrame(in FiniteSlabRayFrame frame, ReadOnlySpan<Vector2d> prismOffsets, bool coveredSection = fa
 49    {
 1184050        _frame = frame;
 1184051        _fieldWords = frame.FieldWords;
 52        // Slot zero serves an isolated owner. Joined members retain their chosen
 53        // peak only for this build, so switching suppliers does not solve the
 54        // same intrinsic plane again. Every new build overwrites active slots.
 1184055        int slots = _member + 2;
 1211556        if (_values.Length < slots * SelectionWords) Array.Resize(ref _values, slots * SelectionWords);
 1210657        if (_signs.Length < slots * FiniteSlabRaySelection.SignCount) Array.Resize(ref _signs, slots * FiniteSlabRaySele
 1210658        if (_peaks.Length < slots) Array.Resize(ref _peaks, slots);
 1184059        _hasPlaneSamples = _member < 0 && coveredSection;
 1433260        if (_member < 0) _events.FastClear();
 61        // The admitted section intersects this plane. Exact support projections
 62        // choose the nearer exit before either expensive witness construction.
 1184063        int order = frame.ComparePlaneExitDepths(prismOffsets);
 1184064        _orientation = order <= 0 ? 1 : -1;
 1184065        if (_member >= 0 && order == 0)
 66        {
 2767            WideDirection3d normal = frame.Plane.Normal;
 2768            int sign = !normal.X.IsZero ? normal.X.Sign : !normal.Y.IsZero ? normal.Y.Sign : normal.Z.Sign;
 2769            _orientation = -sign;
 70        }
 1404871        if (_hasPlaneSamples) { _region = 0; _intrinsicOnly = false; }
 1184072        var maximum = BorrowPeak();
 1184073        maximum.Restore(default);
 1184074        FiniteSlabRayExtrema.AccumulatePlane(frame, prismOffsets, _orientation, ref maximum,
 1184075            _hasPlaneSamples ? _visitor : null, includeInteriorSample: !_hasPlaneSamples);
 1184076        _peaks[_member + 1] = maximum.Metadata;
 77        System.Diagnostics.Debug.Assert(maximum.HasValue);
 1184078        _supportDimension = frame.GetSupportDimension(prismOffsets, _orientation);
 1184079    }
 80
 81    // With at least one admitted triangle, no boundary crossing certifies the
 82    // entire connected axial footprint. Without admission it can lie in a hole.
 83    internal static bool ContainsSection(PhysicsMesh mesh, int surfaceTriangle, in FiniteSlabRayFrame frame,
 84        ReadOnlySpan<Vector2d> prismOffsets)
 85    {
 288686        ReadOnlySpan<int> boundary = mesh.GetCanonicalSurfaceBoundaryVertexPairs(surfaceTriangle);
 288687        ReadOnlySpan<Vector3d> vertices = mesh.GeometryVertices;
 288688        bool containsSection = frame.RayNormal.X.IsZero && frame.RayNormal.Z.IsZero;
 1593689        for (int edge = 0; edge < boundary.Length && containsSection; edge += 2)
 508290            containsSection = !frame.Section.IntersectsSegment(new FixedSegment(vertices[boundary[edge]], vertices[bound
 288691        return containsSection;
 92    }
 93
 94    internal void Build(PhysicsMesh mesh, int surfaceTriangle, MeshSurfaceConnectivity connectivity,
 95        ReadOnlySpan<Vector2d> prismOffsets, LSCollider2D? embedded, bool containsSection)
 96    {
 500297        if (!_hasPlaneSamples) _events.FastClear();
 305398        _admitted.FastClear();
 915999        _usesSupportGraph = false; RegionCount = 0; _region = 0;
 3053100        _intrinsicOnly = _supportDimension == 2;
 3053101        if (containsSection)
 102        {
 103            // An axial cap projects to the original footprint; no true-boundary
 104            // crossing certifies that its complete support is inside the fill.
 1112105            if (!_hasPlaneSamples) VisitPlane(prismOffsets);
 1108106            RegionCount = _events.Count == 0 ? 0 : 1;
 1108107            return;
 108        }
 3890109        _events.FastClear(); _hasPlaneSamples = false;
 1945110        ReadOnlySpan<int> boundary = mesh.GetCanonicalSurfaceBoundaryVertexPairs(surfaceTriangle);
 1945111        ReadOnlySpan<Vector3d> vertices = mesh.GeometryVertices;
 1945112        ReadOnlySpan<int> corners = mesh.GetConvexCoplanarPatchCornerVertexIndices(surfaceTriangle);
 1945113        bool hasSupport = false;
 1945114        if (!corners.IsEmpty)
 115        {
 11100116            for (int corner = 1; corner < corners.Length - 1; corner++)
 3700117                hasSupport |= VisitTriangle(new FixedTriangle(vertices[corners[0]], vertices[corners[corner]], vertices[
 118        }
 119        else
 120        {
 190121            _ownerTriangles.FastClear(); _visitedTriangles.Clear();
 190122            _ownerTriangles.Add(surfaceTriangle); _visitedTriangles.Add(surfaceTriangle);
 2150123            for (int index = 0; index < _ownerTriangles.Count; index++)
 124            {
 980125                int triangle = _ownerTriangles[index];
 980126                _region = triangle;
 980127                mesh.GetGeometryTriangleVertices(triangle, out Vector3d a, out Vector3d b, out Vector3d c);
 1290128                if (VisitTriangle(new FixedTriangle(a, b, c), prismOffsets)) { _admitted.Add(triangle); hasSupport = tru
 6032129                foreach (int neighbor in mesh.GetCoplanarTriangleNeighbors(triangle))
 2921130                    if (_visitedTriangles.Add(neighbor)) _ownerTriangles.Add(neighbor);
 131            }
 95132            if (_supportDimension == 2 && hasSupport)
 133            {
 134                // Perimeters have already consumed initial-section connectivity.
 135                // Reuse its graph for the actual projected support footprint.
 55136                connectivity.BuildSlabSupport(mesh, surfaceTriangle, this, embedded, _admitted.AsReadOnlySpan());
 55137                _usesSupportGraph = true;
 138            }
 139        }
 2643140        if (!hasSupport) { _events.FastClear(); return; }
 1596141        RegionCount = _usesSupportGraph ? connectivity.RegionCount : 1;
 10848142        for (int index = 0; index < _events.Count; index++)
 143        {
 3828144            Sample sample = _events[index];
 3828145            _events[index] = sample.WithRegion(_usesSupportGraph ? connectivity.GetRegionOrdinal(sample.Region) : 0);
 146        }
 147        // Only canonical real edges can add clipped support extrema; authored
 148        // diagonals must not change a flat support family's retained levers.
 1596149        _intrinsicOnly = false;
 1596150        if (_member >= 0)
 151        {
 261152            GatherJoinedBoundary(mesh, surfaceTriangle, connectivity);
 261153            return;
 154        }
 1335155        int wholeOwner = mesh.GetManifoldSurfaceOwner(surfaceTriangle);
 13530156        for (int edge = 0; edge < boundary.Length; edge += 2)
 157        {
 5430158            var segment = new FixedSegment(vertices[boundary[edge]], vertices[boundary[edge + 1]]);
 5430159            if (!IntersectsSupport(segment, prismOffsets)) continue;
 668160            _region = _usesSupportGraph ? MeshSurfaceBoundaryTopology.FindSupportEdgeRegion(mesh, wholeOwner,
 668161                boundary[edge], boundary[edge + 1], connectivity, this, embedded) : 0;
 162            // A support-intersecting canonical span contains an admitted real subedge.
 163            System.Diagnostics.Debug.Assert(_region >= 0);
 668164            VisitTriangle(new FixedTriangle(segment.Start, segment.End, segment.End), prismOffsets, boundary: true);
 165        }
 1335166    }
 167
 168    internal bool IntersectsSupport(FixedSegment segment, ReadOnlySpan<Vector2d> prismOffsets)
 169    {
 6074170        Span<ulong> values = stackalloc ulong[SelectionWords];
 6074171        Span<sbyte> signs = stackalloc sbyte[FiniteSlabRaySelection.SignCount];
 6074172        var maximum = new FiniteSlabRaySelection(values, signs, _fieldWords);
 6074173        FiniteSlabRayExtrema.AccumulateTriangle(_frame, new FixedTriangle(segment.Start, segment.End, segment.End),
 6074174            prismOffsets, _orientation, ref maximum);
 6074175        return maximum.HasValue && maximum.CompareDepth(BorrowPeak()) == 0;
 176    }
 177
 178    private bool VisitTriangle(FixedTriangle triangle, ReadOnlySpan<Vector2d> prismOffsets, bool boundary = false)
 179    {
 5348180        Span<ulong> values = stackalloc ulong[SelectionWords];
 5348181        Span<sbyte> signs = stackalloc sbyte[FiniteSlabRaySelection.SignCount];
 5348182        var maximum = new FiniteSlabRaySelection(values, signs, _fieldWords);
 5348183        if (!boundary)
 4680184            FiniteSlabRayExtrema.AccumulatePhysicalSupportTriangle(_frame, triangle, prismOffsets, _orientation, ref max
 185        else
 668186            FiniteSlabRayExtrema.AccumulateTriangle(_frame, triangle, prismOffsets, _orientation, ref maximum, _visitor)
 5348187        return maximum.HasValue && maximum.CompareDepth(BorrowPeak()) == 0;
 188    }
 189
 190    private void VisitPlane(ReadOnlySpan<Vector2d> prismOffsets, FiniteSlabRayCandidateVisitor? visitor = null)
 191    {
 9286192        Span<ulong> values = stackalloc ulong[SelectionWords];
 9286193        Span<sbyte> signs = stackalloc sbyte[FiniteSlabRaySelection.SignCount];
 9286194        var maximum = new FiniteSlabRaySelection(values, signs, _fieldWords);
 9286195        FiniteSlabRayExtrema.AccumulatePlane(_frame, prismOffsets, _orientation, ref maximum, visitor ?? _visitor);
 9286196    }
 197
 198    private void AdmitPoint(scoped in FiniteSlabRaySelection candidate)
 199    {
 200        // A finite-domain ray maximum below the intrinsic peak is controlled by
 201        // a rim, whose real normal belongs to perimeter response, not this face.
 53373202        if (_intrinsicOnly && candidate.Metadata.DomainEdgeMask != 0
 57175203            || !_hasPlaneSamples && candidate.CompareDepth(BorrowPeak()) != 0) return;
 56206204        if (_member >= 0 && _completeSupports[_joined.FindResponseComponent(_member)] && !ContainsSupportPoint(candidate
 42936205        bool represented = candidate.TryGetContactAnchor(_frame, out Fixed64 depth, out bool clamped,
 42936206            out Vector3d point, out FixedPointAnchor exit);
 207        System.Diagnostics.Debug.Assert(represented);
 42936208        Vector3d authored = point;
 42936209        if (_member >= 0 || _frame.Section.RadialFrame.ShapeFrame.HasExactScale)
 210        {
 31612211            bool rounded = candidate.TryGetSourcePointInSamplingFrame(_frame, out point);
 212            System.Diagnostics.Debug.Assert(rounded);
 213        }
 42936214        var sample = new Sample(_region, point, exit, depth, clamped, _member, authored);
 215283215        foreach (Sample retained in _events.AsReadOnlySpan())
 69252216            if (retained.Region == _region && ComparePoints(sample, retained) == 0) return;
 39905217        _events.Add(sample);
 39905218    }
 219
 220    internal void AppendContacts(LSMeshCollider collider, int surfaceTriangle,
 221        ContactManifold manifold, int namespace3D, int namespace2D, PhysicsMaterial targetMaterial)
 222    {
 2492223        collider.Mesh.GetGeometryTriangleVertices(surfaceTriangle, out Vector3d a, out Vector3d b, out Vector3d c);
 2492224        var metrics = _frame.Section.RadialFrame.ShapeFrame.HasExactScale
 2492225            ? new WidePlaneMetrics(new FixedTriangle(a, b, c), collider.Mesh.GeometryFrame)
 2492226            : new WidePlaneMetrics(new FixedTriangle(a, b, c), FixedQuaternion.Identity);
 2492227        int surface = collider.Mesh.GetCanonicalSurfaceOrdinal(surfaceTriangle);
 2492228        Span<int> chosen = stackalloc int[ContactManifold.MaxContactsPerGroup];
 9874229        for (int region = 0; region < RegionCount; region++)
 230        {
 2445231            int count = ReduceSamples(region, _events.AsReadOnlySpan(), metrics, _supportDimension, chosen);
 2445232            var group = new ContactGroupKey(namespace3D, namespace2D, surface, 0, region);
 19522233            for (int slot = 0; slot < count; slot++)
 234            {
 7316235                Sample sample = _pool[chosen[slot]];
 7316236                FixedPointAnchor source = _frame.Section.RadialFrame.ShapeFrame.HasExactScale
 7316237                    ? new FixedPointAnchor(_frame.Center, FixedQuaternion.Identity, sample.Point)
 7316238                    : new FixedPointAnchor(_frame.Origin, _frame.Rotation, sample.Point);
 7316239                manifold.AddContact(new ContactAnchor(source),
 7316240                    new ContactAnchor(sample.Exit), sample.Depth, _frame.GetNormal(_orientation),
 7316241                    collider.Material, targetMaterial, sample.Clamped,
 7316242                    featureNamespaceA: namespace3D, featureNamespaceB: namespace2D, group: group);
 243            }
 244        }
 2492245    }
 246
 247    private int ReduceSamples(int region, ReadOnlySpan<Sample> events, WidePlaneMetrics metrics, int dimension, Span<int
 248    {
 10218249        _pool.FastClear();
 102676250        foreach (Sample sample in events)
 251        {
 41120252            if (sample.Region != region) continue;
 40844253            bool duplicate = false;
 284777254            foreach (Sample retained in _pool.AsReadOnlySpan()) if (ComparePoints(sample, retained) == 0) { duplicate = 
 81120255            if (!duplicate) _pool.Add(sample);
 256        }
 257        // Every nonempty support region retains an intrinsic pole or a real boundary endpoint.
 258        System.Diagnostics.Debug.Assert(_pool.Count > 0);
 10218259        _pool.SortInPlace(PointComparer);
 10218260        int count = dimension == 0 ? 1 : dimension == 1 ? Math.Min(2, _pool.Count)
 10218261            : Math.Min(ContactManifold.MaxContactsPerGroup, _pool.Count);
 262        // Retaining every point needs no geometric ranking; the manifold
 263        // publishes the same set in stable anchor order regardless of insertion.
 10218264        if (count == _pool.Count)
 265        {
 75761266            for (int slot = 0; slot < count; slot++) chosen[slot] = slot;
 6202267            return count;
 268        }
 269        // Normal velocity and wrench are affine along a genuine support line.
 5468270        if (dimension <= 1) { chosen[0] = 0; chosen[1] = _pool.Count - 1; }
 271        else
 272        {
 3290273            chosen[0] = 0;
 36190274            for (int slot = 1; slot < count; slot++) chosen[slot] = MeshPlaneSampleReduction.ChooseNext(_pool.AsReadOnly
 275        }
 4016276        return count;
 277    }
 278
 279    private FiniteSlabRaySelection BorrowPeak()
 280    {
 81056281        int index = _member + 1;
 81056282        var result = new FiniteSlabRaySelection(_values.AsSpan(index * SelectionWords, SelectionWords),
 81056283            _signs.AsSpan(index * FiniteSlabRaySelection.SignCount, FiniteSlabRaySelection.SignCount), _fieldWords);
 162112284        result.Restore(_peaks[index]); return result;
 285    }
 286
 287    private static int ComparePoints(Sample first, Sample second)
 288    {
 188994289        int order = first.Point.X.CompareTo(second.Point.X);
 266492290        if (order == 0) order = first.Point.Y.CompareTo(second.Point.Y);
 250441291        if (order == 0) order = first.Point.Z.CompareTo(second.Point.Z);
 188994292        return order != 0 ? order : first.Exit.CompareLocalFeature(second.Exit);
 293    }
 294
 295    private readonly struct Sample : IPlaneContactSample
 296    {
 297        internal readonly int Region;
 298        internal readonly FixedPointAnchor Exit;
 299        internal readonly Fixed64 Depth;
 300        internal readonly bool Clamped;
 301        internal readonly int Member;
 302        internal readonly Vector3d Authored;
 303        public Vector3d Point { get; }
 304        internal Sample(int region, Vector3d point, FixedPointAnchor exit, Fixed64 depth, bool clamped, int member = -1,
 870192305        { Region = region; Point = point; Exit = exit; Depth = depth; Clamped = clamped; Member = member; Authored = aut
 65838306        internal Sample WithRegion(int region) => new(region, Point, Exit, Depth, Clamped, Member, Authored);
 307    }
 308}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/Mesh/FaceRegions/MeshSlabFaceRegions.Joined.cs

#LineLine coverage
 1//=======================================================================
 2// MeshSlabFaceRegions.Joined.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 Gravitas.Materials;
 13using SwiftCollections;
 14using SwiftCollections.Query;
 15using Member = Gravitas.CollisionHandling.Member<FixedMathSharp.Geometry.FiniteSlabRayFrame>;
 16
 17namespace Gravitas.CollisionHandling;
 18
 19/// <content>Combines native finite extrusion supports across declared surface members.</content>
 20internal sealed partial class MeshSlabFaceRegions
 21{
 22    private MeshJoinedSurfaceRegions<FiniteSlabRayFrame> _joined = null!;
 23
 1033224    private readonly SwiftList<Sample> _joinedEvents = new();
 1033225    private readonly MeshSurfaceConnectivity _boundaryConnectivity = new();
 1033226    private Vector2d[] _boxOffsets = new Vector2d[4];
 3099627    private int[] _memberCounts = Array.Empty<int>(), _orientations = Array.Empty<int>(), _dimensions = Array.Empty<int>
 1033228    private bool[] _completeSupports = Array.Empty<bool>();
 1033229    private int _member = -1, _otherMember;
 30    private FixedBoundVolume _slabBounds;
 31    private FiniteSlabRayCandidateVisitor? _joinVisitor;
 32    private FiniteSlabRayCandidateVisitor? _convexSupportVisitor;
 33    private bool _convexSupportCovered;
 34    internal ReadOnlyMemory<Vector2d> PrismOffsets { get; private set; }
 108635    internal int SourceId => _member < 0 ? 0 : _joined.Members[_member].Collider.Id + 1;
 108636    internal int SourceOrder => _member < 0 ? 0 : ((IPhysicsColliderRegistryItem)_joined.Members[_member].Collider).Repl
 37
 58438    internal void ReleaseJoined() { _joined = null!; _member = -1; _joinedEvents.FastClear(); }
 39
 40    internal void BuildJoined(ReadOnlySpan<(LSMeshCollider Collider, int Triangle)> sources,
 41        LSCollider mover, Fixed64 radius, Fixed64 halfThickness, Vector2d halfFootprint,
 42        ReadOnlySpan<PhysicsMesh> meshes, SwiftDictionary<(PhysicsMesh, int), MeshSurfaceBoundaryDomain> boundaries)
 43    {
 551744        Span<Vector2d> offsets = stackalloc Vector2d[4];
 551745        if (halfFootprint != Vector2d.Zero)
 46        {
 554447            offsets[0] = -halfFootprint; offsets[1] = new(halfFootprint.X, -halfFootprint.Y);
 554448            offsets[2] = halfFootprint; offsets[3] = new(-halfFootprint.X, halfFootprint.Y);
 49        }
 551750        BuildJoined(sources, mover.Center, mover.Rotation, Fixed64.Zero, radius, halfThickness,
 551751            halfFootprint == Vector2d.Zero ? ReadOnlySpan<Vector2d>.Empty : offsets,
 551752            new(mover.BoundsMin, mover.BoundsMax), mover is LSCylinderCollider, meshes, boundaries);
 551753    }
 54
 55    internal void BuildJoined(ReadOnlySpan<(LSMeshCollider Collider, int Triangle)> sources,
 56        Vector3d center, FixedQuaternion rotation, Fixed64 length, Fixed64 radius, Fixed64 halfThickness,
 57        ReadOnlySpan<Vector2d> offsets, FixedBoundVolume bounds, bool fullHeight,
 58        ReadOnlySpan<PhysicsMesh> meshes, SwiftDictionary<(PhysicsMesh, int), MeshSurfaceBoundaryDomain> boundaries)
 59    {
 737760        _slabBounds = bounds;
 737961        if (_boxOffsets.Length < offsets.Length) Array.Resize(ref _boxOffsets, offsets.Length);
 737762        offsets.CopyTo(_boxOffsets);
 737763        PrismOffsets = _boxOffsets.AsMemory(0, offsets.Length);
 737764        _joined ??= new();
 1475465        _joined.Prepare(sources, meshes, boundaries); _joinedEvents.FastClear();
 737766        if (_memberCounts.Length < _joined.Inputs.Count)
 67        {
 16268            Array.Resize(ref _memberCounts, _joined.Inputs.Count);
 32469            Array.Resize(ref _orientations, _joined.Inputs.Count); Array.Resize(ref _dimensions, _joined.Inputs.Count);
 16270            Array.Resize(ref _completeSupports, _joined.Inputs.Count);
 71        }
 737772        _joined.PrepareResponseComponents();
 4182473        for (int index = 0; index < _joined.Inputs.Count; index++)
 2707074        { _memberCounts[index] = 0; _completeSupports[index] = true; }
 4182475        for (int index = 0; index < _joined.Inputs.Count; index++)
 76        {
 2707077            Member member = _joined.Members[index]; PhysicsMesh mesh = member.Collider.Mesh;
 1353578            mesh.GetGeometryTriangleVertices(member.Triangle, out Vector3d a, out Vector3d b, out Vector3d c);
 1353579            member.Frame = new(new FixedTriangle(a, b, c), mesh.GeometryFrame,
 1353580                center, rotation, length, radius, halfThickness, fullHeight: fullHeight);
 2707081            member.Admitted.FastClear(); member.Collider.GetTrianglesInBounds(bounds, _joined.Candidates);
 6483482            foreach (int triangle in _joined.Candidates.AsReadOnlySpan())
 83            {
 1888284                if (mesh.GetManifoldSurfaceOwner(triangle) != member.Owner) continue;
 1886285                mesh.GetGeometryTriangleVertices(triangle, out a, out b, out c);
 2827086                if (member.Frame.Section.IntersectsTriangle(new FixedTriangle(a, b, c), PrismOffsets.Span)) member.Admit
 87            }
 2270488            if (member.Admitted.Count > 0) _joined.AddAdmittedMember(index);
 89        }
 737790        bool wideBanks = false;
 4182491        foreach (Member member in _joined.Members.AsReadOnlySpan()[.._joined.Inputs.Count])
 92        {
 1353593            wideBanks |= member.Frame.UsesWideBanks;
 18978194            foreach (var span in member.Boundary.Spans) wideBanks |= span.Interval.HasWideBounds;
 95        }
 737796        if (wideBanks)
 3097            foreach (Member member in _joined.Members.AsReadOnlySpan()[.._joined.Inputs.Count])
 1098                member.Frame = member.Frame.WithWideParameters();
 737799        CertifyCompleteSupports();
 41824100        for (int index = 0; index < _joined.Inputs.Count; index++)
 101        {
 13535102            Member member = _joined.Members[index];
 103            // Only an actually intersected coplanar component owns response.
 104            // The carrier's pair remains an ordinary, genuine overlap; samples
 105            // keep their own finite supplier, material and provenance.
 13591106            if (_joined.GetResponseMember(index) < 0) { _joined.AddRegions(index, 0); continue; }
 13507107            PhysicsMesh mesh = member.Collider.Mesh;
 20387108            if (_completeSupports[_joined.FindResponseComponent(index)] && member.Admitted.Count == 0) { _joined.AddRegi
 10067109            if (!CanReachSupport(member.Frame, mesh, member.Collider.Bounds))
 1438110            { _joined.AddRegions(index, 0); continue; }
 9348111            member.Connectivity.BuildSlab(mesh, member.Triangle, member.Frame.Section, PrismOffsets, member.Admitted.AsR
 18696112            _member = index; PrepareFrame(member.Frame, PrismOffsets.Span);
 18696113            _orientations[index] = _orientation; _dimensions[index] = _supportDimension;
 9348114            if (_completeSupports[_joined.FindResponseComponent(index)])
 115            {
 22185116                _events.FastClear(); _region = 0; _intrinsicOnly = _usesSupportGraph = false;
 117                // An admitted member without a pole still connects neighboring
 118                // suppliers through the shared finite span graph.
 7395119                RegionCount = 1;
 7395120                VisitPlane(PrismOffsets.Span);
 121            }
 2514122            else if (!TryUseConvexSupport(mesh, member.Triangle)) Build(mesh, member.Triangle, member.Connectivity, Pris
 561123                member.Admitted.Count > 0 && ContainsSection(mesh, member.Triangle, member.Frame, PrismOffsets.Span));
 18696124            _memberCounts[index] = RegionCount; _joined.AddRegions(index, RegionCount);
 111711125            foreach (Sample sample in _events.AsReadOnlySpan()) _joinedEvents.Add(sample.WithRegion(member.Offset + samp
 126        }
 14754127        JoinSupportSpans(); _joined.CompleteRegions();
 7377128        RegionCount = _joined.Roots.Count;
 76764129        for (int index = 0; index < _joinedEvents.Count; index++)
 130        {
 31005131            Sample sample = _joinedEvents[index];
 31005132            _joinedEvents[index] = sample.WithRegion(_joined.RegionByRoot[_joined.Find(sample.Region)]);
 133        }
 7377134        _joined.Commit();
 7377135    }
 136
 137    private bool TryUseConvexSupport(PhysicsMesh mesh, int triangle)
 138    {
 139        // A nonaxial extrusion support is a point, segment or rectangle. Its
 140        // exact extremes inside one convex fill certify the entire support.
 141        // Axial disk caps need the existing perimeter proof, not sampled poles.
 1953142        if (mesh.GetConvexCoplanarPatchCornerVertexIndices(triangle).IsEmpty
 2019143            || _frame.Plane.Normal.X.IsZero && _frame.Plane.Normal.Z.IsZero) return false;
 5661144        _events.FastClear(); _region = 0; _intrinsicOnly = _usesSupportGraph = false;
 1887145        _convexSupportCovered = true;
 1887146        _convexSupportVisitor ??= AdmitConvexSupport;
 1887147        VisitPlane(PrismOffsets.Span, _convexSupportVisitor);
 2877148        if (!_convexSupportCovered || _events.Count == 0) { _events.FastClear(); return false; }
 1392149        RegionCount = 1;
 1392150        return true;
 151    }
 152
 153    private void AdmitConvexSupport(scoped in FiniteSlabRaySelection candidate)
 154    {
 4960155        if (candidate.CompareDepth(BorrowPeak()) != 0) return;
 4634156        Member member = _joined.Members[_member];
 4634157        PhysicsMesh mesh = member.Collider.Mesh;
 4634158        ReadOnlySpan<int> corners = mesh.GetConvexCoplanarPatchCornerVertexIndices(member.Triangle);
 4634159        ReadOnlySpan<Vector3d> vertices = mesh.GeometryVertices;
 16824160        for (int corner = 1; corner < corners.Length - 1; corner++)
 7487161            if (candidate.ContainsTrianglePoint(member.Frame,
 7487162                new(vertices[corners[0]], vertices[corners[corner]], vertices[corners[corner + 1]]), member.Frame))
 7418163            { AdmitPoint(candidate); return; }
 925164        _convexSupportCovered = false;
 925165    }
 166
 167    private void CertifyCompleteSupports()
 168    {
 41824169        for (int index = 0; index < _joined.Inputs.Count; index++)
 170        {
 27070171            Member member = _joined.Members[index]; int component = _joined.FindResponseComponent(index);
 13535172            if (!_completeSupports[component]) continue;
 12394173            if (!member.BoundaryTrusted || !member.Frame.Plane.Normal.X.IsZero || !member.Frame.Plane.Normal.Z.IsZero)
 3064174            { _completeSupports[component] = false; continue; }
 175            // For an axial cap the support footprint equals the original
 176            // convex section. One filled point and no real perimeter crossing
 177            // certify complete fill, including exclusion of enclosed holes.
 108594178            for (int span = 0; span < member.Boundary.Spans.Length; span++)
 179            {
 43452180                var edge = member.Boundary.Spans[span];
 43452181                if (!member.JoinedSpans[span] && member.Frame.Section.IntersectsSegment(new FixedSegment(edge.Start, edg
 34182                { _completeSupports[component] = false; break; }
 183            }
 184        }
 7377185    }
 186
 187    private bool ContainsSupportPoint(scoped in FiniteSlabRaySelection candidate)
 188    {
 33680189        Member member = _joined.Members[_member];
 107791190        foreach (int triangle in member.Admitted.AsReadOnlySpan())
 191        {
 33738192            member.Collider.Mesh.GetGeometryTriangleVertices(triangle, out Vector3d a, out Vector3d b, out Vector3d c);
 60783193            if (candidate.ContainsTrianglePoint(member.Frame, new(a, b, c), member.Frame)) return true;
 194        }
 6635195        return false;
 196    }
 197
 198    private void GatherJoinedBoundary(PhysicsMesh mesh, int triangle, MeshSurfaceConnectivity connectivity)
 199    {
 261200        Member member = _joined.Members[_member];
 261201        Span<ulong> values = stackalloc ulong[SelectionWords];
 261202        Span<sbyte> signs = stackalloc sbyte[FiniteSlabRaySelection.SignCount];
 2780203        for (int span = 0; span < member.Boundary.Spans.Length; span++)
 204        {
 1129205            var piece = member.Boundary.Spans[span];
 1129206            if (member.JoinedSpans[span]) continue;
 853207            FixedBoundBox bounds = mesh.GeometryFrame.GetWorldBounds(Vector3d.Min(piece.Start, piece.End),
 853208                Vector3d.Max(piece.Start, piece.End));
 853209            if (!CanReachSupport(member.Frame, mesh, bounds)) continue;
 93210            RationalSegmentInterval clip = member.GetRetainedInterval(ref span);
 93211            _region = _usesSupportGraph ? MeshSurfaceBoundaryTopology.FindSupportEdgeRegion(mesh, member.Owner,
 93212                piece.First, piece.Second, connectivity, this, null) : 0;
 93213            if (_region < 0) continue;
 85214            var maximum = new FiniteSlabRaySelection(values, signs, _fieldWords);
 85215            FiniteSlabRayExtrema.AccumulateSegment(_frame, new FixedSegment(piece.Start, piece.End), clip,
 85216                PrismOffsets.Span, _orientation, ref maximum, _visitor);
 217        }
 261218    }
 219
 220    private bool CanReachSupport(in FiniteSlabRayFrame frame, PhysicsMesh mesh, FixedBoundBox bounds)
 221    {
 222        // Translation along the exact plane normal leaves its zero components
 223        // unchanged. Disjoint outward bounds on those axes cannot supply support.
 10920224        WideDirection3d normal = new WideDirection3d(frame.Plane.AuthoredNormal).Transform(mesh.GeometryFrame.GeometryBa
 10920225        return (!normal.X.IsZero || bounds.Max.X >= _slabBounds.Min.X && bounds.Min.X <= _slabBounds.Max.X)
 10920226            && (!normal.Y.IsZero || bounds.Max.Y >= _slabBounds.Min.Y && bounds.Min.Y <= _slabBounds.Max.Y)
 10920227            && (!normal.Z.IsZero || bounds.Max.Z >= _slabBounds.Min.Z && bounds.Min.Z <= _slabBounds.Max.Z);
 228    }
 229
 230    private void SelectJoinedMember(int index)
 231    {
 37362232        _member = index; _frame = _joined.Members[index].Frame;
 18681233        _fieldWords = _frame.FieldWords;
 37362234        _orientation = _orientations[index]; _supportDimension = _dimensions[index];
 18681235    }
 236
 237    private void JoinSupportSpans()
 238    {
 7377239        _joinVisitor ??= JoinAtSupportPoint;
 7377240        Span<ulong> values = stackalloc ulong[SelectionWords];
 7377241        Span<sbyte> signs = stackalloc sbyte[FiniteSlabRaySelection.SignCount];
 41824242        for (int index = 0; index < _joined.Inputs.Count; index++)
 243        {
 13535244            if (_memberCounts[index] == 0) continue;
 18104245            SelectJoinedMember(index); Member member = _joined.Members[index];
 90698246            for (int span = 0; span < member.Boundary.Spans.Length; span++)
 247            {
 36297248                if (!member.JoinedSpans[span]) continue;
 7836249                var edge = member.Boundary.Spans[span];
 7836250                _otherMember = _joined.MemberBySurface[(_joined.Meshes[edge.OtherMember], edge.OtherSurface)];
 7836251                if (_memberCounts[_otherMember] == 0) continue;
 3406252                var maximum = new FiniteSlabRaySelection(values, signs, _fieldWords);
 3406253                FiniteSlabRayExtrema.AccumulateSegment(_frame, new FixedSegment(edge.Start, edge.End), edge.Interval,
 3406254                    PrismOffsets.Span, _orientation, ref maximum, _joinVisitor);
 255            }
 256        }
 7377257    }
 258
 259    private void JoinAtSupportPoint(scoped in FiniteSlabRaySelection candidate)
 260    {
 13830261        if (candidate.CompareDepth(BorrowPeak()) != 0) return;
 27500262        Member first = _joined.Members[_member], second = _joined.Members[_otherMember];
 13750263        if (_memberCounts[_member] == 1 && _memberCounts[_otherMember] == 1)
 264        {
 13606265            _joined.Union(first.Offset, second.Offset);
 13606266            return;
 267        }
 268        // The certified joined span already lies in both finite owners. A
 269        // unique support region needs no initial-section triangle lookup:
 270        // oblique support projections can lie outside that initial section.
 144271        Span<int> singleton = stackalloc int[1] { -1 };
 144272        ReadOnlySpan<int> firstDomain = _memberCounts[_member] == 1 ? singleton : first.Connectivity.TriangleIndices;
 144273        ReadOnlySpan<int> secondDomain = _memberCounts[_otherMember] == 1 ? singleton : second.Connectivity.TriangleIndi
 1108274        foreach (int a in firstDomain)
 275        {
 410276            if (a >= 0)
 277            {
 378278                first.Collider.Mesh.GetGeometryTriangleVertices(a, out Vector3d aa, out Vector3d ab, out Vector3d ac);
 378279                if (!candidate.ContainsTrianglePoint(first.Frame, new(aa, ab, ac), _frame)) continue;
 280            }
 1304281            foreach (int b in secondDomain)
 282            {
 486283                if (b >= 0)
 284                {
 454285                    second.Collider.Mesh.GetGeometryTriangleVertices(b, out Vector3d ba, out Vector3d bb, out Vector3d b
 454286                    if (!candidate.ContainsTrianglePoint(second.Frame, new(ba, bb, bc), _frame)) continue;
 287                }
 192288                _joined.Union(first.Offset + (a < 0 ? 0 : first.Connectivity.GetRegionOrdinal(a)),
 192289                    second.Offset + (b < 0 ? 0 : second.Connectivity.GetRegionOrdinal(b)));
 290            }
 291        }
 144292    }
 293
 294    internal bool AppendJoinedContacts(LSMeshCollider collider, PhysicsMaterial material, MeshSlabSurfaceBoundary bounda
 295        ContactManifold manifold, LSCollider2D? embedded = null, int namespace3D = 0, int namespace2D = 0)
 296    {
 9801297        Span<int> chosen = stackalloc int[ContactManifold.MaxContactsPerGroup];
 39180298        for (int region = 0; region < _joined.Roots.Count; region++)
 299        {
 9789300            int rootMember = _joined.NodeMembers[_joined.Roots[region]];
 9789301            Member root = _joined.Members[rootMember];
 9789302            if (_joined.Members[_joined.GetResponseMember(rootMember)].Collider != collider) continue;
 7773303            int count = ReduceSamples(region, _joinedEvents.AsReadOnlySpan(),
 7773304                new WidePlaneMetrics(root.Frame.SourcePlane, root.Collider.Mesh.GeometryFrame), _dimensions[rootMember],
 72376305            for (int index = 0; index < count; index++)
 306            {
 56830307                Sample sample = _pool[chosen[index]]; Member supplier = _joined.Members[sample.Member];
 28415308                manifold.AddContact(new ContactAnchor(new FixedPointAnchor(supplier.Frame.Center, FixedQuaternion.Identi
 28415309                    new ContactAnchor(sample.Exit), sample.Depth, root.Frame.GetNormal(_orientations[rootMember]), suppl
 28415310                    material, sample.Clamped, featureNamespaceA: namespace3D, featureNamespaceB: namespace2D,
 28415311                    group: new ContactGroupKey(namespace3D, namespace2D, supplier.Owner + 1, 0, region, sourceIdA: suppl
 28415312                        sourceOrderA: ((IPhysicsColliderRegistryItem)supplier.Collider).ReplayOrder + 1));
 313            }
 314        }
 9801315        bool overlaps = false;
 55944316        for (int member = 0; member < _joined.Inputs.Count; member++)
 317        {
 18171318            Member source = _joined.Members[member];
 18171319            if (source.Admitted.Count == 0) continue;
 13495320            overlaps |= source.Collider == collider;
 13495321            if (_joined.Members[_joined.GetResponseMember(member)].Collider != collider) continue;
 9629322            SelectJoinedMember(member);
 323            // Keep the component's face and perimeter rows in one solver pass;
 324            // otherwise matching normals receive positional correction twice.
 9629325            _boundaryConnectivity.BuildSlab(source.Collider.Mesh, source.Triangle, source.Frame.Section, PrismOffsets, s
 9629326            boundary.BuildSurfaceContacts(source.Collider, embedded, source.Triangle, _boundaryConnectivity, this,
 9629327                manifold, namespace3D, namespace2D, material);
 328        }
 9801329        return overlaps;
 330    }
 331
 11017332    internal MeshSurfaceBoundaryDomain? JoinedBoundary => _member < 0 ? null : _joined.Members[_member].Boundary;
 38612333    internal bool IsJoinedSpan(int span) => _joined.Members[_member].JoinedSpans[span];
 224334    internal RationalSegmentInterval GetRetainedInterval(ref int span) => _joined.Members[_member].GetRetainedInterval(r
 335    internal ReadOnlySpan<WideAxis3> GetJoinedCornerFan(LSMeshCollider collider, int triangle, int vertex, out bool supp
 192336        _joined.GetCornerFan(collider, triangle, vertex, out suppress);
 337
 338    internal bool TryGetContinuousFamily(in ContactGroupKey group, out LSMeshCollider supplier, out int owner)
 339    {
 248340        supplier = null!; owner = -1;
 341        System.Diagnostics.Debug.Assert(_joined != null && _joined.Active);
 342        // This producer's nonnegative regions are native face groups. Boundary
 343        // groups use negative regions and different surface ordinals.
 125344        if (group.Region < 0 || group.Region >= _joined.Roots.Count) return false;
 340345        for (int index = 0; index < _joined.Inputs.Count; index++)
 346        {
 168347            Member member = _joined.Members[index];
 168348            if (member.Collider.Id + 1 != group.SourceIdA || member.Owner + 1 != group.SurfaceA) continue;
 121349            int rootMember = _joined.NodeMembers[_joined.Roots[group.Region]];
 122350            if (_joined.FindResponseComponent(index) != _joined.FindResponseComponent(rootMember)) return false;
 360351            supplier = member.Collider; owner = member.Owner; return true;
 352        }
 2353        return false;
 354    }
 355
 356    internal bool IsSameContinuousFamily(LSMeshCollider collider, int owner, LSMeshCollider supplier, int supplierOwner)
 357    {
 358        System.Diagnostics.Debug.Assert(_joined != null && _joined.Active);
 412359        if (!_joined.MemberBySurface.TryGetValue((collider.Mesh, owner), out int member)
 468360            || !_joined.MemberBySurface.TryGetValue((supplier.Mesh, supplierOwner), out int resolved)) return false;
 361        // The caller's handoff is phase-local and callback-free. Prepare owns
 362        // cross-step geometry/lifetime validation; missing local owners stay unknown.
 356363        return _joined.FindResponseComponent(member) == _joined.FindResponseComponent(resolved);
 364    }
 365
 366    internal bool IntersectsContinuousBoundary(LSMeshCollider collider, int owner, in FiniteSlabSectionFrame section)
 367    {
 278368        Member member = _joined.Members[_joined.MemberBySurface[(collider.Mesh, owner)]];
 278369        ReadOnlySpan<BoundarySpan3D> pieces = member.Boundary.Spans;
 2726370        for (int span = 0; span < pieces.Length; span++)
 371        {
 1168372            if (member.JoinedSpans[span]) continue;
 960373            var piece = pieces[span];
 960374            RationalSegmentInterval clip = member.GetRetainedInterval(ref span);
 1043375            if (section.IntersectsSegment(new FixedSegment(piece.Start, piece.End), clip)) return true;
 376        }
 195377        return false;
 378    }
 379}

Methods/Properties

.ctor()
.cctor()
get_SelectionWords()
get_Orientation()
get_Frame()
Prepare(FixedMathSharp.Geometry.FiniteSlabRayFrame&,System.ReadOnlySpan`1<FixedMathSharp.Vector2d>,System.Boolean)
PrepareFrame(FixedMathSharp.Geometry.FiniteSlabRayFrame&,System.ReadOnlySpan`1<FixedMathSharp.Vector2d>,System.Boolean)
ContainsSection(Gravitas.Colliders.PhysicsMesh,System.Int32,FixedMathSharp.Geometry.FiniteSlabRayFrame&,System.ReadOnlySpan`1<FixedMathSharp.Vector2d>)
Build(Gravitas.Colliders.PhysicsMesh,System.Int32,Gravitas.CollisionHandling.MeshSurfaceConnectivity,System.ReadOnlySpan`1<FixedMathSharp.Vector2d>,Gravitas.Colliders.LSCollider2D,System.Boolean)
IntersectsSupport(FixedMathSharp.Geometry.FixedSegment,System.ReadOnlySpan`1<FixedMathSharp.Vector2d>)
VisitTriangle(FixedMathSharp.Geometry.FixedTriangle,System.ReadOnlySpan`1<FixedMathSharp.Vector2d>,System.Boolean)
VisitPlane(System.ReadOnlySpan`1<FixedMathSharp.Vector2d>,FixedMathSharp.Geometry.FiniteSlabRayCandidateVisitor)
AdmitPoint(FixedMathSharp.Geometry.FiniteSlabRaySelection&)
AppendContacts(Gravitas.Colliders.LSMeshCollider,System.Int32,Gravitas.CollisionHandling.ContactManifold,System.Int32,System.Int32,Gravitas.Materials.PhysicsMaterial)
ReduceSamples(System.Int32,System.ReadOnlySpan`1<Gravitas.CollisionHandling.MeshSlabFaceRegions/Sample>,FixedMathSharp.Geometry.WidePlaneMetrics,System.Int32,System.Span`1<System.Int32>)
BorrowPeak()
ComparePoints(Gravitas.CollisionHandling.MeshSlabFaceRegions/Sample,Gravitas.CollisionHandling.MeshSlabFaceRegions/Sample)
.ctor(System.Int32,FixedMathSharp.Vector3d,FixedMathSharp.Geometry.FixedPointAnchor,FixedMathSharp.Fixed64,System.Boolean,System.Int32,FixedMathSharp.Vector3d)
WithRegion(System.Int32)
.ctor()
get_SourceId()
get_SourceOrder()
ReleaseJoined()
BuildJoined(System.ReadOnlySpan`1<System.ValueTuple`2<Gravitas.Colliders.LSMeshCollider,System.Int32>>,Gravitas.Colliders.LSCollider,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,System.ReadOnlySpan`1<Gravitas.Colliders.PhysicsMesh>,SwiftCollections.SwiftDictionary`2<System.ValueTuple`2<Gravitas.Colliders.PhysicsMesh,System.Int32>,Gravitas.CollisionHandling.MeshSurfaceBoundaryDomain>)
BuildJoined(System.ReadOnlySpan`1<System.ValueTuple`2<Gravitas.Colliders.LSMeshCollider,System.Int32>>,FixedMathSharp.Vector3d,FixedMathSharp.FixedQuaternion,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,System.ReadOnlySpan`1<FixedMathSharp.Vector2d>,SwiftCollections.Query.FixedBoundVolume,System.Boolean,System.ReadOnlySpan`1<Gravitas.Colliders.PhysicsMesh>,SwiftCollections.SwiftDictionary`2<System.ValueTuple`2<Gravitas.Colliders.PhysicsMesh,System.Int32>,Gravitas.CollisionHandling.MeshSurfaceBoundaryDomain>)
TryUseConvexSupport(Gravitas.Colliders.PhysicsMesh,System.Int32)
AdmitConvexSupport(FixedMathSharp.Geometry.FiniteSlabRaySelection&)
CertifyCompleteSupports()
ContainsSupportPoint(FixedMathSharp.Geometry.FiniteSlabRaySelection&)
GatherJoinedBoundary(Gravitas.Colliders.PhysicsMesh,System.Int32,Gravitas.CollisionHandling.MeshSurfaceConnectivity)
CanReachSupport(FixedMathSharp.Geometry.FiniteSlabRayFrame&,Gravitas.Colliders.PhysicsMesh,FixedMathSharp.Geometry.FixedBoundBox)
SelectJoinedMember(System.Int32)
JoinSupportSpans()
JoinAtSupportPoint(FixedMathSharp.Geometry.FiniteSlabRaySelection&)
AppendJoinedContacts(Gravitas.Colliders.LSMeshCollider,Gravitas.Materials.PhysicsMaterial,Gravitas.CollisionHandling.MeshSlabSurfaceBoundary,Gravitas.CollisionHandling.ContactManifold,Gravitas.Colliders.LSCollider2D,System.Int32,System.Int32)
get_JoinedBoundary()
IsJoinedSpan(System.Int32)
GetRetainedInterval(System.Int32&)
GetJoinedCornerFan(Gravitas.Colliders.LSMeshCollider,System.Int32,System.Int32,System.Boolean&)
TryGetContinuousFamily(Gravitas.CollisionHandling.ContactGroupKey&,Gravitas.Colliders.LSMeshCollider&,System.Int32&)
IsSameContinuousFamily(Gravitas.Colliders.LSMeshCollider,System.Int32,Gravitas.Colliders.LSMeshCollider,System.Int32)
IntersectsContinuousBoundary(Gravitas.Colliders.LSMeshCollider,System.Int32,FixedMathSharp.Geometry.FiniteSlabSectionFrame&)