< Summary

Line coverage
100%
Covered lines: 890
Uncovered lines: 0
Coverable lines: 890
Total lines: 1757
Line coverage: 100%
Branch coverage
100%
Covered branches: 470
Total branches: 470
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: .cctor()100%11100%
File 1: .ctor(...)100%11100%
File 1: get_Context()100%11100%
File 1: get_ActivePartitionCount()100%11100%
File 1: get_InactivePartitionCount()100%11100%
File 1: get_InactivePartitionMembershipCount()100%11100%
File 1: get_RetainedPartitionCount()100%11100%
File 1: get_ActivePairCount()100%11100%
File 1: get_PooledPairCount()100%11100%
File 1: GetCandidate(...)100%11100%
File 1: Simulate()100%11100%
File 1: LateSimulate()100%11100%
File 1: ProcessMixedContacts()100%22100%
File 1: DistributeMixedCandidates()100%88100%
File 1: Visualize()100%11100%
File 1: Reset()100%11100%
File 2: RemovePairsFor3DCollider(...)100%11100%
File 2: InvalidatePairsFor3DColliderReconfiguration(...)100%11100%
File 2: QueuePairsFor3DCollider(...)100%44100%
File 2: RemovePairsFor2DCollider(...)100%44100%
File 2: RequireCollisionPair(...)100%2020100%
File 2: InvalidateSurfaceContacts(...)100%2626100%
File 2: ProcessCandidate(...)100%3030100%
File 2: CleanupUntouchedPairs(...)100%1212100%
File 2: TryKeepUntouchedPair(...)100%1616100%
File 2: CreatePair(...)100%44100%
File 2: RemoveQueuedPairs(...)100%44100%
File 2: RemoveQueuedPairs(...)100%44100%
File 2: IsCurrentPair(...)100%44100%
File 2: RemoveCurrentPair(...)100%22100%
File 2: RecyclePair(...)100%1010100%
File 3: Refresh3DColliderPartition(...)100%66100%
File 3: Refresh2DColliderPartition(...)100%11100%
File 3: Refresh2DColliderPartition(...)100%88100%
File 3: ClearPartitioned3DCollider(...)100%66100%
File 3: Remove3DPartitionMemberships(...)100%1010100%
File 3: ClearPartitioned2DCollider(...)100%66100%
File 3: Remove2DPartitionMemberships(...)100%1010100%
File 3: Refresh3DPartitionAwakeState(...)100%1010100%
File 3: Refresh2DPartitionAwakeState(...)100%1010100%
File 3: ProcessPartitionCandidate(...)100%1010100%
File 3: Collect2DCandidatesInMixedBounds(...)100%1212100%
File 3: Collect3DCandidatesInMixedBounds(...)100%1212100%
File 3: ActivatePartition(...)100%11100%
File 3: DeactivatePartition(...)100%11100%
File 3: RentPartition()100%44100%
File 3: ReleasePartition(...)100%11100%
File 3: RentPartitionMembership()100%22100%
File 3: ReleasePartitionMembership(...)100%22100%
File 3: Refresh3DColliderPartitions()100%22100%
File 3: Refresh3DColliderPartitionsForQuery(...)100%66100%
File 3: Refresh2DColliderPartitions(...)100%22100%
File 3: Refresh2DColliderPartitionsForQuery(...)100%1212100%
File 3: Partition3DCollider(...)100%22100%
File 3: Partition2DCollider(...)100%22100%
File 3: ScanCovered3DVoxels(...)100%66100%
File 3: ScanCovered2DMixedVoxels(...)100%66100%
File 3: CollectCoveredMixedQueryPartitions(...)100%11100%
File 3: ScanCoveredMixedQueryPartitions(...)100%11100%
File 3: VisitCoveredVoxelsForMixedQuery(...)100%88100%
File 3: Partition3DVoxel(...)100%22100%
File 3: TryPartition2DMixedVoxel(...)100%44100%
File 3: GetOrCreatePartition(...)100%22100%
File 3: Get3DCoverageBounds(...)100%11100%
File 3: Get2DMixedCoverageBounds(...)100%11100%
File 3: Get3DMobilityKind(...)100%44100%
File 3: Get2DMobilityKind(...)100%44100%
File 3: GetStoredMobilityKind(...)100%44100%
File 3: Add3DObject(...)100%44100%
File 3: Add2DObject(...)100%44100%
File 3: Remove3DObject(...)100%44100%
File 3: Remove2DObject(...)100%44100%
File 3: MixedBoundsOverlap(...)100%11100%
File 3: Is2DQueryCandidate(...)100%22100%
File 3: Is3DQueryCandidate(...)100%44100%
File 3: DetachRetainedPartitions()100%11100%
File 3: TrackRetainedPartition(...)100%11100%
File 3: UntrackRetainedPartition(...)100%11100%
File 3: RefreshRetainedPartitionEligibility(...)100%11100%
File 3: RetireExpiredRetainedPartitions()100%11100%
File 3: TryRetireEmptyRetainedPartitionForReuse()100%11100%
File 4: ContributeReplayHash(...)100%88100%
File 5: JoinSleepIslands(...)100%1616100%
File 5: SolveMixedResponsePairs()100%3636100%
File 5: BuildMixedIslands()100%1616100%
File 5: AddMixedIslandNodeIfMovable(...)100%22100%
File 5: AddMixedIslandNodeIfMovable(...)100%22100%
File 5: SortAndDeduplicateMixedIslandNodes()100%11100%
File 5: FindMixedIslandNode(...)100%22100%
File 5: FindMixedIslandNode(...)100%22100%
File 5: FindMixedIslandNode(...)100%11100%
File 5: UnionMixedIslandNodes(...)100%11100%
File 5: CompressMixedIslandRoots()100%11100%
File 5: ResolveMixedConstraintRootKey(...)100%11100%
File 5: WakeMixedIslandBodies(...)100%11100%
File 5: SolveMixedIslandRange(...)100%1010100%
File 5: HasAwakeMovableParticipant(...)100%22100%
File 5: HasAwakeResponseParticipant(...)100%22100%
File 5: ShouldSolveSingleMixedPair(...)100%44100%
File 5: IsAwakeMovable(...)100%44100%
File 5: IsAwakeMovable(...)100%44100%
File 5: IsMovableMixedIslandBody(...)100%44100%
File 5: IsMovableMixedIslandBody(...)100%44100%
File 5: Create3DBodyKey(...)100%11100%
File 5: Create2DBodyKey(...)100%11100%
File 6: Compare(...)100%11100%
File 6: Compare(...)100%11100%
File 6: Compare(...)100%11100%
File 6: Compare(...)100%22100%
File 6: Compare(...)100%11100%
File 6: Compare(...)100%11100%
File 6: .ctor(...)100%11100%
File 6: get_IsAwakeForCollision()100%22100%
File 6: WakeFromCollision()100%22100%
File 6: .ctor(...)100%11100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/Mixed/GravitasMixedCollisionService.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasMixedCollisionService.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 Gravitas.CollisionHandling;
 10using GridForge.Grids;
 11using GridForge.Spatial;
 12using SwiftCollections;
 13
 14namespace Gravitas;
 15
 16/// <summary>
 17/// Owns mixed 2D/3D collision lifecycle and broad-phase state for one <see cref="GravitasWorldContext"/>.
 18/// </summary>
 19internal sealed partial class GravitasMixedCollisionService
 20{
 21    private const int DefaultPartitionPoolCapacity = 1024;
 122    private static readonly PhysicsMixedPartitionOrderComparer PartitionOrderComparer = new();
 123    private static readonly MixedColliderKeyComparer CandidatePairComparer = new();
 124    private static readonly MixedResponsePairComparer ResponsePairComparer = new();
 125    private static readonly IslandNodeKeyComparer<MixedIslandNode> IslandNodeComparer = new();
 126    private static readonly MixedIslandConstraintComparer IslandConstraintComparer = new();
 127    private static readonly Collider2DIdComparer Collider2DIdOrderComparer = new();
 128    private static readonly Collider3DIdComparer Collider3DIdOrderComparer = new();
 29
 30    private readonly GravitasWorldContext _context;
 1019131    private readonly SwiftSlotMap<PhysicsMixedPartition> _activePartitions = new(DefaultPartitionPoolCapacity);
 1019132    private readonly SwiftStack<PhysicsMixedPartition> _inactivePartitionPool = new(DefaultPartitionPoolCapacity);
 1019133    private readonly SwiftStack<SwiftHashSet<int>> _inactivePartitionMembershipPool = new(DefaultPartitionPoolCapacity);
 1019134    private readonly SwiftHashSet<ulong> _processedPairKeys = new();
 1019135    private readonly SwiftList<Voxel> _coveredVoxels = new();
 1019136    private readonly SwiftHashSet<WorldVoxelIndex> _nextCoveredCoordinates = new();
 1019137    private readonly GridTraceScratch _traceScratch = new();
 1019138    private readonly SwiftList<PhysicsMixedPartition> _retainedPartitions = new();
 1019139    private readonly SwiftList<PhysicsMixedPartition> _emptyRetainedPartitions = new();
 1019140    private readonly SwiftList<PhysicsMixedPartition> _distributionPartitions = new();
 1019141    private readonly SwiftList<int> _distributionDynamic3DIds = new();
 1019142    private readonly SwiftList<int> _distributionKinematic3DIds = new();
 1019143    private readonly SwiftList<int> _distributionStatic3DIds = new();
 1019144    private readonly SwiftList<int> _distributionDynamic2DIds = new();
 1019145    private readonly SwiftList<int> _distributionKinematic2DIds = new();
 1019146    private readonly SwiftList<int> _distributionStatic2DIds = new();
 1019147    private readonly SwiftList<MixedColliderKey> _candidatePairs = new();
 1019148    private readonly SwiftList<PhysicsMixedPartition> _queryPartitions = new();
 1019149    private readonly SwiftList<int> _queryColliderIds = new();
 1019150    private readonly SwiftHashSet<int> _queryColliderRedundancy = new();
 1019151    private readonly SwiftDictionary<ulong, CollisionPairMixed> _pairs = new();
 1019152    private readonly SwiftList<MixedPairLifetimeToken> _pairsToRemove = new();
 1019153    private readonly SwiftStack<CollisionPairMixed> _cachedPairs = new();
 1019154    private readonly SwiftList<CollisionPairMixed> _mixedResponsePairs = new();
 55    private SwiftHashSet<int>? _surfaceChangedMovers;
 1019156    private readonly SwiftList<MixedIslandNode> _mixedIslandNodes = new();
 1019157    private readonly SwiftList<MixedIslandConstraint> _mixedIslandConstraints = new();
 58    private readonly Action<PhysicsMixedPartition> _releaseRetainedPartition;
 59
 60    private int _retainedPartitionRetirementCursor;
 1019161    private long _cached3DQueryRefreshFrame = -1;
 1019162    private long _cached3DQueryRefreshLateToken = -1;
 1019163    private long _cached2DQueryRefreshFrame = -1;
 1019164    private long _cached2DQueryRefreshLateToken = -1;
 65
 1019166    internal GravitasMixedCollisionService(GravitasWorldContext context)
 67    {
 1019168        ChronicleGuard.ThrowIfNull(context, nameof(context));
 1019169        _context = context;
 1019170        _releaseRetainedPartition = ReleasePartition;
 1019171    }
 72
 13460173    internal GravitasWorldContext Context => _context;
 74
 75    internal uint Version { get; private set; } = 1;
 76
 24977    internal int ActivePartitionCount => _activePartitions.Count;
 78
 25379    internal int InactivePartitionCount => _inactivePartitionPool.Count;
 80
 481    internal int InactivePartitionMembershipCount => _inactivePartitionMembershipPool.Count;
 82
 25783    internal int RetainedPartitionCount => _retainedPartitions.Count;
 84
 85    internal int LastBroadPhaseCandidateCount { get; private set; }
 86
 79287    internal int ActivePairCount => _pairs.Count;
 88
 24589    internal int PooledPairCount => _cachedPairs.Count;
 90
 91    internal int SimulateCount { get; private set; }
 92
 93    internal int LateSimulateCount { get; private set; }
 94
 95    internal int VisualizeCount { get; private set; }
 96
 2697    internal MixedColliderKey GetCandidate(int index) => _candidatePairs[index];
 98
 99    internal void Simulate()
 100    {
 15810101        SimulateCount++;
 15810102        LastBroadPhaseCandidateCount = 0;
 15810103    }
 104
 105    internal void LateSimulate()
 106    {
 15999107        LateSimulateCount++;
 15999108        ProcessMixedContacts();
 15999109    }
 110
 111    private void ProcessMixedContacts()
 112    {
 15999113        LastBroadPhaseCandidateCount = 0;
 15999114        _candidatePairs.FastClear();
 15999115        _mixedResponsePairs.FastClear();
 15999116        _processedPairKeys.Clear();
 117
 15999118        Refresh3DColliderPartitions();
 15999119        Refresh2DColliderPartitions(rebuildShapes: false);
 120
 15999121        Version++;
 15999122        DistributeMixedCandidates();
 123
 15999124        _candidatePairs.SortInPlace(CandidatePairComparer);
 15999125        LastBroadPhaseCandidateCount = _candidatePairs.Count;
 15999126        long frame = _context.FrameCount;
 65188127        for (int i = 0; i < _candidatePairs.Count; i++)
 16595128            ProcessCandidate(_candidatePairs[i], frame);
 129
 15999130        SolveMixedResponsePairs();
 15999131        CleanupUntouchedPairs(frame);
 15999132        RetireExpiredRetainedPartitions();
 15999133    }
 134
 135    private void DistributeMixedCandidates()
 136    {
 15999137        _distributionPartitions.FastClear();
 138        // Only distribution is impossible; the caller still refreshes indexes and retires lifetimes.
 15999139        if (_context.Physics.ColliderCount == 0 || _context.Physics2D.ColliderCount == 0)
 1941140            return;
 141
 806368142        foreach (PhysicsMixedPartition partition in _activePartitions)
 389126143            _distributionPartitions.Add(partition);
 144
 14058145        _distributionPartitions.SortInPlace(PartitionOrderComparer);
 806368146        for (int i = 0; i < _distributionPartitions.Count; i++)
 147        {
 389126148            _distributionPartitions[i].Distribute(
 389126149                _distributionDynamic3DIds,
 389126150                _distributionKinematic3DIds,
 389126151                _distributionStatic3DIds,
 389126152                _distributionDynamic2DIds,
 389126153                _distributionKinematic2DIds,
 389126154                _distributionStatic2DIds);
 155        }
 14058156    }
 157
 158    internal void Visualize()
 159    {
 6160        VisualizeCount++;
 6161    }
 162
 163    internal void Reset()
 164    {
 113165        DetachRetainedPartitions();
 113166        _activePartitions.Clear();
 113167        _inactivePartitionPool.Clear();
 113168        _inactivePartitionMembershipPool.Clear();
 113169        _processedPairKeys.Clear();
 113170        _coveredVoxels.FastClear();
 113171        _nextCoveredCoordinates.Clear();
 113172        _traceScratch.Clear();
 113173        _distributionPartitions.FastClear();
 113174        _distributionDynamic3DIds.FastClear();
 113175        _distributionKinematic3DIds.FastClear();
 113176        _distributionStatic3DIds.FastClear();
 113177        _distributionDynamic2DIds.FastClear();
 113178        _distributionKinematic2DIds.FastClear();
 113179        _distributionStatic2DIds.FastClear();
 113180        _candidatePairs.FastClear();
 113181        _queryPartitions.FastClear();
 113182        _queryColliderIds.FastClear();
 113183        _queryColliderRedundancy.Clear();
 113184        _pairs.Clear();
 113185        _pairsToRemove.Clear(clearRetainedReferences: true);
 113186        _cachedPairs.Clear();
 113187        _mixedResponsePairs.Clear(clearRetainedReferences: true);
 113188        _mixedIslandNodes.Clear(clearRetainedReferences: true);
 113189        _mixedIslandConstraints.Clear(clearRetainedReferences: true);
 113190        _cached3DQueryRefreshFrame = -1;
 113191        _cached3DQueryRefreshLateToken = -1;
 113192        _cached2DQueryRefreshFrame = -1;
 113193        _cached2DQueryRefreshLateToken = -1;
 113194        Version = 1;
 113195        LastBroadPhaseCandidateCount = 0;
 113196        SimulateCount = 0;
 113197        LateSimulateCount = 0;
 113198        VisualizeCount = 0;
 113199        _retainedPartitionRetirementCursor = 0;
 113200    }
 201
 202}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/Mixed/GravitasMixedCollisionService.Pairs.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasMixedCollisionService.Pairs.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.Runtime.CompilerServices;
 10using Gravitas.Colliders;
 11using Gravitas.CollisionHandling;
 12using SwiftCollections;
 13
 14namespace Gravitas;
 15
 16/// <content>Finds and maintains pairs between spatial and planar colliders and clears invalid contacts.</content>
 17internal sealed partial class GravitasMixedCollisionService
 18{
 19    internal void RemovePairsFor3DCollider(LSCollider collider)
 20    {
 45121        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 45122        int removalStart = QueuePairsFor3DCollider(collider);
 45123        RemoveQueuedPairs(removalStart, _pairsToRemove.Count);
 45124    }
 25
 26    internal void InvalidatePairsFor3DColliderReconfiguration(
 27        LSCollider collider,
 28        ref SwiftList<Exception>? notificationExceptions)
 29    {
 12830        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 12831        int removalStart = QueuePairsFor3DCollider(collider);
 12832        RemoveQueuedPairs(
 12833            removalStart,
 12834            _pairsToRemove.Count,
 12835            ref notificationExceptions);
 12836    }
 37
 38    private int QueuePairsFor3DCollider(LSCollider collider)
 39    {
 57940        int removalStart = _pairsToRemove.Count;
 133641        foreach (var pairEntry in _pairs)
 42        {
 8943            CollisionPairMixed pair = pairEntry.Value;
 8944            if (!ReferenceEquals(pair.Collider3D, collider))
 45                continue;
 46
 3747            _pairsToRemove.Add(new MixedPairLifetimeToken(pair));
 48        }
 49
 57950        return removalStart;
 51    }
 52
 53    internal void RemovePairsFor2DCollider(LSCollider2D collider)
 54    {
 50455        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 50456        int removalStart = _pairsToRemove.Count;
 117857        foreach (var pairEntry in _pairs)
 58        {
 8559            CollisionPairMixed pair = pairEntry.Value;
 8560            if (!ReferenceEquals(pair.Collider2D, collider))
 61                continue;
 62
 1763            _pairsToRemove.Add(new MixedPairLifetimeToken(pair));
 64        }
 65
 50466        RemoveQueuedPairs(removalStart, _pairsToRemove.Count);
 50467    }
 68
 69    internal bool RequireCollisionPair(LSCollider collider3D, LSCollider2D collider2D)
 70    {
 36060471        return collider3D.IsActive && !collider3D.IsDeactivationInProgress && collider2D.IsActive
 36060472            && collider3D.Shape != ColliderType.None && collider2D.Shape != ColliderType2D.None
 36060473            && (collider3D.Body != null || collider2D.Body != null)
 36060474            && !ReferenceEquals(collider3D.AgentOrNull, collider2D.AgentOrNull)
 36060475            && !collider3D.ExcludesMixedCollisionWith(collider2D)
 36060476            && ColliderCollisionFilter.AllowsPhysicalPair(collider3D, collider2D)
 36060477            && !_context.Physics.IsLayerCollisionDisabled(collider3D.Layer, collider2D.Layer);
 78    }
 79
 80    internal void InvalidateSurfaceContacts(StaticSurface? spatial, StaticSurface2D? planar,
 81        SwiftHashSet<int> changedSuppliers)
 82    {
 725483        if (_pairs.Count == 0 || changedSuppliers.Count == 0) return;
 16484        bool sourceIsPlanar = planar != null;
 16485        SwiftHashSet<int> movers = _surfaceChangedMovers ??= new();
 16486        movers.Clear();
 85887        foreach (var entry in _pairs)
 88        {
 26589            CollisionPairMixed pair = entry.Value;
 26590            if (!OwnsSurface(pair)) continue;
 23191            int supplier = (sourceIsPlanar ? pair.Collider2DId : pair.Collider3DId) + 1;
 23192            if (!changedSuppliers.Contains(supplier)
 23193                && !pair.Manifold.ReferencesSuppliers(changedSuppliers, !sourceIsPlanar, supplier)) continue;
 23094            pair.InvalidateSurfaceContact(wake: true);
 23095            movers.Add(sourceIsPlanar ? pair.Collider3DId : pair.Collider2DId);
 96        }
 97        // Response can move to an existing empty noncarrier. Discard its old
 98        // empty snapshot too, without waking unrelated users of the surface.
 85899        foreach (var entry in _pairs)
 100        {
 265101            CollisionPairMixed pair = entry.Value;
 265102            if (OwnsSurface(pair) && movers.Contains(sourceIsPlanar ? pair.Collider3DId : pair.Collider2DId))
 230103                pair.InvalidateSurfaceContact(wake: false);
 104        }
 164105        movers.Clear();
 106
 107        bool OwnsSurface(CollisionPairMixed pair) => sourceIsPlanar
 108            ? pair.Collider2D.StaticSurface == planar
 109            : pair.Collider3D is LSMeshCollider mesh && mesh.StaticSurface == spatial;
 164110    }
 111
 112    private void ProcessCandidate(MixedColliderKey candidate, long frame)
 113    {
 16595114        if (!_context.Physics.TryGetColliderById(candidate.Collider3DId, out LSCollider? collider3D)
 16595115            || !_context.Physics2D.TryGetColliderById(candidate.Collider2DId, out LSCollider2D? collider2D))
 116        {
 2117            return;
 118        }
 119
 16593120        LSCollider resolved3D = collider3D!;
 16593121        LSCollider2D resolved2D = collider2D!;
 16593122        if (!RequireCollisionPair(resolved3D, resolved2D) || !MixedBoundsOverlap(resolved3D, resolved2D))
 3123            return;
 16590124        bool hasPair = _pairs.TryGetValue(candidate.Key, out CollisionPairMixed pair);
 16590125        bool triggerPair = resolved3D.IsTrigger || resolved2D.IsTrigger;
 16590126        bool hasAwakeMovableParticipant = HasAwakeMovableParticipant(resolved3D, resolved2D);
 16590127        if (!hasPair && !triggerPair && !hasAwakeMovableParticipant)
 1128            return;
 129
 16589130        ContactManifold manifold = _context.CollisionScratch.MixedManifold;
 16589131        if (!(hasPair && pair!.TryCopyCachedManifold(frame, manifold))
 16589132            && !CollisionDetectionMixed.TryBuildDiscreteManifold(resolved3D, resolved2D, manifold))
 575133            return;
 134
 16014135        if (!triggerPair && !hasAwakeMovableParticipant)
 136        {
 1137            pair!.MarkResting(frame, manifold);
 1138            _mixedResponsePairs.Add(pair);
 1139            return;
 140        }
 141
 16013142        if (!hasPair)
 143        {
 655144            pair = CreatePair(resolved3D, resolved2D);
 655145            _pairs.Add(candidate.Key, pair);
 146        }
 147
 16013148        pair!.MarkColliding(frame, manifold);
 16013149        if (!triggerPair)
 15925150            _mixedResponsePairs.Add(pair);
 16013151    }
 152
 153    private void CleanupUntouchedPairs(long frame)
 154    {
 15999155        int removalStart = _pairsToRemove.Count;
 64560156        foreach (var pairEntry in _pairs)
 16281157            _pairsToRemove.Add(new MixedPairLifetimeToken(pairEntry.Value));
 158
 15999159        int removalEnd = _pairsToRemove.Count;
 160        try
 161        {
 64560162            for (int i = removalStart; i < removalEnd; i++)
 163            {
 16281164                MixedPairLifetimeToken token = _pairsToRemove[i];
 16281165                CollisionPairMixed pair = token.Pair;
 16281166                if (!IsCurrentPair(token))
 167                    continue;
 168
 16281169                if (pair.LastVisitToken == _context.LateSimulateToken)
 170                    continue;
 171
 286172                if (TryKeepUntouchedPair(pair, frame))
 173                    continue;
 174
 130175                RemoveCurrentPair(token);
 176            }
 15999177        }
 178        finally
 179        {
 15999180            if (removalStart == 0)
 15998181                _pairsToRemove.FastClear();
 15999182        }
 15999183    }
 184
 185    private bool TryKeepUntouchedPair(CollisionPairMixed pair, long frame)
 186    {
 286187        LSCollider collider3D = pair.Collider3D;
 286188        LSCollider2D collider2D = pair.Collider2D;
 286189        bool triggerPair = collider3D.IsTrigger || collider2D.IsTrigger;
 286190        ContactManifold manifold = _context.CollisionScratch.MixedManifold;
 286191        if ((!triggerPair && HasAwakeMovableParticipant(collider3D, collider2D))
 286192            || !RequireCollisionPair(collider3D, collider2D)
 286193            || !MixedBoundsOverlap(collider3D, collider2D)
 286194            || !(pair.TryCopyCachedManifold(frame, manifold)
 286195                || CollisionDetectionMixed.TryBuildDiscreteManifold(collider3D, collider2D, manifold)))
 196        {
 130197            return false;
 198        }
 199
 156200        if (triggerPair)
 201        {
 42202            pair.MarkColliding(frame, manifold);
 42203            return true;
 204        }
 205
 114206        pair.MarkResting(frame, manifold);
 114207        return true;
 208    }
 209
 210    private CollisionPairMixed CreatePair(LSCollider collider3D, LSCollider2D collider2D)
 211    {
 655212        if (_context.Settings.PoolingEnabled && _cachedPairs.Count > 0)
 213        {
 8214            CollisionPairMixed pair = _cachedPairs.Pop();
 8215            pair.Initialize(collider3D, collider2D);
 8216            return pair;
 217        }
 218
 647219        return new CollisionPairMixed(collider3D, collider2D);
 220    }
 221
 222    private void RemoveQueuedPairs(int removalStart, int removalEnd)
 223    {
 224        try
 225        {
 2014226            for (int i = removalStart; i < removalEnd; i++)
 52227                RemoveCurrentPair(_pairsToRemove[i]);
 955228        }
 229        finally
 230        {
 955231            if (removalStart == 0)
 950232                _pairsToRemove.FastClear();
 955233        }
 955234    }
 235
 236    private void RemoveQueuedPairs(
 237        int removalStart,
 238        int removalEnd,
 239        ref SwiftList<Exception>? notificationExceptions)
 240    {
 241        try
 242        {
 260243            for (int i = removalStart; i < removalEnd; i++)
 244            {
 245                try
 246                {
 2247                    RemoveCurrentPair(_pairsToRemove[i]);
 1248                }
 1249                catch (Exception exception)
 250                {
 1251                    CollisionNotificationExceptions.Capture(
 1252                        ref notificationExceptions,
 1253                        exception);
 1254                }
 255            }
 128256        }
 257        finally
 258        {
 128259            if (removalStart == 0)
 128260                _pairsToRemove.FastClear();
 128261        }
 128262    }
 263
 264    private bool IsCurrentPair(in MixedPairLifetimeToken token) =>
 32386265        token.IsCurrentLifetime
 32386266        && _pairs.TryGetValue(token.Pair.Key, out CollisionPairMixed currentPair)
 32386267        && ReferenceEquals(currentPair, token.Pair);
 268
 269    private void RemoveCurrentPair(in MixedPairLifetimeToken token)
 270    {
 184271        if (!IsCurrentPair(token))
 3272            return;
 273
 181274        CollisionPairMixed pair = token.Pair;
 181275        _pairs.Remove(pair.Key);
 181276        pair.MarkSeparated();
 180277        RecyclePair(pair);
 180278    }
 279
 280    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 281    private void RecyclePair(CollisionPairMixed pair)
 282    {
 283        // Later callbacks can reuse this object for a different pair in this pass.
 284        // Retire its pending response before the pool can publish that new lifetime.
 180285        if (pair.LastVisitToken == _context.LateSimulateToken)
 214286            for (int i = _mixedResponsePairs.Count - 1; i >= 0; i--)
 88287                if (ReferenceEquals(_mixedResponsePairs[i], pair)) _mixedResponsePairs.RemoveAt(i);
 180288        if (_context.Settings.PoolingEnabled && !pair.IsNotificationInProgress)
 165289            _cachedPairs.Push(pair);
 180290    }
 291
 292}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/Mixed/GravitasMixedCollisionService.Partitioning.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasMixedCollisionService.Partitioning.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.Runtime.CompilerServices;
 9using FixedMathSharp;
 10using FixedMathSharp.Geometry;
 11using Gravitas.Colliders;
 12using Gravitas.Support;
 13using GridForge.Grids;
 14using GridForge.Spatial;
 15using GridForge.Utility;
 16using SwiftCollections;
 17
 18namespace Gravitas;
 19
 20/// <content>Maintains mixed collider partition membership and gathers cross-dimensional broad-phase candidates.</conten
 21internal sealed partial class GravitasMixedCollisionService
 22{
 23    internal bool Refresh3DColliderPartition(LSCollider collider)
 24    {
 3104325        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 3104326        ChronicleGuard.ThrowIfArgument(
 3104327            !ReferenceEquals(collider.Context, _context),
 3104328            nameof(collider),
 3104329            "3D collider must belong to this mixed collision service context.");
 30
 3104331        if (!collider.IsActive || collider.Shape == ColliderType.None)
 32        {
 333            ClearPartitioned3DCollider(collider, force: true);
 334            collider.MarkMixedUnpartitioned();
 335            collider.ClearMixedPartitionCoordinates();
 36
 337            return false;
 38        }
 39
 3104040        Get3DCoverageBounds(collider, out Vector3d coverageMin, out Vector3d coverageMax);
 3104041        PhysicsMobilityType kind = Get3DMobilityKind(collider);
 3104042        if (collider.MatchesMixedPartitionGridBounds(coverageMin, coverageMax, (int)kind))
 43        {
 1043644            Refresh3DPartitionAwakeState(collider);
 1043645            return false;
 46        }
 47
 2060448        return Partition3DCollider(collider, coverageMin, coverageMax);
 49    }
 50
 51    internal bool Refresh2DColliderPartition(LSCollider2D collider) =>
 15052        Refresh2DColliderPartition(collider, rebuildShape: true);
 53
 54    internal bool Refresh2DColliderPartition(LSCollider2D collider, bool rebuildShape)
 55    {
 3565756        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 3565757        ChronicleGuard.ThrowIfArgument(
 3565758            !ReferenceEquals(collider.Context, _context),
 3565759            nameof(collider),
 3565760            "2D collider must belong to this mixed collision service context.");
 61
 3565762        if (rebuildShape)
 91363            collider.Rebuild();
 64
 3565765        if (!collider.IsActive || collider.Shape == ColliderType2D.None)
 66        {
 567            ClearPartitioned2DCollider(collider, force: true);
 568            collider.MarkMixedUnpartitioned();
 569            collider.ClearMixedPartitionCoordinates();
 70
 571            return false;
 72        }
 73
 3565274        Get2DMixedCoverageBounds(collider, out Vector3d coverageMin, out Vector3d coverageMax);
 3565275        PhysicsMobilityType kind = Get2DMobilityKind(collider);
 3565276        if (collider.MatchesMixedPartitionGridBounds(coverageMin, coverageMax, (int)kind))
 77        {
 2696278            Refresh2DPartitionAwakeState(collider);
 2696279            return false;
 80        }
 81
 869082        return Partition2DCollider(collider, coverageMin, coverageMax);
 83    }
 84
 85    internal bool ClearPartitioned3DCollider(LSCollider collider, bool force = false)
 86    {
 9187        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 9188        if (!collider.IsMixedPartitioned)
 389            return false;
 90
 8891        Get3DCoverageBounds(collider, out Vector3d coverageMin, out Vector3d coverageMax);
 8892        PhysicsMobilityType currentKind = Get3DMobilityKind(collider);
 8893        if (!force && collider.MatchesMixedPartitionGridBounds(coverageMin, coverageMax, (int)currentKind))
 194            return false;
 95
 8796        SwiftList<WorldVoxelIndex> coordinates = collider.MixedPartitionCoordinates!;
 8797        PhysicsMobilityType partitionKind = GetStoredMobilityKind(collider.MixedPartitionKind);
 8798        Remove3DPartitionMemberships(collider, coordinates, partitionKind, preserveCovered: false);
 99
 87100        collider.MarkMixedUnpartitioned();
 87101        collider.ClearMixedPartitionCoordinates();
 87102        return true;
 103    }
 104
 105    private void Remove3DPartitionMemberships(
 106        LSCollider collider,
 107        SwiftList<WorldVoxelIndex> coordinates,
 108        PhysicsMobilityType partitionKind,
 109        bool preserveCovered)
 110    {
 20691111        GridWorld world = _context.World;
 1529854112        for (int i = 0; i < coordinates.Count; i++)
 113        {
 744236114            WorldVoxelIndex coordinate = coordinates[i];
 744236115            if (preserveCovered && _nextCoveredCoordinates.Contains(coordinate))
 116                continue;
 117
 37586118            if (!world.TryGetVoxel(coordinate, out Voxel? voxel)
 37586119                || !voxel!.TryGetPartition(out PhysicsMixedPartition? partition))
 120            {
 121                continue;
 122            }
 123
 37556124            Remove3DObject(partition!, collider.Id, partitionKind);
 125        }
 20691126    }
 127
 128    internal bool ClearPartitioned2DCollider(LSCollider2D collider, bool force = false)
 129    {
 112130        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 112131        if (!collider.IsMixedPartitioned)
 5132            return false;
 133
 107134        Get2DMixedCoverageBounds(collider, out Vector3d coverageMin, out Vector3d coverageMax);
 107135        PhysicsMobilityType currentKind = Get2DMobilityKind(collider);
 107136        if (!force && collider.MatchesMixedPartitionGridBounds(coverageMin, coverageMax, (int)currentKind))
 3137            return false;
 138
 104139        SwiftList<WorldVoxelIndex> coordinates = collider.MixedPartitionCoordinates!;
 104140        PhysicsMobilityType partitionKind = GetStoredMobilityKind(collider.MixedPartitionKind);
 104141        Remove2DPartitionMemberships(collider, coordinates, partitionKind, preserveCovered: false);
 142
 104143        collider.MarkMixedUnpartitioned();
 104144        collider.ClearMixedPartitionCoordinates();
 104145        return true;
 146    }
 147
 148    private void Remove2DPartitionMemberships(
 149        LSCollider2D collider,
 150        SwiftList<WorldVoxelIndex> coordinates,
 151        PhysicsMobilityType partitionKind,
 152        bool preserveCovered)
 153    {
 8794154        GridWorld world = _context.World;
 199270155        for (int i = 0; i < coordinates.Count; i++)
 156        {
 90841157            WorldVoxelIndex coordinate = coordinates[i];
 90841158            if (preserveCovered && _nextCoveredCoordinates.Contains(coordinate))
 159                continue;
 160
 10650161            if (!world.TryGetVoxel(coordinate, out Voxel? voxel)
 10650162                || !voxel!.TryGetPartition(out PhysicsMixedPartition? partition))
 163            {
 164                continue;
 165            }
 166
 10621167            Remove2DObject(partition!, collider.Id, partitionKind);
 168        }
 8794169    }
 170
 171    internal void Refresh3DPartitionAwakeState(LSCollider collider)
 172    {
 12843173        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 12843174        if (!collider.IsMixedPartitioned)
 1999175            return;
 176
 10844177        SwiftList<WorldVoxelIndex> coordinates = collider.MixedPartitionCoordinates!;
 10844178        SolidBody? body = collider.Body;
 10844179        if (collider.IsStatic)
 8756180            return;
 181
 2088182        bool awake = body!.IsAwakeForCollision;
 2088183        GridWorld world = _context.World;
 186260184        for (int i = 0; i < coordinates.Count; i++)
 185        {
 91042186            WorldVoxelIndex coordinate = coordinates[i];
 91042187            if (!world.TryGetVoxel(coordinate, out Voxel? voxel)
 91042188                || !voxel!.TryGetPartition(out PhysicsMixedPartition? partition))
 189            {
 190                continue;
 191            }
 192
 91039193            partition!.SetDynamic3DObjectAwake(collider.Id, awake);
 194        }
 2088195    }
 196
 197    internal void Refresh2DPartitionAwakeState(LSCollider2D collider)
 198    {
 28866199        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 28866200        if (!collider.IsMixedPartitioned)
 1607201            return;
 202
 27259203        SwiftList<WorldVoxelIndex> coordinates = collider.MixedPartitionCoordinates!;
 27259204        SolidBody2D? body = collider.Body;
 27259205        if (collider.IsStatic)
 25342206            return;
 207
 1917208        bool awake = body!.IsAwakeForCollision;
 1917209        GridWorld world = _context.World;
 87172210        for (int i = 0; i < coordinates.Count; i++)
 211        {
 41669212            WorldVoxelIndex coordinate = coordinates[i];
 41669213            if (!world.TryGetVoxel(coordinate, out Voxel? voxel)
 41669214                || !voxel!.TryGetPartition(out PhysicsMixedPartition? partition))
 215            {
 216                continue;
 217            }
 218
 41667219            partition!.SetDynamic2DObjectAwake(collider.Id, awake);
 220        }
 1917221    }
 222
 223    internal void ProcessPartitionCandidate(int collider3DId, int collider2DId)
 224    {
 301622225        if (!_context.Physics.TryGetColliderById(collider3DId, out LSCollider? collider3D)
 301622226            || !_context.Physics2D.TryGetColliderById(collider2DId, out LSCollider2D? collider2D)
 301622227            || !RequireCollisionPair(collider3D!, collider2D!)
 301622228            || !MixedBoundsOverlap(collider3D!, collider2D!))
 229        {
 25387230            return;
 231        }
 232
 276235233        ulong key = MixedColliderKey.CreateKey(collider3DId, collider2DId);
 276235234        if (!_processedPairKeys.Add(key))
 259640235            return;
 236
 16595237        _candidatePairs.Add(new MixedColliderKey(collider3DId, collider2DId));
 16595238    }
 239
 240    internal void Collect2DCandidatesInMixedBounds(
 241        Vector3d min,
 242        Vector3d max,
 243        PhysicsLayerMask layerMask,
 244        SwiftList<LSCollider2D> candidates,
 245        bool staticStyleOnly = false,
 246        bool cachePartitionRefresh = false)
 247    {
 9861248        ChronicleGuard.ThrowIfNull(candidates, nameof(candidates));
 9861249        Refresh2DColliderPartitionsForQuery(cachePartitionRefresh);
 9852250        candidates.FastClear();
 9852251        FixedBoundBox queryBounds = FixedBoundBox.FromMinMax(min, max);
 9852252        CollectCoveredMixedQueryPartitions(min, max, _queryPartitions);
 9852253        _queryPartitions.SortInPlace(PartitionOrderComparer);
 9852254        _queryColliderRedundancy.Clear();
 255
 2085090256        for (int i = 0; i < _queryPartitions.Count; i++)
 257        {
 1032693258            PhysicsMixedPartition partition = _queryPartitions[i];
 1032693259            if (staticStyleOnly)
 1016077260                partition.CopyStaticStyle2DColliderIds(_queryColliderIds);
 261            else
 16616262                partition.Copy2DColliderIds(_queryColliderIds);
 263
 4124118264            for (int j = 0; j < _queryColliderIds.Count; j++)
 265            {
 1029366266                int colliderId = _queryColliderIds[j];
 1029366267                if (!_queryColliderRedundancy.Add(colliderId)
 1029366268                    || !_context.Physics2D.TryGetColliderById(colliderId, out LSCollider2D? collider)
 1029366269                    || !Is2DQueryCandidate(collider!, queryBounds, layerMask))
 270                {
 271                    continue;
 272                }
 273
 19975274                candidates.Add(collider!);
 275            }
 276        }
 277
 9852278        _queryColliderRedundancy.Clear();
 9852279        candidates.SortInPlace(Collider2DIdOrderComparer);
 9852280    }
 281
 282    internal void Collect3DCandidatesInMixedBounds(
 283        Vector3d min,
 284        Vector3d max,
 285        PhysicsLayerMask layerMask,
 286        SwiftList<LSCollider> candidates,
 287        bool staticStyleOnly = false,
 288        bool cachePartitionRefresh = false)
 289    {
 1803290        ChronicleGuard.ThrowIfNull(candidates, nameof(candidates));
 1803291        Refresh3DColliderPartitionsForQuery(cachePartitionRefresh);
 1803292        candidates.FastClear();
 1803293        FixedBoundBox queryBounds = FixedBoundBox.FromMinMax(min, max);
 1803294        CollectCoveredMixedQueryPartitions(min, max, _queryPartitions);
 1803295        _queryPartitions.SortInPlace(PartitionOrderComparer);
 1803296        _queryColliderRedundancy.Clear();
 297
 130416298        for (int i = 0; i < _queryPartitions.Count; i++)
 299        {
 63405300            PhysicsMixedPartition partition = _queryPartitions[i];
 63405301            if (staticStyleOnly)
 16259302                partition.CopyStaticStyle3DColliderIds(_queryColliderIds);
 303            else
 47146304                partition.Copy3DColliderIds(_queryColliderIds);
 305
 241004306            for (int j = 0; j < _queryColliderIds.Count; j++)
 307            {
 57097308                int colliderId = _queryColliderIds[j];
 57097309                if (!_queryColliderRedundancy.Add(colliderId)
 57097310                    || !_context.Physics.TryGetColliderById(colliderId, out LSCollider? collider)
 57097311                    || !Is3DQueryCandidate(collider!, queryBounds, layerMask))
 312                {
 313                    continue;
 314                }
 315
 1928316                candidates.Add(collider!);
 317            }
 318        }
 319
 1803320        _queryColliderRedundancy.Clear();
 1803321        candidates.SortInPlace(Collider3DIdOrderComparer);
 1803322    }
 323
 324
 325    internal int ActivatePartition(PhysicsMixedPartition partition)
 326    {
 96420327        ChronicleGuard.ThrowIfNull(partition, nameof(partition));
 96420328        ChronicleGuard.ThrowIfArgument(
 96420329            !ReferenceEquals(partition.Owner, this),
 96420330            nameof(partition),
 96420331            "Mixed partition must belong to this collision service.");
 332
 96420333        return _activePartitions.Add(partition);
 334    }
 335
 96418336    internal void DeactivatePartition(int activationId) => _activePartitions.TryRemoveAt(activationId);
 337
 338    internal PhysicsMixedPartition RentPartition()
 339    {
 434916340        if (_inactivePartitionPool.Count == 0)
 434875341            TryRetireEmptyRetainedPartitionForReuse();
 342
 434916343        PhysicsMixedPartition partition = _inactivePartitionPool.Count > 0
 434916344            ? _inactivePartitionPool.Pop()
 434916345            : new PhysicsMixedPartition();
 434916346        partition.SetOwner(this);
 434916347        return partition;
 348    }
 349
 350    internal void ReleasePartition(PhysicsMixedPartition partition)
 351    {
 434915352        ChronicleGuard.ThrowIfNull(partition, nameof(partition));
 434915353        ChronicleGuard.ThrowIfArgument(
 434915354            !ReferenceEquals(partition.Owner, this),
 434915355            nameof(partition),
 434915356            "Mixed partition must be released through its owning collision service.");
 357
 434915358        UntrackRetainedPartition(partition);
 434915359        partition.ResetForPool();
 434915360        _inactivePartitionPool.Push(partition);
 434915361    }
 362
 363    internal SwiftHashSet<int> RentPartitionMembership()
 364    {
 566978365        return _inactivePartitionMembershipPool.Count > 0
 566978366            ? _inactivePartitionMembershipPool.Pop()
 566978367            : new SwiftHashSet<int>();
 368    }
 369
 370    internal void ReleasePartitionMembership(ref SwiftHashSet<int>? membership)
 371    {
 3559096372        if (membership == null)
 2992128373            return;
 374
 566968375        SwiftHashSet<int> released = membership;
 566968376        membership = null;
 566968377        released.Clear();
 566968378        _inactivePartitionMembershipPool.Push(released);
 566968379    }
 380
 381    private void Refresh3DColliderPartitions()
 382    {
 17576383        int count = _context.Physics.ColliderCount;
 75912384        for (int i = 0; i < count; i++)
 20380385            Refresh3DColliderPartition(_context.Physics.GetColliderByServiceIndex(i));
 17576386    }
 387
 388    private void Refresh3DColliderPartitionsForQuery(bool cachePartitionRefresh)
 389    {
 1803390        if (!cachePartitionRefresh)
 391        {
 1124392            Refresh3DColliderPartitions();
 1124393            return;
 394        }
 395
 679396        long frame = _context.FrameCount;
 679397        long lateToken = _context.LateSimulateToken;
 398        // CCD batches query stable opposite-dimension targets many times in one late-sim phase.
 399        // Cache only the partition refresh; every sweep still gathers and sorts its own hits.
 679400        if (_cached3DQueryRefreshFrame == frame && _cached3DQueryRefreshLateToken == lateToken)
 226401            return;
 402
 453403        Refresh3DColliderPartitions();
 453404        _cached3DQueryRefreshFrame = frame;
 453405        _cached3DQueryRefreshLateToken = lateToken;
 453406    }
 407
 408    private void Refresh2DColliderPartitions(bool rebuildShapes = true)
 409    {
 21606410        int count = _context.Physics2D.ColliderCount;
 109194411        for (int i = 0; i < count; i++)
 32991412            Refresh2DColliderPartition(_context.Physics2D.GetColliderByServiceIndex(i), rebuildShapes);
 21606413    }
 414
 415    private void Refresh2DColliderPartitionsForQuery(bool cachePartitionRefresh)
 416    {
 9861417        if (!_context.Settings.RuntimeMode.RunsMixedContacts())
 418        {
 419            // Explicit mixed queries can index slabs that pure 2D admission did not use.
 32420            for (int i = 0; i < _context.Physics2D.ColliderCount; i++)
 421            {
 11422                LSCollider2D collider = _context.Physics2D.GetColliderByServiceIndex(i);
 11423                if (collider.IsActive)
 424                {
 10425                    collider.Rebuild();
 9426                    collider.ValidateCommittedMixedGeometry();
 427                }
 428            }
 5429            Refresh2DColliderPartitions(rebuildShapes: false);
 5430            return;
 431        }
 9847432        if (!cachePartitionRefresh)
 433        {
 581434            Refresh2DColliderPartitions();
 581435            return;
 436        }
 437
 9266438        long frame = _context.FrameCount;
 9266439        long lateToken = _context.LateSimulateToken;
 440        // CCD batches query stable opposite-dimension targets many times in one late-sim phase.
 441        // Cache only the partition refresh; every sweep still gathers and sorts its own hits.
 9266442        if (_cached2DQueryRefreshFrame == frame && _cached2DQueryRefreshLateToken == lateToken)
 4245443            return;
 444
 445        // CCD callers request a cached refresh only after the 2D frame has
 446        // prepared its authoritative target poses. Rebuilding those shapes
 447        // again here duplicates work and can churn shape-owned scratch state.
 5021448        Refresh2DColliderPartitions(rebuildShapes: false);
 5021449        _cached2DQueryRefreshFrame = frame;
 5021450        _cached2DQueryRefreshLateToken = lateToken;
 5021451    }
 452
 453    private bool Partition3DCollider(LSCollider collider, Vector3d coverageMin, Vector3d coverageMax)
 454    {
 20604455        PhysicsMobilityType kind = Get3DMobilityKind(collider);
 20604456        SwiftList<WorldVoxelIndex> coordinates = collider.GetOrCreateMixedPartitionCoordinates();
 20604457        ScanCovered3DVoxels(collider, coverageMin, coverageMax, coordinates, kind);
 20604458        if (coordinates.Count == 0)
 459        {
 75460            collider.MarkMixedUnpartitioned();
 75461            return false;
 462        }
 463
 20529464        collider.MarkMixedPartitioned(coverageMin, coverageMax, (int)kind);
 20529465        return true;
 466    }
 467
 468    private bool Partition2DCollider(LSCollider2D collider, Vector3d coverageMin, Vector3d coverageMax)
 469    {
 8690470        PhysicsMobilityType kind = Get2DMobilityKind(collider);
 8690471        SwiftList<WorldVoxelIndex> coordinates = collider.GetOrCreateMixedPartitionCoordinates();
 8690472        ScanCovered2DMixedVoxels(collider, coverageMin, coverageMax, coordinates, kind);
 8690473        if (coordinates.Count == 0)
 474        {
 59475            collider.MarkMixedUnpartitioned();
 59476            return false;
 477        }
 478
 8631479        collider.MarkMixedPartitioned(coverageMin, coverageMax, (int)kind);
 8631480        return true;
 481    }
 482
 483    private void ScanCovered3DVoxels(
 484        LSCollider collider,
 485        Vector3d coverageMin,
 486        Vector3d coverageMax,
 487        SwiftList<WorldVoxelIndex> coordinates,
 488        PhysicsMobilityType kind)
 489    {
 20604490        GridWorld world = _context.World;
 20604491        GridTracer.GetCoveredVoxelsInto(
 20604492            world,
 20604493            coverageMin,
 20604494            coverageMax,
 20604495            _coveredVoxels,
 20604496            _traceScratch,
 20604497            Fixed64.Half);
 498
 20604499        var traversal = new GridTraversalState(world, GridTraversalPaddingMode.MaxCellEdge);
 20604500        _nextCoveredCoordinates.Clear();
 20604501        int coveredCount = 0;
 2885832502        for (int i = 0; i < _coveredVoxels.Count; i++)
 503        {
 1422312504            Voxel voxel = _coveredVoxels[i];
 1422312505            if (collider.IsPositionInBounds(traversal.GetCellEdge(voxel), voxel.WorldPosition))
 506            {
 924648507                _nextCoveredCoordinates.Add(voxel.WorldIndex);
 924648508                _coveredVoxels[coveredCount++] = voxel;
 509            }
 510        }
 511
 512        // Remove departures in the previous coordinate order, then publish the
 513        // new tracer order. Hash storage never determines simulation order.
 20604514        PhysicsMobilityType previousKind = GetStoredMobilityKind(collider.MixedPartitionKind);
 20604515        Remove3DPartitionMemberships(collider, coordinates, previousKind, previousKind == kind);
 20604516        coordinates.FastClear();
 1890504517        for (int i = 0; i < coveredCount; i++)
 924648518            Partition3DVoxel(collider, coordinates, _coveredVoxels[i], kind);
 20604519    }
 520
 521    private void ScanCovered2DMixedVoxels(
 522        LSCollider2D collider,
 523        Vector3d coverageMin,
 524        Vector3d coverageMax,
 525        SwiftList<WorldVoxelIndex> coordinates,
 526        PhysicsMobilityType kind)
 527    {
 8690528        GridWorld world = _context.World;
 8690529        GridTracer.GetCoveredVoxelsInto(
 8690530            world,
 8690531            coverageMin,
 8690532            coverageMax,
 8690533            _coveredVoxels,
 8690534            _traceScratch,
 8690535            Fixed64.Half);
 536
 8690537        var traversal = new GridTraversalState(world, GridTraversalPaddingMode.MaxCellEdge);
 8690538        _nextCoveredCoordinates.Clear();
 1891694539        for (int i = 0; i < _coveredVoxels.Count; i++)
 540        {
 937157541            Voxel voxel = _coveredVoxels[i];
 937157542            if (collider.IsPositionInMixedBounds(traversal.GetCellEdge(voxel), voxel.WorldPosition))
 374546543                _nextCoveredCoordinates.Add(voxel.WorldIndex);
 544        }
 545
 8690546        PhysicsMobilityType previousKind = GetStoredMobilityKind(collider.MixedPartitionKind);
 8690547        Remove2DPartitionMemberships(collider, coordinates, previousKind, previousKind == kind);
 8690548        coordinates.FastClear();
 1891694549        for (int i = 0; i < _coveredVoxels.Count; i++)
 937157550            TryPartition2DMixedVoxel(collider, coordinates, _coveredVoxels[i], kind);
 8690551    }
 552
 553    private void CollectCoveredMixedQueryPartitions(
 554        Vector3d min,
 555        Vector3d max,
 556        SwiftList<PhysicsMixedPartition> partitions)
 557    {
 11655558        partitions.FastClear();
 11655559        ScanCoveredMixedQueryPartitions(min, max, partitions);
 11655560    }
 561
 562    private void ScanCoveredMixedQueryPartitions(
 563        Vector3d queryMin,
 564        Vector3d queryMax,
 565        SwiftList<PhysicsMixedPartition> partitions)
 566    {
 11655567        GridTracer.GetCoveredVoxelsInto(
 11655568            _context.World,
 11655569            queryMin,
 11655570            queryMax,
 11655571            _coveredVoxels,
 11655572            _traceScratch,
 11655573            Fixed64.Half);
 574
 11655575        VisitCoveredVoxelsForMixedQuery(queryMin, queryMax, partitions);
 11655576    }
 577
 578    private void VisitCoveredVoxelsForMixedQuery(
 579        Vector3d queryMin,
 580        Vector3d queryMax,
 581        SwiftList<PhysicsMixedPartition> partitions)
 582    {
 11655583        GridWorld world = _context.World;
 11655584        var traversal = new GridTraversalState(world, GridTraversalPaddingMode.MaxCellEdge);
 18359236585        for (int i = 0; i < _coveredVoxels.Count; i++)
 586        {
 9167963587            Voxel voxel = _coveredVoxels[i];
 9167963588            Fixed64 cellEdge = traversal.GetCellEdge(voxel);
 589
 9167963590            if (!GridTraversal.IsWorldPositionInPaddedBounds(queryMin, queryMax, cellEdge, voxel.WorldPosition)
 9167963591                || !voxel.TryGetPartition(out PhysicsMixedPartition? partition)
 9167963592                || partition!.IsEmpty)
 593            {
 594                continue;
 595            }
 596
 1096098597            partitions.Add(partition);
 598        }
 11655599    }
 600
 601    private void Partition3DVoxel(
 602        LSCollider collider,
 603        SwiftList<WorldVoxelIndex> coordinates,
 604        Voxel voxel,
 605        PhysicsMobilityType kind)
 606    {
 924648607        PhysicsMixedPartition partition = GetOrCreatePartition(voxel);
 924648608        coordinates.Add(voxel.WorldIndex);
 924648609        Add3DObject(partition, collider.Id, kind);
 610        // Duplicate additions leave membership unchanged, including its awake
 611        // bit. Mixed refresh remains responsible for synchronizing that bit.
 924648612        if (kind == PhysicsMobilityType.Dynamic)
 782469613            partition.SetDynamic3DObjectAwake(collider.Id, collider.Body!.IsAwakeForCollision);
 924648614    }
 615
 616    private void TryPartition2DMixedVoxel(
 617        LSCollider2D collider,
 618        SwiftList<WorldVoxelIndex> coordinates,
 619        Voxel voxel,
 620        PhysicsMobilityType kind)
 621    {
 937157622        if (!_nextCoveredCoordinates.Contains(voxel.WorldIndex))
 562611623            return;
 624
 374546625        PhysicsMixedPartition partition = GetOrCreatePartition(voxel);
 374546626        coordinates.Add(voxel.WorldIndex);
 374546627        Add2DObject(partition, collider.Id, kind);
 374546628        if (kind == PhysicsMobilityType.Dynamic)
 96272629            partition.SetDynamic2DObjectAwake(collider.Id, collider.Body!.IsAwakeForCollision);
 374546630    }
 631
 632    private PhysicsMixedPartition GetOrCreatePartition(Voxel voxel)
 633    {
 1299194634        if (voxel.TryGetPartition(out PhysicsMixedPartition? partition))
 864289635            return partition!;
 636
 434905637        partition = RentPartition();
 434905638        ChronicleGuard.ThrowIfTrue(
 434905639            !voxel.TryAddPartition(partition),
 434905640            nameof(GravitasMixedCollisionService),
 434905641            "Unable to attach mixed physics partition to voxel.");
 642
 434905643        TrackRetainedPartition(partition);
 434905644        return partition;
 645    }
 646
 647    private void Get3DCoverageBounds(LSCollider collider, out Vector3d coverageMin, out Vector3d coverageMax)
 648    {
 31128649        coverageMin = collider.BoundsMin;
 31128650        coverageMax = collider.BoundsMax;
 31128651    }
 652
 653    private void Get2DMixedCoverageBounds(LSCollider2D collider, out Vector3d coverageMin, out Vector3d coverageMax)
 654    {
 35759655        FixedBoundBox bounds = collider.MixedBounds3D;
 35759656        coverageMin = bounds.Min;
 35759657        coverageMax = bounds.Max;
 35759658    }
 659
 660    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 661    private static PhysicsMobilityType Get3DMobilityKind(LSCollider collider)
 662    {
 51732663        if (collider.IsStatic)
 10038664            return PhysicsMobilityType.Static;
 665
 41694666        SolidBody? body = collider.Body;
 41694667        return body!.IsKinematic ? PhysicsMobilityType.Kinematic : PhysicsMobilityType.Dynamic;
 668    }
 669
 670    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 671    private static PhysicsMobilityType Get2DMobilityKind(LSCollider2D collider)
 672    {
 44449673        if (collider.IsStatic)
 28415674            return PhysicsMobilityType.Static;
 675
 16034676        SolidBody2D? body = collider.Body;
 16034677        return body!.IsKinematic ? PhysicsMobilityType.Kinematic : PhysicsMobilityType.Dynamic;
 678    }
 679
 680    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 681    private static PhysicsMobilityType GetStoredMobilityKind(int partitionKind)
 682    {
 29485683        return partitionKind == (int)PhysicsMobilityType.Kinematic
 29485684            ? PhysicsMobilityType.Kinematic
 29485685            : partitionKind == (int)PhysicsMobilityType.Static
 29485686                ? PhysicsMobilityType.Static
 29485687                : PhysicsMobilityType.Dynamic;
 688    }
 689
 690    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 691    private static void Add3DObject(PhysicsMixedPartition partition, int id, PhysicsMobilityType kind)
 692    {
 924648693        if (kind == PhysicsMobilityType.Static)
 694        {
 126338695            partition.AddStatic3DObject(id);
 126338696            return;
 697        }
 698
 798310699        if (kind == PhysicsMobilityType.Kinematic)
 700        {
 15841701            partition.AddKinematic3DObject(id);
 15841702            return;
 703        }
 704
 782469705        partition.AddDynamic3DObject(id);
 782469706    }
 707
 708    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 709    private static void Add2DObject(PhysicsMixedPartition partition, int id, PhysicsMobilityType kind)
 710    {
 374546711        if (kind == PhysicsMobilityType.Static)
 712        {
 273396713            partition.AddStatic2DObject(id);
 273396714            return;
 715        }
 716
 101150717        if (kind == PhysicsMobilityType.Kinematic)
 718        {
 4878719            partition.AddKinematic2DObject(id);
 4878720            return;
 721        }
 722
 96272723        partition.AddDynamic2DObject(id);
 96272724    }
 725
 726    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 727    private static void Remove3DObject(PhysicsMixedPartition partition, int id, PhysicsMobilityType kind)
 728    {
 37556729        if (kind == PhysicsMobilityType.Static)
 730        {
 8956731            partition.RemoveStatic3DObject(id);
 8956732            return;
 733        }
 734
 28600735        if (kind == PhysicsMobilityType.Kinematic)
 736        {
 5992737            partition.RemoveKinematic3DObject(id);
 5992738            return;
 739        }
 740
 22608741        partition.RemoveDynamic3DObject(id);
 22608742    }
 743
 744    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 745    private static void Remove2DObject(PhysicsMixedPartition partition, int id, PhysicsMobilityType kind)
 746    {
 10621747        if (kind == PhysicsMobilityType.Static)
 748        {
 4461749            partition.RemoveStatic2DObject(id);
 4461750            return;
 751        }
 752
 6160753        if (kind == PhysicsMobilityType.Kinematic)
 754        {
 1629755            partition.RemoveKinematic2DObject(id);
 1629756            return;
 757        }
 758
 4531759        partition.RemoveDynamic2DObject(id);
 4531760    }
 761
 762    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 763    private static bool MixedBoundsOverlap(LSCollider collider3D, LSCollider2D collider2D)
 764    {
 318098765        return collider3D.Bounds.Intersects(collider2D.MixedBounds3D);
 766    }
 767
 768    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 769    private static bool Is2DQueryCandidate(LSCollider2D collider, FixedBoundBox queryBounds, PhysicsLayerMask layerMask)
 770    {
 21103771        if (!layerMask.Includes(collider.Layer))
 3772            return false;
 773
 21100774        return collider.MixedBounds3D.Intersects(queryBounds);
 775    }
 776
 777    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 778    private static bool Is3DQueryCandidate(LSCollider collider, FixedBoundBox queryBounds, PhysicsLayerMask layerMask)
 779    {
 2089780        return collider.IsActive
 2089781            && layerMask.Includes(collider.Layer)
 2089782            && collider.Bounds.Intersects(queryBounds);
 783    }
 784
 113785    private void DetachRetainedPartitions() => RetainedPartitionLifecycle.DetachAll(
 113786            _retainedPartitions,
 113787            _emptyRetainedPartitions,
 113788            _context.World,
 113789            this,
 113790            _releaseRetainedPartition,
 113791            nameof(PhysicsMixedPartition),
 113792            "Unable to detach retained mixed physics partition from its voxel during reset.");
 793
 434906794    private void TrackRetainedPartition(PhysicsMixedPartition partition) => RetainedPartitionLifecycle.Track(
 434906795            _retainedPartitions,
 434906796            _emptyRetainedPartitions,
 434906797            this,
 434906798            partition,
 434906799            nameof(PhysicsMixedPartition));
 800
 434915801    private void UntrackRetainedPartition(PhysicsMixedPartition partition) => RetainedPartitionLifecycle.Untrack(
 434915802            _retainedPartitions,
 434915803            _emptyRetainedPartitions,
 434915804            this,
 434915805            partition,
 434915806            ref _retainedPartitionRetirementCursor);
 807
 546727808    internal void RefreshRetainedPartitionEligibility(PhysicsMixedPartition partition) => RetainedPartitionLifecycle.Ref
 546727809        _emptyRetainedPartitions, this, partition);
 810
 15999811    private void RetireExpiredRetainedPartitions() => RetainedPartitionLifecycle.RetireExpired(
 15999812            _retainedPartitions,
 15999813            _context.World,
 15999814            this,
 15999815            _context.Settings.RetainedPartitionRetirementSweepBudget,
 15999816            _context.FrameCount,
 15999817            _context.Settings.RetainedPartitionTimeToKillFrames,
 15999818            _releaseRetainedPartition,
 15999819            ref _retainedPartitionRetirementCursor);
 820
 434875821    private bool TryRetireEmptyRetainedPartitionForReuse() => RetainedPartitionLifecycle.TryRetireEmptyForReuse(
 434875822            _emptyRetainedPartitions,
 434875823            _inactivePartitionPool,
 434875824            _context.World,
 434875825            this,
 434875826            _releaseRetainedPartition);
 827
 828}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/Mixed/GravitasMixedCollisionService.ReplayHash.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasMixedCollisionService.ReplayHash.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 Chronicler.Hashing;
 9using Gravitas.Colliders;
 10using Gravitas.CollisionHandling;
 11using SwiftCollections;
 12
 13namespace Gravitas;
 14
 15/// <content>Writes mixed collision pairs and optional broad-phase cache state to the replay hash.</content>
 16internal sealed partial class GravitasMixedCollisionService
 17{
 18    internal void ContributeReplayHash(
 19        ref ChronicleHashWriter writer,
 20        GravitasReplayHashMode mode)
 21    {
 50922        SwiftList<LSCollider> replay3DColliders = _context.Physics.PrepareReplayColliders();
 50923        SwiftList<LSCollider2D> replay2DColliders = _context.Physics2D.PrepareReplayColliders();
 24
 50925        writer.WriteSection("physics.mixed", 2);
 50926        writer.WriteUInt32(Version);
 50927        writer.WriteInt32(ActivePairCount);
 28
 273229        for (int i = 0; i < replay3DColliders.Count; i++)
 30        {
 85731            int collider3DId = replay3DColliders[i].Id;
 556032            for (int j = 0; j < replay2DColliders.Count; j++)
 33            {
 192334                int collider2DId = replay2DColliders[j].Id;
 192335                ulong key = MixedColliderKey.CreateKey(collider3DId, collider2DId);
 192336                if (_pairs.TryGetValue(key, out CollisionPairMixed? pair))
 24937                    pair!.ContributeReplayHash(ref writer, mode);
 38            }
 39        }
 40
 50941        if (mode != GravitasReplayHashMode.AuthoritativeWithSolverCaches)
 27142            return;
 43
 23844        writer.WriteSection("physics.mixed.caches", 2);
 23845        writer.WriteInt32(ActivePartitionCount);
 23846        writer.WriteInt32(InactivePartitionCount);
 23847        writer.WriteInt32(RetainedPartitionCount);
 23848        writer.WriteInt32(PooledPairCount);
 23849        writer.WriteInt32(LastBroadPhaseCandidateCount);
 23850        writer.WriteInt32(SimulateCount);
 23851        writer.WriteInt32(LateSimulateCount);
 23852        writer.WriteInt32(VisualizeCount);
 23853        writer.WriteInt32(_retainedPartitionRetirementCursor);
 23854        writer.WriteInt64(_cached3DQueryRefreshFrame);
 23855        writer.WriteInt64(_cached3DQueryRefreshLateToken);
 23856        writer.WriteInt64(_cached2DQueryRefreshFrame);
 23857        writer.WriteInt64(_cached2DQueryRefreshLateToken);
 23858    }
 59}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/Mixed/GravitasMixedCollisionService.Response.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasMixedCollisionService.Response.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.Runtime.CompilerServices;
 9using Gravitas.Colliders;
 10using Gravitas.CollisionHandling;
 11
 12namespace Gravitas;
 13
 14/// <content>Builds mixed islands and solves every retained contact constraint.</content>
 15internal sealed partial class GravitasMixedCollisionService
 16{
 17    internal void JoinSleepIslands(SleepIslands islands, int planarOffset)
 18    {
 8019        foreach (var entry in _pairs)
 20        {
 1921            CollisionPairMixed pair = entry.Value;
 1922            if (!pair.Manifold.HasContact)
 23                continue;
 24
 1925            int spatial = _context.Physics.GetSleepSlot(pair.Collider3D.Body);
 1926            int planar = _context.Physics2D.GetSleepSlot(pair.Collider2D.Body, planarOffset);
 1927            if (spatial >= 0 && planar >= 0 && !pair.Collider3D.IsTrigger && !pair.Collider2D.IsTrigger
 1928                && RequireCollisionPair(pair.Collider3D, pair.Collider2D)
 1929                && CollisionResponseMixed.HasPlanarResponseCoupling(pair.Manifold))
 1830                islands.Join(spatial, planar);
 31        }
 2132    }
 33
 34    private void SolveMixedResponsePairs()
 35    {
 36        // A later member callback can retire a previously queued carrier or supplier.
 6384037        for (int i = _mixedResponsePairs.Count - 1; i >= 0; i--)
 38        {
 1592139            CollisionPairMixed pair = _mixedResponsePairs[i];
 1592140            bool current = IsCurrentPair(new MixedPairLifetimeToken(pair))
 1592141                && !pair.Collider3D.IsTrigger && !pair.Collider2D.IsTrigger
 1592142                && RequireCollisionPair(pair.Collider3D, pair.Collider2D);
 1592143            if (current && !pair.HasCurrentManifoldCache)
 44            {
 1145                ContactManifold rebuilt = _context.CollisionScratch.MixedManifold;
 1146                current = CollisionDetectionMixed.TryBuildDiscreteManifold(pair.Collider3D, pair.Collider2D, rebuilt);
 2047                if (current) pair.MarkResting(_context.FrameCount, rebuilt);
 48            }
 1722149            if (!current || !pair.Manifold.HasContact) _mixedResponsePairs.RemoveAt(i);
 50        }
 1599951        if (_mixedResponsePairs.Count == 0)
 260852            return;
 53
 1339154        if (_mixedResponsePairs.Count == 1)
 55        {
 1220256            CollisionPairMixed pair = _mixedResponsePairs[0];
 1220257            bool hasPlanarResponseCoupling = CollisionResponseMixed.HasPlanarResponseCoupling(pair.Manifold);
 1220258            if (!ShouldSolveSingleMixedPair(pair, hasPlanarResponseCoupling))
 259                return;
 60
 1220061            if (hasPlanarResponseCoupling)
 1039762                pair.WakeSleepingBodiesForCollision();
 1220063            CollisionResponseMixed.ResolveManifold(pair);
 1220064            return;
 65        }
 66
 118967        _mixedResponsePairs.SortInPlace(ResponsePairComparer);
 118968        BuildMixedIslands();
 118969        if (_mixedIslandConstraints.Count == 0)
 170            return;
 71
 118872        _mixedIslandConstraints.SortInPlace(IslandConstraintComparer);
 73
 118874        int start = 0;
 242875        while (start < _mixedIslandConstraints.Count)
 76        {
 124077            int rootKey = _mixedIslandConstraints[start].RootKey;
 124078            int end = start + 1;
 241679            while (end < _mixedIslandConstraints.Count
 241680                && _mixedIslandConstraints[end].RootKey == rootKey)
 81            {
 117682                end++;
 83            }
 84
 124085            if (WakeMixedIslandBodies(rootKey))
 123886                SolveMixedIslandRange(rootKey, start, end);
 87
 124088            start = end;
 89        }
 118890    }
 91
 92    private void BuildMixedIslands()
 93    {
 118994        _mixedIslandNodes.FastClear();
 118995        _mixedIslandConstraints.FastClear();
 96
 721697        for (int i = 0; i < _mixedResponsePairs.Count; i++)
 98        {
 241999            CollisionPairMixed pair = _mixedResponsePairs[i];
 2419100            AddMixedIslandNodeIfMovable(pair.Collider3D.Body);
 2419101            AddMixedIslandNodeIfMovable(pair.Collider2D.Body);
 102        }
 103
 1189104        SortAndDeduplicateMixedIslandNodes();
 1189105        if (_mixedIslandNodes.Count == 0)
 1106            return;
 107
 7210108        for (int i = 0; i < _mixedResponsePairs.Count; i++)
 109        {
 2417110            CollisionPairMixed pair = _mixedResponsePairs[i];
 2417111            int node3D = FindMixedIslandNode(pair.Collider3D.Body);
 2417112            int node2D = FindMixedIslandNode(pair.Collider2D.Body);
 2417113            if (CollisionResponseMixed.HasPlanarResponseCoupling(pair.Manifold)
 2417114                && node3D >= 0
 2417115                && node2D >= 0)
 19116                UnionMixedIslandNodes(node3D, node2D);
 117        }
 118
 1188119        CompressMixedIslandRoots();
 120
 7210121        for (int i = 0; i < _mixedResponsePairs.Count; i++)
 122        {
 2417123            CollisionPairMixed pair = _mixedResponsePairs[i];
 2417124            int node3D = FindMixedIslandNode(pair.Collider3D.Body);
 2417125            int node2D = FindMixedIslandNode(pair.Collider2D.Body);
 2417126            int rootKey = ResolveMixedConstraintRootKey(node3D, node2D);
 2417127            if (rootKey < 0)
 128                continue;
 129
 2416130            _mixedIslandConstraints.Add(new MixedIslandConstraint(pair, rootKey, pair.Key));
 131        }
 1188132    }
 133
 134    private void AddMixedIslandNodeIfMovable(SolidBody? body)
 135    {
 2419136        if (!IsMovableMixedIslandBody(body))
 35137            return;
 138
 2384139        _mixedIslandNodes.Add(new MixedIslandNode(Create3DBodyKey(body!), body!, null));
 2384140    }
 141
 142    private void AddMixedIslandNodeIfMovable(SolidBody2D? body)
 143    {
 2419144        if (!IsMovableMixedIslandBody(body))
 2348145            return;
 146
 71147        _mixedIslandNodes.Add(new MixedIslandNode(Create2DBodyKey(body!), null, body!));
 71148    }
 149
 150    private void SortAndDeduplicateMixedIslandNodes() =>
 1189151        IslandGraphUtility.SortAndDeduplicate(_mixedIslandNodes, IslandNodeComparer);
 152
 153    private int FindMixedIslandNode(SolidBody? body)
 154    {
 4834155        if (!IsMovableMixedIslandBody(body))
 66156            return -1;
 157
 4768158        return FindMixedIslandNode(Create3DBodyKey(body!));
 159    }
 160
 161    private int FindMixedIslandNode(SolidBody2D? body)
 162    {
 4834163        if (!IsMovableMixedIslandBody(body))
 4692164            return -1;
 165
 142166        return FindMixedIslandNode(Create2DBodyKey(body!));
 167    }
 168
 169    private int FindMixedIslandNode(int key) =>
 4910170        IslandGraphUtility.Find(_mixedIslandNodes, key);
 171
 172    private void UnionMixedIslandNodes(int nodeA, int nodeB) =>
 19173        IslandGraphUtility.Union(_mixedIslandNodes, nodeA, nodeB);
 174
 175    private void CompressMixedIslandRoots() =>
 1188176        IslandGraphUtility.CompressRoots(_mixedIslandNodes);
 177
 178    private int ResolveMixedConstraintRootKey(int node3D, int node2D) =>
 2417179        IslandGraphUtility.ResolveConstraintRootKey(_mixedIslandNodes, node3D, node2D);
 180
 181    private bool WakeMixedIslandBodies(int rootKey) =>
 1240182        IslandGraphUtility.WakeBodies(_mixedIslandNodes, rootKey);
 183
 184    private void SolveMixedIslandRange(int rootKey, int start, int end)
 185    {
 1238186        if (end - start == 1)
 187        {
 94188            CollisionPairMixed pair = _mixedIslandConstraints[start].Pair;
 94189            CollisionResponseMixed.ResolveManifold(pair);
 94190            return;
 191        }
 192
 193        // Snapshot every pair before the first row changes an island participant.
 6928194        for (int i = start; i < end; i++)
 2320195            CollisionResponseMixed.PrepareSolve(_mixedIslandConstraints[i].Pair);
 1144196        int iterationLimit = _context.Settings.DiscreteSolverIterations;
 1144197        int iterationsUsed = 0;
 15978198        for (int iteration = 0; iteration < iterationLimit; iteration++)
 199        {
 6845200            bool applyPositionCorrection = iteration == 0;
 41454201            for (int i = start; i < end; i++)
 202            {
 13882203                CollisionPairMixed pair = _mixedIslandConstraints[i].Pair;
 13882204                CollisionResponseMixed.ResolveManifold(
 13882205                    pair,
 13882206                    iteration,
 13882207                    iterationLimit,
 13882208                    applyPositionCorrection);
 209            }
 210
 6845211            iterationsUsed = iteration + 1;
 212        }
 6928213        for (int i = start; i < end; i++)
 2320214            _mixedIslandConstraints[i].Pair.ResponseSnapshot = default;
 215
 1144216        _context.Diagnostics.EmitMixedResponseIsland(
 1144217            rootKey,
 1144218            end - start,
 1144219            iterationsUsed,
 1144220            iterationsUsed >= iterationLimit);
 1144221    }
 222
 223    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 224    private static bool HasAwakeMovableParticipant(LSCollider collider3D, LSCollider2D collider2D) =>
 16828225        IsAwakeMovable(collider3D.Body) || IsAwakeMovable(collider2D.Body);
 226
 227    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 228    private static bool HasAwakeResponseParticipant(CollisionPairMixed pair) =>
 10397229        IsAwakeMovable(pair.Collider3D.Body) || IsAwakeMovable(pair.Collider2D.Body);
 230
 231    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 232    private static bool ShouldSolveSingleMixedPair(CollisionPairMixed pair, bool hasPlanarResponseCoupling)
 233    {
 12202234        if (hasPlanarResponseCoupling)
 10397235            return HasAwakeResponseParticipant(pair);
 236
 1805237        return IsMovableMixedIslandBody(pair.Collider3D.Body)
 1805238            ? IsAwakeMovable(pair.Collider3D.Body)
 1805239            : IsAwakeMovable(pair.Collider2D.Body);
 240    }
 241
 242    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 243    private static bool IsAwakeMovable(SolidBody? body) =>
 27504244        body != null && body.HasSolverMobility && !body.IsSleeping;
 245
 246    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 247    private static bool IsAwakeMovable(SolidBody2D? body) =>
 9168248        body != null && body.HasSolverMobility && !body.IsSleeping;
 249
 250    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 251    private static bool IsMovableMixedIslandBody(SolidBody? body) =>
 9058252        body != null && body.DynamicId >= 0 && body.HasSolverMobility;
 253
 254    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 255    private static bool IsMovableMixedIslandBody(SolidBody2D? body) =>
 7253256        body != null && body.DynamicId >= 0 && body.HasSolverMobility;
 257
 258    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 259    private static int Create3DBodyKey(SolidBody body) =>
 7152260        body.DynamicId << 1;
 261
 262    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 263    private static int Create2DBodyKey(SolidBody2D body) =>
 213264        (body.DynamicId << 1) | 1;
 265
 266}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/Mixed/GravitasMixedCollisionService.SupportTypes.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasMixedCollisionService.SupportTypes.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.Collections.Generic;
 9using Gravitas.Colliders;
 10using Gravitas.CollisionHandling;
 11
 12namespace Gravitas;
 13
 14/// <content>Provides deterministic ordering and response-island records for mixed collision solving.</content>
 15internal sealed partial class GravitasMixedCollisionService
 16{
 17    private sealed class PhysicsMixedPartitionOrderComparer : IComparer<PhysicsMixedPartition>
 18    {
 19        public int Compare(PhysicsMixedPartition? left, PhysicsMixedPartition? right) =>
 733239320            WorldVoxelIndexOrdering.Compare3D(left!.WorldIndex, right!.WorldIndex);
 21    }
 22
 23    private sealed class MixedColliderKeyComparer : IComparer<MixedColliderKey>
 24    {
 25        public int Compare(MixedColliderKey left, MixedColliderKey right) =>
 342726            left.Key.CompareTo(right.Key);
 27    }
 28
 29    private sealed class MixedResponsePairComparer : IComparer<CollisionPairMixed>
 30    {
 31        public int Compare(CollisionPairMixed? left, CollisionPairMixed? right) =>
 123032            left!.Key.CompareTo(right!.Key);
 33    }
 34
 35    private sealed class MixedIslandConstraintComparer : IComparer<MixedIslandConstraint>
 36    {
 37        public int Compare(MixedIslandConstraint left, MixedIslandConstraint right)
 38        {
 122839            int compare = left.RootKey.CompareTo(right.RootKey);
 122840            if (compare != 0)
 5241                return compare;
 42
 117643            return left.PairKey.CompareTo(right.PairKey);
 44        }
 45    }
 46
 47    private sealed class Collider2DIdComparer : IComparer<LSCollider2D>
 48    {
 49        public int Compare(LSCollider2D? left, LSCollider2D? right) =>
 1286450            left!.Id.CompareTo(right!.Id);
 51    }
 52
 53    private sealed class Collider3DIdComparer : IComparer<LSCollider>
 54    {
 55        public int Compare(LSCollider? left, LSCollider? right) =>
 49656            left!.Id.CompareTo(right!.Id);
 57    }
 58
 59    private struct MixedIslandNode : IIslandNodeState
 60    {
 61        public MixedIslandNode(int bodyKey, SolidBody? body3D, SolidBody2D? body2D)
 62        {
 245563            BodyKey = bodyKey;
 245564            Body3D = body3D;
 245565            Body2D = body2D;
 245566            ParentIndex = -1;
 245567            RootKey = bodyKey;
 245568        }
 69
 70        public int BodyKey { get; }
 71
 72        public SolidBody? Body3D { get; }
 73
 74        public SolidBody2D? Body2D { get; }
 75
 76        public int ParentIndex { get; set; }
 77
 78        public int RootKey { get; set; }
 79
 80        public bool IsAwakeForCollision =>
 124081            Body3D?.IsAwakeForCollision ?? Body2D!.IsAwakeForCollision;
 82
 83        public void WakeFromCollision()
 84        {
 125785            if (Body3D != null)
 86            {
 121687                Body3D.WakeFromCollision();
 121688                return;
 89            }
 90
 4191            Body2D!.WakeFromCollision();
 4192        }
 93    }
 94
 95    private readonly struct MixedIslandConstraint
 96    {
 97        public MixedIslandConstraint(CollisionPairMixed pair, int rootKey, ulong pairKey)
 98        {
 241699            Pair = pair;
 2416100            RootKey = rootKey;
 2416101            PairKey = pairKey;
 2416102        }
 103
 104        public CollisionPairMixed Pair { get; }
 105
 106        public int RootKey { get; }
 107
 108        public ulong PairKey { get; }
 109    }
 110}

