< Summary

Information
Class: Gravitas.CollisionHandling.MeshJoinedSurfaceRegions<T>
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/Mesh/FaceRegions/MeshJoinedSurfaceRegions.cs
Line coverage
100%
Covered lines: 131
Uncovered lines: 0
Coverable lines: 131
Total lines: 230
Line coverage: 100%
Branch coverage
100%
Covered branches: 118
Total branches: 118
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%22100%
Prepare(...)100%4444100%
AddRegions(...)100%11100%
PrepareResponseComponents()100%1212100%
AddAdmittedMember(...)100%22100%
FindResponseComponent(...)100%22100%
GetResponseMember(...)100%11100%
AddRegions(...)100%22100%
Union(...)100%11100%
Find(...)100%22100%
CompleteRegions()100%44100%
Commit()100%22100%
GetEndpointFan(...)100%1616100%
GetCornerFan(...)100%3030100%

File(s)

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

#LineLine coverage
 1//=======================================================================
 2// MeshJoinedSurfaceRegions.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using System;
 9using System.Collections.Generic;
 10using FixedMathSharp;
 11using FixedMathSharp.Geometry;
 12using Gravitas.Colliders;
 13using SwiftCollections;
 14
 15namespace Gravitas.CollisionHandling;
 16
 17/// <summary>Shared source ownership and graph of exactly admitted joined surface regions.</summary>
 18internal partial class MeshJoinedSurfaceRegions<TFrame> where TFrame : struct
 19{
 46320    internal readonly SwiftList<(LSMeshCollider Collider, int Triangle)> Inputs = new();
 46321    internal readonly SwiftList<PhysicsMesh> Meshes = new();
 46322    internal readonly SwiftList<int> Candidates = new();
 46323    internal readonly SwiftList<MeshSurfaceBoundaryDomain> PreparedBoundaries = new();
 46324    internal readonly MeshSurfaceBoundaryFan Fan = new();
 46325    internal readonly SwiftDictionary<(PhysicsMesh Mesh, int Owner), int> MemberBySurface = new();
 46326    internal readonly SwiftList<Member<TFrame>> Members = new();
 185227    internal readonly SwiftList<int> Parents = new(), Roots = new(), RegionByRoot = new(), NodeMembers = new();
 92628    private int[] _responseComponents = Array.Empty<int>(), _responseMembers = Array.Empty<int>();
 46329    private readonly IComparer<(LSMeshCollider Collider, int Triangle)> _memberComparer =
 46330        Comparer<(LSMeshCollider Collider, int Triangle)>.Create(static (a, b) =>
 46331        {
 46332            int order = ((IPhysicsColliderRegistryItem)a.Collider).ReplayOrder.CompareTo(((IPhysicsColliderRegistryItem)
 46333            return order != 0 ? order : a.Triangle.CompareTo(b.Triangle);
 46334        });
 46335    internal int PreparedCount = -1;
 36    internal bool Active;
 37
 38    internal void Prepare(ReadOnlySpan<(LSMeshCollider Collider, int Triangle)> surfaces,
 39        ReadOnlySpan<PhysicsMesh> preparedMeshes,
 40        SwiftDictionary<(PhysicsMesh, int), MeshSurfaceBoundaryDomain>? prepared)
 41    {
 2150542        Active = true;
 4301043        Inputs.FastClear(); MemberBySurface.Clear();
 12526444        foreach (var input in surfaces)
 45        {
 4112746            int owner = input.Collider.Mesh.GetManifoldSurfaceOwner(input.Triangle);
 8225347            if (MemberBySurface.TryAdd((input.Collider.Mesh, owner), 0)) Inputs.Add((input.Collider, owner));
 48        }
 2150549        Inputs.SortInPlace(_memberComparer);
 2150550        bool reuse = PreparedCount == Inputs.Count;
 11991651        for (int index = 0; reuse && index < Inputs.Count; index++)
 52        {
 7690653            Member<TFrame> member = Members[index]; var input = Inputs[index];
 3845354            reuse = member.Collider == input.Collider && member.Owner == input.Triangle
 3845355                && member.PreparedLifetime == input.Collider.LifetimeVersion
 3845356                && member.PreparedVersion == input.Collider.RuntimeShapeVersion;
 57        }
 58        // Only a fully completed build publishes the reusable set.
 2150559        PreparedCount = -1;
 10752560        Meshes.FastClear(); Parents.FastClear(); Roots.FastClear(); RegionByRoot.FastClear(); NodeMembers.FastClear();
 2150561        if (prepared != null)
 33323962            foreach (PhysicsMesh mesh in preparedMeshes) Meshes.Add(mesh);
 63        else
 134264            foreach (var input in Inputs.AsReadOnlySpan())
 84965                if (Meshes.Count == 0 || Meshes[Meshes.Count - 1] != input.Collider.Mesh) Meshes.Add(input.Collider.Mesh
 2150566        PreparedBoundaries.FastClear();
 2150567        int meshIndex = -1;
 12526268        for (int index = 0; index < Inputs.Count; index++)
 69        {
 4206970            if (index == Members.Count) Members.Add(new Member<TFrame>());
 4112671            Member<TFrame> member = Members[index];
 8225272            member.Collider = Inputs[index].Collider; member.Triangle = member.Owner = Inputs[index].Triangle;
 4112673            PhysicsMesh mesh = member.Collider.Mesh;
 4112674            MemberBySurface[(mesh, member.Owner)] = index;
 8222175            if (index == 0 || Inputs[index - 1].Collider != member.Collider) meshIndex++;
 4112676            bool changed = !reuse;
 4112677            if (prepared != null)
 78            {
 4070179                MeshSurfaceBoundaryDomain boundary = prepared[(mesh, member.Owner)];
 4070180                changed |= !ReferenceEquals(member.Boundary, boundary);
 4070181                member.Boundary = boundary;
 82            }
 59983            else if (!reuse) member.Boundary.Build(Meshes.AsReadOnlySpan(), meshIndex, member.Triangle);
 4112684            if (changed)
 85            {
 269986                member.BoundaryTrusted = true;
 2781487                foreach (var span in member.Boundary.Spans)
 1140688                    if (span.Kind == SpanKind.Ambiguous) member.BoundaryTrusted = false;
 89            }
 4112690            PreparedBoundaries.Add(member.Boundary);
 4112691            if (member.JoinedSpans.Length < member.Boundary.Spans.Length)
 94592                Array.Resize(ref member.JoinedSpans, member.Boundary.Spans.Length);
 4112693            Array.Clear(member.JoinedSpans, 0, member.Boundary.Spans.Length);
 94        }
 2150595    }
 96
 97    internal void AddRegions(int index)
 1913298        => AddRegions(index, Members[index].Connectivity.RegionCount);
 99
 100    internal void PrepareResponseComponents()
 101    {
 23591102        if (_responseComponents.Length < Inputs.Count)
 103        {
 365104            Array.Resize(ref _responseComponents, Inputs.Count);
 365105            Array.Resize(ref _responseMembers, Inputs.Count);
 106        }
 134258107        for (int index = 0; index < Inputs.Count; index++)
 87076108        { _responseComponents[index] = index; _responseMembers[index] = -1; }
 109        // Geometry certifies coverage independently of finite support admission.
 110        // A covered rim stays covered even when its owner supplies no sample.
 134258111        for (int index = 0; index < Inputs.Count; index++)
 112        {
 43538113            Member<TFrame> member = Members[index];
 450220114            for (int span = 0; span < member.Boundary.Spans.Length; span++)
 115            {
 181572116                var edge = member.Boundary.Spans[span];
 117                // Coverage certifies this span independently. An ambiguous or
 118                // folded edge elsewhere still keeps its own native perimeter.
 181572119                member.JoinedSpans[span] = edge.Kind == SpanKind.Joined
 181572120                    && MemberBySurface.TryGetValue((Meshes[edge.OtherMember], edge.OtherSurface), out int other);
 181572121                if (!member.JoinedSpans[span]) continue;
 79668122                int a = FindResponseComponent(index), b = FindResponseComponent(MemberBySurface[(Meshes[edge.OtherMember
 39834123                _responseComponents[Math.Max(a, b)] = Math.Min(a, b);
 124            }
 125        }
 23591126    }
 127
 128    internal void AddAdmittedMember(int index)
 129    {
 26481130        int component = FindResponseComponent(index);
 131        // Inputs are sorted, so the first genuine overlap is the stable carrier.
 46666132        if (_responseMembers[component] < 0) _responseMembers[component] = index;
 26481133    }
 134
 135    internal int FindResponseComponent(int index)
 136    {
 456365137        while (_responseComponents[index] != index)
 237244138        { _responseComponents[index] = _responseComponents[_responseComponents[index]]; index = _responseComponents[inde
 337743139        return index;
 140    }
 141
 65157142    internal int GetResponseMember(int index) => _responseMembers[FindResponseComponent(index)];
 143
 144    internal void AddRegions(int index, int count)
 145    {
 100524146        Member<TFrame> member = Members[index]; member.Offset = Parents.Count;
 168610147        for (int region = 0; region < count; region++)
 102129148        { Parents.Add(Parents.Count); RegionByRoot.Add(-1); NodeMembers.Add(index); }
 50262149    }
 150
 151    internal void Union(int first, int second)
 152    {
 52132153        int a = Find(first), b = Find(second);
 26066154        Parents[Math.Max(a, b)] = Math.Min(a, b);
 26066155    }
 156
 157    internal int Find(int node)
 158    {
 415245159        while (Parents[node] != node) { Parents[node] = Parents[Parents[node]]; node = Parents[node]; }
 225312160        return node;
 161    }
 162
 163    internal void CompleteRegions()
 164    {
 121166165        for (int node = 0; node < Parents.Count; node++)
 166        {
 34043167            int root = Find(node);
 34043168            if (RegionByRoot[root] >= 0) continue;
 53292169            RegionByRoot[root] = Roots.Count; Roots.Add(root);
 170        }
 26540171    }
 172
 173    internal void Commit()
 174    {
 125262175        foreach (Member<TFrame> member in Members.AsReadOnlySpan()[..Inputs.Count])
 82252176        { member.PreparedVersion = member.Collider.RuntimeShapeVersion; member.PreparedLifetime = member.Collider.Lifeti
 21505177        PreparedCount = Inputs.Count;
 21505178    }
 179
 180    internal ReadOnlySpan<WideAxis3> GetEndpointFan(LSMeshCollider collider, int triangle, int span, bool upper, out boo
 181    {
 76182        Member<TFrame> member = Members[MemberBySurface[(collider.Mesh, collider.Mesh.GetManifoldSurfaceOwner(triangle))
 76183        bool trusted = Fan.BuildEndpoint(Meshes.AsReadOnlySpan(), member.Boundary, span, upper, PreparedBoundaries.AsRea
 76184        suppress = trusted && !Fan.HasExposedBoundary;
 185        // A genuine shared corner supplies one physical row in stable collider/surface order.
 76186        if (trusted)
 468187            foreach (var owner in Fan.Owners)
 161188                if (MemberBySurface.TryGetValue((Meshes[owner.Member], owner.Surface), out int other)
 161189                    && (((IPhysicsColliderRegistryItem)Members[other].Collider).ReplayOrder < ((IPhysicsColliderRegistry
 161190                        && collider.Mesh.GetCanonicalSurfaceOrdinal(owner.Surface) < collider.Mesh.GetCanonicalSurfaceOr
 40191                    suppress = true;
 76192        return trusted ? Fan.Rays : default;
 193    }
 194
 195    internal ReadOnlySpan<WideAxis3> GetCornerFan(LSMeshCollider collider, int triangle, int vertex, out bool suppress)
 196    {
 227197        Member<TFrame> member = Members[MemberBySurface[(collider.Mesh, collider.Mesh.GetManifoldSurfaceOwner(triangle))
 227198        Vector3d point = collider.Mesh.GeometryVertices[vertex];
 227199        bool trusted = Fan.BuildAtPoint(Meshes.AsReadOnlySpan(), member.Boundary.SourceMember, member.Owner,
 227200            point, PreparedBoundaries.AsReadOnlySpan());
 227201        suppress = trusted && !Fan.HasExposedBoundary;
 202        // A finite canonical-owner corner can borrow a fan only when every
 203        // incident owner's complete perimeter retains its classification.
 227204        if (trusted)
 1259205            foreach (var owner in Fan.Owners)
 408206                if (MemberBySurface.TryGetValue((Meshes[owner.Member], owner.Surface), out int incident) && !Members[inc
 2207                { suppress = false; return default; }
 226208        if (trusted)
 1254209            foreach (var owner in Fan.Owners)
 210            {
 406211                if (!MemberBySurface.TryGetValue((Meshes[owner.Member], owner.Surface), out int other)
 406212                    || ((IPhysicsColliderRegistryItem)Members[other].Collider).ReplayOrder > ((IPhysicsColliderRegistryI
 406213                    && collider.Mesh.GetCanonicalSurfaceOrdinal(owner.Surface) >= collider.Mesh.GetCanonicalSurfaceOrdin
 109214                PhysicsMesh mesh = Members[other].Collider.Mesh;
 109215                ReadOnlySpan<int> edges = mesh.GetCanonicalSurfaceBoundaryVertexPairs(owner.Surface);
 720216                for (int edge = 0; edge < edges.Length; edge += 2)
 217                {
 318218                    int location = WideTriangleRelations.LocateEdgePoint(new FixedSegment(point, point),
 318219                        collider.Mesh.GeometryFrame, default(Signed832), Signed832.ExtendValue(Signed192.Signed(1)),
 318220                        new FixedSegment(mesh.GeometryVertices[edges[edge]], mesh.GeometryVertices[edges[edge + 1]]), me
 221                    // Certified exposed/joined transitions are authored corners
 222                    // of some member. An interior-edge owner cannot supply one.
 452223                    if (location == 0 || location == 2) { suppress = true; break; }
 224                }
 225            }
 226226        return trusted ? Fan.Rays : default;
 227    }
 228
 229
 230}