< Summary

Line coverage
100%
Covered lines: 989
Uncovered lines: 0
Coverable lines: 989
Total lines: 1965
Line coverage: 100%
Branch coverage
100%
Covered branches: 584
Total branches: 584
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: InvalidatePairsForColliderReconfiguration(...)100%2222100%
File 2: PrepareContinuousCollisionFrame()100%1212100%
File 2: AddContinuousCollisionCandidate(...)100%44100%
File 2: QueryPlanarContinuousCollisionCandidates(...)100%11100%
File 2: RefreshContinuousCollisionCandidate(...)100%22100%
File 2: CanAdmitContinuousCollisionCandidateRefresh(...)100%11100%
File 2: TryReserveContinuousCollisionCandidateRefresh(...)100%22100%
File 2: ReleaseContinuousCollisionCandidateRefresh(...)100%11100%
File 2: ReleaseContinuousCollisionCandidateRefresh(...)100%22100%
File 2: InvalidateContinuousCollisionStateForBodyMutation(...)100%22100%
File 2: CanAdmitContinuousCollisionCandidateRefresh(...)100%11100%
File 2: TryReserveContinuousCollisionCandidateRefresh(...)100%11100%
File 2: QueryMixedContinuousCollisionCandidates(...)100%22100%
File 2: MergeContinuousCollisionCandidateIds()100%1212100%
File 2: TryGetContinuousCollisionCandidate(...)100%44100%
File 2: GetContinuousCollisionCandidate(...)100%11100%
File 2: QueueContinuousCollisionHandoff(...)100%44100%
File 2: ProcessQueuedContinuousCollisionHandoffs()100%11100%
File 2: ReportContinuousCollisionIterationLimit()100%11100%
File 2: ProcessQueuedContinuousCollisionHandoffs(...)100%1414100%
File 2: BeginContinuousCollisionHandoffFrame()100%11100%
File 2: AbortContinuousCollisionHandoffFrame()100%11100%
File 2: ClearContinuousCollisionHandoffQueue()100%11100%
File 2: DiscardContinuousCollisionHandoffQueue()100%22100%
File 3: .cctor()100%11100%
File 3: .ctor(...)100%11100%
File 3: get_ColliderCount()100%11100%
File 3: AssimilateBody(...)100%44100%
File 3: RefreshBodyMotionTypeRegistration(...)100%1010100%
File 3: AssimilateCollider(...)100%11100%
File 3: DessimilateBody(...)100%44100%
File 3: DessimilateCollider(...)100%88100%
File 3: CreateStaticSurface(...)100%11100%
File 3: RemoveStaticSurface(...)100%11100%
File 3: ReleaseStaticSurfaces()100%22100%
File 3: Simulate()100%22100%
File 3: LateSimulate()100%22100%
File 3: BeginLateSimulateBodies(...)100%66100%
File 3: CompleteLateSimulatePhysicsStep(...)100%22100%
File 3: MarkCollisionPositionPublicationPending()100%11100%
File 3: PublishCollisionPositionStates()100%44100%
File 3: PrepareCollisionPartitions()100%44100%
File 3: RunDiscreteCollisionStep()100%11100%
File 3: Visualize()100%22100%
File 3: Reset()100%11100%
File 3: TryGetColliderById(...)100%11100%
File 3: TryGetColliderByServiceIndex(...)100%11100%
File 3: GetColliderByServiceIndex(...)100%11100%
File 3: PrepareReplayColliders()100%11100%
File 3: TryGetDynamicBody(...)100%11100%
File 3: RefreshColliderServiceRefreshRegistration(...)100%22100%
File 3: AddServiceRefreshCollider(...)100%11100%
File 3: RemoveServiceRefreshCollider(...)100%66100%
File 3: EnsureFrameCapacity()100%44100%
File 4: .ctor(...)100%11100%
File 4: .ctor(...)100%11100%
File 4: get_IsActive()100%11100%
File 4: .ctor(...)100%11100%
File 4: get_IsCurrentLifetime()100%11100%
File 4: RefreshGroundingFromDiscreteResponse(...)100%3434100%
File 4: ShouldUseDiscreteGroundingPair(...)100%44100%
File 4: ShouldUseDiscreteGroundingManifold(...)100%22100%
File 5: ProcessPartitionCandidate(...)100%1212100%
File 5: IsCanonicalSharedPartition(...)100%1010100%
File 5: Max(...)100%22100%
File 5: TryGetMinimumVoxelIndexForGrid(...)100%1212100%
File 5: ProcessCandidate(...)100%2020100%
File 5: RegisterPair(...)100%11100%
File 5: ExpandDiscreteResponsePairs(...)100%88100%
File 5: AddExistingResponsePairs(...)100%1414100%
File 5: TryAddExistingResponsePair(...)100%1818100%
File 5: AddDiscreteResponseBody(...)100%44100%
File 5: IsCurrentResponsePair(...)100%1414100%
File 5: RequireCollisionPair(...)100%2020100%
File 5: CleanupUntouchedPairs(...)100%1010100%
File 5: TryKeepUntouchedPair(...)100%1212100%
File 5: CreatePair(...)100%44100%
File 5: RecyclePair(...)100%44100%
File 5: RemovePairsForCollider(...)100%1818100%
File 5: ClearWarmStartCachesForCollider(...)100%1616100%
File 6: ContributeReplayHash(...)100%2424100%
File 6: TryGetReplayHashPair(...)100%22100%
File 7: get_BodySlotCount()100%11100%
File 7: GetSleepSlot(...)100%88100%
File 7: AdvanceSleepCounters()100%22100%
File 7: BlockUnreadySleepIslands(...)100%88100%
File 7: SleepReadyIslands(...)100%66100%
File 7: JoinSleepIslands(...)100%1818100%
File 7: SolveDiscreteResponsePairs()100%2626100%
File 7: BuildDiscreteIslands()100%1414100%
File 7: AddJointIslandNodes()100%44100%
File 7: UnionJointIslandNodes()100%88100%
File 7: AddJointIslandConstraints()100%44100%
File 7: AddIslandNodeIfMovable(...)100%22100%
File 7: SortAndDeduplicateIslandNodes()100%11100%
File 7: FindIslandNode(...)100%22100%
File 7: UnionIslandNodes(...)100%11100%
File 7: CompressIslandRoots()100%11100%
File 7: ResolveConstraintRootKey(...)100%11100%
File 7: WakeIslandBodies(...)100%11100%
File 7: SolveDiscreteIslandRange(...)100%3232100%
File 8: HasAwakeMovableParticipant(...)100%22100%
File 8: HasAwakeResponseParticipant(...)100%22100%
File 8: IsAwakeMovable(...)100%44100%
File 8: IsMovableIslandBody(...)100%44100%
File 8: IsAwakeIslandBody(...)100%22100%
File 8: IsLayerCollisionDisabled(...)100%44100%
File 8: RemovePairReferences(...)100%66100%
File 8: CreatePairKey(...)100%22100%
File 8: GetStablePairKey(...)100%22100%
File 8: GetStableJointKey(...)100%22100%
File 8: Compare(...)100%22100%
File 8: Compare(...)100%88100%
File 8: .ctor(...)100%11100%
File 8: get_IsAwakeForCollision()100%11100%
File 8: WakeFromCollision()100%11100%
File 8: .ctor(...)100%11100%
File 8: CreatePair(...)100%11100%
File 8: CreateJoint(...)100%11100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/2D/Services/GravitasPhysics2DService.ColliderReconfiguration.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasPhysics2DService.ColliderReconfiguration.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.Colliders;
 10using Gravitas.CollisionHandling;
 11using SwiftCollections;
 12
 13namespace Gravitas;
 14
 15/// <content>Retires exact pair lifetimes after accepted native 2D posture changes.</content>
 16public sealed partial class GravitasPhysics2DService
 17{
 18    internal void InvalidatePairsForColliderReconfiguration(
 19        LSCollider2D collider, ref SwiftList<Exception>? notificationExceptions)
 20    {
 21        // Invocation-local snapshots survive nested transactions and callbacks
 22        // that remove, recycle, or recreate a pair under the same collider IDs.
 5523        var snapshot = new SwiftList<(CollisionPair2D Pair, long Lifetime)>();
 5524        if (collider.CollisionPairs != null)
 25        {
 3226            foreach (var entry in collider.CollisionPairs)
 1027                snapshot.Add((entry.Value, entry.Value.LifetimeVersion));
 28        }
 5529        if (collider.CollisionPairHolders != null)
 30        {
 1431            foreach (int holderId in collider.CollisionPairHolders)
 32            {
 133                if (TryGetColliderById(holderId, out LSCollider2D? holder)
 134                    && holder!.TryGetCollisionPair(collider.Id, out CollisionPair2D? pair))
 135                    snapshot.Add((pair!, pair!.LifetimeVersion));
 36            }
 37        }
 38
 13239        for (int i = 0; i < snapshot.Count; i++)
 40        {
 1141            var token = snapshot[i];
 1142            CollisionPair2D pair = token.Pair;
 1143            ulong key = CreatePairKey(pair.Id1, pair.Id2);
 1144            if (pair.LifetimeVersion != token.Lifetime
 1145                || !_pairs.TryGetValue(key, out CollisionPair2D current)
 1146                || !ReferenceEquals(current, pair))
 47                continue;
 48
 749            RemovePairReferences(pair);
 750            _pairs.Remove(key);
 51            try
 52            {
 753                pair.MarkSeparated();
 454            }
 355            catch (Exception exception)
 56            {
 357                CollisionNotificationExceptions.Capture(ref notificationExceptions, exception);
 358            }
 59            finally
 60            {
 761                if (pair.LifetimeVersion == token.Lifetime)
 762                    RecyclePair(pair);
 763            }
 64        }
 65        // Do not clear whole pair tables or hierarchy: callbacks may have
 66        // published a new registration or fresh pair ownership on this shell.
 5567    }
 68}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/2D/Services/GravitasPhysics2DService.ContinuousCollision.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasPhysics2DService.ContinuousCollision.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 FixedMathSharp;
 9using Gravitas.Colliders;
 10using Gravitas.CollisionHandling;
 11using SwiftCollections;
 12using SwiftCollections.Query;
 13
 14namespace Gravitas;
 15
 16/// <content>Maintains planar sweep candidates and coordinates continuous collision handoffs and iteration limits.</cont
 17public sealed partial class GravitasPhysics2DService
 18{
 19    internal void PrepareContinuousCollisionFrame()
 20    {
 5212521        long token = _context.LateSimulateToken;
 5212522        bool buildMixedIndex = _context.Settings.RuntimeMode.RunsMixedContacts();
 5212523        if (_continuousCollisionPreparedToken == token
 5212524            && _continuousCollisionPreparedMixedIndex == buildMixedIndex)
 25        {
 2753326            return;
 27        }
 28
 2459229        _planarContinuousCollisionCandidates.Clear();
 2459230        _dirtyPlanarContinuousCollisionCandidates.Clear();
 2459231        _dirtyPlanarContinuousCollisionBodies.FastClear();
 2459232        _dirtyPlanarContinuousCollisionBodySet.Clear();
 2459233        _mixedContinuousCollisionCandidates.Clear();
 2459234        _dirtyMixedContinuousCollisionCandidates.Clear();
 2459235        int bodyLimit = _dynamicBodies.PeakCount;
 8264236        for (int i = 0; i < bodyLimit; i++)
 37        {
 1673238            if (_dynamicBodies.TryGetValue(i, out SolidBody2D body)
 1673239                && body.EnsureContinuousCollisionFramePrepared(token, refreshGroundSupport: true))
 40            {
 1564941                AddContinuousCollisionCandidate(body, buildMixedIndex);
 42            }
 43        }
 44
 2458945        _planarContinuousCollisionCandidates.Sort();
 2458946        if (buildMixedIndex)
 1620347            _mixedContinuousCollisionCandidates.Sort();
 48
 2458949        _continuousCollisionPreparedToken = token;
 2458950        _continuousCollisionPreparedMixedIndex = buildMixedIndex;
 2458951    }
 52
 53    private void AddContinuousCollisionCandidate(SolidBody2D body, bool buildMixedIndex)
 54    {
 1564955        Fixed64 planarRadius = body.ResolveContinuousCollisionProxyRadius();
 1564956        if (planarRadius <= Fixed64.Epsilon)
 457            return;
 58
 1564559        _continuousCollisionCandidateLifetimes[body.DynamicId] =
 1564560            new ColliderLifetimeToken2D(body.Collider);
 1564561        _planarContinuousCollisionCandidates.Add(
 1564562            body.DynamicId,
 1564563            DynamicCcdCandidateIndex2D.CreateBoundsBetween(
 1564564                body.ContinuousCollisionFrameStart,
 1564565                body.ContinuousCollisionFrameEnd,
 1564566                planarRadius));
 67
 1564568        if (!buildMixedIndex)
 949469            return;
 70
 615171        _mixedContinuousCollisionCandidates.Add(
 615172            body.DynamicId,
 615173            body.ResolveMixedContinuousCollisionTrajectoryBounds(planarRadius));
 615174    }
 75
 76
 77    internal SwiftList<int> QueryPlanarContinuousCollisionCandidates(DynamicCcdPlanarBounds sourceBounds)
 78    {
 219079        PrepareContinuousCollisionFrame();
 219080        _planarContinuousCollisionCandidates.Query(sourceBounds, _continuousCollisionCandidateIds);
 219081        _dirtyPlanarContinuousCollisionCandidates.Query(sourceBounds, _dirtyContinuousCollisionCandidateIds);
 219082        return MergeContinuousCollisionCandidateIds();
 83    }
 84
 85    internal void RefreshContinuousCollisionCandidate(SolidBody2D body)
 86    {
 57787        Fixed64 radius = body.ResolveContinuousCollisionProxyRadius();
 57788        TryReserveContinuousCollisionCandidateRefresh(body);
 89
 57790        _dirtyPlanarContinuousCollisionCandidates.AddOrUpdate(
 57791            body.DynamicId,
 57792            body.ResolveContinuousCollisionTrajectoryBounds(radius));
 57793        if (_continuousCollisionPreparedMixedIndex)
 94        {
 36295            _dirtyMixedContinuousCollisionCandidates.AddOrUpdate(
 36296                body.DynamicId,
 36297                body.ResolveMixedContinuousCollisionTrajectoryBounds(radius));
 98        }
 57799    }
 100
 230101    internal bool CanAdmitContinuousCollisionCandidateRefresh(SolidBody2D body) => true;
 102
 103    internal bool TryReserveContinuousCollisionCandidateRefresh(SolidBody2D body)
 104    {
 1156105        if (_dirtyPlanarContinuousCollisionBodySet.Add(body))
 522106            _dirtyPlanarContinuousCollisionBodies.Add(body);
 107
 1156108        return true;
 109    }
 110
 111    private void ReleaseContinuousCollisionCandidateRefresh(SolidBody2D body) =>
 177112        ReleaseContinuousCollisionCandidateRefresh(body, body.DynamicId);
 113
 114    private void ReleaseContinuousCollisionCandidateRefresh(SolidBody2D body, int dynamicId)
 115    {
 1309116        if (!_dirtyPlanarContinuousCollisionBodySet.Remove(body))
 1304117            return;
 118
 5119        _dirtyPlanarContinuousCollisionBodies.Remove(body);
 5120        _dirtyPlanarContinuousCollisionCandidates.Remove(dynamicId);
 5121        _dirtyMixedContinuousCollisionCandidates.Remove(dynamicId);
 5122    }
 123
 124    internal void InvalidateContinuousCollisionStateForBodyMutation(
 125        SolidBody2D body,
 126        int dynamicId)
 127    {
 1132128        if (dynamicId >= 0)
 1105129            _continuousCollisionCandidateLifetimes[dynamicId] = default;
 130
 1132131        ReleaseContinuousCollisionCandidateRefresh(body, dynamicId);
 1132132        _processedContinuousCollisionBodies.Remove(body);
 1132133        _queuedContinuousCollisionHandoffBodies.Remove(body);
 1132134        _continuousCollisionHandoffQueue.Remove(body);
 1132135        body.DiscardContinuousCollisionHandoff();
 1132136        _continuousCollisionPreparedToken = -1;
 1132137        _continuousCollisionPreparedMixedIndex = false;
 1132138    }
 139
 140    internal bool CanAdmitContinuousCollisionCandidateRefresh(
 141        SolidBody2D first,
 8142        SolidBody2D second) => true;
 143
 144    internal bool TryReserveContinuousCollisionCandidateRefresh(
 145        SolidBody2D first,
 146        SolidBody2D second)
 147    {
 48148        TryReserveContinuousCollisionCandidateRefresh(first);
 48149        TryReserveContinuousCollisionCandidateRefresh(second);
 48150        return true;
 151    }
 152
 153    internal SwiftList<int> QueryMixedContinuousCollisionCandidates(FixedBoundVolume sourceBounds)
 154    {
 1073155        if (!_context.Settings.RuntimeMode.RunsMixedContacts())
 156        {
 1157            _continuousCollisionCandidateIds.FastClear();
 1158            return _continuousCollisionCandidateIds;
 159        }
 160
 1072161        PrepareContinuousCollisionFrame();
 1072162        _mixedContinuousCollisionCandidates.Query(sourceBounds, _continuousCollisionCandidateIds);
 1072163        _dirtyMixedContinuousCollisionCandidates.Query(
 1072164            sourceBounds,
 1072165            _dirtyContinuousCollisionCandidateIds);
 1072166        return MergeContinuousCollisionCandidateIds();
 167    }
 168
 169    private SwiftList<int> MergeContinuousCollisionCandidateIds()
 170    {
 3262171        int retainedCount = 0;
 12394172        for (int i = 0; i < _continuousCollisionCandidateIds.Count; i++)
 173        {
 2935174            int dynamicId = _continuousCollisionCandidateIds[i];
 2935175            if (TryGetContinuousCollisionCandidate(dynamicId, out SolidBody2D body)
 2935176                && !_dirtyPlanarContinuousCollisionBodySet.Contains(body))
 177            {
 2315178                _continuousCollisionCandidateIds[retainedCount++] = dynamicId;
 179            }
 180        }
 181
 3882182        while (_continuousCollisionCandidateIds.Count > retainedCount)
 620183            _continuousCollisionCandidateIds.RemoveAt(
 620184                _continuousCollisionCandidateIds.Count - 1);
 185
 7732186        for (int i = 0; i < _dirtyContinuousCollisionCandidateIds.Count; i++)
 187        {
 604188            int dynamicId = _dirtyContinuousCollisionCandidateIds[i];
 604189            if (TryGetContinuousCollisionCandidate(dynamicId, out _))
 602190                _continuousCollisionCandidateIds.Add(dynamicId);
 191        }
 192
 3262193        return _continuousCollisionCandidateIds;
 194    }
 195
 196    internal bool TryGetContinuousCollisionCandidate(int dynamicId, out SolidBody2D body)
 197    {
 3543198        ColliderLifetimeToken2D registration = _continuousCollisionCandidateLifetimes[dynamicId];
 3543199        if (registration.Collider != null && registration.IsActive)
 200        {
 3524201            body = registration.Collider.Body!;
 3524202            return true;
 203        }
 204
 19205        body = null!;
 19206        return false;
 207    }
 208
 209    internal SolidBody2D GetContinuousCollisionCandidate(int dynamicId) =>
 2778210        _dynamicBodies[dynamicId];
 211
 212    internal void QueueContinuousCollisionHandoff(SolidBody2D body)
 213    {
 190214        if (!_processedContinuousCollisionBodies.Contains(body)
 190215            || !_queuedContinuousCollisionHandoffBodies.Add(body))
 216        {
 110217            return;
 218        }
 219
 80220        _continuousCollisionHandoffQueue.Add(body);
 80221    }
 222
 223    internal bool ProcessQueuedContinuousCollisionHandoffs() =>
 4224        ProcessQueuedContinuousCollisionHandoffs(_context.Settings.ContinuousCollisionMaxToiIterations) > 0;
 225
 226    internal void ReportContinuousCollisionIterationLimit() =>
 51227        LastContinuousCollisionIslandLimitReached = true;
 228
 229    internal int ProcessQueuedContinuousCollisionHandoffs(int iterationBudget)
 230    {
 24374231        if (_continuousCollisionHandoffQueue.Count == 0)
 24352232            return 0;
 233
 22234        if (iterationBudget <= 0)
 235        {
 3236            LastContinuousCollisionIslandLimitReached = true;
 3237            DiscardContinuousCollisionHandoffQueue();
 3238            return 0;
 239        }
 240
 19241        int readIndex = 0;
 19242        int iterations = 0;
 19243        bool processed = false;
 19244        bool completed = false;
 19245        bool limitReached = false;
 246        try
 247        {
 49248            while (readIndex < _continuousCollisionHandoffQueue.Count && iterations < iterationBudget)
 249            {
 31250                SolidBody2D body = _continuousCollisionHandoffQueue[readIndex++];
 251                // Consumption can synchronously return work to this body; dequeue ends dedupe ownership first.
 31252                _queuedContinuousCollisionHandoffBodies.Remove(body);
 253
 31254                if (body.TryConsumeContinuousCollisionHandoff(updateSleepState: false, updateColliderState: false))
 255                {
 25256                    processed = true;
 25257                    iterations++;
 258                }
 259            }
 260
 18261            limitReached = readIndex < _continuousCollisionHandoffQueue.Count;
 18262            completed = true;
 18263            return iterations;
 264        }
 265        finally
 266        {
 19267            if (processed)
 14268                LastContinuousCollisionIslandCount++;
 269
 19270            LastContinuousCollisionIslandIterationCount += iterations;
 19271            LastContinuousCollisionIslandLimitReached |= completed && limitReached;
 19272            if (!completed || limitReached)
 3273                DiscardContinuousCollisionHandoffQueue();
 274            else
 16275                ClearContinuousCollisionHandoffQueue();
 19276        }
 18277    }
 278
 279    private void BeginContinuousCollisionHandoffFrame()
 280    {
 24321281        _processedContinuousCollisionBodies.Clear();
 24321282        DiscardContinuousCollisionHandoffQueue();
 24321283        LastContinuousCollisionIslandCount = 0;
 24321284        LastContinuousCollisionIslandIterationCount = 0;
 24321285        LastContinuousCollisionIslandLimitReached = false;
 24321286    }
 287
 288    internal void AbortContinuousCollisionHandoffFrame()
 289    {
 1290        _processedContinuousCollisionBodies.Clear();
 1291        DiscardContinuousCollisionHandoffQueue();
 1292    }
 293
 294    private void ClearContinuousCollisionHandoffQueue()
 295    {
 24461296        _queuedContinuousCollisionHandoffBodies.Clear();
 24461297        _continuousCollisionHandoffQueue.FastClear();
 24461298    }
 299
 300    private void DiscardContinuousCollisionHandoffQueue()
 301    {
 48988302        for (int i = 0; i < _continuousCollisionHandoffQueue.Count; i++)
 49303            _continuousCollisionHandoffQueue[i].DiscardContinuousCollisionHandoff();
 304
 24445305        ClearContinuousCollisionHandoffQueue();
 24445306    }
 307
 308}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/2D/Services/GravitasPhysics2DService.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasPhysics2DService.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;
 11using SwiftCollections;
 12
 13namespace Gravitas;
 14
 15/// <summary>
 16/// Context-owned pure 2D body, broad-phase, narrow-phase, response, and query service.
 17/// </summary>
 18/// <content>Owns registration, static continuity, collision passes and dimensional solver lifecycle.</content>
 19public sealed partial class GravitasPhysics2DService
 20{
 121    private static readonly CollisionPair2DStableKeyComparer ResponsePairComparer = new();
 122    private static readonly IslandNodeKeyComparer<DiscreteIslandNode2D> IslandNodeComparer = new();
 123    private static readonly DiscreteIslandConstraint2DComparer IslandConstraintComparer = new();
 24
 25    private readonly GravitasWorldContext _context;
 1019126    private readonly SwiftSlotMap<SolidBody2D> _dynamicBodies = new();
 1019127    private readonly ColliderRegistry<LSCollider2D> _colliders = new();
 1019128    private readonly SwiftList<LSCollider2D> _serviceRefreshColliders = new();
 1019129    private readonly SwiftList<StaticSurface2D> _staticSurfaces = new();
 1019130    private readonly SwiftHashSet<ulong> _processedPairKeys = new();
 1019131    private readonly SwiftDictionary<ulong, CollisionPair2D> _pairs = new();
 1019132    private readonly SwiftList<ulong> _pairsToRemove = new();
 1019133    private readonly SwiftList<CollisionPair2D> _pairsPendingSeparation = new();
 1019134    private readonly SwiftStack<CollisionPair2D> _cachedPairs = new();
 1019135    private readonly SwiftList<CollisionPair2D> _discreteResponsePairs = new();
 1019136    private readonly SwiftList<CollisionPair2D> _existingResponsePairCandidates = new();
 1019137    private readonly SwiftHashSet<int> _discreteResponseBodyKeys = new();
 1019138    private readonly SwiftList<int> _discreteResponseBodyQueue = new();
 1019139    private readonly SwiftList<DiscreteIslandNode2D> _discreteIslandNodes = new();
 1019140    private readonly SwiftList<DiscreteIslandConstraint2D> _discreteIslandConstraints = new();
 1019141    private readonly DynamicCcdCandidateIndex2D _planarContinuousCollisionCandidates = new();
 1019142    private readonly DynamicCcdCandidateIndex2D _dirtyPlanarContinuousCollisionCandidates =
 1019143        new(supportsUpdates: true);
 1019144    private readonly SwiftList<SolidBody2D> _dirtyPlanarContinuousCollisionBodies = new();
 1019145    private readonly SwiftHashSet<SolidBody2D> _dirtyPlanarContinuousCollisionBodySet = new();
 1019146    private readonly DynamicCcdCandidateIndex _mixedContinuousCollisionCandidates = new();
 1019147    private readonly DynamicCcdCandidateIndex _dirtyMixedContinuousCollisionCandidates =
 1019148        new(supportsUpdates: true);
 1019149    private readonly SwiftList<ColliderLifetimeToken2D> _continuousCollisionCandidateLifetimes = new();
 1019150    private readonly SwiftList<int> _continuousCollisionCandidateIds = new();
 1019151    private readonly SwiftList<int> _dirtyContinuousCollisionCandidateIds = new();
 1019152    private readonly SwiftHashSet<SolidBody2D> _processedContinuousCollisionBodies = new();
 1019153    private readonly SwiftHashSet<SolidBody2D> _queuedContinuousCollisionHandoffBodies = new();
 1019154    private readonly SwiftList<SolidBody2D> _continuousCollisionHandoffQueue = new();
 1019155    private long _continuousCollisionPreparedToken = -1;
 56    private bool _continuousCollisionPreparedMixedIndex;
 57
 58    /// <summary>Creates the pure 2D physics service for a world context.</summary>
 1019159    public GravitasPhysics2DService(GravitasWorldContext context)
 60    {
 1019161        ChronicleGuard.ThrowIfNull(context, nameof(context));
 1019162        _context = context;
 1019163    }
 64
 65    /// <summary>Gets the number of registered dynamic bodies.</summary>
 66    public int BodyCount { get; private set; }
 67
 68    /// <summary>Gets the number of registered 2D colliders.</summary>
 6715469    public int ColliderCount => _colliders.Count;
 70
 71    /// <summary>Gets or sets whether this service advances pure 2D physics.</summary>
 72    public bool SimulatePhysics { get; set; } = true;
 73
 74    internal int LastBroadPhaseCandidateCount { get; private set; }
 75
 76    /// <summary>
 77    /// Gets how many service-owned continuous-collision handoff batches were consumed during the last late step.
 78    /// </summary>
 79    public int LastContinuousCollisionIslandCount { get; private set; }
 80
 81    /// <summary>
 82    /// Gets how many service-owned continuous-collision handoff iterations were consumed during the last late step.
 83    /// </summary>
 84    public int LastContinuousCollisionIslandIterationCount { get; private set; }
 85
 86    /// <summary>
 87    /// Gets whether the service-owned continuous-collision handoff queue hit its deterministic iteration cap.
 88    /// </summary>
 89    public bool LastContinuousCollisionIslandLimitReached { get; private set; }
 90
 91    internal void AssimilateBody(SolidBody2D body, PhysicsMobilityType motionType)
 92    {
 645993        ChronicleGuard.ThrowIfNull(body, nameof(body));
 645994        ChronicleGuard.ThrowIfArgument(
 645995            !ReferenceEquals(body.Context, _context),
 645996            nameof(body),
 645997            "2D body must belong to this physics service context.");
 98
 645999        if (motionType != PhysicsMobilityType.Static)
 100        {
 4789101            body.DynamicId = _dynamicBodies.Add(body);
 4789102            _context.ReserveSleepIslands();
 9537103            while (_continuousCollisionCandidateLifetimes.Count <= body.DynamicId)
 4748104                _continuousCollisionCandidateLifetimes.Add(default);
 4789105            BodyCount++;
 106        }
 107
 6459108        AssimilateCollider(body.Collider);
 6459109    }
 110
 111    internal void RefreshBodyMotionTypeRegistration(
 112        SolidBody2D body,
 113        PhysicsMobilityType previousMotionType)
 114    {
 152115        if (!body.IsStatic) body.Collider.StaticSurface?.Remove(body.Collider);
 84116        if (previousMotionType == PhysicsMobilityType.Static)
 117        {
 15118            body.DynamicId = _dynamicBodies.Add(body);
 15119            _context.ReserveSleepIslands();
 24120            while (_continuousCollisionCandidateLifetimes.Count <= body.DynamicId)
 9121                _continuousCollisionCandidateLifetimes.Add(default);
 15122            BodyCount++;
 15123            return;
 124        }
 125
 69126        if (body.MotionType == PhysicsMobilityType.Static)
 127        {
 16128            int previousDynamicId = body.DynamicId;
 16129            _dynamicBodies.RemoveAt(previousDynamicId);
 16130            _continuousCollisionCandidateLifetimes[previousDynamicId] = default;
 16131            ReleaseContinuousCollisionCandidateRefresh(body);
 16132            body.DynamicId = -1;
 16133            BodyCount--;
 134        }
 69135    }
 136
 137    internal void AssimilateCollider(LSCollider2D collider)
 138    {
 9455139        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 9455140        ChronicleGuard.ThrowIfArgument(
 9455141            !ReferenceEquals(collider.Context, _context),
 9455142            nameof(collider),
 9455143            "2D collider must belong to this physics service context.");
 144
 9455145        _colliders.Register(collider);
 9455146        RefreshColliderServiceRefreshRegistration(collider);
 9455147        _context.Collisions2D.PartitionCollider(collider);
 9455148    }
 149
 150    internal void DessimilateBody(SolidBody2D body)
 151    {
 208152        ChronicleGuard.ThrowIfNull(body, nameof(body));
 208153        if (body.DynamicId >= 0 && _dynamicBodies.TryRemoveAt(body.DynamicId))
 154        {
 161155            _continuousCollisionCandidateLifetimes[body.DynamicId] = default;
 161156            ReleaseContinuousCollisionCandidateRefresh(body);
 161157            BodyCount--;
 158        }
 159
 208160        LSCollider2D collider = body.Collider;
 208161        DessimilateCollider(collider);
 208162    }
 163
 164    internal void DessimilateCollider(LSCollider2D collider)
 165    {
 504166        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 504167        collider.IsDeactivationInProgress = true;
 168        try
 169        {
 504170            collider.StaticSurface?.Remove(collider);
 504171            if (collider.Body != null)
 208172                _context.Constraints2D.RemoveJointsForBody(collider.Body);
 504173            RemovePairsForCollider(collider);
 504174            _context.MixedCollisions.RemovePairsFor2DCollider(collider);
 504175            if (collider.IsMixedPartitioned)
 97176                _context.MixedCollisions.ClearPartitioned2DCollider(collider, force: true);
 504177            if (collider.IsPartitioned)
 466178                _context.Collisions2D.ClearPartitionedCollider(collider, force: true);
 179
 504180            RemoveServiceRefreshCollider(collider);
 504181            _colliders.Remove(collider);
 504182        }
 183        finally
 184        {
 504185            collider.IsDeactivationInProgress = false;
 504186        }
 504187    }
 188
 189    /// <summary>Creates a context-owned continuity declaration for static filled planar pieces.</summary>
 190    /// <param name="members">Distinct active bodyless or explicit-static AABB or convex polygon colliders registered in
 191    /// <returns>A declaration that retains each member's collider identity and joins only exact shared boundary spans.<
 192    /// <remarks>Call between complete fixed steps. Compound roots/leaves are ineligible. Context reset or disposal expi
 193    /// <exception cref="System.ArgumentException">A member is ineligible or already belongs to a declaration.</exceptio
 194    /// <exception cref="System.ObjectDisposedException">The context has ended.</exception>
 195    /// <exception cref="System.InvalidOperationException">A fixed step is in progress.</exception>
 196    public StaticSurface2D CreateStaticSurface(System.ReadOnlySpan<LSCollider2D> members)
 197    {
 600198        var surface = new StaticSurface2D(_context, members);
 597199        _staticSurfaces.Add(surface);
 597200        return surface;
 201    }
 202
 584203    internal void RemoveStaticSurface(StaticSurface2D surface) => _staticSurfaces.Remove(surface);
 204
 205    internal void ReleaseStaticSurfaces()
 206    {
 20655207        foreach (StaticSurface2D surface in _staticSurfaces) surface.Release();
 10308208        _staticSurfaces.Clear();
 10308209    }
 210
 211    /// <summary>Runs the authoritative pure 2D simulation phase.</summary>
 212    public void Simulate()
 213    {
 23870214        _context.EnterSimulationPhase();
 215        try
 216        {
 23870217            if (!SimulatePhysics)
 16218                return;
 219
 23854220            LastBroadPhaseCandidateCount = 0;
 23854221        }
 222        finally
 223        {
 23870224            _context.ExitSimulationPhase();
 23870225        }
 23870226    }
 227
 228    /// <summary>Completes deferred pure 2D collision, response, and bookkeeping work.</summary>
 229    public void LateSimulate()
 230    {
 5231        _context.EnterSimulationPhase();
 232        try
 233        {
 5234            if (!BeginLateSimulateBodies(continuousCollisionFramePrepared: false))
 1235                return;
 236
 4237            ProcessQueuedContinuousCollisionHandoffs();
 4238            CompleteLateSimulatePhysicsStep();
 4239            PublishCollisionPositionStates();
 4240        }
 241        finally
 242        {
 5243            _context.ExitSimulationPhase();
 5244        }
 5245    }
 246
 247    internal bool BeginLateSimulateBodies(bool continuousCollisionFramePrepared)
 248    {
 24322249        if (!SimulatePhysics)
 1250            return false;
 251
 24321252        if (!continuousCollisionFramePrepared)
 18253            _context.AdvanceLateSimulateToken();
 254
 24321255        PrepareContinuousCollisionFrame();
 24321256        BeginContinuousCollisionHandoffFrame();
 257
 79335258        foreach (SolidBody2D body in _dynamicBodies)
 259        {
 15347260            body.LateSimulate(updateSleepState: false, updateColliderState: false);
 15346261            _processedContinuousCollisionBodies.Add(body);
 262        }
 263
 24320264        return true;
 265    }
 266
 267    internal void CompleteLateSimulatePhysicsStep(bool deferSleep = false)
 268    {
 24303269        PrepareCollisionPartitions();
 24303270        RunDiscreteCollisionStep();
 24302271        if (!deferSleep)
 8318272            _context.UpdateAutomaticSleep(ran3D: false, ran2D: true);
 24302273    }
 274
 275    private bool _collisionPositionPublicationPending;
 276
 3847277    internal void MarkCollisionPositionPublicationPending() => _collisionPositionPublicationPending = true;
 278
 279    internal void PublishCollisionPositionStates()
 280    {
 113451281        if (!_collisionPositionPublicationPending)
 110313282            return;
 3138283        _collisionPositionPublicationPending = false;
 13762284        foreach (SolidBody2D body in _dynamicBodies)
 3743285            body.PublishCollisionPositionState();
 3138286    }
 287
 288    private void PrepareCollisionPartitions()
 289    {
 79238290        foreach (SolidBody2D body in _dynamicBodies)
 15316291            body.Collider.Simulate();
 292
 100740293        for (int i = 0; i < _serviceRefreshColliders.Count; i++)
 26067294            _serviceRefreshColliders[i].Simulate();
 24303295    }
 296
 297    private void RunDiscreteCollisionStep()
 298    {
 24303299        LastBroadPhaseCandidateCount = 0;
 24303300        EnsureFrameCapacity();
 24303301        _processedPairKeys.Clear();
 24303302        _discreteResponsePairs.FastClear();
 24303303        long frame = _context.FrameCount;
 24303304        _context.Collisions2D.CheckAndDistributeCollisions();
 24303305        ExpandDiscreteResponsePairs(frame);
 24303306        SolveDiscreteResponsePairs();
 24302307        RefreshGroundingFromDiscreteResponse(frame);
 24302308        CleanupUntouchedPairs(frame);
 24302309        _context.Collisions2D.RetireExpiredRetainedPartitions();
 24302310    }
 311
 312    /// <summary>Publishes interpolated presentation state for registered 2D bodies.</summary>
 313    public void Visualize()
 314    {
 86315        foreach (SolidBody2D body in _dynamicBodies)
 21316            body.OnVisualize();
 22317    }
 318
 319    /// <summary>Clears all context-local pure 2D registration and solver state.</summary>
 320    public void Reset()
 321    {
 117322        _collisionPositionPublicationPending = false;
 117323        ReleaseStaticSurfaces();
 117324        DiscardContinuousCollisionHandoffQueue();
 325        // FastClear during simulation can leave references beyond the current count.
 117326        _continuousCollisionHandoffQueue.Clear(clearRetainedReferences: true);
 117327        _dynamicBodies.Clear();
 117328        _colliders.Clear();
 117329        _serviceRefreshColliders.Clear();
 117330        _groundingBodySnapshot.Clear(clearRetainedReferences: true);
 117331        _groundingPairSnapshot.Clear(clearRetainedReferences: true);
 117332        _processedPairKeys.Clear();
 117333        _pairs.Clear();
 117334        _pairsToRemove.FastClear();
 117335        _pairsPendingSeparation.Clear(clearRetainedReferences: true);
 117336        _cachedPairs.Clear();
 117337        _discreteResponsePairs.Clear(clearRetainedReferences: true);
 117338        _existingResponsePairCandidates.Clear(clearRetainedReferences: true);
 117339        _discreteResponseBodyKeys.Clear();
 117340        _discreteResponseBodyQueue.FastClear();
 117341        _discreteIslandNodes.Clear(clearRetainedReferences: true);
 117342        _discreteIslandConstraints.Clear(clearRetainedReferences: true);
 117343        _planarContinuousCollisionCandidates.Clear();
 117344        _dirtyPlanarContinuousCollisionCandidates.Clear();
 117345        _dirtyPlanarContinuousCollisionBodies.Clear(clearRetainedReferences: true);
 117346        _dirtyPlanarContinuousCollisionBodySet.Clear();
 117347        _mixedContinuousCollisionCandidates.Clear();
 117348        _dirtyMixedContinuousCollisionCandidates.Clear();
 117349        _continuousCollisionCandidateLifetimes.Clear();
 117350        _continuousCollisionCandidateIds.FastClear();
 117351        _dirtyContinuousCollisionCandidateIds.FastClear();
 117352        _processedContinuousCollisionBodies.Clear();
 117353        _continuousCollisionPreparedToken = -1;
 117354        _continuousCollisionPreparedMixedIndex = false;
 117355        BodyCount = 0;
 117356        LastBroadPhaseCandidateCount = 0;
 117357        LastContinuousCollisionIslandCount = 0;
 117358        LastContinuousCollisionIslandIterationCount = 0;
 117359        LastContinuousCollisionIslandLimitReached = false;
 117360    }
 361
 362    internal bool TryGetColliderById(int colliderId, out LSCollider2D? collider) =>
 888957363        _colliders.TryGetById(colliderId, out collider);
 364
 365    internal bool TryGetColliderByServiceIndex(int serviceIndex, out LSCollider2D? collider) =>
 2366        _colliders.TryGetByServiceIndex(serviceIndex, out collider);
 367
 33381368    internal LSCollider2D GetColliderByServiceIndex(int serviceIndex) => _colliders[serviceIndex];
 369
 4578370    internal SwiftList<LSCollider2D> PrepareReplayColliders() => _colliders.PrepareReplayColliders();
 371
 372    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 373    internal bool TryGetDynamicBody(int dynamicId, out SolidBody2D body) =>
 6480374        _dynamicBodies.TryGetValue(dynamicId, out body);
 375
 376    internal void RefreshColliderServiceRefreshRegistration(LSCollider2D collider)
 377    {
 9539378        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 379
 9539380        if (collider.RequiresServiceSideRefresh)
 4682381            AddServiceRefreshCollider(collider);
 382        else
 4857383            RemoveServiceRefreshCollider(collider);
 4857384    }
 385
 386    private void AddServiceRefreshCollider(LSCollider2D collider)
 387    {
 4682388        collider.SetServiceRefreshIndex(_serviceRefreshColliders.Count);
 4682389        _serviceRefreshColliders.Add(collider);
 4682390    }
 391
 392    private void RemoveServiceRefreshCollider(LSCollider2D collider)
 393    {
 5361394        int index = collider.ServiceRefreshIndex;
 5361395        if (index < 0 || !ReferenceEquals(_serviceRefreshColliders[index], collider))
 396        {
 5004397            collider.ClearServiceRefreshIndex();
 5004398            return;
 399        }
 400
 357401        int lastIndex = _serviceRefreshColliders.Count - 1;
 357402        if (index != lastIndex)
 403        {
 69404            LSCollider2D moved = _serviceRefreshColliders[lastIndex];
 69405            _serviceRefreshColliders[index] = moved;
 69406            moved.SetServiceRefreshIndex(index);
 407        }
 408
 357409        _serviceRefreshColliders.RemoveAt(lastIndex);
 357410        collider.ClearServiceRefreshIndex();
 357411    }
 412
 413    private void EnsureFrameCapacity()
 414    {
 24303415        int colliderCount = _colliders.Count;
 24303416        if (colliderCount <= 0)
 2054417            return;
 418
 22249419        int expectedPairKeyCapacity = System.Math.Max(colliderCount * 4, _pairs.Count);
 22249420        _processedPairKeys.EnsureCapacity(expectedPairKeyCapacity);
 22249421        _pairsToRemove.EnsureCapacity(expectedPairKeyCapacity);
 22249422        _pairsPendingSeparation.EnsureCapacity(expectedPairKeyCapacity);
 22249423        _discreteResponsePairs.EnsureCapacity(expectedPairKeyCapacity);
 22249424        _existingResponsePairCandidates.EnsureCapacity(expectedPairKeyCapacity);
 22249425        _discreteResponseBodyKeys.EnsureCapacity(colliderCount);
 22249426        _discreteResponseBodyQueue.EnsureCapacity(colliderCount);
 22249427        _discreteIslandNodes.EnsureCapacity(colliderCount);
 22249428        _discreteIslandConstraints.EnsureCapacity(expectedPairKeyCapacity);
 22249429        if (_context.Settings.PoolingEnabled)
 22241430            _cachedPairs.EnsureCapacity(colliderCount);
 22249431    }
 432
 433}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/2D/Services/GravitasPhysics2DService.Grounding.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasPhysics2DService.Grounding.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 Gravitas.Colliders;
 9using Gravitas.CollisionHandling;
 10
 11namespace Gravitas;
 12
 13/// <content>Refreshes planar body grounding from current discrete contact manifolds.</content>
 14public sealed partial class GravitasPhysics2DService
 15{
 1019116    private readonly SwiftCollections.SwiftList<GroundingBodySnapshotEntry> _groundingBodySnapshot = new();
 1019117    private readonly SwiftCollections.SwiftList<GroundingPairSnapshotEntry> _groundingPairSnapshot = new();
 18
 19    private readonly struct GroundingBodySnapshotEntry
 20    {
 21        private readonly ColliderLifetimeToken2D _registration;
 22
 23        internal GroundingBodySnapshotEntry(SolidBody2D body)
 24        {
 1531425            Body = body;
 1531426            _registration = new ColliderLifetimeToken2D(body.Collider);
 1531427        }
 28
 29        internal SolidBody2D Body { get; }
 30
 3062831        internal bool IsActive => _registration.IsActive;
 32    }
 33
 34    private readonly struct GroundingPairSnapshotEntry
 35    {
 36        private readonly long _lifetimeVersion;
 37
 38        internal GroundingPairSnapshotEntry(CollisionPair2D pair)
 39        {
 571040            Pair = pair;
 571041            _lifetimeVersion = pair.LifetimeVersion;
 571042        }
 43
 44        internal CollisionPair2D Pair { get; }
 45
 571046        internal bool IsCurrentLifetime => Pair.LifetimeVersion == _lifetimeVersion;
 47    }
 48
 49    private void RefreshGroundingFromDiscreteResponse(long frame)
 50    {
 2430251        int snapshotStart = _groundingBodySnapshot.Count;
 2430252        _groundingBodySnapshot.EnsureCapacity(snapshotStart + _dynamicBodies.Count);
 7923253        foreach (SolidBody2D body in _dynamicBodies)
 1531454            _groundingBodySnapshot.Add(new GroundingBodySnapshotEntry(body));
 2430255        int snapshotEnd = _groundingBodySnapshot.Count;
 56
 2430257        int pairSnapshotStart = _groundingPairSnapshot.Count;
 2430258        _groundingPairSnapshot.EnsureCapacity(pairSnapshotStart + _discreteResponsePairs.Count);
 6002459        for (int i = 0; i < _discreteResponsePairs.Count; i++)
 571060            _groundingPairSnapshot.Add(new GroundingPairSnapshotEntry(_discreteResponsePairs[i]));
 2430261        int pairSnapshotEnd = _groundingPairSnapshot.Count;
 62
 63        try
 64        {
 7923265            for (int i = snapshotStart; i < snapshotEnd; i++)
 66            {
 1531467                GroundingBodySnapshotEntry registration = _groundingBodySnapshot[i];
 1531468                if (!registration.IsActive)
 69                    continue;
 70
 1531471                registration.Body.BeginAutomaticGroundingRefresh();
 72            }
 73
 6002474            for (int i = pairSnapshotStart; i < pairSnapshotEnd; i++)
 75            {
 571076                GroundingPairSnapshotEntry registration = _groundingPairSnapshot[i];
 571077                if (!registration.IsCurrentLifetime)
 78                    continue;
 79
 571080                CollisionPair2D pair = registration.Pair;
 571081                if (!ShouldUseDiscreteGroundingPair(pair, frame))
 82                    continue;
 83
 570984                ContactManifold2D manifold = pair.Manifold;
 570985                if (!ShouldUseDiscreteGroundingManifold(manifold, frame))
 86                    continue;
 87
 570388                SolidBody2D? bodyA = pair.ColliderA.Body;
 570389                SolidBody2D? bodyB = pair.ColliderB.Body;
 2493490                for (int contactIndex = 0; contactIndex < manifold.Count; contactIndex++)
 91                {
 676492                    ManifoldContact2D contact = manifold[contactIndex];
 676493                    bodyA?.TryAcceptContactGroundCandidate(pair.ColliderA, pair.ColliderB, contact, ownColliderIsA: true
 676494                    bodyB?.TryAcceptContactGroundCandidate(pair.ColliderB, pair.ColliderA, contact, ownColliderIsA: fals
 95                }
 96            }
 97
 7923298            for (int i = snapshotStart; i < snapshotEnd; i++)
 99            {
 15314100                GroundingBodySnapshotEntry registration = _groundingBodySnapshot[i];
 15314101                if (!registration.IsActive)
 102                    continue;
 103
 15313104                registration.Body.CompleteAutomaticGroundingRefresh();
 105            }
 24302106        }
 107        finally
 108        {
 24302109            if (pairSnapshotStart == 0)
 110            {
 24300111                _groundingPairSnapshot.Clear();
 112            }
 113            else
 114            {
 5115                while (_groundingPairSnapshot.Count > pairSnapshotStart)
 3116                    _groundingPairSnapshot.RemoveAt(_groundingPairSnapshot.Count - 1);
 117            }
 118
 24302119            if (snapshotStart == 0)
 120            {
 24300121                _groundingBodySnapshot.Clear();
 122            }
 123            else
 124            {
 7125                while (_groundingBodySnapshot.Count > snapshotStart)
 5126                    _groundingBodySnapshot.RemoveAt(_groundingBodySnapshot.Count - 1);
 127            }
 24302128        }
 24302129    }
 130
 131    internal static bool ShouldUseDiscreteGroundingPair(CollisionPair2D pair, long frame) =>
 5714132        pair.LastFrame == frame && !pair.ColliderA.IsTrigger && !pair.ColliderB.IsTrigger;
 133
 134    internal static bool ShouldUseDiscreteGroundingManifold(ContactManifold2D manifold, long frame) =>
 5712135        manifold.HasContact && manifold.LastUpdatedFrame == frame;
 136}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/2D/Services/GravitasPhysics2DService.Pairs.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasPhysics2DService.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.Runtime.CompilerServices;
 9using Gravitas.Colliders;
 10using Gravitas.CollisionHandling;
 11using GridForge.Spatial;
 12using SwiftCollections;
 13
 14namespace Gravitas;
 15
 16/// <content>Finds planar collider pairs, expands the response set, and manages pair reuse and cleanup.</content>
 17public sealed partial class GravitasPhysics2DService
 18{
 19    internal void ProcessPartitionCandidate(int firstId, int secondId, WorldVoxelIndex partitionIndex)
 20    {
 2669821        if (!TryGetColliderById(firstId, out LSCollider2D? first)
 2669822            || !TryGetColliderById(secondId, out LSCollider2D? second))
 23        {
 1124            return;
 25        }
 26
 27        // Shared coarse voxels can link separated shapes. Their cached bounds
 28        // reject them before hierarchy, layer and constraint policy is needed.
 2668729        if (!CollisionDetection2D.BoundsOverlap(first!, second!)
 2668730            || !RequireCollisionPair(first!, second!)
 2668731            || !IsCanonicalSharedPartition(first!, second!, partitionIndex))
 32        {
 2034833            return;
 34        }
 35
 633936        ulong key = CreatePairKey(firstId, secondId);
 633937        if (!_processedPairKeys.Add(key))
 338            return;
 633639        LastBroadPhaseCandidateCount++;
 633640        ProcessCandidate(first!, second!, _context.FrameCount);
 633641    }
 42
 43    internal static bool IsCanonicalSharedPartition(LSCollider2D first, LSCollider2D second, WorldVoxelIndex currentInde
 44    {
 1710345        SwiftList<WorldVoxelIndex>? firstCoordinates = first.PartitionCoordinates;
 1710346        SwiftList<WorldVoxelIndex>? secondCoordinates = second.PartitionCoordinates;
 1710347        if (firstCoordinates == null || secondCoordinates == null)
 148            return true;
 49
 1710250        if (!TryGetMinimumVoxelIndexForGrid(firstCoordinates, currentIndex, out VoxelIndex firstMin)
 1710251            || !TryGetMinimumVoxelIndexForGrid(secondCoordinates, currentIndex, out VoxelIndex secondMin))
 52        {
 153            return true;
 54        }
 55
 1710156        VoxelIndex current = currentIndex.VoxelIndex;
 1710157        return current.x == Max(firstMin.x, secondMin.x)
 1710158            && current.z == Max(firstMin.z, secondMin.z);
 59    }
 60
 61    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 2469462    private static int Max(int first, int second) => first >= second ? first : second;
 63
 64    internal static bool TryGetMinimumVoxelIndexForGrid(
 65        SwiftList<WorldVoxelIndex> coordinates,
 66        WorldVoxelIndex gridIdentity,
 67        out VoxelIndex minimum)
 68    {
 3420569        minimum = default;
 3420570        bool found = false;
 122776871        for (int i = 0; i < coordinates.Count; i++)
 72        {
 57967973            WorldVoxelIndex candidate = coordinates[i];
 57967974            if (candidate.GridIndex != gridIdentity.GridIndex || candidate.GridSpawnToken != gridIdentity.GridSpawnToken
 75                continue;
 76
 57966777            VoxelIndex voxel = candidate.VoxelIndex;
 57966778            if (!found)
 79            {
 3420380                minimum = voxel;
 3420381                found = true;
 3420382                continue;
 83            }
 84
 54546485            if (voxel.x < minimum.x)
 186                minimum.x = voxel.x;
 54546487            if (voxel.z < minimum.z)
 388                minimum.z = voxel.z;
 89        }
 90
 3420591        return found;
 92    }
 93
 94    private void ProcessCandidate(LSCollider2D first, LSCollider2D second, long frame)
 95    {
 633796        ulong key = CreatePairKey(first.Id, second.Id);
 633797        bool hasPair = _pairs.TryGetValue(key, out CollisionPair2D pair);
 633798        bool hasAwakeMovableParticipant = HasAwakeMovableParticipant(first, second);
 99        // Partition distribution places a body-backed dynamic first; 2D triggers are bodyless static candidates.
 6337100        bool triggerPair = second.IsTrigger;
 6337101        if (!hasPair && !hasAwakeMovableParticipant && !triggerPair)
 1102            return;
 103
 6336104        bool createdPair = false;
 6336105        if (!hasPair)
 106        {
 958107            pair = CreatePair(first, second);
 958108            createdPair = true;
 109        }
 110
 6336111        if (!CollisionDetection2D.TryCollide(pair!, pair!.Manifold, frame))
 112        {
 473113            if (createdPair)
 439114                RecyclePair(pair);
 473115            return;
 116        }
 117
 5863118        if (triggerPair)
 119        {
 57120            if (createdPair)
 36121                RegisterPair(key, pair);
 122
 57123            pair.MarkColliding(frame);
 57124            return;
 125        }
 126
 5806127        if (!hasAwakeMovableParticipant)
 128        {
 4129            pair.MarkResting(frame);
 4130            _discreteResponsePairs.Add(pair);
 4131            return;
 132        }
 133
 5802134        if (createdPair)
 483135            RegisterPair(key, pair);
 136
 5802137        pair.MarkCollidingDeferred(frame);
 138        // Validate once after all notifications, including callbacks from later pairs.
 5802139        _discreteResponsePairs.Add(pair);
 5802140    }
 141
 142    private void RegisterPair(ulong key, CollisionPair2D pair)
 143    {
 535144        _pairs.Add(key, pair);
 535145        pair.ColliderA.TryAddCollisionPair(pair.Id2, pair);
 535146        pair.ColliderB.TryAddCollisionPairHolder(pair.Id1);
 535147    }
 148
 149    private void ExpandDiscreteResponsePairs(long frame)
 150    {
 24303151        if (_discreteResponsePairs.Count == 0)
 19301152            return;
 153
 5002154        _discreteResponseBodyKeys.Clear();
 5002155        _discreteResponseBodyQueue.FastClear();
 156
 21606157        for (int i = 0; i < _discreteResponsePairs.Count; i++)
 158        {
 5801159            CollisionPair2D pair = _discreteResponsePairs[i];
 5801160            AddDiscreteResponseBody(pair.ColliderA.Body);
 5801161            AddDiscreteResponseBody(pair.ColliderB.Body);
 162        }
 163
 21472164        for (int readIndex = 0; readIndex < _discreteResponseBodyQueue.Count; readIndex++)
 165        {
 5734166            int dynamicId = _discreteResponseBodyQueue[readIndex];
 5734167            if (!TryGetDynamicBody(dynamicId, out SolidBody2D body))
 168                continue;
 169
 5733170            AddExistingResponsePairs(body.Collider, frame);
 171        }
 5002172    }
 173
 174    private void AddExistingResponsePairs(LSCollider2D collider, long frame)
 175    {
 5733176        _existingResponsePairCandidates.FastClear();
 5733177        SwiftDictionary<int, CollisionPair2D>? ownedPairs = collider.CollisionPairs;
 5733178        if (ownedPairs != null)
 179        {
 13848180            foreach (var pairEntry in ownedPairs)
 1191181                _existingResponsePairCandidates.Add(pairEntry.Value);
 182        }
 183
 5733184        SwiftHashSet<int>? pairHolders = collider.CollisionPairHolders;
 5733185        if (pairHolders != null)
 186        {
 21566187            foreach (int holderId in pairHolders)
 188            {
 5050189                if (!TryGetColliderById(holderId, out LSCollider2D? holder)
 5050190                    || !holder!.TryGetCollisionPair(collider.Id, out CollisionPair2D? pair))
 191                {
 192                    continue;
 193                }
 194
 5050195                _existingResponsePairCandidates.Add(pair!);
 196            }
 197        }
 198
 23948199        for (int i = 0; i < _existingResponsePairCandidates.Count; i++)
 6241200            TryAddExistingResponsePair(_existingResponsePairCandidates[i], frame);
 5733201    }
 202
 203    private void TryAddExistingResponsePair(CollisionPair2D pair, long frame)
 204    {
 6241205        ulong key = CreatePairKey(pair.Id1, pair.Id2);
 6241206        if (!_pairs.TryGetValue(key, out CollisionPair2D currentPair)
 6241207            || !ReferenceEquals(currentPair, pair))
 208        {
 1209            return;
 210        }
 211
 6240212        if (!_processedPairKeys.Add(key))
 6228213            return;
 214
 12215        LSCollider2D first = pair.ColliderA;
 12216        LSCollider2D second = pair.ColliderB;
 12217        if (first.IsTrigger
 12218            || second.IsTrigger
 12219            || !RequireCollisionPair(first, second)
 12220            || !CollisionDetection2D.BoundsOverlap(first, second)
 12221            || !CollisionDetection2D.TryCollide(pair, pair.Manifold, frame))
 222        {
 5223            return;
 224        }
 225
 7226        if (HasAwakeMovableParticipant(first, second))
 3227            pair.MarkCollidingDeferred(frame);
 228        else
 4229            pair.MarkResting(frame);
 230
 7231        _discreteResponsePairs.Add(pair);
 7232        AddDiscreteResponseBody(first.Body);
 7233        AddDiscreteResponseBody(second.Body);
 7234    }
 235
 236    private void AddDiscreteResponseBody(SolidBody2D? body)
 237    {
 11616238        if (!IsMovableIslandBody(body) || !_discreteResponseBodyKeys.Add(body!.DynamicId))
 5882239            return;
 240
 5734241        _discreteResponseBodyQueue.Add(body.DynamicId);
 5734242    }
 243
 244    private bool IsCurrentResponsePair(ulong key, CollisionPair2D pair)
 245    {
 5824246        if (!_pairs.TryGetValue(key, out CollisionPair2D currentPair)
 5824247            || !ReferenceEquals(currentPair, pair)
 5824248            || pair.ColliderA.IsTrigger || pair.ColliderB.IsTrigger
 5839249            || !RequireCollisionPair(pair.ColliderA, pair.ColliderB)) return false;
 250        // Notifications may remove a supplier that has no pair of its own.
 251        // Rebuild from committed geometry before using the carrier's old rows.
 5809252        if (pair.ContactDependenciesChanged)
 253        {
 6254            if (!CollisionDetection2D.TryCollide(pair, pair.Manifold, _context.FrameCount)) return false;
 4255            pair.RefreshContactDependencies();
 256        }
 5808257        return pair.HasResponse;
 258    }
 259
 260    internal bool RequireCollisionPair(LSCollider2D first, LSCollider2D second)
 261    {
 31767262        return first.IsActive && second.IsActive
 31767263            && first.Shape != ColliderType2D.None && second.Shape != ColliderType2D.None
 31767264            && (first.Body != null || second.Body != null)
 31767265            && !ReferenceEquals(first.AgentOrNull, second.AgentOrNull)
 31767266            && !IsLayerCollisionDisabled(first.Layer, second.Layer)
 31767267            && ColliderCollisionFilter.AllowsPhysicalPair(first, second)
 31767268            && !_context.Constraints2D.ShouldExcludeLinkedCollision(first, second)
 31767269            && !first.IsSibling(second);
 270    }
 271
 272    private void CleanupUntouchedPairs(long frame)
 273    {
 24302274        _pairsToRemove.FastClear();
 61776275        foreach (var pairEntry in _pairs)
 6586276            _pairsToRemove.Add(pairEntry.Key);
 277
 61776278        for (int i = 0; i < _pairsToRemove.Count; i++)
 279        {
 6586280            ulong key = _pairsToRemove[i];
 6586281            if (!_pairs.TryGetValue(key, out CollisionPair2D pair))
 282                continue;
 283
 6585284            if (pair.LastVisitToken == _context.LateSimulateToken)
 285                continue;
 286
 741287            if (TryKeepUntouchedPair(pair, frame))
 288                continue;
 289
 72290            RemovePairReferences(pair);
 72291            _pairs.Remove(key);
 72292            pair.MarkSeparated();
 72293            RecyclePair(pair);
 294        }
 24302295    }
 296
 297    private bool TryKeepUntouchedPair(CollisionPair2D pair, long frame)
 298    {
 741299        LSCollider2D first = pair.ColliderA;
 741300        LSCollider2D second = pair.ColliderB;
 741301        bool triggerPair = first.IsTrigger || second.IsTrigger;
 741302        if ((!triggerPair && HasAwakeMovableParticipant(first, second))
 741303            || !RequireCollisionPair(first, second)
 741304            || !CollisionDetection2D.TryCollide(pair, pair.Manifold, frame))
 305        {
 72306            return false;
 307        }
 308
 669309        if (triggerPair)
 310        {
 21311            pair.MarkColliding(frame);
 21312            return true;
 313        }
 314
 648315        pair.MarkResting(frame);
 648316        return true;
 317    }
 318
 319    private CollisionPair2D CreatePair(LSCollider2D first, LSCollider2D second)
 320    {
 958321        if (_context.Settings.PoolingEnabled && _cachedPairs.Count > 0)
 322        {
 446323            CollisionPair2D pair = _cachedPairs.Pop();
 446324            pair.Initialize(first, second);
 446325            return pair;
 326        }
 327
 512328        return new CollisionPair2D(first, second);
 329    }
 330
 331    private void RecyclePair(CollisionPair2D pair)
 332    {
 618333        if (_context.Settings.PoolingEnabled && !pair.IsNotificationInProgress)
 604334            _cachedPairs.Push(pair);
 618335    }
 336
 337    private void RemovePairsForCollider(LSCollider2D collider)
 338    {
 504339        int separationStart = _pairsPendingSeparation.Count;
 504340        SwiftDictionary<int, CollisionPair2D>? collisionPairs = collider.CollisionPairs;
 504341        if (collisionPairs != null)
 342        {
 368343            foreach (var pairEntry in collisionPairs)
 56344                _pairsPendingSeparation.Add(pairEntry.Value);
 345        }
 346
 504347        SwiftHashSet<int>? collisionPairHolders = collider.CollisionPairHolders;
 504348        if (collisionPairHolders != null)
 349        {
 346350            foreach (int holderId in collisionPairHolders)
 351            {
 45352                if (!TryGetColliderById(holderId, out LSCollider2D? holder)
 45353                    || !holder!.TryGetCollisionPair(collider.Id, out CollisionPair2D? pair))
 354                {
 355                    continue;
 356                }
 357
 45358                _pairsPendingSeparation.Add(pair!);
 359            }
 360        }
 361
 504362        int separationEnd = _pairsPendingSeparation.Count;
 1210363        for (int i = separationStart; i < separationEnd; i++)
 364        {
 101365            CollisionPair2D pair = _pairsPendingSeparation[i];
 101366            ulong key = CreatePairKey(pair.Id1, pair.Id2);
 101367            if (!_pairs.ContainsKey(key))
 368                continue;
 369
 100370            RemovePairReferences(pair);
 100371            _pairs.Remove(key);
 100372            pair.MarkSeparated();
 100373            RecyclePair(pair);
 374        }
 375
 504376        collider.ClearCollisionPairState();
 504377        collider.ClearRuntimeRelationships();
 378
 504379        if (separationStart == 0)
 503380            _pairsPendingSeparation.FastClear();
 504381    }
 382
 383    internal void ClearWarmStartCachesForCollider(LSCollider2D collider, SwiftHashSet<int>? changedSuppliers = null)
 384    {
 6557385        SwiftDictionary<int, CollisionPair2D>? collisionPairs = collider.CollisionPairs;
 6557386        if (collisionPairs != null)
 387        {
 408388            foreach (var pairEntry in collisionPairs)
 389            {
 89390                if (changedSuppliers == null) pairEntry.Value.ClearWarmStart();
 69391                else pairEntry.Value.InvalidateSurfaceContact(collider, changedSuppliers);
 392            }
 393        }
 394
 6557395        SwiftHashSet<int>? collisionPairHolders = collider.CollisionPairHolders;
 6557396        if (collisionPairHolders == null)
 6432397            return;
 398
 258399        foreach (int holderId in collisionPairHolders)
 400        {
 4401            if (TryGetColliderById(holderId, out LSCollider2D? holder)
 4402                && holder!.TryGetCollisionPair(collider.Id, out CollisionPair2D? pair))
 403            {
 6404                if (changedSuppliers == null) pair!.ClearWarmStart();
 2405                else pair!.InvalidateSurfaceContact(collider, changedSuppliers);
 406            }
 407        }
 125408    }
 409}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/2D/Services/GravitasPhysics2DService.ReplayHash.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasPhysics2DService.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 SwiftCollections;
 11
 12namespace Gravitas;
 13
 14/// <content>Writes planar collider, body, pair, and optional solver-cache state to the replay hash.</content>
 15public sealed partial class GravitasPhysics2DService
 16{
 17    internal void ContributeReplayHash(
 18        ref ChronicleHashWriter writer,
 19        GravitasReplayHashMode mode)
 20    {
 202721        SwiftList<LSCollider2D> replayColliders = PrepareReplayColliders();
 22
 202723        writer.WriteSection("physics.2d", 2);
 202724        writer.WriteBool(SimulatePhysics);
 202725        writer.WriteInt32(BodyCount);
 202726        writer.WriteInt32(ColliderCount);
 202727        writer.WriteInt32(_dynamicBodies.PeakCount);
 202728        writer.WriteInt32(replayColliders.Count);
 29
 1538830        for (int i = 0; i < replayColliders.Count; i++)
 31        {
 566732            LSCollider2D collider = replayColliders[i];
 566733            collider.ContributeReplayHash(ref writer, mode);
 566734            if (collider.Body == null)
 395235                writer.WriteBool(false);
 36            else
 37            {
 171538                writer.WriteBool(true);
 171539                collider.Body.ContributeReplayHash(ref writer, mode);
 40            }
 41        }
 42
 202743        bool membership = false;
 563544        foreach (StaticSurface2D surface in _staticSurfaces) membership |= surface.ReplayMembership != 0;
 202745        if (membership)
 46        {
 51747            writer.WriteSection("physics.2d.surfaces", 1);
 51748            writer.WriteInt32(replayColliders.Count);
 502649            foreach (LSCollider2D collider in replayColliders.AsReadOnlySpan())
 199650                writer.WriteInt32(collider.StaticSurface?.ReplayMembership ?? 0);
 51        }
 52
 202753        writer.WriteSection("physics.2d.pairs", 2);
 1538854        for (int i = 0; i < replayColliders.Count; i++)
 55        {
 566756            LSCollider2D collider = replayColliders[i];
 57
 2546658            for (int j = i + 1; j < replayColliders.Count; j++)
 59            {
 706660                LSCollider2D other = replayColliders[j];
 706661                if (!TryGetReplayHashPair(collider, other, out CollisionPair2D? pair))
 62                {
 63                    continue;
 64                }
 65
 16366                pair!.ContributeReplayHash(ref writer, mode);
 67            }
 68        }
 69
 202770        if (mode != GravitasReplayHashMode.AuthoritativeWithSolverCaches)
 128271            return;
 72
 74573        writer.WriteSection("physics.2d.caches", 4);
 74574        writer.WriteInt32(_colliders.PeakCount);
 74575        writer.WriteInt32(_processedPairKeys.Count);
 74576        writer.WriteInt32(_pairs.Count);
 74577        writer.WriteInt32(_pairsToRemove.Count);
 74578        writer.WriteInt32(_cachedPairs.Count);
 74579        writer.WriteInt32(_discreteResponsePairs.Count);
 74580        writer.WriteInt64(_continuousCollisionPreparedToken);
 74581        writer.WriteBool(_continuousCollisionPreparedMixedIndex);
 74582        writer.WriteInt32(_planarContinuousCollisionCandidates.Count);
 74583        writer.WriteInt32(_dirtyPlanarContinuousCollisionCandidates.Count);
 74584        writer.WriteInt32(_dirtyPlanarContinuousCollisionBodies.Count);
 157885        for (int i = 0; i < _dirtyPlanarContinuousCollisionBodies.Count; i++)
 4486            writer.WriteInt32(_dirtyPlanarContinuousCollisionBodies[i].Collider.ReplayOrdinal);
 74587        writer.WriteInt32(_mixedContinuousCollisionCandidates.Count);
 74588        writer.WriteInt32(_dirtyMixedContinuousCollisionCandidates.Count);
 74589        writer.WriteInt32(_processedContinuousCollisionBodies.Count);
 74590        writer.WriteInt32(_queuedContinuousCollisionHandoffBodies.Count);
 74591        writer.WriteInt32(_continuousCollisionHandoffQueue.Count);
 150692        for (int i = 0; i < _continuousCollisionHandoffQueue.Count; i++)
 893            writer.WriteInt32(_continuousCollisionHandoffQueue[i].DynamicId);
 74594        writer.WriteInt32(LastBroadPhaseCandidateCount);
 74595        writer.WriteInt32(LastContinuousCollisionIslandCount);
 74596        writer.WriteInt32(LastContinuousCollisionIslandIterationCount);
 74597        writer.WriteBool(LastContinuousCollisionIslandLimitReached);
 74598    }
 99
 100    private static bool TryGetReplayHashPair(
 101        LSCollider2D first,
 102        LSCollider2D second,
 103        out CollisionPair2D? pair) =>
 7066104        first.TryGetCollisionPair(second.Id, out pair)
 7066105        || second.TryGetCollisionPair(first.Id, out pair);
 106}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/2D/Services/GravitasPhysics2DService.Response.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasPhysics2DService.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 Gravitas.CollisionHandling;
 9using Gravitas.Constraints;
 10
 11namespace Gravitas;
 12
 13/// <content>Groups planar contacts and joints into islands and solves each island in deterministic order.</content>
 14public sealed partial class GravitasPhysics2DService
 15{
 1254116    internal int BodySlotCount => _dynamicBodies.PeakCount;
 17
 97918    internal int GetSleepSlot(SolidBody2D? body, int offset) => body?.HasSolverMobility == true
 97919        && TryGetDynamicBody(body.DynamicId, out SolidBody2D registered) && ReferenceEquals(body, registered)
 97920        ? offset + body.DynamicId : -1;
 21
 22    internal bool AdvanceSleepCounters()
 23    {
 2430224        bool ready = false;
 7921825        foreach (SolidBody2D body in _dynamicBodies)
 1530726            ready |= body.AdvanceSleepCounter();
 2430227        return ready;
 28    }
 29
 30    internal void BlockUnreadySleepIslands(SleepIslands islands, int offset, bool advanced)
 31    {
 158232        foreach (SolidBody2D body in _dynamicBodies)
 53133            if (!body.IsSleeping && (!advanced || !body.ReadyForAutomaticSleep))
 25634                islands.Block(offset + body.DynamicId);
 26035    }
 36
 37    internal void SleepReadyIslands(SleepIslands islands, int offset)
 38    {
 152439        foreach (SolidBody2D body in _dynamicBodies)
 51040            if (!body.IsSleeping && islands.CanSleep(offset + body.DynamicId))
 2341                body.Sleep();
 25242    }
 43
 44    internal void JoinSleepIslands(SleepIslands islands, int offset)
 45    {
 146046        foreach (var entry in _pairs)
 47        {
 47748            CollisionPair2D pair = entry.Value;
 47749            if (!pair.HasResponse)
 50                continue;
 51
 47752            int first = GetSleepSlot(pair.ColliderA.Body, offset);
 47753            int second = GetSleepSlot(pair.ColliderB.Body, offset);
 47754            if (first >= 0 && second >= 0 && !pair.ColliderA.IsTrigger && !pair.ColliderB.IsTrigger
 47755                && RequireCollisionPair(pair.ColliderA, pair.ColliderB))
 24456                islands.Join(first, second);
 57        }
 58
 25359        GravitasConstraint2DService constraints = _context.Constraints2D;
 51460        for (int id = 1; id <= constraints.PeakJointCount; id++)
 461            if (constraints.TryGetJointForSolver(id, out Joint2D? joint))
 362                islands.Join(GetSleepSlot(joint!.BodyA, offset), GetSleepSlot(joint.BodyB, offset));
 63
 25364    }
 65
 66    private void SolveDiscreteResponsePairs()
 67    {
 68        // Later pair callbacks can retire a previously queued row's supplier.
 6027869        for (int i = _discreteResponsePairs.Count - 1; i >= 0; i--)
 70        {
 582471            CollisionPair2D pair = _discreteResponsePairs[i];
 582472            if (!IsCurrentResponsePair(CreatePairKey(pair.Id1, pair.Id2), pair))
 10373                _discreteResponsePairs.RemoveAt(i);
 74        }
 2431575        bool hasJoints = _context.Constraints2D.HasActiveJoints;
 2431576        if (_discreteResponsePairs.Count == 0 && !hasJoints)
 1914977            return;
 78
 516679        if (!hasJoints && _discreteResponsePairs.Count == 1)
 80        {
 459581            CollisionPair2D pair = _discreteResponsePairs[0];
 459582            if (!HasAwakeResponseParticipant(pair))
 183                return;
 84
 459485            pair.WakeSleepingBodiesForCollision();
 459486            CollisionResponse2D.Resolve(pair);
 459387            return;
 88        }
 89
 57190        if (_discreteResponsePairs.Count > 1)
 38991            _discreteResponsePairs.SortInPlace(ResponsePairComparer);
 57192        BuildDiscreteIslands();
 57193        if (_discreteIslandConstraints.Count == 0)
 194            return;
 95
 57096        _discreteIslandConstraints.SortInPlace(IslandConstraintComparer);
 97
 57098        int start = 0;
 148899        while (start < _discreteIslandConstraints.Count)
 100        {
 918101            int rootKey = _discreteIslandConstraints[start].RootKey;
 918102            int end = start + 1;
 1346103            while (end < _discreteIslandConstraints.Count
 1346104                && _discreteIslandConstraints[end].RootKey == rootKey)
 105            {
 428106                end++;
 107            }
 108
 918109            if (WakeIslandBodies(rootKey))
 917110                SolveDiscreteIslandRange(start, end);
 111
 918112            start = end;
 113        }
 570114    }
 115
 116    private void BuildDiscreteIslands()
 117    {
 571118        _discreteIslandNodes.FastClear();
 571119        _discreteIslandConstraints.FastClear();
 120
 3394121        for (int i = 0; i < _discreteResponsePairs.Count; i++)
 122        {
 1126123            CollisionPair2D pair = _discreteResponsePairs[i];
 1126124            AddIslandNodeIfMovable(pair.ColliderA.Body);
 1126125            AddIslandNodeIfMovable(pair.ColliderB.Body);
 126        }
 127
 571128        AddJointIslandNodes();
 129
 571130        SortAndDeduplicateIslandNodes();
 571131        if (_discreteIslandNodes.Count == 0)
 1132            return;
 133
 3392134        for (int i = 0; i < _discreteResponsePairs.Count; i++)
 135        {
 1126136            CollisionPair2D pair = _discreteResponsePairs[i];
 1126137            int nodeA = FindIslandNode(pair.ColliderA.Body);
 1126138            int nodeB = FindIslandNode(pair.ColliderB.Body);
 1126139            if (nodeA >= 0 && nodeB >= 0)
 351140                UnionIslandNodes(nodeA, nodeB);
 141        }
 142
 570143        UnionJointIslandNodes();
 144
 570145        CompressIslandRoots();
 146
 3392147        for (int i = 0; i < _discreteResponsePairs.Count; i++)
 148        {
 1126149            CollisionPair2D pair = _discreteResponsePairs[i];
 1126150            int nodeA = FindIslandNode(pair.ColliderA.Body);
 1126151            int nodeB = FindIslandNode(pair.ColliderB.Body);
 1126152            int rootKey = ResolveConstraintRootKey(nodeA, nodeB);
 1126153            if (rootKey < 0)
 154                continue;
 155
 1125156            GetStablePairKey(pair, out int minColliderId, out int maxColliderId);
 1125157            _discreteIslandConstraints.Add(DiscreteIslandConstraint2D.CreatePair(
 1125158                pair,
 1125159                rootKey,
 1125160                minColliderId,
 1125161                maxColliderId));
 162        }
 163
 570164        AddJointIslandConstraints();
 570165    }
 166
 167    private void AddJointIslandNodes()
 168    {
 571169        GravitasConstraint2DService constraints = _context.Constraints2D;
 1590170        for (int jointId = 1; jointId <= constraints.PeakJointCount; jointId++)
 171        {
 224172            if (!constraints.TryGetJointForSolver(jointId, out Joint2D? joint))
 173                continue;
 174
 221175            AddIslandNodeIfMovable(joint!.BodyA);
 221176            AddIslandNodeIfMovable(joint.BodyB);
 177        }
 571178    }
 179
 180    private void UnionJointIslandNodes()
 181    {
 570182        GravitasConstraint2DService constraints = _context.Constraints2D;
 1586183        for (int jointId = 1; jointId <= constraints.PeakJointCount; jointId++)
 184        {
 223185            if (!constraints.TryGetJointForSolver(jointId, out Joint2D? joint))
 186                continue;
 187
 221188            int nodeA = FindIslandNode(joint!.BodyA);
 221189            int nodeB = FindIslandNode(joint.BodyB);
 221190            if (nodeA >= 0 && nodeB >= 0)
 177191                UnionIslandNodes(nodeA, nodeB);
 192        }
 570193    }
 194
 195    private void AddJointIslandConstraints()
 196    {
 570197        GravitasConstraint2DService constraints = _context.Constraints2D;
 1586198        for (int jointId = 1; jointId <= constraints.PeakJointCount; jointId++)
 199        {
 223200            if (!constraints.TryGetJointForSolver(jointId, out Joint2D? joint))
 201                continue;
 202
 221203            int nodeA = FindIslandNode(joint!.BodyA);
 221204            int nodeB = FindIslandNode(joint.BodyB);
 221205            int rootKey = ResolveConstraintRootKey(nodeA, nodeB);
 206
 221207            GetStableJointKey(joint, out int minColliderId, out int maxColliderId);
 221208            _discreteIslandConstraints.Add(DiscreteIslandConstraint2D.CreateJoint(
 221209                joint,
 221210                rootKey,
 221211                minColliderId,
 221212                maxColliderId));
 213        }
 570214    }
 215
 216    private void AddIslandNodeIfMovable(SolidBody2D? body)
 217    {
 2694218        if (!IsMovableIslandBody(body))
 820219            return;
 220
 1874221        _discreteIslandNodes.Add(new DiscreteIslandNode2D(body!.DynamicId, body));
 1874222    }
 223
 224    private void SortAndDeduplicateIslandNodes() =>
 571225        IslandGraphUtility.SortAndDeduplicate(_discreteIslandNodes, IslandNodeComparer);
 226
 227    private int FindIslandNode(SolidBody2D? body)
 228    {
 5388229        if (!IsMovableIslandBody(body))
 1640230            return -1;
 231
 3748232        return IslandGraphUtility.Find(_discreteIslandNodes, body!.DynamicId);
 233    }
 234
 235    private void UnionIslandNodes(int nodeA, int nodeB) =>
 528236        IslandGraphUtility.Union(_discreteIslandNodes, nodeA, nodeB);
 237
 238    private void CompressIslandRoots() =>
 570239        IslandGraphUtility.CompressRoots(_discreteIslandNodes);
 240
 241    private int ResolveConstraintRootKey(int nodeA, int nodeB) =>
 1347242        IslandGraphUtility.ResolveConstraintRootKey(_discreteIslandNodes, nodeA, nodeB);
 243
 244    private bool WakeIslandBodies(int rootKey) =>
 918245        IslandGraphUtility.WakeBodies(_discreteIslandNodes, rootKey);
 246
 247    private void SolveDiscreteIslandRange(int start, int end)
 248    {
 917249        if (end - start == 1 && _discreteIslandConstraints[start].Kind == DiscreteIslandConstraint2DKind.Contact)
 250        {
 368251            CollisionResponse2D.Resolve(_discreteIslandConstraints[start].Pair);
 368252            return;
 253        }
 254
 255        // Capture every grouped contact before another contact or joint changes
 256        // a shared body's incoming restitution target.
 3052257        for (int i = start; i < end; i++)
 258        {
 977259            DiscreteIslandConstraint2D constraint = _discreteIslandConstraints[i];
 977260            if (constraint.Kind == DiscreteIslandConstraint2DKind.Contact && constraint.Pair.Manifold.GroupCount > 1)
 4261                CollisionResponse2D.PrepareSolve(constraint.Pair);
 262        }
 263
 549264        bool seededNormals = end - start == 2
 549265            && _discreteIslandConstraints[start].Kind == DiscreteIslandConstraint2DKind.Contact
 549266            && _discreteIslandConstraints[start + 1].Kind == DiscreteIslandConstraint2DKind.Contact
 549267            && CollisionResponse2D.TrySeedSupportedIslandNormals(
 549268                _discreteIslandConstraints[start].Pair, _discreteIslandConstraints[start + 1].Pair);
 549269        int iterations = _context.Settings.DiscreteSolverIterations;
 8350270        for (int iteration = 0; iteration < iterations; iteration++)
 271        {
 3626272            bool prepare = iteration == 0 && !seededNormals;
 19852273            for (int i = start; i < end; i++)
 274            {
 6300275                DiscreteIslandConstraint2D constraint = _discreteIslandConstraints[i];
 6300276                if (constraint.Kind == DiscreteIslandConstraint2DKind.Contact)
 277                {
 4558278                    CollisionResponse2D.Resolve(
 4558279                        constraint.Pair,
 4558280                        applyCachedImpulse: prepare,
 4558281                        applyPositionCorrection: prepare);
 282                }
 283                else
 1742284                    JointSolver2D.Solve(constraint.Joint!, prepare);
 285            }
 286        }
 287        // Use the incoming normals and depths together after the velocity refinement.
 549288        if (seededNormals)
 83289            CollisionResponse2D.CorrectSeededSupportPositions(
 83290                _discreteIslandConstraints[start].Pair, _discreteIslandConstraints[start + 1].Pair);
 3052291        for (int i = start; i < end; i++)
 292        {
 977293            DiscreteIslandConstraint2D constraint = _discreteIslandConstraints[i];
 977294            if (constraint.Kind == DiscreteIslandConstraint2DKind.Contact && constraint.Pair.Manifold.GroupCount > 1)
 4295                constraint.Pair.ClearResponseSnapshot();
 296        }
 549297    }
 298
 299}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/2D/Services/GravitasPhysics2DService.SupportTypes.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasPhysics2DService.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 System.Runtime.CompilerServices;
 10using Gravitas.Colliders;
 11using Gravitas.Constraints;
 12using Gravitas.Support;
 13
 14namespace Gravitas;
 15
 16/// <content>Provides planar pair ordering, body mobility checks, and response-island records and comparers.</content>
 17public sealed partial class GravitasPhysics2DService
 18{
 19    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 20    private static bool HasAwakeMovableParticipant(LSCollider2D first, LSCollider2D second) =>
 705921        IsAwakeMovable(first.Body) || IsAwakeMovable(second.Body);
 22
 23    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 24    private static bool HasAwakeResponseParticipant(CollisionPair2D pair) =>
 459525        IsAwakeIslandBody(pair.ColliderA.Body) || IsAwakeIslandBody(pair.ColliderB.Body);
 26
 27    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 28    private static bool IsAwakeMovable(SolidBody2D? body) =>
 778629        body != null && body.HasSolverMobility && !body.IsSleeping;
 30
 31    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 32    private static bool IsMovableIslandBody(SolidBody2D? body) =>
 2872533        body != null && body.DynamicId >= 0 && body.HasSolverMobility;
 34
 35    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 36    private static bool IsAwakeIslandBody(SolidBody2D? body) =>
 902737        IsMovableIslandBody(body) && body!.IsAwakeForCollision;
 38
 39    private bool IsLayerCollisionDisabled(PhysicsLayer layer1, PhysicsLayer layer2)
 40    {
 3069941        bool[,] matrix = _context.Settings.CollisionMatrix;
 3069942        int layerIndex1 = layer1.Index;
 3069943        int layerIndex2 = layer2.Index;
 3069944        if (layerIndex1 >= matrix.GetLength(0) || layerIndex2 >= matrix.GetLength(1))
 673145            return false;
 46
 2396847        return !matrix[layerIndex1, layerIndex2];
 48    }
 49
 50    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 51    private void RemovePairReferences(CollisionPair2D pair)
 52    {
 53        // Separation resets the visit token; retire queued aliases before that reset and pooling.
 17954        if (pair.LastVisitToken == _context.LateSimulateToken)
 156455            for (int i = _discreteResponsePairs.Count - 1; i >= 0; i--)
 75656                if (ReferenceEquals(_discreteResponsePairs[i], pair)) _discreteResponsePairs.RemoveAt(i);
 17957        pair.ColliderA.TryRemoveCollisionPair(pair.Id2, out _);
 17958        pair.ColliderB.TryRemoveCollisionPairHolder(pair.Id1);
 17959    }
 60
 61    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 62    private static ulong CreatePairKey(int firstId, int secondId)
 63    {
 2487564        if (firstId > secondId)
 1096665            (firstId, secondId) = (secondId, firstId);
 66
 2487567        return ((ulong)(uint)firstId << 32) | (uint)secondId;
 68    }
 69
 70    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 71    private static void GetStablePairKey(CollisionPair2D pair, out int minColliderId, out int maxColliderId)
 72    {
 565573        int idA = pair.ColliderA.Id;
 565574        int idB = pair.ColliderB.Id;
 565575        if (idA <= idB)
 76        {
 526977            minColliderId = idA;
 526978            maxColliderId = idB;
 526979            return;
 80        }
 81
 38682        minColliderId = idB;
 38683        maxColliderId = idA;
 38684    }
 85
 86    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 87    private static void GetStableJointKey(Joint2D joint, out int minColliderId, out int maxColliderId)
 88    {
 22189        int idA = joint.BodyA.Collider.Id;
 22190        int idB = joint.BodyB.Collider.Id;
 22191        if (idA <= idB)
 92        {
 22093            minColliderId = idA;
 22094            maxColliderId = idB;
 22095            return;
 96        }
 97
 198        minColliderId = idB;
 199        maxColliderId = idA;
 1100    }
 101
 102    private sealed class CollisionPair2DStableKeyComparer : IComparer<CollisionPair2D>
 103    {
 104        public int Compare(CollisionPair2D? left, CollisionPair2D? right)
 105        {
 2265106            GetStablePairKey(left!, out int leftMin, out int leftMax);
 2265107            GetStablePairKey(right!, out int rightMin, out int rightMax);
 108
 2265109            int compare = leftMin.CompareTo(rightMin);
 2265110            return compare != 0 ? compare : leftMax.CompareTo(rightMax);
 111        }
 112    }
 113
 114    private sealed class DiscreteIslandConstraint2DComparer : IComparer<DiscreteIslandConstraint2D>
 115    {
 116        public int Compare(DiscreteIslandConstraint2D left, DiscreteIslandConstraint2D right)
 117        {
 1373118            int compare = left.RootKey.CompareTo(right.RootKey);
 1373119            if (compare != 0)
 920120                return compare;
 121
 453122            compare = left.MinColliderId.CompareTo(right.MinColliderId);
 453123            if (compare != 0)
 103124                return compare;
 125
 350126            compare = left.MaxColliderId.CompareTo(right.MaxColliderId);
 350127            if (compare != 0)
 316128                return compare;
 129
 34130            compare = left.Kind.CompareTo(right.Kind);
 34131            return compare != 0 ? compare : left.JointId.CompareTo(right.JointId);
 132        }
 133    }
 134
 135    private struct DiscreteIslandNode2D : IIslandNodeState
 136    {
 137        public DiscreteIslandNode2D(int bodyKey, SolidBody2D body)
 138        {
 1874139            BodyKey = bodyKey;
 1874140            Body = body;
 1874141            ParentIndex = -1;
 1874142            RootKey = bodyKey;
 1874143        }
 144
 145        public int BodyKey { get; }
 146
 147        public SolidBody2D Body { get; }
 148
 149        public int ParentIndex { get; set; }
 150
 151        public int RootKey { get; set; }
 152
 926153        public bool IsAwakeForCollision => Body.IsAwakeForCollision;
 154
 1411155        public void WakeFromCollision() => Body.WakeFromCollision();
 156    }
 157
 158    private readonly struct DiscreteIslandConstraint2D
 159    {
 160        private DiscreteIslandConstraint2D(
 161            DiscreteIslandConstraint2DKind kind,
 162            CollisionPair2D pair,
 163            Joint2D? joint,
 164            int rootKey,
 165            int minColliderId,
 166            int maxColliderId,
 167            int jointId)
 168        {
 1346169            Kind = kind;
 1346170            Pair = pair;
 1346171            Joint = joint;
 1346172            RootKey = rootKey;
 1346173            MinColliderId = minColliderId;
 1346174            MaxColliderId = maxColliderId;
 1346175            JointId = jointId;
 1346176        }
 177
 178        public static DiscreteIslandConstraint2D CreatePair(
 179            CollisionPair2D pair,
 180            int rootKey,
 181            int minColliderId,
 182            int maxColliderId) =>
 1125183            new(DiscreteIslandConstraint2DKind.Contact, pair, null, rootKey, minColliderId, maxColliderId, 0);
 184
 185        public static DiscreteIslandConstraint2D CreateJoint(
 186            Joint2D joint,
 187            int rootKey,
 188            int minColliderId,
 189            int maxColliderId) =>
 221190            new(DiscreteIslandConstraint2DKind.Joint, null!, joint, rootKey, minColliderId, maxColliderId, joint.Id);
 191
 192        public DiscreteIslandConstraint2DKind Kind { get; }
 193        public CollisionPair2D Pair { get; }
 194        public Joint2D? Joint { get; }
 195        public int RootKey { get; }
 196        public int MinColliderId { get; }
 197        public int MaxColliderId { get; }
 198        public int JointId { get; }
 199    }
 200
 201    private enum DiscreteIslandConstraint2DKind : byte
 202    {
 203        Contact = 0,
 204        Joint = 1
 205    }
 206}

Methods/Properties

InvalidatePairsForColliderReconfiguration(Gravitas.Colliders.LSCollider2D,SwiftCollections.SwiftList`1<System.Exception>&)
PrepareContinuousCollisionFrame()
AddContinuousCollisionCandidate(Gravitas.SolidBody2D,System.Boolean)
QueryPlanarContinuousCollisionCandidates(Gravitas.CollisionHandling.DynamicCcdPlanarBounds)
RefreshContinuousCollisionCandidate(Gravitas.SolidBody2D)
CanAdmitContinuousCollisionCandidateRefresh(Gravitas.SolidBody2D)
TryReserveContinuousCollisionCandidateRefresh(Gravitas.SolidBody2D)
ReleaseContinuousCollisionCandidateRefresh(Gravitas.SolidBody2D)
ReleaseContinuousCollisionCandidateRefresh(Gravitas.SolidBody2D,System.Int32)
InvalidateContinuousCollisionStateForBodyMutation(Gravitas.SolidBody2D,System.Int32)
CanAdmitContinuousCollisionCandidateRefresh(Gravitas.SolidBody2D,Gravitas.SolidBody2D)
TryReserveContinuousCollisionCandidateRefresh(Gravitas.SolidBody2D,Gravitas.SolidBody2D)
QueryMixedContinuousCollisionCandidates(SwiftCollections.Query.FixedBoundVolume)
MergeContinuousCollisionCandidateIds()
TryGetContinuousCollisionCandidate(System.Int32,Gravitas.SolidBody2D&)
GetContinuousCollisionCandidate(System.Int32)
QueueContinuousCollisionHandoff(Gravitas.SolidBody2D)
ProcessQueuedContinuousCollisionHandoffs()
ReportContinuousCollisionIterationLimit()
ProcessQueuedContinuousCollisionHandoffs(System.Int32)
BeginContinuousCollisionHandoffFrame()
AbortContinuousCollisionHandoffFrame()
ClearContinuousCollisionHandoffQueue()
DiscardContinuousCollisionHandoffQueue()
.cctor()
.ctor(Gravitas.GravitasWorldContext)
get_ColliderCount()
AssimilateBody(Gravitas.SolidBody2D,Gravitas.PhysicsMobilityType)
RefreshBodyMotionTypeRegistration(Gravitas.SolidBody2D,Gravitas.PhysicsMobilityType)
AssimilateCollider(Gravitas.Colliders.LSCollider2D)
DessimilateBody(Gravitas.SolidBody2D)
DessimilateCollider(Gravitas.Colliders.LSCollider2D)
CreateStaticSurface(System.ReadOnlySpan`1<Gravitas.Colliders.LSCollider2D>)
RemoveStaticSurface(Gravitas.StaticSurface2D)
ReleaseStaticSurfaces()
Simulate()
LateSimulate()
BeginLateSimulateBodies(System.Boolean)
CompleteLateSimulatePhysicsStep(System.Boolean)
MarkCollisionPositionPublicationPending()
PublishCollisionPositionStates()
PrepareCollisionPartitions()
RunDiscreteCollisionStep()
Visualize()
Reset()
TryGetColliderById(System.Int32,Gravitas.Colliders.LSCollider2D&)
TryGetColliderByServiceIndex(System.Int32,Gravitas.Colliders.LSCollider2D&)
GetColliderByServiceIndex(System.Int32)
PrepareReplayColliders()
TryGetDynamicBody(System.Int32,Gravitas.SolidBody2D&)
RefreshColliderServiceRefreshRegistration(Gravitas.Colliders.LSCollider2D)
AddServiceRefreshCollider(Gravitas.Colliders.LSCollider2D)
RemoveServiceRefreshCollider(Gravitas.Colliders.LSCollider2D)
EnsureFrameCapacity()
.ctor(Gravitas.GravitasWorldContext)
.ctor(Gravitas.SolidBody2D)
get_IsActive()
.ctor(Gravitas.CollisionPair2D)
get_IsCurrentLifetime()
RefreshGroundingFromDiscreteResponse(System.Int64)
ShouldUseDiscreteGroundingPair(Gravitas.CollisionPair2D,System.Int64)
ShouldUseDiscreteGroundingManifold(Gravitas.CollisionHandling.ContactManifold2D,System.Int64)
ProcessPartitionCandidate(System.Int32,System.Int32,GridForge.Spatial.WorldVoxelIndex)
IsCanonicalSharedPartition(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D,GridForge.Spatial.WorldVoxelIndex)
Max(System.Int32,System.Int32)
TryGetMinimumVoxelIndexForGrid(SwiftCollections.SwiftList`1<GridForge.Spatial.WorldVoxelIndex>,GridForge.Spatial.WorldVoxelIndex,GridForge.Spatial.VoxelIndex&)
ProcessCandidate(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D,System.Int64)
RegisterPair(System.UInt64,Gravitas.CollisionPair2D)
ExpandDiscreteResponsePairs(System.Int64)
AddExistingResponsePairs(Gravitas.Colliders.LSCollider2D,System.Int64)
TryAddExistingResponsePair(Gravitas.CollisionPair2D,System.Int64)
AddDiscreteResponseBody(Gravitas.SolidBody2D)
IsCurrentResponsePair(System.UInt64,Gravitas.CollisionPair2D)
RequireCollisionPair(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D)
CleanupUntouchedPairs(System.Int64)
TryKeepUntouchedPair(Gravitas.CollisionPair2D,System.Int64)
CreatePair(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D)
RecyclePair(Gravitas.CollisionPair2D)
RemovePairsForCollider(Gravitas.Colliders.LSCollider2D)
ClearWarmStartCachesForCollider(Gravitas.Colliders.LSCollider2D,SwiftCollections.SwiftHashSet`1<System.Int32>)
ContributeReplayHash(Chronicler.Hashing.ChronicleHashWriter&,Gravitas.GravitasReplayHashMode)
TryGetReplayHashPair(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D,Gravitas.CollisionPair2D&)
get_BodySlotCount()
GetSleepSlot(Gravitas.SolidBody2D,System.Int32)
AdvanceSleepCounters()
BlockUnreadySleepIslands(Gravitas.SleepIslands,System.Int32,System.Boolean)
SleepReadyIslands(Gravitas.SleepIslands,System.Int32)
JoinSleepIslands(Gravitas.SleepIslands,System.Int32)
SolveDiscreteResponsePairs()
BuildDiscreteIslands()
AddJointIslandNodes()
UnionJointIslandNodes()
AddJointIslandConstraints()
AddIslandNodeIfMovable(Gravitas.SolidBody2D)
SortAndDeduplicateIslandNodes()
FindIslandNode(Gravitas.SolidBody2D)
UnionIslandNodes(System.Int32,System.Int32)
CompressIslandRoots()
ResolveConstraintRootKey(System.Int32,System.Int32)
WakeIslandBodies(System.Int32)
SolveDiscreteIslandRange(System.Int32,System.Int32)
HasAwakeMovableParticipant(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D)
HasAwakeResponseParticipant(Gravitas.CollisionPair2D)
IsAwakeMovable(Gravitas.SolidBody2D)
IsMovableIslandBody(Gravitas.SolidBody2D)
IsAwakeIslandBody(Gravitas.SolidBody2D)
IsLayerCollisionDisabled(Gravitas.Support.PhysicsLayer,Gravitas.Support.PhysicsLayer)
RemovePairReferences(Gravitas.CollisionPair2D)
CreatePairKey(System.Int32,System.Int32)
GetStablePairKey(Gravitas.CollisionPair2D,System.Int32&,System.Int32&)
GetStableJointKey(Gravitas.Constraints.Joint2D,System.Int32&,System.Int32&)
Compare(Gravitas.CollisionPair2D,Gravitas.CollisionPair2D)
Compare(Gravitas.GravitasPhysics2DService/DiscreteIslandConstraint2D,Gravitas.GravitasPhysics2DService/DiscreteIslandConstraint2D)
.ctor(System.Int32,Gravitas.SolidBody2D)
get_IsAwakeForCollision()
WakeFromCollision()
.ctor(Gravitas.GravitasPhysics2DService/DiscreteIslandConstraint2DKind,Gravitas.CollisionPair2D,Gravitas.Constraints.Joint2D,System.Int32,System.Int32,System.Int32,System.Int32)
CreatePair(Gravitas.CollisionPair2D,System.Int32,System.Int32,System.Int32)
CreateJoint(Gravitas.Constraints.Joint2D,System.Int32,System.Int32,System.Int32)