< Summary

Line coverage
100%
Covered lines: 774
Uncovered lines: 0
Coverable lines: 774
Total lines: 1591
Line coverage: 100%
Branch coverage
100%
Covered branches: 424
Total branches: 424
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: PrepareContinuousCollisionFrame()100%88100%
File 1: AddContinuousCollisionCandidate(...)100%22100%
File 1: QueryContinuousCollisionCandidates(...)100%1212100%
File 1: TryGetContinuousCollisionCandidate(...)100%44100%
File 1: GetContinuousCollisionCandidate(...)100%11100%
File 1: CanAdmitContinuousCollisionCandidateRefresh(...)100%11100%
File 1: CanAdmitContinuousCollisionCandidateRefresh(...)100%11100%
File 1: TryReserveContinuousCollisionCandidateRefresh(...)100%22100%
File 1: ReleaseContinuousCollisionCandidateRefresh(...)100%11100%
File 1: ReleaseContinuousCollisionCandidateRefresh(...)100%22100%
File 1: InvalidateContinuousCollisionStateForBodyMutation(...)100%22100%
File 1: TryReserveContinuousCollisionCandidateRefresh(...)100%11100%
File 1: RefreshContinuousCollisionCandidate(...)100%11100%
File 1: QueueContinuousCollisionHandoff(...)100%44100%
File 1: ProcessQueuedContinuousCollisionHandoffs()100%11100%
File 1: ReportContinuousCollisionIterationLimit()100%11100%
File 1: ProcessQueuedContinuousCollisionHandoffs(...)100%1616100%
File 1: BeginContinuousCollisionHandoffFrame()100%11100%
File 1: AbortContinuousCollisionHandoffFrame()100%11100%
File 1: ClearContinuousCollisionHandoffQueue()100%11100%
File 1: DiscardContinuousCollisionHandoffQueue()100%22100%
File 2: .cctor()100%11100%
File 2: .ctor(...)100%11100%
File 2: get_PeakColliderCount()100%11100%
File 2: get_ColliderCount()100%11100%
File 2: Simulate()100%11100%
File 2: PrepareCollisionPartitions()100%44100%
File 2: LateSimulate()100%22100%
File 2: BeginLateSimulateBodies(...)100%88100%
File 2: CompleteLateSimulatePhysicsStep(...)100%22100%
File 2: MarkCollisionPositionPublicationPending()100%11100%
File 2: PublishCollisionPositionStates()100%44100%
File 2: RunDiscreteCollisionStep()100%11100%
File 2: Visualize()100%44100%
File 2: Reset()100%11100%
File 2: CreateStaticSurface(...)100%11100%
File 2: RemoveStaticSurface(...)100%11100%
File 2: ReleaseStaticSurfaces()100%22100%
File 2: AssimilateBody(...)100%44100%
File 2: RefreshBodyMotionTypeRegistration(...)100%1212100%
File 2: AssimilateCollider(...)100%22100%
File 2: DessimilateBody(...)100%22100%
File 2: DessimilateCollider(...)100%1616100%
File 2: RefreshColliderServiceRefreshRegistration(...)100%22100%
File 2: TryGetColliderById(...)100%22100%
File 2: TryGetColliderByServiceIndex(...)100%11100%
File 2: GetColliderByServiceIndex(...)100%11100%
File 2: PrepareReplayColliders()100%11100%
File 2: AddServiceRefreshCollider(...)100%11100%
File 2: RemoveServiceRefreshCollider(...)100%66100%
File 3: GetCollisionPair(...)100%1414100%
File 3: RequireCollisionPair(...)100%2222100%
File 3: IsLayerCollisionDisabled(...)100%44100%
File 3: PoolForDeactivation(...)100%11100%
File 3: FullDeactivateCollisionPair(...)100%11100%
File 3: DeactivateAndPoolPair(...)100%66100%
File 3: RemovePairReferences(...)100%11100%
File 3: RemovePairsForCollider(...)100%11100%
File 3: InvalidatePairsForColliderReconfiguration(...)100%11100%
File 3: RemovePairsForCollider(...)100%2626100%
File 3: ClearWarmStartCachesForCollider(...)100%1616100%
File 3: CreatePair(...)100%44100%
File 3: ProcessActiveCollisionPairs()100%3030100%
File 4: ContributeReplayHash(...)100%2626100%
File 4: TryGetReplayHashPair(...)100%22100%
File 5: get_BodySlotCount()100%11100%
File 5: GetSleepSlot(...)100%88100%
File 5: AdvanceSleepCounters()100%22100%
File 5: BlockUnreadySleepIslands(...)100%88100%
File 5: SleepReadyIslands(...)100%66100%
File 5: JoinSleepIslands(...)100%88100%
File 5: QueueDiscreteResponsePair(...)100%11100%
File 5: SolveDiscreteResponsePairs()100%2222100%
File 5: BuildDiscreteIslands()100%1414100%
File 5: AddJointIslandNodes()100%44100%
File 5: UnionJointIslandNodes()100%88100%
File 5: AddJointIslandConstraints()100%44100%
File 5: AddIslandNodeIfMovable(...)100%22100%
File 5: SortAndDeduplicateIslandNodes()100%11100%
File 5: FindIslandNode(...)100%22100%
File 5: UnionIslandNodes(...)100%11100%
File 5: CompressIslandRoots()100%11100%
File 5: ResolveConstraintRootKey(...)100%11100%
File 5: WakeIslandBodies(...)100%11100%
File 5: SolveDiscreteIslandRange(...)100%2828100%
File 5: GetJointLinearCorrectionRate(...)100%1212100%
File 6: IsMovableIslandBody(...)100%22100%
File 6: HasAwakeResponseParticipant(...)100%22100%
File 6: IsAwakeIslandBody(...)100%22100%
File 6: GetStablePairKey(...)100%22100%
File 6: GetStableJointKey(...)100%22100%
File 6: Compare(...)100%22100%
File 6: Compare(...)100%88100%
File 6: .ctor(...)100%11100%
File 6: get_IsAwakeForCollision()100%11100%
File 6: WakeFromCollision()100%11100%
File 6: .ctor(...)100%11100%
File 6: CreatePair(...)100%11100%
File 6: CreateJoint(...)100%11100%
File 6: get_InactiveFrameThreshold()100%11100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/3D/Services/GravitasPhysicsService.ContinuousCollision.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasPhysicsService.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 spatial sweep candidates and coordinates continuous collision handoffs and iteration limits.</con
 17public sealed partial class GravitasPhysicsService
 18{
 19    internal void PrepareContinuousCollisionFrame()
 20    {
 14306821        long token = _context.LateSimulateToken;
 14306822        if (_continuousCollisionPreparedToken == token)
 7972323            return;
 24
 6334525        _continuousCollisionCandidates.Clear();
 6334526        _dirtyContinuousCollisionCandidates.Clear();
 6334527        _dirtyContinuousCollisionBodyIds.Clear();
 6334528        _dirtyContinuousCollisionBodies.FastClear();
 6334529        int peak = _dynamicBodies.PeakCount;
 27995430        for (int i = 0; i < peak; i++)
 31        {
 7663532            if (_dynamicBodies.TryGetValue(i, out SolidBody body))
 33            {
 7440634                if (!body.EnsureContinuousCollisionFramePrepared(token, refreshGroundSupport: true))
 35                    continue;
 7440136                AddContinuousCollisionCandidate(body);
 37            }
 38        }
 39
 6334240        _continuousCollisionCandidates.Sort();
 6334241        _continuousCollisionPreparedToken = token;
 6334242    }
 43
 44    private void AddContinuousCollisionCandidate(SolidBody body)
 45    {
 7440146        Fixed64 radius = body.ResolveContinuousCollisionProxyRadius();
 7440147        if (radius <= Fixed64.Epsilon)
 348            return;
 49
 7439850        _continuousCollisionCandidateLifetimes[body.DynamicId] =
 7439851            new ColliderLifetimeToken(body.Collider);
 7439852        _continuousCollisionCandidates.Add(
 7439853            body.DynamicId,
 7439854            DynamicCcdCandidateIndex.CreateBoundsBetween(
 7439855                body.ContinuousCollisionFrameStart,
 7439856                body.ContinuousCollisionFrameEnd,
 7439857                Vector3d.One * radius));
 7439858    }
 59
 60    /// <summary>
 61    /// Runs this context's visual interpolation step for dynamic bodies.
 62    /// </summary>
 63
 64    internal SwiftList<int> QueryContinuousCollisionCandidates(FixedBoundVolume sourceBounds)
 65    {
 1669866        PrepareContinuousCollisionFrame();
 1669867        _continuousCollisionCandidates.Query(sourceBounds, _continuousCollisionCandidateIds);
 1669868        _dirtyContinuousCollisionCandidates.Query(sourceBounds, _dirtyContinuousCollisionCandidateIds);
 1669869        int retainedCount = 0;
 6665070        for (int i = 0; i < _continuousCollisionCandidateIds.Count; i++)
 71        {
 1662772            int dynamicId = _continuousCollisionCandidateIds[i];
 1662773            if (!_dirtyContinuousCollisionBodyIds.Contains(dynamicId)
 1662774                && TryGetContinuousCollisionCandidate(dynamicId, out _))
 75            {
 1561776                _continuousCollisionCandidateIds[retainedCount++] = dynamicId;
 77            }
 78        }
 79
 1770880        while (_continuousCollisionCandidateIds.Count > retainedCount)
 101081            _continuousCollisionCandidateIds.RemoveAt(
 101082                _continuousCollisionCandidateIds.Count - 1);
 83
 3537484        for (int i = 0; i < _dirtyContinuousCollisionCandidateIds.Count; i++)
 85        {
 98986            int dynamicId = _dirtyContinuousCollisionCandidateIds[i];
 98987            if (TryGetContinuousCollisionCandidate(dynamicId, out _))
 98788                _continuousCollisionCandidateIds.Add(dynamicId);
 89        }
 90
 1669891        return _continuousCollisionCandidateIds;
 92    }
 93
 94    internal bool TryGetContinuousCollisionCandidate(int dynamicId, out SolidBody body)
 95    {
 1662596        ColliderLifetimeToken registration = _continuousCollisionCandidateLifetimes[dynamicId];
 1662597        if (registration.Collider != null && registration.IsActive)
 98        {
 1660699            body = registration.Collider.Body!;
 16606100            return true;
 101        }
 102
 19103        body = null!;
 19104        return false;
 105    }
 106
 107    internal SolidBody GetContinuousCollisionCandidate(int dynamicId) =>
 16191108        _dynamicBodies[dynamicId];
 109
 1110    internal bool CanAdmitContinuousCollisionCandidateRefresh(SolidBody body) => true;
 111
 112    internal bool CanAdmitContinuousCollisionCandidateRefresh(
 113        SolidBody first,
 1114        SolidBody second) => true;
 115
 116    internal bool TryReserveContinuousCollisionCandidateRefresh(SolidBody body)
 117    {
 686118        if (_dirtyContinuousCollisionBodyIds.Add(body.DynamicId))
 612119            _dirtyContinuousCollisionBodies.Add(body);
 120
 686121        return true;
 122    }
 123
 124    private void ReleaseContinuousCollisionCandidateRefresh(SolidBody body) =>
 158125        ReleaseContinuousCollisionCandidateRefresh(body, body.DynamicId);
 126
 127    private void ReleaseContinuousCollisionCandidateRefresh(SolidBody body, int dynamicId)
 128    {
 818129        if (!_dirtyContinuousCollisionBodyIds.Remove(dynamicId))
 813130            return;
 131
 5132        _dirtyContinuousCollisionBodies.Remove(body);
 5133        _dirtyContinuousCollisionCandidates.Remove(dynamicId);
 5134    }
 135
 136    internal void InvalidateContinuousCollisionStateForBodyMutation(
 137        SolidBody body,
 138        int dynamicId)
 139    {
 660140        if (dynamicId >= 0)
 630141            _continuousCollisionCandidateLifetimes[dynamicId] = default;
 142
 660143        ReleaseContinuousCollisionCandidateRefresh(body, dynamicId);
 660144        _processedContinuousCollisionBodies.Remove(body);
 660145        _queuedContinuousCollisionHandoffBodies.Remove(body);
 660146        _continuousCollisionHandoffQueue.Remove(body);
 660147        body.DiscardContinuousCollisionHandoff();
 660148        _continuousCollisionPreparedToken = -1;
 660149    }
 150
 151    internal bool TryReserveContinuousCollisionCandidateRefresh(
 152        SolidBody first,
 153        SolidBody second)
 154    {
 57155        TryReserveContinuousCollisionCandidateRefresh(first);
 57156        TryReserveContinuousCollisionCandidateRefresh(second);
 57157        return true;
 158    }
 159
 160    internal void RefreshContinuousCollisionCandidate(SolidBody body)
 161    {
 884162        Fixed64 radius = body.ResolveContinuousCollisionProxyRadius();
 884163        _dirtyContinuousCollisionCandidates.AddOrUpdate(
 884164            body.DynamicId,
 884165            body.ResolveContinuousCollisionTrajectoryBounds(radius));
 884166    }
 167
 168    internal void QueueContinuousCollisionHandoff(SolidBody body)
 169    {
 226170        if (!_processedContinuousCollisionBodies.Contains(body)
 226171            || !_queuedContinuousCollisionHandoffBodies.Add(body))
 172        {
 121173            return;
 174        }
 175
 105176        _continuousCollisionHandoffQueue.Add(body);
 105177    }
 178
 179    internal bool ProcessQueuedContinuousCollisionHandoffs() =>
 3180        ProcessQueuedContinuousCollisionHandoffs(_context.Settings.ContinuousCollisionMaxToiIterations) > 0;
 181
 182    internal void ReportContinuousCollisionIterationLimit() =>
 61183        LastContinuousCollisionIslandLimitReached = true;
 184
 185    internal int ProcessQueuedContinuousCollisionHandoffs(int iterationBudget)
 186    {
 63136187        if (_continuousCollisionHandoffQueue.Count == 0)
 63056188            return 0;
 189
 80190        if (iterationBudget <= 0)
 191        {
 1192            LastContinuousCollisionIslandLimitReached = true;
 1193            DiscardContinuousCollisionHandoffQueue();
 1194            return 0;
 195        }
 196
 79197        int readIndex = 0;
 79198        int iterations = 0;
 79199        bool processed = false;
 79200        bool completed = false;
 79201        bool limitReached = false;
 202        try
 203        {
 169204            while (readIndex < _continuousCollisionHandoffQueue.Count && iterations < iterationBudget)
 205            {
 92206                SolidBody body = _continuousCollisionHandoffQueue[readIndex++];
 207                // Consumption can synchronously return work to this body; dequeue ends dedupe ownership first.
 92208                _queuedContinuousCollisionHandoffBodies.Remove(body);
 209
 92210                if (body.TryConsumeQueuedContinuousCollisionHandoff(
 92211                        updateSleepState: false,
 92212                        updateColliderState: false,
 92213                        out bool shouldNotifyMovement))
 214                {
 87215                    processed = true;
 87216                    iterations++;
 87217                    if (shouldNotifyMovement)
 84218                        body.NotifyAuthoritativeMovement();
 219                }
 220            }
 221
 77222            limitReached = readIndex < _continuousCollisionHandoffQueue.Count;
 77223            completed = true;
 77224            return iterations;
 225        }
 226        finally
 227        {
 79228            if (processed)
 75229                LastContinuousCollisionIslandCount++;
 230
 79231            LastContinuousCollisionIslandIterationCount += iterations;
 79232            LastContinuousCollisionIslandLimitReached |= completed && limitReached;
 79233            if (!completed || limitReached)
 4234                DiscardContinuousCollisionHandoffQueue();
 235            else
 75236                ClearContinuousCollisionHandoffQueue();
 79237        }
 77238    }
 239
 240    private void BeginContinuousCollisionHandoffFrame()
 241    {
 63073242        _processedContinuousCollisionBodies.Clear();
 63073243        DiscardContinuousCollisionHandoffQueue();
 63073244        LastContinuousCollisionIslandCount = 0;
 63073245        LastContinuousCollisionIslandIterationCount = 0;
 63073246        LastContinuousCollisionIslandLimitReached = false;
 63073247    }
 248
 249    internal void AbortContinuousCollisionHandoffFrame()
 250    {
 1251        _processedContinuousCollisionBodies.Clear();
 1252        DiscardContinuousCollisionHandoffQueue();
 1253    }
 254
 255    private void ClearContinuousCollisionHandoffQueue()
 256    {
 63272257        _queuedContinuousCollisionHandoffBodies.Clear();
 63272258        _continuousCollisionHandoffQueue.FastClear();
 63272259    }
 260
 261    private void DiscardContinuousCollisionHandoffQueue()
 262    {
 126422263        for (int i = 0; i < _continuousCollisionHandoffQueue.Count; i++)
 14264            _continuousCollisionHandoffQueue[i].DiscardContinuousCollisionHandoff();
 265
 63197266        ClearContinuousCollisionHandoffQueue();
 63197267    }
 268
 269}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/3D/Services/GravitasPhysicsService.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasPhysicsService.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/// Owns physics registration and collision-pair state for one <see cref="GravitasWorldContext"/>.
 17/// </summary>
 18/// <content>Context-owned registration, static-surface declarations and fixed-step orchestration.</content>
 19public sealed partial class GravitasPhysicsService
 20{
 21    private const int DefaultColliderSize = 2048;
 22    private const int DefaultBodySize = DefaultColliderSize / 4;
 23    private const int DefaultColliderIdSize = DefaultColliderSize / 8;
 124    private static readonly CollisionPairStableKeyComparer ResponsePairComparer = new();
 125    private static readonly IslandNodeKeyComparer<DiscreteIslandNode> IslandNodeComparer = new();
 126    private static readonly DiscreteIslandConstraintComparer IslandConstraintComparer = new();
 27
 28    private readonly GravitasWorldContext _context;
 29
 1019130    private SwiftSlotMap<SolidBody> _dynamicBodies = new(DefaultBodySize);
 1019131    private readonly ColliderRegistry<LSCollider> _colliders = new(DefaultColliderSize);
 1019132    private SwiftList<LSCollider> _serviceRefreshColliders = new(DefaultColliderIdSize);
 1019133    private SwiftStack<CollisionPair> _cachedCollisionPairs = new();
 1019134    private SwiftQueue<CollisionPairLifetimeToken> _activeCollisionPairs = new();
 1019135    private readonly SwiftList<CollisionPairLifetimeToken> _activeCollisionPairSnapshot = new();
 1019136    private readonly SwiftList<CollisionPairLifetimeToken> _pairsPendingDeactivation = new();
 1019137    private readonly SwiftList<CollisionPair> _discreteResponsePairs = new();
 1019138    private readonly SwiftList<DiscreteIslandNode> _discreteIslandNodes = new();
 1019139    private readonly SwiftList<DiscreteIslandConstraint> _discreteIslandConstraints = new();
 1019140    private readonly DynamicCcdCandidateIndex _continuousCollisionCandidates = new(DefaultBodySize);
 1019141    private readonly DynamicCcdCandidateIndex _dirtyContinuousCollisionCandidates =
 1019142        new(DefaultBodySize, supportsUpdates: true);
 1019143    private readonly SwiftList<ColliderLifetimeToken> _continuousCollisionCandidateLifetimes =
 1019144        new(DefaultBodySize);
 1019145    private readonly SwiftList<int> _continuousCollisionCandidateIds = new(DefaultBodySize);
 1019146    private readonly SwiftList<int> _dirtyContinuousCollisionCandidateIds = new(DefaultBodySize);
 1019147    private readonly SwiftHashSet<int> _dirtyContinuousCollisionBodyIds = new(DefaultBodySize);
 1019148    private readonly SwiftList<SolidBody> _dirtyContinuousCollisionBodies = new(DefaultBodySize);
 1019149    private readonly SwiftHashSet<SolidBody> _processedContinuousCollisionBodies = new(DefaultBodySize);
 1019150    private readonly SwiftHashSet<SolidBody> _queuedContinuousCollisionHandoffBodies = new(DefaultBodySize);
 1019151    private readonly SwiftList<SolidBody> _continuousCollisionHandoffQueue = new(DefaultBodySize);
 1019152    private long _continuousCollisionPreparedToken = -1;
 1019153    private readonly SwiftList<StaticSurface> _staticSurfaces = new();
 54    private bool _collisionPositionPublicationPending;
 55
 56    /// <summary>
 57    /// Initializes a new physics service for the supplied context.
 58    /// </summary>
 59    /// <param name="context">The owning world context.</param>
 1019160    public GravitasPhysicsService(GravitasWorldContext context)
 61    {
 1019162        ChronicleGuard.ThrowIfNull(context, nameof(context));
 1019163        _context = context;
 1019164    }
 65
 66    /// <summary>
 67    /// Gets or sets whether this context should simulate physics.
 68    /// </summary>
 69    public bool SimulatePhysics { get; set; } = true;
 70
 71    /// <summary>
 72    /// Gets the highest collider ID allocated in this context.
 73    /// </summary>
 162774    public int PeakColliderCount => _colliders.PeakCount;
 75
 76    /// <summary>
 77    /// Gets the number of dynamic bodies currently registered in this context.
 78    /// </summary>
 79    public int BodyCount { get; private set; }
 80
 81    /// <summary>
 82    /// Gets the number of colliders currently registered in this context.
 83    /// </summary>
 4699184    public int ColliderCount => _colliders.Count;
 85
 86    /// <summary>
 87    /// Gets how many service-owned continuous-collision handoff batches were consumed during the last late step.
 88    /// </summary>
 89    public int LastContinuousCollisionIslandCount { get; private set; }
 90
 91    /// <summary>
 92    /// Gets how many service-owned continuous-collision handoff iterations were consumed during the last late step.
 93    /// </summary>
 94    public int LastContinuousCollisionIslandIterationCount { get; private set; }
 95
 96    /// <summary>
 97    /// Gets whether the service-owned continuous-collision handoff queue hit its deterministic iteration cap.
 98    /// </summary>
 99    public bool LastContinuousCollisionIslandLimitReached { get; private set; }
 100
 101    /// <summary>
 102    /// Runs this context's physics simulation step.
 103    /// </summary>
 104    public void Simulate()
 105    {
 62983106        _context.EnterSimulationPhase();
 107        try
 108        {
 62983109            if (!SimulatePhysics)
 110                return;
 62983111        }
 112        finally
 113        {
 62983114            _context.ExitSimulationPhase();
 62983115        }
 62983116    }
 117
 118    private void PrepareCollisionPartitions()
 119    {
 274428120        foreach (SolidBody body in _dynamicBodies)
 74158121            body.Collider.Simulate();
 122
 430722123        for (int i = 0; i < _serviceRefreshColliders.Count; i++)
 152305124            _serviceRefreshColliders[i].Simulate();
 63056125    }
 126
 127    /// <summary>
 128    /// Runs this context's late physics step.
 129    /// </summary>
 130    public void LateSimulate()
 131    {
 4132        _context.EnterSimulationPhase();
 133        try
 134        {
 4135            if (!BeginLateSimulateBodies(continuousCollisionFramePrepared: false))
 1136                return;
 137
 3138            ProcessQueuedContinuousCollisionHandoffs();
 3139            CompleteLateSimulatePhysicsStep();
 3140            PublishCollisionPositionStates();
 3141        }
 142        finally
 143        {
 4144            _context.ExitSimulationPhase();
 4145        }
 4146    }
 147
 148    internal bool BeginLateSimulateBodies(bool continuousCollisionFramePrepared)
 149    {
 63074150        if (!SimulatePhysics)
 1151            return false;
 152
 63073153        if (!continuousCollisionFramePrepared)
 19154            _context.AdvanceLateSimulateToken();
 155
 63073156        PrepareContinuousCollisionFrame();
 63073157        BeginContinuousCollisionHandoffFrame();
 158
 63073159        int peak = _dynamicBodies.PeakCount;
 278984160        for (int i = 0; i < peak; i++)
 161        {
 76420162            if (_dynamicBodies.TryGetValue(i, out SolidBody body))
 163            {
 74187164                body.LateSimulate(updateSleepState: false, updateColliderState: false);
 74186165                _processedContinuousCollisionBodies.Add(body);
 166            }
 167        }
 168
 63072169        return true;
 170    }
 171
 172    internal void CompleteLateSimulatePhysicsStep(bool deferSleep = false)
 173    {
 63056174        PrepareCollisionPartitions();
 63056175        RunDiscreteCollisionStep();
 63056176        ProcessActiveCollisionPairs();
 63053177        if (!deferSleep)
 47069178            _context.UpdateAutomaticSleep(ran3D: true, ran2D: false);
 63053179    }
 180
 55370181    internal void MarkCollisionPositionPublicationPending() => _collisionPositionPublicationPending = true;
 182
 183    internal void PublishCollisionPositionStates()
 184    {
 71302185        if (!_collisionPositionPublicationPending)
 22880186            return;
 48422187        _collisionPositionPublicationPending = false;
 209360188        foreach (SolidBody body in _dynamicBodies)
 56258189            body.PublishCollisionPositionState();
 48422190    }
 191
 192    private void RunDiscreteCollisionStep()
 193    {
 63056194        _discreteResponsePairs.FastClear();
 195        try
 196        {
 63056197            _context.Collisions.CheckAndDistributeCollisions();
 63056198            SolveDiscreteResponsePairs();
 63056199        }
 200        finally
 201        {
 63056202            _discreteResponsePairs.Clear();
 63056203            _discreteIslandNodes.Clear();
 63056204            _discreteIslandConstraints.Clear();
 63056205        }
 63056206        _context.Collisions.RetireExpiredRetainedPartitions();
 63056207    }
 208
 209    /// <summary>Publishes interpolated presentation state for registered 3D bodies.</summary>
 210    public void Visualize()
 211    {
 38212        int peak = _dynamicBodies.PeakCount;
 170213        for (int i = 0; i < peak; i++)
 214        {
 47215            if (_dynamicBodies.TryGetValue(i, out SolidBody body))
 46216                body.OnVisualize();
 217        }
 38218    }
 219
 220    /// <summary>
 221    /// Clears all context-local physics registration state.
 222    /// </summary>
 223    public void Reset()
 224    {
 118225        _collisionPositionPublicationPending = false;
 118226        ReleaseStaticSurfaces();
 118227        DiscardContinuousCollisionHandoffQueue();
 228        // FastClear during simulation can leave references beyond the current count.
 118229        _continuousCollisionHandoffQueue.Clear(clearRetainedReferences: true);
 118230        _dynamicBodies.Clear();
 118231        _colliders.Clear();
 118232        _serviceRefreshColliders.Clear();
 118233        _cachedCollisionPairs.Clear();
 118234        _activeCollisionPairs.Clear();
 118235        _activeCollisionPairSnapshot.Clear(clearRetainedReferences: true);
 118236        _pairsPendingDeactivation.Clear(clearRetainedReferences: true);
 118237        _discreteResponsePairs.Clear(clearRetainedReferences: true);
 118238        _discreteIslandNodes.Clear(clearRetainedReferences: true);
 118239        _discreteIslandConstraints.Clear(clearRetainedReferences: true);
 118240        _continuousCollisionCandidates.Clear();
 118241        _dirtyContinuousCollisionCandidates.Clear();
 118242        _continuousCollisionCandidateLifetimes.Clear();
 118243        _continuousCollisionCandidateIds.FastClear();
 118244        _dirtyContinuousCollisionCandidateIds.FastClear();
 118245        _dirtyContinuousCollisionBodyIds.Clear();
 118246        _dirtyContinuousCollisionBodies.Clear(clearRetainedReferences: true);
 118247        _processedContinuousCollisionBodies.Clear();
 118248        _continuousCollisionPreparedToken = -1;
 118249        LastContinuousCollisionIslandCount = 0;
 118250        LastContinuousCollisionIslandIterationCount = 0;
 118251        LastContinuousCollisionIslandLimitReached = false;
 252
 118253        BodyCount = 0;
 118254    }
 255
 256    /// <summary>Creates a context-owned continuity declaration for static meshes using triangle-surface collision.</sum
 257    /// <param name="members">Distinct active bodyless or explicit-static meshes in <see cref="MeshColliderMode.Concave"
 258    /// <returns>A declaration that retains each member's collider identity and joins only exact shared boundary spans.<
 259    /// <remarks>Call between complete fixed steps. Context reset or disposal expires the returned handle.</remarks>
 260    /// <exception cref="System.ArgumentException">A member is ineligible or already belongs to a declaration.</exceptio
 261    /// <exception cref="System.ObjectDisposedException">The context has ended.</exception>
 262    /// <exception cref="System.InvalidOperationException">A fixed step is in progress.</exception>
 263    public StaticSurface CreateStaticSurface(System.ReadOnlySpan<LSMeshCollider> members)
 264    {
 493265        var surface = new StaticSurface(_context, members);
 490266        _staticSurfaces.Add(surface);
 490267        return surface;
 268    }
 269
 483270    internal void RemoveStaticSurface(StaticSurface surface) => _staticSurfaces.Remove(surface);
 271
 272    internal void ReleaseStaticSurfaces()
 273    {
 20639274        foreach (StaticSurface surface in _staticSurfaces) surface.Release();
 10309275        _staticSurfaces.Clear();
 10309276    }
 277
 278    internal int AssimilateBody(SolidBody body, PhysicsMobilityType motionType)
 279    {
 8416280        ChronicleGuard.ThrowIfNull(body, nameof(body));
 8416281        ChronicleGuard.ThrowIfArgument(
 8416282            !ReferenceEquals(body.Context, _context),
 8416283            nameof(body),
 8416284            "Body must belong to this physics service context.");
 285
 8416286        int dynamicId = -1;
 8416287        if (motionType != PhysicsMobilityType.Static)
 288        {
 7456289            dynamicId = _dynamicBodies.Add(body);
 7456290            _context.ReserveSleepIslands();
 14871291            while (_continuousCollisionCandidateLifetimes.Count <= dynamicId)
 7415292                _continuousCollisionCandidateLifetimes.Add(default);
 7456293            BodyCount++;
 294        }
 295
 8416296        return dynamicId;
 297    }
 298
 299    internal void RefreshBodyMotionTypeRegistration(
 300        SolidBody body,
 301        PhysicsMobilityType previousMotionType)
 302    {
 74303        if (body.MotionType != PhysicsMobilityType.Static && body.Collider is LSMeshCollider mesh)
 2304            mesh.StaticSurface?.Remove(mesh);
 74305        if (previousMotionType == PhysicsMobilityType.Static)
 306        {
 21307            int dynamicId = _dynamicBodies.Add(body);
 21308            _context.ReserveSleepIslands();
 36309            while (_continuousCollisionCandidateLifetimes.Count <= dynamicId)
 15310                _continuousCollisionCandidateLifetimes.Add(default);
 21311            body.SetDynamicId(dynamicId);
 21312            BodyCount++;
 21313            return;
 314        }
 315
 53316        if (body.MotionType == PhysicsMobilityType.Static)
 317        {
 18318            int previousDynamicId = body.DynamicId;
 18319            _dynamicBodies.RemoveAt(previousDynamicId);
 18320            _continuousCollisionCandidateLifetimes[previousDynamicId] = default;
 18321            ReleaseContinuousCollisionCandidateRefresh(body);
 18322            body.SetDynamicId(-1);
 18323            BodyCount--;
 324        }
 53325    }
 326
 327    internal int AssimilateCollider(LSCollider collider)
 328    {
 13254329        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 13254330        collider.BindContext(_context);
 331
 13254332        int id = _colliders.Register(collider);
 333        // Match the 2D registration baseline: returning ordinary contact pairs
 334        // should not allocate the pool's first backing array during retirement.
 335        // Dense contact graphs may still exceed this collider-count reservation.
 13254336        if (_context.Settings.PoolingEnabled)
 13249337            _cachedCollisionPairs.EnsureCapacity(_colliders.Count);
 13254338        RefreshColliderServiceRefreshRegistration(collider);
 13254339        return id;
 340    }
 341
 342    internal void DessimilateBody(SolidBody body)
 343    {
 167344        ChronicleGuard.ThrowIfNull(body, nameof(body));
 167345        int dynamicId = body.DynamicId;
 167346        if (!_dynamicBodies.TryRemoveAt(dynamicId))
 27347            return;
 348
 140349        _continuousCollisionCandidateLifetimes[dynamicId] = default;
 140350        ReleaseContinuousCollisionCandidateRefresh(body);
 140351        BodyCount--;
 140352    }
 353
 354    internal void DessimilateCollider(LSCollider collider)
 355    {
 456356        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 456357        int id = collider.Id;
 358
 456359        if (!_colliders.TryGetById(id, out LSCollider? registered) || !ReferenceEquals(registered, collider))
 360        {
 4361            GravitasLogger.Channel.Warn($"Object with ID {collider.Id} cannot be dessimilated because it is not assimila
 4362            return;
 363        }
 364
 463365        if (collider is LSMeshCollider mesh) mesh.StaticSurface?.Remove(mesh);
 452366        if (collider.Body != null)
 168367            _context.Constraints3D.RemoveJointsForBody(collider.Body);
 452368        RemovePairsForCollider(collider);
 451369        if (collider.IsPartitioned)
 447370            _context.Collisions.ClearPartitionedObject(collider, true);
 371
 451372        _context.MixedCollisions.RemovePairsFor3DCollider(collider);
 451373        if (collider.IsMixedPartitioned)
 79374            _context.MixedCollisions.ClearPartitioned3DCollider(collider, force: true);
 375
 451376        RemoveServiceRefreshCollider(collider);
 451377        _colliders.Remove(collider);
 451378    }
 379
 380    internal void RefreshColliderServiceRefreshRegistration(LSCollider collider)
 381    {
 13328382        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 383
 13328384        if (collider.RequiresServiceSideRefresh)
 5815385            AddServiceRefreshCollider(collider);
 386        else
 7513387            RemoveServiceRefreshCollider(collider);
 7513388    }
 389
 390    /// <summary>
 391    /// Resolves a context-local collider ID.
 392    /// </summary>
 393    /// <param name="id">The context-local collider ID.</param>
 394    /// <param name="collider">The resolved collider, if present.</param>
 395    /// <returns>True when the ID resolves in this context.</returns>
 396    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 397    public bool TryGetColliderById(int id, out LSCollider? collider)
 398    {
 7244838399        if (id < 0)
 400        {
 20401            collider = null;
 20402            return false;
 403        }
 404
 7244818405        return _colliders.TryGetById(id, out collider);
 406    }
 407
 408    internal bool TryGetColliderByServiceIndex(int serviceIndex, out LSCollider? collider) =>
 8409        _colliders.TryGetByServiceIndex(serviceIndex, out collider);
 410
 21035411    internal LSCollider GetColliderByServiceIndex(int serviceIndex) => _colliders[serviceIndex];
 412
 7282413    internal SwiftList<LSCollider> PrepareReplayColliders() => _colliders.PrepareReplayColliders();
 414
 415    private void AddServiceRefreshCollider(LSCollider collider)
 416    {
 5815417        collider.SetServiceRefreshIndex(_serviceRefreshColliders.Count);
 5815418        _serviceRefreshColliders.Add(collider);
 5815419    }
 420
 421    private void RemoveServiceRefreshCollider(LSCollider collider)
 422    {
 7964423        int index = collider.ServiceRefreshIndex;
 7964424        if (index < 0 || !ReferenceEquals(_serviceRefreshColliders[index], collider))
 425        {
 7633426            collider.ClearServiceRefreshIndex();
 7633427            return;
 428        }
 429
 331430        int lastIndex = _serviceRefreshColliders.Count - 1;
 331431        if (index != lastIndex)
 432        {
 61433            LSCollider moved = _serviceRefreshColliders[lastIndex];
 61434            _serviceRefreshColliders[index] = moved;
 61435            moved.SetServiceRefreshIndex(index);
 436        }
 437
 331438        _serviceRefreshColliders.RemoveAt(lastIndex);
 331439        collider.ClearServiceRefreshIndex();
 331440    }
 441
 442}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/3D/Services/GravitasPhysicsService.Pairs.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasPhysicsService.Pairs.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using System;
 9using Gravitas.Colliders;
 10using Gravitas.CollisionHandling;
 11using Gravitas.Support;
 12using SwiftCollections;
 13
 14namespace Gravitas;
 15
 16/// <content>Maintains spatial collision pairs, including collider invalidation, response processing, and pooled deactiv
 17public sealed partial class GravitasPhysicsService
 18{
 19    internal CollisionPair? GetCollisionPair(int id1, int id2)
 20    {
 244338721        if (!TryGetColliderById(id1, out LSCollider? collider1)
 244338722            || !TryGetColliderById(id2, out LSCollider? collider2))
 23        {
 2924            return null;
 25        }
 26
 244335827        if (collider1!.Id > collider2!.Id)
 214326528            (collider2, collider1) = (collider1, collider2);
 29
 244335830        if (!RequireCollisionPair(collider1, collider2))
 14738531            return null;
 32
 229597333        if (!collider1.TryGetCollisionPair(collider2.Id, out CollisionPair? pair)
 229597334            && !collider2.TryGetCollisionPair(collider1.Id, out pair))
 35        {
 21467936            if (!CollisionPair.BoundsOverlapInclusive(collider1, collider2))
 21386237                return null;
 38
 81739            pair = CreatePair(collider1, collider2);
 81740            pair.ColliderA.TryAddCollisionPair(pair.ColliderB.Id, pair);
 81741            pair.ColliderB.TryAddCollisionPairHolder(pair.ColliderA.Id);
 42        }
 43
 208211144        return pair;
 45    }
 46
 47    internal bool RequireCollisionPair(LSCollider collider1, LSCollider collider2)
 48    {
 263752049        return collider1.IsActive && collider2.IsActive
 263752050            && !collider1.IsDeactivationInProgress && !collider2.IsDeactivationInProgress
 263752051            && collider1.Shape != ColliderType.None && collider2.Shape != ColliderType.None
 263752052            && (collider1.Body != null || collider2.Body != null)
 263752053            && !IsLayerCollisionDisabled(collider1.Layer, collider2.Layer)
 263752054            && ColliderCollisionFilter.AllowsPhysicalPair(collider1, collider2)
 263752055            && !_context.Constraints3D.ShouldExcludeLinkedCollision(collider1, collider2)
 263752056            && !collider1.IsSibling(collider2);
 57    }
 58
 59    internal bool IsLayerCollisionDisabled(PhysicsLayer layer1, PhysicsLayer layer2)
 60    {
 300593361        bool[,] matrix = _context.Settings.CollisionMatrix;
 300593362        int layerIndex1 = layer1.Index;
 300593363        int layerIndex2 = layer2.Index;
 300593364        if (layerIndex1 >= matrix.GetLength(0) || layerIndex2 >= matrix.GetLength(1))
 157501365            return false;
 66
 143092067        return !matrix[layerIndex1, layerIndex2];
 68    }
 69
 70    internal void PoolForDeactivation(CollisionPair pair)
 71    {
 79272        ChronicleGuard.ThrowIfNull(pair, nameof(pair));
 79273        lock (_activeCollisionPairs)
 79274            _activeCollisionPairs.Enqueue(new CollisionPairLifetimeToken(pair));
 79275    }
 76
 77    internal void FullDeactivateCollisionPair(CollisionPair pair)
 78    {
 13479        RemovePairReferences(pair);
 13480        DeactivateAndPoolPair(pair);
 12981    }
 82
 83    internal void DeactivateAndPoolPair(CollisionPair pair)
 84    {
 13485        if (!pair.Active)
 186            return;
 87
 13388        pair.Deactivate();
 12889        if (_context.Settings.PoolingEnabled && !pair.IsNotificationInProgress)
 90        {
 11491            pair.ReleaseEndpointsForPooling();
 11492            _cachedCollisionPairs.Push(pair);
 93        }
 12894    }
 95
 96    internal void RemovePairReferences(CollisionPair pair)
 97    {
 13498        pair.ColliderA.TryRemoveCollisionPair(pair.Id2);
 13499        pair.ColliderB.TryRemoveCollisionPairHolder(pair.Id1);
 134100    }
 101
 102    internal void RemovePairsForCollider(LSCollider collider)
 103    {
 452104        SwiftList<Exception>? notificationExceptions = null;
 452105        RemovePairsForCollider(
 452106            collider,
 452107            clearRuntimeRelationships: true,
 452108            deferNotificationExceptions: false,
 452109            ref notificationExceptions);
 451110    }
 111
 112    internal void InvalidatePairsForColliderReconfiguration(
 113        LSCollider collider,
 114        ref SwiftList<Exception>? notificationExceptions) =>
 129115        RemovePairsForCollider(
 129116            collider,
 129117            clearRuntimeRelationships: false,
 129118            deferNotificationExceptions: true,
 129119            ref notificationExceptions);
 120
 121    private void RemovePairsForCollider(
 122        LSCollider collider,
 123        bool clearRuntimeRelationships,
 124        bool deferNotificationExceptions,
 125        ref SwiftList<Exception>? notificationExceptions)
 126    {
 581127        var registration = new ColliderLifetimeToken(collider);
 128        // Accepted reconfiguration callbacks may reset the context or start a
 129        // nested transaction. Their snapshot must outlive service scratch state.
 581130        SwiftList<CollisionPairLifetimeToken> pending = deferNotificationExceptions
 581131            ? new SwiftList<CollisionPairLifetimeToken>()
 581132            : _pairsPendingDeactivation;
 581133        int deactivationStart = pending.Count;
 581134        SwiftDictionary<int, CollisionPair>? collisionPairs = collider.CollisionPairs;
 581135        if (collisionPairs != null)
 136        {
 268137            foreach (var pairEntry in collisionPairs)
 37138                pending.Add(new CollisionPairLifetimeToken(pairEntry.Value));
 139        }
 140
 581141        SwiftHashSet<int>? collisionPairHolders = collider.CollisionPairHolders;
 581142        if (collisionPairHolders != null)
 143        {
 286144            foreach (int holderId in collisionPairHolders)
 145            {
 46146                if (!TryGetColliderById(holderId, out LSCollider? holder))
 147                    continue;
 148
 46149                if (holder!.TryGetCollisionPair(collider.Id, out CollisionPair? pair))
 46150                    pending.Add(new CollisionPairLifetimeToken(pair!));
 151            }
 152        }
 153
 581154        int deactivationEnd = pending.Count;
 155        try
 156        {
 1324157            for (int i = deactivationStart; i < deactivationEnd; i++)
 158            {
 82159                CollisionPairLifetimeToken token = pending[i];
 82160                if (!token.IsCurrentLifetime)
 161                    continue;
 162
 79163                if (!deferNotificationExceptions)
 164                {
 67165                    FullDeactivateCollisionPair(token.Pair);
 66166                    continue;
 167                }
 168
 169                try
 170                {
 12171                    FullDeactivateCollisionPair(token.Pair);
 9172                }
 3173                catch (Exception exception)
 174                {
 3175                    CollisionNotificationExceptions.Capture(
 3176                        ref notificationExceptions,
 3177                        exception);
 3178                }
 179            }
 180
 181            // Exact retirement already removes old references. Reconfiguration
 182            // callbacks may create fresh pairs, including on a new registration.
 580183            if (clearRuntimeRelationships && registration.IsCurrentLifetime)
 184            {
 451185                collider.ClearCollisionPairState();
 451186                collider.ClearRuntimeRelationships();
 187            }
 580188        }
 189        finally
 190        {
 581191            if (deactivationStart == 0)
 578192                pending.Clear();
 581193        }
 580194    }
 195
 196    internal void ClearWarmStartCachesForCollider(LSCollider collider, SwiftHashSet<int>? changedSuppliers = null)
 197    {
 4744198        SwiftDictionary<int, CollisionPair>? collisionPairs = collider.CollisionPairs;
 4744199        if (collisionPairs != null)
 200        {
 834201            foreach (var pairEntry in collisionPairs)
 202            {
 205203                if (changedSuppliers == null) pairEntry.Value.ClearWarmStart();
 185204                else pairEntry.Value.InvalidateSurfaceContact(collider, changedSuppliers);
 205            }
 206        }
 207
 4744208        SwiftHashSet<int>? collisionPairHolders = collider.CollisionPairHolders;
 4744209        if (collisionPairHolders == null)
 4522210            return;
 211
 498212        foreach (int holderId in collisionPairHolders)
 213        {
 27214            if (TryGetColliderById(holderId, out LSCollider? holder)
 27215                && holder!.TryGetCollisionPair(collider.Id, out CollisionPair? pair))
 216            {
 31217                if (changedSuppliers == null) pair!.ClearWarmStart();
 23218                else pair!.InvalidateSurfaceContact(collider, changedSuppliers);
 219            }
 220        }
 222221    }
 222
 223    private CollisionPair CreatePair(LSCollider collider1, LSCollider collider2)
 224    {
 817225        if (!_context.Settings.PoolingEnabled || _cachedCollisionPairs.Count <= 0)
 792226            return new CollisionPair(collider1, collider2);
 227
 25228        CollisionPair pair = _cachedCollisionPairs.Pop();
 25229        pair.Initialize(collider1, collider2);
 25230        return pair;
 231    }
 232
 233    private void ProcessActiveCollisionPairs()
 234    {
 63056235        int snapshotStart = _activeCollisionPairSnapshot.Count;
 63056236        int collisionCounter = _activeCollisionPairs.Count;
 322204237        for (int i = 0; i < collisionCounter; i++)
 98046238            _activeCollisionPairSnapshot.Add(_activeCollisionPairs.Dequeue());
 239
 63056240        int snapshotEnd = _activeCollisionPairSnapshot.Count;
 63056241        int processingIndex = snapshotStart;
 242        try
 243        {
 259138244            for (; processingIndex < snapshotEnd; processingIndex++)
 245            {
 98044246                CollisionPairLifetimeToken token = _activeCollisionPairSnapshot[processingIndex];
 98044247                CollisionPair instancePair = token.Pair;
 98044248                if (!token.IsCurrentLifetime || !instancePair.Active)
 249                    continue;
 250
 98003251                if (!RequireCollisionPair(instancePair.ColliderA, instancePair.ColliderB)
 98003252                    || !instancePair.TryRefreshRetainedContact())
 253                {
 25254                    FullDeactivateCollisionPair(instancePair);
 24255                    continue;
 256                }
 257
 97978258                long passedFrames = _context.FrameCount - instancePair.LastCollidedFrame;
 97978259                if (passedFrames >= InactiveFrameThreshold)
 5260                    FullDeactivateCollisionPair(instancePair);
 261                else
 262                {
 97973263                    if (instancePair.CullCounter <= 0 || instancePair.HasContactTransition)
 95547264                        instancePair.NotifyCollidersOfContact();
 97971265                    if (token.IsCurrentLifetime && instancePair.Active)
 97962266                        _activeCollisionPairs.Enqueue(token);
 267                }
 268            }
 63053269        }
 270        finally
 271        {
 63066272            for (; processingIndex < snapshotEnd; processingIndex++)
 273            {
 5274                CollisionPairLifetimeToken token = _activeCollisionPairSnapshot[processingIndex];
 5275                if (token.IsCurrentLifetime && token.Pair.Active)
 4276                    _activeCollisionPairs.Enqueue(token);
 277            }
 278
 63056279            if (snapshotStart == 0)
 63052280                _activeCollisionPairSnapshot.Clear();
 63056281        }
 63053282    }
 283
 284}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/3D/Services/GravitasPhysicsService.ReplayHash.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasPhysicsService.ReplayHash.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using Chronicler.Hashing;
 9using Gravitas.Colliders;
 10using Gravitas.CollisionHandling;
 11using SwiftCollections;
 12
 13namespace Gravitas;
 14
 15/// <content>Writes spatial collider, body, pair, and optional solver-cache state to the replay hash.</content>
 16public sealed partial class GravitasPhysicsService
 17{
 18    internal void ContributeReplayHash(
 19        ref ChronicleHashWriter writer,
 20        GravitasReplayHashMode mode)
 21    {
 338122        SwiftList<LSCollider> replayColliders = PrepareReplayColliders();
 23
 338124        writer.WriteSection("physics.3d", 2);
 338125        writer.WriteBool(SimulatePhysics);
 338126        writer.WriteInt32(BodyCount);
 338127        writer.WriteInt32(ColliderCount);
 338128        writer.WriteInt32(_dynamicBodies.PeakCount);
 338129        writer.WriteInt32(replayColliders.Count);
 30
 2892831        for (int i = 0; i < replayColliders.Count; i++)
 32        {
 1108333            LSCollider collider = replayColliders[i];
 1108334            collider.ContributeReplayHash(ref writer, mode);
 1108335            if (collider.Body == null)
 643936                writer.WriteBool(false);
 37            else
 38            {
 464439                writer.WriteBool(true);
 464440                collider.Body.ContributeReplayHash(ref writer, mode);
 41            }
 42        }
 43
 338144        bool membership = false;
 1007145        foreach (StaticSurface surface in _staticSurfaces) membership |= surface.ReplayMembership != 0;
 338146        if (membership)
 47        {
 109348            writer.WriteSection("physics.3d.surfaces", 1);
 109349            writer.WriteInt32(replayColliders.Count);
 1052450            foreach (LSCollider collider in replayColliders.AsReadOnlySpan())
 416951                writer.WriteInt32(collider is LSMeshCollider mesh ? mesh.StaticSurface?.ReplayMembership ?? 0 : 0);
 52        }
 53
 338154        writer.WriteSection("physics.3d.pairs", 2);
 2892855        for (int i = 0; i < replayColliders.Count; i++)
 56        {
 1108357            LSCollider collider = replayColliders[i];
 58
 6457059            for (int j = i + 1; j < replayColliders.Count; j++)
 60            {
 2120261                LSCollider other = replayColliders[j];
 2120262                if (!TryGetReplayHashPair(collider, other, out CollisionPair? pair))
 63                {
 64                    continue;
 65                }
 66
 137567                pair!.ContributeReplayHash(ref writer, mode);
 68            }
 69        }
 70
 338171        if (mode != GravitasReplayHashMode.AuthoritativeWithSolverCaches)
 175572            return;
 73
 162674        writer.WriteSection("physics.3d.caches", 5);
 162675        writer.WriteInt32(PeakColliderCount);
 162676        writer.WriteInt32(_cachedCollisionPairs.Count);
 162677        writer.WriteInt32(_activeCollisionPairs.Count);
 162678        writer.WriteInt64(_continuousCollisionPreparedToken);
 162679        writer.WriteInt32(_continuousCollisionCandidates.Count);
 162680        writer.WriteInt32(_dirtyContinuousCollisionCandidates.Count);
 162681        writer.WriteInt32(_dirtyContinuousCollisionBodies.Count);
 334882        for (int i = 0; i < _dirtyContinuousCollisionBodies.Count; i++)
 4883            writer.WriteInt32(_dirtyContinuousCollisionBodies[i].Collider.ReplayOrdinal);
 162684        writer.WriteInt32(_processedContinuousCollisionBodies.Count);
 162685        writer.WriteInt32(_queuedContinuousCollisionHandoffBodies.Count);
 162686        writer.WriteInt32(_continuousCollisionHandoffQueue.Count);
 326887        for (int i = 0; i < _continuousCollisionHandoffQueue.Count; i++)
 888            writer.WriteInt32(_continuousCollisionHandoffQueue[i].DynamicId);
 162689        writer.WriteInt32(LastContinuousCollisionIslandCount);
 162690        writer.WriteInt32(LastContinuousCollisionIslandIterationCount);
 162691        writer.WriteBool(LastContinuousCollisionIslandLimitReached);
 162692    }
 93
 94    private static bool TryGetReplayHashPair(
 95        LSCollider first,
 96        LSCollider second,
 97        out CollisionPair? pair) =>
 2120298        first.TryGetCollisionPair(second.Id, out pair)
 2120299        || second.TryGetCollisionPair(first.Id, out pair);
 100}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/3D/Services/GravitasPhysicsService.Response.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasPhysicsService.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 FixedMathSharp;
 9using Gravitas.CollisionHandling;
 10using Gravitas.Constraints;
 11
 12namespace Gravitas;
 13
 14/// <content>Queues spatial contact response and solves deterministic islands of contacts and joints.</content>
 15public sealed partial class GravitasPhysicsService
 16{
 1255417    internal int BodySlotCount => _dynamicBodies.PeakCount;
 18
 104319    internal int GetSleepSlot(SolidBody? body) => body?.HasSolverMobility == true
 104320        && _dynamicBodies.TryGetValue(body.DynamicId, out SolidBody registered) && ReferenceEquals(body, registered)
 104321        ? body.DynamicId : -1;
 22
 23    internal bool AdvanceSleepCounters()
 24    {
 6305325        bool ready = false;
 27440626        foreach (SolidBody body in _dynamicBodies)
 7415027            ready |= body.AdvanceSleepCounter();
 6305328        return ready;
 29    }
 30
 31    internal void BlockUnreadySleepIslands(SleepIslands islands, bool advanced)
 32    {
 164633        foreach (SolidBody body in _dynamicBodies)
 55034            if (!body.IsSleeping && (!advanced || !body.ReadyForAutomaticSleep))
 26635                islands.Block(body.DynamicId);
 27336    }
 37
 38    internal void SleepReadyIslands(SleepIslands islands)
 39    {
 159840        foreach (SolidBody body in _dynamicBodies)
 53541            if (!body.IsSleeping && islands.CanSleep(body.DynamicId))
 2542                body.Sleep();
 26443    }
 44
 45    internal void JoinSleepIslands(SleepIslands islands)
 46    {
 152047        foreach (CollisionPairLifetimeToken token in _activeCollisionPairs)
 49448            JoinContact(token);
 49        // A nested late step can run while an outer notification owns tokens.
 53850        foreach (CollisionPairLifetimeToken token in _activeCollisionPairSnapshot)
 351            JoinContact(token);
 52
 26653        GravitasConstraint3DService constraints = _context.Constraints3D;
 56454        for (int id = 1; id <= constraints.PeakJointCount; id++)
 1655            if (constraints.TryGetJointForSolver(id, out Joint3D? joint))
 1556                islands.Join(GetSleepSlot(joint!.BodyA), GetSleepSlot(joint.BodyB));
 57
 58        void JoinContact(CollisionPairLifetimeToken token)
 59        {
 60            CollisionPair pair = token.Pair;
 61            if (!token.IsCurrentLifetime || !pair.Active || !pair.Manifold.HasContact)
 62                return;
 63
 64            int first = GetSleepSlot(pair.ColliderA.Body);
 65            int second = GetSleepSlot(pair.ColliderB.Body);
 66            if (first >= 0 && second >= 0 && !pair.ColliderA.IsTrigger && !pair.ColliderB.IsTrigger
 67                && RequireCollisionPair(pair.ColliderA, pair.ColliderB))
 68                islands.Join(first, second);
 69        }
 26670    }
 71
 72    internal void QueueDiscreteResponsePair(CollisionPair pair)
 73    {
 4658174        ChronicleGuard.ThrowIfNull(pair, nameof(pair));
 4658175        _discreteResponsePairs.Add(pair);
 4658176    }
 77
 78    private void SolveDiscreteResponsePairs()
 79    {
 6306680        bool hasJoints = _context.Constraints3D.HasActiveJoints;
 6306681        if (_discreteResponsePairs.Count == 0 && !hasJoints)
 2148682            return;
 83
 4158084        if (!hasJoints && _discreteResponsePairs.Count == 1)
 85        {
 3844486            CollisionPair pair = _discreteResponsePairs[0];
 3844487            if (!HasAwakeResponseParticipant(pair))
 188                return;
 89
 3844390            pair.WakeSleepingBodiesForCollision();
 3844391            CollisionResponse.CalculateImpulse(pair);
 3844392            return;
 93        }
 94
 313695        if (_discreteResponsePairs.Count > 1)
 233196            _discreteResponsePairs.SortInPlace(ResponsePairComparer);
 313697        BuildDiscreteIslands();
 313698        if (_discreteIslandConstraints.Count == 0)
 199            return;
 100
 3135101        _discreteIslandConstraints.SortInPlace(IslandConstraintComparer);
 102
 3135103        int start = 0;
 6414104        while (start < _discreteIslandConstraints.Count)
 105        {
 3279106            int rootKey = _discreteIslandConstraints[start].RootKey;
 3279107            int end = start + 1;
 19609108            while (end < _discreteIslandConstraints.Count
 19609109                && _discreteIslandConstraints[end].RootKey == rootKey)
 110            {
 16330111                end++;
 112            }
 113
 3279114            if (WakeIslandBodies(rootKey))
 3250115                SolveDiscreteIslandRange(start, end);
 116
 3279117            start = end;
 118        }
 3135119    }
 120
 121    private void BuildDiscreteIslands()
 122    {
 3136123        _discreteIslandNodes.FastClear();
 3136124        _discreteIslandConstraints.FastClear();
 125
 22494126        for (int i = 0; i < _discreteResponsePairs.Count; i++)
 127        {
 8111128            CollisionPair pair = _discreteResponsePairs[i];
 8111129            AddIslandNodeIfMovable(pair.ColliderA.Body);
 8111130            AddIslandNodeIfMovable(pair.ColliderB.Body);
 131        }
 132
 3136133        AddJointIslandNodes();
 134
 3136135        SortAndDeduplicateIslandNodes();
 3136136        if (_discreteIslandNodes.Count == 0)
 1137            return;
 138
 22492139        for (int i = 0; i < _discreteResponsePairs.Count; i++)
 140        {
 8111141            CollisionPair pair = _discreteResponsePairs[i];
 8111142            int nodeA = FindIslandNode(pair.ColliderA.Body);
 8111143            int nodeB = FindIslandNode(pair.ColliderB.Body);
 8111144            if (nodeA >= 0 && nodeB >= 0)
 561145                UnionIslandNodes(nodeA, nodeB);
 146        }
 147
 3135148        UnionJointIslandNodes();
 149
 3135150        CompressIslandRoots();
 151
 22492152        for (int i = 0; i < _discreteResponsePairs.Count; i++)
 153        {
 8111154            CollisionPair pair = _discreteResponsePairs[i];
 8111155            int nodeA = FindIslandNode(pair.ColliderA.Body);
 8111156            int nodeB = FindIslandNode(pair.ColliderB.Body);
 8111157            int rootKey = ResolveConstraintRootKey(nodeA, nodeB);
 8111158            if (rootKey < 0)
 159                continue;
 160
 8110161            GetStablePairKey(pair, out int minColliderId, out int maxColliderId);
 8110162            _discreteIslandConstraints.Add(DiscreteIslandConstraint.CreatePair(
 8110163                pair,
 8110164                rootKey,
 8110165                minColliderId,
 8110166                maxColliderId));
 167        }
 168
 3135169        AddJointIslandConstraints();
 3135170    }
 171
 172    private void AddJointIslandNodes()
 173    {
 3136174        GravitasConstraint3DService constraints = _context.Constraints3D;
 29276175        for (int jointId = 1; jointId <= constraints.PeakJointCount; jointId++)
 176        {
 11502177            if (!constraints.TryGetJointForSolver(jointId, out Joint3D? joint))
 178                continue;
 179
 11499180            AddIslandNodeIfMovable(joint!.BodyA);
 11499181            AddIslandNodeIfMovable(joint.BodyB);
 182        }
 3136183    }
 184
 185    private void UnionJointIslandNodes()
 186    {
 3135187        GravitasConstraint3DService constraints = _context.Constraints3D;
 29272188        for (int jointId = 1; jointId <= constraints.PeakJointCount; jointId++)
 189        {
 11501190            if (!constraints.TryGetJointForSolver(jointId, out Joint3D? joint))
 191                continue;
 192
 11499193            int nodeA = FindIslandNode(joint!.BodyA);
 11499194            int nodeB = FindIslandNode(joint.BodyB);
 11499195            if (nodeA >= 0 && nodeB >= 0)
 11027196                UnionIslandNodes(nodeA, nodeB);
 197        }
 3135198    }
 199
 200    private void AddJointIslandConstraints()
 201    {
 3135202        GravitasConstraint3DService constraints = _context.Constraints3D;
 29272203        for (int jointId = 1; jointId <= constraints.PeakJointCount; jointId++)
 204        {
 11501205            if (!constraints.TryGetJointForSolver(jointId, out Joint3D? joint))
 206                continue;
 207
 11499208            int nodeA = FindIslandNode(joint!.BodyA);
 11499209            int nodeB = FindIslandNode(joint.BodyB);
 11499210            int rootKey = ResolveConstraintRootKey(nodeA, nodeB);
 211
 11499212            GetStableJointKey(joint, out int minColliderId, out int maxColliderId);
 11499213            _discreteIslandConstraints.Add(DiscreteIslandConstraint.CreateJoint(
 11499214                joint,
 11499215                rootKey,
 11499216                minColliderId,
 11499217                maxColliderId));
 218        }
 3135219    }
 220
 221    private void AddIslandNodeIfMovable(SolidBody? body)
 222    {
 39220223        if (!IsMovableIslandBody(body))
 8023224            return;
 225
 31197226        _discreteIslandNodes.Add(new DiscreteIslandNode(body!.DynamicId, body));
 31197227    }
 228
 229    private void SortAndDeduplicateIslandNodes() =>
 3136230        IslandGraphUtility.SortAndDeduplicate(_discreteIslandNodes, IslandNodeComparer);
 231
 232    private int FindIslandNode(SolidBody? body)
 233    {
 78440234        if (!IsMovableIslandBody(body))
 16046235            return -1;
 236
 62394237        return IslandGraphUtility.Find(_discreteIslandNodes, body!.DynamicId);
 238    }
 239
 240    private void UnionIslandNodes(int nodeA, int nodeB) =>
 11588241        IslandGraphUtility.Union(_discreteIslandNodes, nodeA, nodeB);
 242
 243    private void CompressIslandRoots() =>
 3135244        IslandGraphUtility.CompressRoots(_discreteIslandNodes);
 245
 246    private int ResolveConstraintRootKey(int nodeA, int nodeB) =>
 19610247        IslandGraphUtility.ResolveConstraintRootKey(_discreteIslandNodes, nodeA, nodeB);
 248
 249    private bool WakeIslandBodies(int rootKey) =>
 3279250        IslandGraphUtility.WakeBodies(_discreteIslandNodes, rootKey);
 251
 252    private void SolveDiscreteIslandRange(int start, int end)
 253    {
 3250254        if (end - start == 1
 3250255            && _discreteIslandConstraints[start].Kind == DiscreteIslandConstraintKind.Contact)
 256        {
 141257            CollisionResponse.CalculateImpulse(_discreteIslandConstraints[start].Pair);
 141258            return;
 259        }
 260
 261        // Restitution targets belong to the incoming island state. Capture all
 262        // contacts before any contact or joint warm start changes shared bodies.
 45096263        for (int i = start; i < end; i++)
 264        {
 19439265            DiscreteIslandConstraint constraint = _discreteIslandConstraints[i];
 19439266            if (constraint.Kind == DiscreteIslandConstraintKind.Contact)
 7941267                CollisionResponse.PrepareSolve(constraint.Pair);
 268        }
 269
 3109270        bool correctedPositions = false;
 3109271        bool seededNormals = end - start == 2
 3109272            && _discreteIslandConstraints[start].Kind == DiscreteIslandConstraintKind.Contact
 3109273            && _discreteIslandConstraints[start + 1].Kind == DiscreteIslandConstraintKind.Contact
 3109274            && CollisionResponse.TrySeedSupportedIslandNormals(
 3109275                _discreteIslandConstraints[start].Pair, _discreteIslandConstraints[start + 1].Pair,
 3109276                out correctedPositions);
 3109277        Fixed64 linearCorrectionRate = GetJointLinearCorrectionRate(start, end);
 3109278        int iterations = _context.Settings.DiscreteSolverIterations;
 64912279        for (int iteration = 0; iteration < iterations; iteration++)
 280        {
 29347281            bool applyCachedImpulse = iteration == 0;
 29347282            bool applyPositionCorrection = iteration == 0;
 480228283            for (int i = start; i < end; i++)
 284            {
 210767285                DiscreteIslandConstraint constraint = _discreteIslandConstraints[i];
 210767286                if (constraint.Kind == DiscreteIslandConstraintKind.Contact)
 287                {
 85374288                    CollisionResponse.CalculateImpulse(
 85374289                        constraint.Pair,
 85374290                        applyCachedImpulse && !seededNormals,
 85374291                        applyPositionCorrection && !correctedPositions);
 292                }
 293                else
 125393294                    JointSolver3D.Solve(constraint.Joint!, applyCachedImpulse, linearCorrectionRate);
 295            }
 296        }
 297
 298        // These pre-solve velocities and lever positions are phase-local scratch,
 299        // not state carried into the next frame or a retained pair's replay hash.
 45096300        for (int i = start; i < end; i++)
 301        {
 19439302            DiscreteIslandConstraint constraint = _discreteIslandConstraints[i];
 19439303            if (constraint.Kind == DiscreteIslandConstraintKind.Contact)
 7941304                constraint.Pair.ResponseSnapshot = default;
 305        }
 3109306    }
 307
 308    private Fixed64 GetJointLinearCorrectionRate(int start, int end)
 309    {
 3109310        Fixed64 distance = Fixed64.Zero;
 45094311        for (int i = start; i < end; i++)
 312        {
 19439313            DiscreteIslandConstraint constraint = _discreteIslandConstraints[i];
 19439314            if (constraint.Kind != DiscreteIslandConstraintKind.Joint)
 315                continue;
 11498316            if (!JointSolver3D.TryGetLinearCorrectionDistance(constraint.Joint!, out Fixed64 error))
 317                continue;
 11492318            if (!Fixed64.TryAdd(distance, error, out distance))
 1319                return Fixed64.Zero;
 320        }
 321
 322        // Bound the connected chain's total repair demand before individual bodies reach their speed cap.
 3108323        Fixed64 rate = _context.InvDeltaTime;
 3108324        Fixed64 speed = _context.Environment.MaxSpeed;
 3108325        return Fixed64.TryMultiplyDivide(distance, rate, Fixed64.One, out Fixed64 demand) && demand <= speed
 3108326            ? rate : speed / distance;
 327    }
 328
 329}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/3D/Services/GravitasPhysicsService.SupportTypes.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasPhysicsService.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.CollisionHandling;
 11using Gravitas.Constraints;
 12
 13namespace Gravitas;
 14
 15/// <content>Provides spatial pair ordering, body mobility checks, and response-island records and comparers.</content>
 16public sealed partial class GravitasPhysicsService
 17{
 18    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 18452619    private static bool IsMovableIslandBody(SolidBody? body) => body?.HasSolverMobility == true;
 20
 21    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 22    private static bool HasAwakeResponseParticipant(CollisionPair pair) =>
 3844423        IsAwakeIslandBody(pair.ColliderA.Body) || IsAwakeIslandBody(pair.ColliderB.Body);
 24
 25    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 26    private static bool IsAwakeIslandBody(SolidBody? body) =>
 6686627        IsMovableIslandBody(body) && body!.IsAwakeForCollision;
 28
 29    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 30    private static void GetStablePairKey(CollisionPair pair, out int minColliderId, out int maxColliderId)
 31    {
 2005432        int idA = pair.ColliderA.Id;
 2005433        int idB = pair.ColliderB.Id;
 2005434        if (idA <= idB)
 35        {
 1950536            minColliderId = idA;
 1950537            maxColliderId = idB;
 1950538            return;
 39        }
 40
 54941        minColliderId = idB;
 54942        maxColliderId = idA;
 54943    }
 44
 45    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 46    private static void GetStableJointKey(Joint3D joint, out int minColliderId, out int maxColliderId)
 47    {
 1149948        int idA = joint.BodyA.Collider.Id;
 1149949        int idB = joint.BodyB.Collider.Id;
 1149950        if (idA <= idB)
 51        {
 1149552            minColliderId = idA;
 1149553            maxColliderId = idB;
 1149554            return;
 55        }
 56
 457        minColliderId = idB;
 458        maxColliderId = idA;
 459    }
 60
 61    private sealed class CollisionPairStableKeyComparer : IComparer<CollisionPair>
 62    {
 63        public int Compare(CollisionPair? left, CollisionPair? right)
 64        {
 597265            GetStablePairKey(left!, out int leftMin, out int leftMax);
 597266            GetStablePairKey(right!, out int rightMin, out int rightMax);
 67
 597268            int compare = leftMin.CompareTo(rightMin);
 597269            return compare != 0 ? compare : leftMax.CompareTo(rightMax);
 70        }
 71    }
 72
 73    private sealed class DiscreteIslandConstraintComparer : IComparer<DiscreteIslandConstraint>
 74    {
 75        public int Compare(DiscreteIslandConstraint left, DiscreteIslandConstraint right)
 76        {
 1714677            int compare = left.RootKey.CompareTo(right.RootKey);
 1714678            if (compare != 0)
 15879                return compare;
 80
 1698881            compare = left.MinColliderId.CompareTo(right.MinColliderId);
 1698882            if (compare != 0)
 907083                return compare;
 84
 791885            compare = left.MaxColliderId.CompareTo(right.MaxColliderId);
 791886            if (compare != 0)
 783487                return compare;
 88
 8489            compare = ((byte)left.Kind).CompareTo((byte)right.Kind);
 8490            return compare != 0 ? compare : left.JointId.CompareTo(right.JointId);
 91        }
 92    }
 93
 94    private struct DiscreteIslandNode : IIslandNodeState
 95    {
 96        public DiscreteIslandNode(int bodyKey, SolidBody body)
 97        {
 3119798            BodyKey = bodyKey;
 3119799            Body = body;
 31197100            ParentIndex = -1;
 31197101            RootKey = bodyKey;
 31197102        }
 103
 104        public int BodyKey { get; }
 105
 106        public SolidBody Body { get; }
 107
 108        public int ParentIndex { get; set; }
 109
 110        public int RootKey { get; set; }
 111
 3286112        public bool IsAwakeForCollision => Body.IsAwakeForCollision;
 113
 14621114        public void WakeFromCollision() => Body.WakeFromCollision();
 115    }
 116
 117    private readonly struct DiscreteIslandConstraint
 118    {
 119        private DiscreteIslandConstraint(
 120            DiscreteIslandConstraintKind kind,
 121            CollisionPair pair,
 122            Joint3D? joint,
 123            int rootKey,
 124            int minColliderId,
 125            int maxColliderId,
 126            int jointId)
 127        {
 19609128            Kind = kind;
 19609129            Pair = pair;
 19609130            Joint = joint;
 19609131            RootKey = rootKey;
 19609132            MinColliderId = minColliderId;
 19609133            MaxColliderId = maxColliderId;
 19609134            JointId = jointId;
 19609135        }
 136
 137        public static DiscreteIslandConstraint CreatePair(
 138            CollisionPair pair,
 139            int rootKey,
 140            int minColliderId,
 141            int maxColliderId) =>
 8110142            new(DiscreteIslandConstraintKind.Contact, pair, null, rootKey, minColliderId, maxColliderId, 0);
 143
 144        public static DiscreteIslandConstraint CreateJoint(
 145            Joint3D joint,
 146            int rootKey,
 147            int minColliderId,
 148            int maxColliderId) =>
 11499149            new(DiscreteIslandConstraintKind.Joint, null!, joint, rootKey, minColliderId, maxColliderId, joint.Id);
 150
 151        public DiscreteIslandConstraintKind Kind { get; }
 152        public CollisionPair Pair { get; }
 153        public Joint3D? Joint { get; }
 154        public int RootKey { get; }
 155        public int MinColliderId { get; }
 156        public int MaxColliderId { get; }
 157        public int JointId { get; }
 158    }
 159
 160    private enum DiscreteIslandConstraintKind : byte
 161    {
 162        Contact = 0,
 163        Joint = 1
 164    }
 165
 97978166    private int InactiveFrameThreshold => _context.FrameRate * 8;
 167}

Methods/Properties

PrepareContinuousCollisionFrame()
AddContinuousCollisionCandidate(Gravitas.SolidBody)
QueryContinuousCollisionCandidates(SwiftCollections.Query.FixedBoundVolume)
TryGetContinuousCollisionCandidate(System.Int32,Gravitas.SolidBody&)
GetContinuousCollisionCandidate(System.Int32)
CanAdmitContinuousCollisionCandidateRefresh(Gravitas.SolidBody)
CanAdmitContinuousCollisionCandidateRefresh(Gravitas.SolidBody,Gravitas.SolidBody)
TryReserveContinuousCollisionCandidateRefresh(Gravitas.SolidBody)
ReleaseContinuousCollisionCandidateRefresh(Gravitas.SolidBody)
ReleaseContinuousCollisionCandidateRefresh(Gravitas.SolidBody,System.Int32)
InvalidateContinuousCollisionStateForBodyMutation(Gravitas.SolidBody,System.Int32)
TryReserveContinuousCollisionCandidateRefresh(Gravitas.SolidBody,Gravitas.SolidBody)
RefreshContinuousCollisionCandidate(Gravitas.SolidBody)
QueueContinuousCollisionHandoff(Gravitas.SolidBody)
ProcessQueuedContinuousCollisionHandoffs()
ReportContinuousCollisionIterationLimit()
ProcessQueuedContinuousCollisionHandoffs(System.Int32)
BeginContinuousCollisionHandoffFrame()
AbortContinuousCollisionHandoffFrame()
ClearContinuousCollisionHandoffQueue()
DiscardContinuousCollisionHandoffQueue()
.cctor()
.ctor(Gravitas.GravitasWorldContext)
get_PeakColliderCount()
get_ColliderCount()
Simulate()
PrepareCollisionPartitions()
LateSimulate()
BeginLateSimulateBodies(System.Boolean)
CompleteLateSimulatePhysicsStep(System.Boolean)
MarkCollisionPositionPublicationPending()
PublishCollisionPositionStates()
RunDiscreteCollisionStep()
Visualize()
Reset()
CreateStaticSurface(System.ReadOnlySpan`1<Gravitas.Colliders.LSMeshCollider>)
RemoveStaticSurface(Gravitas.StaticSurface)
ReleaseStaticSurfaces()
AssimilateBody(Gravitas.SolidBody,Gravitas.PhysicsMobilityType)
RefreshBodyMotionTypeRegistration(Gravitas.SolidBody,Gravitas.PhysicsMobilityType)
AssimilateCollider(Gravitas.Colliders.LSCollider)
DessimilateBody(Gravitas.SolidBody)
DessimilateCollider(Gravitas.Colliders.LSCollider)
RefreshColliderServiceRefreshRegistration(Gravitas.Colliders.LSCollider)
TryGetColliderById(System.Int32,Gravitas.Colliders.LSCollider&)
TryGetColliderByServiceIndex(System.Int32,Gravitas.Colliders.LSCollider&)
GetColliderByServiceIndex(System.Int32)
PrepareReplayColliders()
AddServiceRefreshCollider(Gravitas.Colliders.LSCollider)
RemoveServiceRefreshCollider(Gravitas.Colliders.LSCollider)
GetCollisionPair(System.Int32,System.Int32)
RequireCollisionPair(Gravitas.Colliders.LSCollider,Gravitas.Colliders.LSCollider)
IsLayerCollisionDisabled(Gravitas.Support.PhysicsLayer,Gravitas.Support.PhysicsLayer)
PoolForDeactivation(Gravitas.CollisionHandling.CollisionPair)
FullDeactivateCollisionPair(Gravitas.CollisionHandling.CollisionPair)
DeactivateAndPoolPair(Gravitas.CollisionHandling.CollisionPair)
RemovePairReferences(Gravitas.CollisionHandling.CollisionPair)
RemovePairsForCollider(Gravitas.Colliders.LSCollider)
InvalidatePairsForColliderReconfiguration(Gravitas.Colliders.LSCollider,SwiftCollections.SwiftList`1<System.Exception>&)
RemovePairsForCollider(Gravitas.Colliders.LSCollider,System.Boolean,System.Boolean,SwiftCollections.SwiftList`1<System.Exception>&)
ClearWarmStartCachesForCollider(Gravitas.Colliders.LSCollider,SwiftCollections.SwiftHashSet`1<System.Int32>)
CreatePair(Gravitas.Colliders.LSCollider,Gravitas.Colliders.LSCollider)
ProcessActiveCollisionPairs()
ContributeReplayHash(Chronicler.Hashing.ChronicleHashWriter&,Gravitas.GravitasReplayHashMode)
TryGetReplayHashPair(Gravitas.Colliders.LSCollider,Gravitas.Colliders.LSCollider,Gravitas.CollisionHandling.CollisionPair&)
get_BodySlotCount()
GetSleepSlot(Gravitas.SolidBody)
AdvanceSleepCounters()
BlockUnreadySleepIslands(Gravitas.SleepIslands,System.Boolean)
SleepReadyIslands(Gravitas.SleepIslands)
JoinSleepIslands(Gravitas.SleepIslands)
QueueDiscreteResponsePair(Gravitas.CollisionHandling.CollisionPair)
SolveDiscreteResponsePairs()
BuildDiscreteIslands()
AddJointIslandNodes()
UnionJointIslandNodes()
AddJointIslandConstraints()
AddIslandNodeIfMovable(Gravitas.SolidBody)
SortAndDeduplicateIslandNodes()
FindIslandNode(Gravitas.SolidBody)
UnionIslandNodes(System.Int32,System.Int32)
CompressIslandRoots()
ResolveConstraintRootKey(System.Int32,System.Int32)
WakeIslandBodies(System.Int32)
SolveDiscreteIslandRange(System.Int32,System.Int32)
GetJointLinearCorrectionRate(System.Int32,System.Int32)
IsMovableIslandBody(Gravitas.SolidBody)
HasAwakeResponseParticipant(Gravitas.CollisionHandling.CollisionPair)
IsAwakeIslandBody(Gravitas.SolidBody)
GetStablePairKey(Gravitas.CollisionHandling.CollisionPair,System.Int32&,System.Int32&)
GetStableJointKey(Gravitas.Constraints.Joint3D,System.Int32&,System.Int32&)
Compare(Gravitas.CollisionHandling.CollisionPair,Gravitas.CollisionHandling.CollisionPair)
Compare(Gravitas.GravitasPhysicsService/DiscreteIslandConstraint,Gravitas.GravitasPhysicsService/DiscreteIslandConstraint)
.ctor(System.Int32,Gravitas.SolidBody)
get_IsAwakeForCollision()
WakeFromCollision()
.ctor(Gravitas.GravitasPhysicsService/DiscreteIslandConstraintKind,Gravitas.CollisionHandling.CollisionPair,Gravitas.Constraints.Joint3D,System.Int32,System.Int32,System.Int32,System.Int32)
CreatePair(Gravitas.CollisionHandling.CollisionPair,System.Int32,System.Int32,System.Int32)
CreateJoint(Gravitas.Constraints.Joint3D,System.Int32,System.Int32,System.Int32)
get_InactiveFrameThreshold()