Methods/Properties

.cctor()
.ctor(Gravitas.GravitasWorldContext)
get_Context()
get_ActivePartitionCount()
get_InactivePartitionCount()
get_InactivePartitionMembershipCount()
get_RetainedPartitionCount()
get_ActivePairCount()
get_PooledPairCount()
GetCandidate(System.Int32)
Simulate()
LateSimulate()
ProcessMixedContacts()
DistributeMixedCandidates()
Visualize()
Reset()
RemovePairsFor3DCollider(Gravitas.Colliders.LSCollider)
InvalidatePairsFor3DColliderReconfiguration(Gravitas.Colliders.LSCollider,SwiftCollections.SwiftList`1<System.Exception>&)
QueuePairsFor3DCollider(Gravitas.Colliders.LSCollider)
RemovePairsFor2DCollider(Gravitas.Colliders.LSCollider2D)
RequireCollisionPair(Gravitas.Colliders.LSCollider,Gravitas.Colliders.LSCollider2D)
InvalidateSurfaceContacts(Gravitas.StaticSurface,Gravitas.StaticSurface2D,SwiftCollections.SwiftHashSet`1<System.Int32>)
ProcessCandidate(Gravitas.MixedColliderKey,System.Int64)
CleanupUntouchedPairs(System.Int64)
TryKeepUntouchedPair(Gravitas.CollisionHandling.CollisionPairMixed,System.Int64)
CreatePair(Gravitas.Colliders.LSCollider,Gravitas.Colliders.LSCollider2D)
RemoveQueuedPairs(System.Int32,System.Int32)
RemoveQueuedPairs(System.Int32,System.Int32,SwiftCollections.SwiftList`1<System.Exception>&)
IsCurrentPair(Gravitas.MixedPairLifetimeToken&)
RemoveCurrentPair(Gravitas.MixedPairLifetimeToken&)
RecyclePair(Gravitas.CollisionHandling.CollisionPairMixed)
Refresh3DColliderPartition(Gravitas.Colliders.LSCollider)
Refresh2DColliderPartition(Gravitas.Colliders.LSCollider2D)
Refresh2DColliderPartition(Gravitas.Colliders.LSCollider2D,System.Boolean)
ClearPartitioned3DCollider(Gravitas.Colliders.LSCollider,System.Boolean)
Remove3DPartitionMemberships(Gravitas.Colliders.LSCollider,SwiftCollections.SwiftList`1<GridForge.Spatial.WorldVoxelIndex>,Gravitas.PhysicsMobilityType,System.Boolean)
ClearPartitioned2DCollider(Gravitas.Colliders.LSCollider2D,System.Boolean)
Remove2DPartitionMemberships(Gravitas.Colliders.LSCollider2D,SwiftCollections.SwiftList`1<GridForge.Spatial.WorldVoxelIndex>,Gravitas.PhysicsMobilityType,System.Boolean)
Refresh3DPartitionAwakeState(Gravitas.Colliders.LSCollider)
Refresh2DPartitionAwakeState(Gravitas.Colliders.LSCollider2D)
ProcessPartitionCandidate(System.Int32,System.Int32)
Collect2DCandidatesInMixedBounds(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Colliders.LSCollider2D>,System.Boolean,System.Boolean)
Collect3DCandidatesInMixedBounds(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Colliders.LSCollider>,System.Boolean,System.Boolean)
ActivatePartition(Gravitas.PhysicsMixedPartition)
DeactivatePartition(System.Int32)
RentPartition()
ReleasePartition(Gravitas.PhysicsMixedPartition)
RentPartitionMembership()
ReleasePartitionMembership(SwiftCollections.SwiftHashSet`1<System.Int32>&)
Refresh3DColliderPartitions()
Refresh3DColliderPartitionsForQuery(System.Boolean)
Refresh2DColliderPartitions(System.Boolean)
Refresh2DColliderPartitionsForQuery(System.Boolean)
Partition3DCollider(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d)
Partition2DCollider(Gravitas.Colliders.LSCollider2D,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d)
ScanCovered3DVoxels(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,SwiftCollections.SwiftList`1<GridForge.Spatial.WorldVoxelIndex>,Gravitas.PhysicsMobilityType)
ScanCovered2DMixedVoxels(Gravitas.Colliders.LSCollider2D,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,SwiftCollections.SwiftList`1<GridForge.Spatial.WorldVoxelIndex>,Gravitas.PhysicsMobilityType)
CollectCoveredMixedQueryPartitions(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,SwiftCollections.SwiftList`1<Gravitas.PhysicsMixedPartition>)
ScanCoveredMixedQueryPartitions(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,SwiftCollections.SwiftList`1<Gravitas.PhysicsMixedPartition>)
VisitCoveredVoxelsForMixedQuery(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,SwiftCollections.SwiftList`1<Gravitas.PhysicsMixedPartition>)
Partition3DVoxel(Gravitas.Colliders.LSCollider,SwiftCollections.SwiftList`1<GridForge.Spatial.WorldVoxelIndex>,GridForge.Grids.Voxel,Gravitas.PhysicsMobilityType)
TryPartition2DMixedVoxel(Gravitas.Colliders.LSCollider2D,SwiftCollections.SwiftList`1<GridForge.Spatial.WorldVoxelIndex>,GridForge.Grids.Voxel,Gravitas.PhysicsMobilityType)
GetOrCreatePartition(GridForge.Grids.Voxel)
Get3DCoverageBounds(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d&,FixedMathSharp.Vector3d&)
Get2DMixedCoverageBounds(Gravitas.Colliders.LSCollider2D,FixedMathSharp.Vector3d&,FixedMathSharp.Vector3d&)
Get3DMobilityKind(Gravitas.Colliders.LSCollider)
Get2DMobilityKind(Gravitas.Colliders.LSCollider2D)
GetStoredMobilityKind(System.Int32)
Add3DObject(Gravitas.PhysicsMixedPartition,System.Int32,Gravitas.PhysicsMobilityType)
Add2DObject(Gravitas.PhysicsMixedPartition,System.Int32,Gravitas.PhysicsMobilityType)
Remove3DObject(Gravitas.PhysicsMixedPartition,System.Int32,Gravitas.PhysicsMobilityType)
Remove2DObject(Gravitas.PhysicsMixedPartition,System.Int32,Gravitas.PhysicsMobilityType)
MixedBoundsOverlap(Gravitas.Colliders.LSCollider,Gravitas.Colliders.LSCollider2D)
Is2DQueryCandidate(Gravitas.Colliders.LSCollider2D,FixedMathSharp.Geometry.FixedBoundBox,Gravitas.Support.PhysicsLayerMask)
Is3DQueryCandidate(Gravitas.Colliders.LSCollider,FixedMathSharp.Geometry.FixedBoundBox,Gravitas.Support.PhysicsLayerMask)
DetachRetainedPartitions()
TrackRetainedPartition(Gravitas.PhysicsMixedPartition)
UntrackRetainedPartition(Gravitas.PhysicsMixedPartition)
RefreshRetainedPartitionEligibility(Gravitas.PhysicsMixedPartition)
RetireExpiredRetainedPartitions()
TryRetireEmptyRetainedPartitionForReuse()
ContributeReplayHash(Chronicler.Hashing.ChronicleHashWriter&,Gravitas.GravitasReplayHashMode)
JoinSleepIslands(Gravitas.SleepIslands,System.Int32)
SolveMixedResponsePairs()
BuildMixedIslands()
AddMixedIslandNodeIfMovable(Gravitas.SolidBody)
AddMixedIslandNodeIfMovable(Gravitas.SolidBody2D)
SortAndDeduplicateMixedIslandNodes()
FindMixedIslandNode(Gravitas.SolidBody)
FindMixedIslandNode(Gravitas.SolidBody2D)
FindMixedIslandNode(System.Int32)
UnionMixedIslandNodes(System.Int32,System.Int32)
CompressMixedIslandRoots()
ResolveMixedConstraintRootKey(System.Int32,System.Int32)
WakeMixedIslandBodies(System.Int32)
SolveMixedIslandRange(System.Int32,System.Int32,System.Int32)
HasAwakeMovableParticipant(Gravitas.Colliders.LSCollider,Gravitas.Colliders.LSCollider2D)
HasAwakeResponseParticipant(Gravitas.CollisionHandling.CollisionPairMixed)
ShouldSolveSingleMixedPair(Gravitas.CollisionHandling.CollisionPairMixed,System.Boolean)
IsAwakeMovable(Gravitas.SolidBody)
IsAwakeMovable(Gravitas.SolidBody2D)
IsMovableMixedIslandBody(Gravitas.SolidBody)
IsMovableMixedIslandBody(Gravitas.SolidBody2D)
Create3DBodyKey(Gravitas.SolidBody)
Create2DBodyKey(Gravitas.SolidBody2D)
Compare(Gravitas.PhysicsMixedPartition,Gravitas.PhysicsMixedPartition)
Compare(Gravitas.MixedColliderKey,Gravitas.MixedColliderKey)
Compare(Gravitas.CollisionHandling.CollisionPairMixed,Gravitas.CollisionHandling.CollisionPairMixed)
Compare(Gravitas.GravitasMixedCollisionService/MixedIslandConstraint,Gravitas.GravitasMixedCollisionService/MixedIslandConstraint)
Compare(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D)
Compare(Gravitas.Colliders.LSCollider,Gravitas.Colliders.LSCollider)
.ctor(System.Int32,Gravitas.SolidBody,Gravitas.SolidBody2D)
get_IsAwakeForCollision()
WakeFromCollision()
.ctor(Gravitas.CollisionHandling.CollisionPairMixed,System.Int32,System.UInt64)