< Summary

Line coverage
100%
Covered lines: 370
Uncovered lines: 0
Coverable lines: 370
Total lines: 658
Line coverage: 100%
Branch coverage
100%
Covered branches: 182
Total branches: 182
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
File 1: .ctor(...)100%11100%
File 1: get_IsColliding()100%11100%
File 1: get_IsNotificationInProgress()100%11100%
File 1: get_LifetimeVersion()100%11100%
File 1: get_ContactDependenciesChanged()100%88100%
File 1: get_CurrentSurfaceCollisionLayers()100%1010100%
File 1: BeginCollisionLayerUpdate(...)100%1010100%
File 1: CompleteCollisionLayerUpdate(...)100%1212100%
File 1: get_HasRecovery()100%11100%
File 1: get_HasResponse()100%22100%
File 1: ClearRecovery()100%11100%
File 1: SetRecovery(...)100%11100%
File 1: ApplyRecovery()100%1414100%
File 1: Initialize(...)100%11100%
File 1: AssignPriority(...)100%22100%
File 1: ShouldFirstColliderLead(...)100%88100%
File 1: MarkColliding(...)100%1010100%
File 1: MarkCollidingDeferred(...)100%66100%
File 1: MarkResting(...)100%22100%
File 1: MarkSeparated()100%88100%
File 1: StoreWarmStartImpulse(...)100%11100%
File 1: TryGetWarmStartImpulse(...)100%11100%
File 1: RemoveWarmStartImpulse(...)100%11100%
File 1: RetainWarmStart()100%11100%
File 1: ClearResponseSnapshot()100%22100%
File 1: ClearWarmStart()100%11100%
File 1: InvalidateSurfaceContact(...)100%66100%
File 1: ResetPairState()100%11100%
File 1: ResetCollisionState()100%11100%
File 1: NotifyColliders(...)100%1818100%
File 1: EndNotification(...)100%22100%
File 1: NotifySeparation(...)100%66100%
File 1: ClearPendingNotificationState()100%11100%
File 1: MarkCollidingState(...)100%22100%
File 1: RefreshContactDependencies()100%1616100%
File 1: WakeBodiesForContactChange()100%44100%
File 1: WakeSleepingBodiesForCollision()100%88100%
File 2: ContributeReplayHash(...)100%1212100%
File 2: ContributeManifoldReplayHash(...)100%66100%
File 2: WriteMaterial(...)100%11100%
File 2: ContributeWarmStartReplayHash(...)100%44100%
File 2: WriteGroupKey(...)100%11100%
File 2: WriteSource(...)100%44100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Pairs/2D/CollisionPair2D.cs

#LineLine coverage
 1//=======================================================================
 2// CollisionPair2D.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using System;
 9using FixedMathSharp;
 10using Gravitas.Colliders;
 11using Gravitas.CollisionHandling;
 12using SwiftCollections;
 13
 14namespace Gravitas;
 15
 16/// <summary>Owns one deterministic pure 2D contact pair and its lifecycle.</summary>
 17/// <content>Owns pair identity, contact notifications, warm starts and collision-pass freshness.</content>
 18internal sealed partial class CollisionPair2D
 19{
 20    private bool _isColliding;
 21    private ContactWarmStartCache2D _warmStart;
 22    internal GroupedSolveState? ResponseState;
 23    private bool _notificationInProgress;
 24    private bool _separationPending;
 25    private bool _colliderANotified;
 26    private bool _colliderBNotified;
 27    private SolidBody2D? _pendingBodyA;
 28    private SolidBody2D? _pendingBodyB;
 29    private long _lifetimeVersion;
 30    private uint _lastColliderAContactDependencyVersion;
 31    private uint _lastColliderBContactDependencyVersion;
 32    private bool _surfaceContactChanged;
 33    private ulong? _surfaceCollisionLayers;
 34    private bool _wasTriggerPair;
 35    private SolidBody2D? _recoveryBody;
 36    private Vector2d _recoveryPosition;
 37
 74538    public CollisionPair2D(LSCollider2D colliderA, LSCollider2D colliderB)
 39    {
 74540        ColliderA = colliderA;
 74541        ColliderB = colliderB;
 74542        Initialize(colliderA, colliderB);
 74543    }
 44
 45    public LSCollider2D ColliderA { get; private set; }
 46
 47    public LSCollider2D ColliderB { get; private set; }
 48
 49    public int Id1 { get; private set; }
 50
 51    public int Id2 { get; private set; }
 52
 53    public CollisionType2D CollisionType { get; private set; }
 54
 55    public long LastFrame { get; private set; } = -1;
 56
 57    // Collision-pass freshness is independent of hosts advancing the public frame clock.
 58    internal long LastVisitToken { get; private set; } = -1;
 59
 5560    public bool IsColliding => _isColliding;
 61
 61962    internal bool IsNotificationInProgress => _notificationInProgress;
 63
 1144964    internal long LifetimeVersion => _lifetimeVersion;
 65
 66    internal bool ContactDependenciesChanged =>
 581867        _surfaceContactChanged || _lastColliderAContactDependencyVersion != ColliderA.ContactDependencyVersion
 581868        || _lastColliderBContactDependencyVersion != ColliderB.ContactDependencyVersion
 581869        || _surfaceCollisionLayers.HasValue && _surfaceCollisionLayers != CurrentSurfaceCollisionLayers;
 70
 71    private ulong? CurrentSurfaceCollisionLayers
 72    {
 73        get
 74        {
 993075            if (ColliderA.IsTrigger || ColliderB.IsTrigger) return null;
 975676            LSCollider2D? mover = ColliderA.StaticSurface != null ? ColliderB
 975677                : ColliderB.StaticSurface != null ? ColliderA : null;
 975678            return mover == null ? null : ColliderA.Context.Settings.GetCollisionLayerMask(mover.Layer, default, true, f
 79        }
 80    }
 81
 82    internal (ulong? Layers, ContactManifold2D? Before, Vector2d? Recovery) BeginCollisionLayerUpdate(ContactManifold2D 
 83    {
 707384        ulong? layers = CurrentSurfaceCollisionLayers;
 707385        if (!_isColliding || !layers.HasValue || !_surfaceCollisionLayers.HasValue || layers == _surfaceCollisionLayers)
 706586            return (layers, null, null);
 887        ContactManifold2D before = ColliderA.Context.CollisionScratch.SurfaceContactSnapshot2D;
 888        before.CopyFrom(target, target.LastUpdatedFrame);
 889        return (layers, before, HasRecovery ? _recoveryPosition : null);
 90    }
 91
 92    internal void CompleteCollisionLayerUpdate(ContactManifold2D target,
 93        (ulong? Layers, ContactManifold2D? Before, Vector2d? Recovery) previous)
 94    {
 707095        if (previous.Before != null)
 96        {
 897            Vector2d? recovery = HasRecovery ? _recoveryPosition : null;
 898            if (!previous.Before.HasSameContacts(target) || previous.Recovery != recovery)
 99            {
 6100                ClearWarmStart(); ClearResponseSnapshot();
 3101                WakeBodiesForContactChange();
 102            }
 103        }
 7070104        _surfaceCollisionLayers = previous.Layers;
 7070105    }
 106
 107    public ContactManifold2D Manifold { get; } = new();
 108
 888109    internal bool HasRecovery => _recoveryBody != null;
 110
 6286111    internal bool HasResponse => Manifold.HasContact || HasRecovery;
 112
 8454113    internal void ClearRecovery() => _recoveryBody = null;
 114
 115    internal void SetRecovery(LSCollider2D mover, Vector2d center)
 116    {
 19117        SolidBody2D body = mover.Body!;
 118        // The immediately preceding certificate proved these bounded operations
 119        // and the actual publishable body pose; no callback intervenes here.
 19120        _recoveryBody = body;
 19121        _recoveryPosition = body.Position + (center - mover.Center);
 19122    }
 123
 124    internal void ApplyRecovery()
 125    {
 11316126        if (_recoveryBody is not { } body) return;
 14127        if (!Vector2d.TrySubtract(_recoveryPosition, body.Position, out Vector2d delta)
 14128            || body.PrepareCollisionPositionCorrection(delta) != _recoveryPosition)
 2129            throw new InvalidOperationException("Pure 2D static-surface recovery is outside the movable body's supported
 12130        StaticSurface2D? surface = ColliderA.StaticSurface ?? ColliderB.StaticSurface;
 131        // An earlier island response may have moved a final-pose blocker.
 12132        if (surface == null || !Vector2d.TryAdd(body.Collider.Center, delta, out Vector2d center)
 12133            || !surface.IsRecoveryClear(body.Collider, center))
 6134            throw new InvalidOperationException("Pure 2D static-surface recovery no longer has a certified clear final p
 6135        ClearRecovery();
 6136        body.ApplyCollisionPositionState(_recoveryPosition);
 6137    }
 138
 139    public void Initialize(LSCollider2D colliderA, LSCollider2D colliderB)
 140    {
 1192141        _lifetimeVersion++;
 1192142        AssignPriority(colliderA, colliderB);
 1192143        Id1 = ColliderA.Id;
 1192144        Id2 = ColliderB.Id;
 1192145        CollisionType = ColliderSettings2D.GetCollisionType(ColliderA.Shape, ColliderB.Shape);
 1192146        ResetPairState();
 1192147    }
 148
 149    private void AssignPriority(LSCollider2D colliderA, LSCollider2D colliderB)
 150    {
 1192151        if (ShouldFirstColliderLead(colliderA, colliderB))
 152        {
 484153            ColliderA = colliderA;
 484154            ColliderB = colliderB;
 484155            return;
 156        }
 157
 708158        ColliderA = colliderB;
 708159        ColliderB = colliderA;
 708160    }
 161
 162    internal static bool ShouldFirstColliderLead(LSCollider2D colliderA, LSCollider2D colliderB)
 163    {
 1192164        if (colliderA.Priority != colliderB.Priority)
 622165            return colliderA.Priority > colliderB.Priority;
 166
 570167        SolidBody2D? bodyA = colliderA.Body;
 570168        SolidBody2D? bodyB = colliderB.Body;
 570169        if (bodyA == null || bodyB == null)
 165170            return colliderA.Id <= colliderB.Id;
 171
 405172        if (bodyA.LinearSpeed != bodyB.LinearSpeed)
 64173            return bodyA.LinearSpeed > bodyB.LinearSpeed;
 174
 341175        return colliderA.Id <= colliderB.Id;
 176    }
 177
 178    public void MarkColliding(long frame)
 179    {
 113180        if (!Manifold.HasContact && ColliderA.StaticSurface == null && ColliderB.StaticSurface == null)
 1181            return;
 182
 112183        bool changed = MarkCollidingState(frame);
 184
 112185        if (!ColliderA.IsTrigger && !ColliderB.IsTrigger)
 186        {
 30187            CollisionResponse2D.Resolve(this);
 30188            WakeSleepingBodiesForCollision();
 189        }
 190
 112191        NotifyColliders(isColliding: true, changed);
 112192    }
 193
 194    internal void MarkCollidingDeferred(long frame)
 195    {
 5816196        if (!Manifold.HasContact && ColliderA.StaticSurface == null && ColliderB.StaticSurface == null)
 1197            return;
 198
 5815199        bool changed = MarkCollidingState(frame);
 5815200        NotifyColliders(isColliding: true, changed);
 5813201    }
 202
 203    public void MarkResting(long frame)
 204    {
 659205        RefreshContactDependencies();
 662206        if (!Manifold.HasContact) ClearWarmStart();
 659207        LastFrame = frame;
 659208        LastVisitToken = ColliderA.Context.LateSimulateToken;
 659209    }
 210
 211    public void MarkSeparated()
 212    {
 185213        bool wasColliding = _isColliding;
 185214        if (wasColliding && !_wasTriggerPair)
 164215            WakeBodiesForContactChange();
 185216        ResetCollisionState();
 185217        if (!wasColliding)
 2218            return;
 219
 183220        if (_notificationInProgress)
 221        {
 13222            _separationPending = true;
 13223            _pendingBodyA = ColliderA.Body;
 13224            _pendingBodyB = ColliderB.Body;
 13225            return;
 226        }
 227
 170228        NotifyColliders(isColliding: false, isChanged: true);
 167229    }
 230
 231    internal void StoreWarmStartImpulse(in ContactGroupKey group, ulong contactId,
 232        Fixed64 normalImpulse, Fixed64 tangentImpulse) =>
 16784233        _warmStart.Set(group, contactId, normalImpulse, tangentImpulse);
 234
 235    internal bool TryGetWarmStartImpulse(in ContactGroupKey group, ulong contactId,
 17816236        out ContactWarmStartImpulse impulse) => _warmStart.TryGet(group, contactId, out impulse);
 237
 238    internal void RemoveWarmStartImpulse(in ContactGroupKey group, ulong contactId) =>
 11239        _warmStart.Remove(group, contactId);
 240
 9813241    internal void RetainWarmStart() => _warmStart.Retain(Manifold);
 242
 243    internal void ClearResponseSnapshot()
 244    {
 2062245        if (ResponseState != null) ResponseState.Impact = default;
 1666246    }
 247
 180248    internal void ClearWarmStart() => _warmStart.Clear();
 249
 250    internal void InvalidateSurfaceContact(LSCollider2D member, SwiftHashSet<int> suppliers)
 251    {
 88252        if (!Manifold.ReferencesSuppliers(suppliers, ColliderA == member, member.Id + 1)) return;
 60253        _surfaceContactChanged = true;
 60254        ClearWarmStart();
 60255        ClearResponseSnapshot();
 118256        if (_isColliding && !_wasTriggerPair) WakeBodiesForContactChange();
 60257    }
 258
 259    private void ResetPairState()
 260    {
 1192261        ResetCollisionState();
 1192262        _notificationInProgress = false;
 1192263        _colliderANotified = false;
 1192264        _colliderBNotified = false;
 1192265        ClearPendingNotificationState();
 1192266    }
 267
 268    private void ResetCollisionState()
 269    {
 1377270        ClearRecovery();
 1377271        ClearResponseSnapshot();
 1377272        _isColliding = false;
 1377273        _lastColliderAContactDependencyVersion = 0;
 1377274        _lastColliderBContactDependencyVersion = 0;
 1377275        _surfaceContactChanged = false;
 1377276        _surfaceCollisionLayers = null;
 1377277        _wasTriggerPair = false;
 1377278        LastFrame = -1;
 1377279        LastVisitToken = -1;
 1377280        Manifold.Reset();
 1377281        _warmStart.Clear();
 1377282    }
 283
 284    private void NotifyColliders(bool isColliding, bool isChanged)
 285    {
 6097286        var registrationA = new ColliderLifetimeToken2D(ColliderA);
 6097287        var registrationB = new ColliderLifetimeToken2D(ColliderB);
 6097288        LSCollider2D colliderA = registrationA.Collider;
 6097289        LSCollider2D colliderB = registrationB.Collider;
 6097290        SolidBody2D? bodyA = colliderA.Body;
 6097291        SolidBody2D? bodyB = colliderB.Body;
 6097292        bool isTriggerPair = colliderA.IsTrigger || colliderB.IsTrigger;
 6097293        bool shouldRaiseTriggerA = isTriggerPair && ColliderTriggerEventPolicy.ShouldRaise(colliderA, colliderB);
 6097294        bool shouldRaiseTriggerB = isTriggerPair && ColliderTriggerEventPolicy.ShouldRaise(colliderB, colliderA);
 6097295        _notificationInProgress = true;
 6097296        SwiftList<Exception>? notificationExceptions = null;
 297        try
 298        {
 6097299            if (isColliding)
 300            {
 5927301                bool notifyEnterA = isChanged || !_colliderANotified;
 5927302                _colliderANotified = true;
 5927303                colliderA.NotifyContact(
 5927304                    colliderB,
 5927305                    bodyB,
 5927306                    isColliding: true,
 5927307                    notifyEnterA,
 5927308                    allowInactive: false,
 5927309                    registrationA,
 5927310                    registrationB,
 5927311                    isTriggerPair,
 5927312                    shouldRaiseTriggerA);
 5926313                if (registrationA.IsActive && registrationB.IsActive && !_separationPending)
 314                {
 5916315                    bool notifyEnterB = isChanged || !_colliderBNotified;
 5916316                    _colliderBNotified = true;
 5916317                    colliderB.NotifyContact(
 5916318                        colliderA,
 5916319                        bodyA,
 5916320                        isColliding: true,
 5916321                        notifyEnterB,
 5916322                        allowInactive: false,
 5916323                        registrationB,
 5916324                        registrationA,
 5916325                        isTriggerPair,
 5916326                        shouldRaiseTriggerB);
 327                }
 328            }
 329            else
 330            {
 170331                NotifySeparation(
 170332                    registrationA,
 170333                    registrationB,
 170334                    bodyA,
 170335                    bodyB,
 170336                    isChanged,
 170337                    allowInactive: false,
 170338                    isTriggerPair,
 170339                    shouldRaiseTriggerA,
 170340                    shouldRaiseTriggerB);
 341            }
 6093342        }
 4343        catch (Exception exception)
 344        {
 4345            CollisionNotificationExceptions.Capture(ref notificationExceptions, exception);
 4346        }
 347
 348        try
 349        {
 6097350            EndNotification(
 6097351                registrationA,
 6097352                registrationB,
 6097353                isTriggerPair,
 6097354                shouldRaiseTriggerA,
 6097355                shouldRaiseTriggerB);
 6096356        }
 1357        catch (Exception exception)
 358        {
 1359            CollisionNotificationExceptions.Capture(ref notificationExceptions, exception);
 1360        }
 361
 6097362        CollisionNotificationExceptions.ThrowIfAny(notificationExceptions);
 6092363    }
 364
 365    private void EndNotification(
 366        in ColliderLifetimeToken2D registrationA,
 367        in ColliderLifetimeToken2D registrationB,
 368        bool isTriggerPair,
 369        bool shouldRaiseTriggerA,
 370        bool shouldRaiseTriggerB)
 371    {
 372        try
 373        {
 6097374            if (!_separationPending)
 6084375                return;
 376
 13377            SolidBody2D? bodyA = _pendingBodyA;
 13378            SolidBody2D? bodyB = _pendingBodyB;
 13379            ClearPendingNotificationState();
 13380            NotifySeparation(
 13381                registrationA,
 13382                registrationB,
 13383                bodyA,
 13384                bodyB,
 13385                isChanged: true,
 13386                allowInactive: true,
 13387                isTriggerPair,
 13388                shouldRaiseTriggerA,
 13389                shouldRaiseTriggerB);
 12390        }
 391        finally
 392        {
 6097393            ClearPendingNotificationState();
 6097394            _notificationInProgress = false;
 6097395        }
 6096396    }
 397
 398    private void NotifySeparation(
 399        in ColliderLifetimeToken2D registrationA,
 400        in ColliderLifetimeToken2D registrationB,
 401        SolidBody2D? bodyA,
 402        SolidBody2D? bodyB,
 403        bool isChanged,
 404        bool allowInactive,
 405        bool isTriggerPair,
 406        bool shouldRaiseTriggerA,
 407        bool shouldRaiseTriggerB)
 408    {
 183409        bool notifyA = _colliderANotified;
 183410        bool notifyB = _colliderBNotified;
 183411        _colliderANotified = false;
 183412        _colliderBNotified = false;
 183413        SwiftList<Exception>? notificationExceptions = null;
 183414        if (notifyA)
 415        {
 416            try
 417            {
 183418                registrationA.Collider.NotifyContact(
 183419                    registrationB.Collider,
 183420                    bodyB,
 183421                    isColliding: false,
 183422                    isChanged,
 183423                    allowInactive,
 183424                    registrationA,
 183425                    registrationB,
 183426                    isTriggerPair,
 183427                    shouldRaiseTriggerA);
 179428            }
 4429            catch (Exception exception)
 430            {
 4431                CollisionNotificationExceptions.Capture(ref notificationExceptions, exception);
 4432            }
 433        }
 434
 183435        if (notifyB && registrationB.IsCurrentLifetime)
 436        {
 437            try
 438            {
 173439                registrationB.Collider.NotifyContact(
 173440                    registrationA.Collider,
 173441                    bodyA,
 173442                    isColliding: false,
 173443                    isChanged,
 173444                    allowInactive,
 173445                    registrationB,
 173446                    registrationA,
 173447                    isTriggerPair,
 173448                    shouldRaiseTriggerB);
 172449            }
 1450            catch (Exception exception)
 451            {
 1452                CollisionNotificationExceptions.Capture(ref notificationExceptions, exception);
 1453            }
 454        }
 455
 183456        CollisionNotificationExceptions.ThrowIfAny(notificationExceptions);
 179457    }
 458
 459    private void ClearPendingNotificationState()
 460    {
 7302461        _separationPending = false;
 7302462        _pendingBodyA = null;
 7302463        _pendingBodyB = null;
 7302464    }
 465
 466    private bool MarkCollidingState(long frame)
 467    {
 5927468        RefreshContactDependencies();
 6025469        if (!Manifold.HasContact) ClearWarmStart();
 5927470        bool changed = !_isColliding;
 5927471        _isColliding = true;
 5927472        LastFrame = frame;
 5927473        LastVisitToken = ColliderA.Context.LateSimulateToken;
 5927474        return changed;
 475    }
 476
 477    internal void RefreshContactDependencies()
 478    {
 6607479        uint versionA = ColliderA.ContactDependencyVersion;
 6607480        uint versionB = ColliderB.ContactDependencyVersion;
 6607481        bool triggerPair = ColliderA.IsTrigger || ColliderB.IsTrigger;
 482        // Even continued overlap can replace a sleeping body's load-bearing
 483        // normal or friction constraint; unchanged solid contacts retain sleep.
 6607484        if (_isColliding)
 485        {
 6026486            if (triggerPair != _wasTriggerPair)
 487            {
 3488                ClearWarmStart();
 3489                WakeBodiesForContactChange();
 490            }
 6023491            else if (!triggerPair)
 492            {
 6246493                if (versionB != _lastColliderBContactDependencyVersion) ColliderA.Body?.WakeForContactChange();
 6188494                if (versionA != _lastColliderAContactDependencyVersion) ColliderB.Body?.WakeForContactChange();
 495            }
 496        }
 497
 6607498        _lastColliderAContactDependencyVersion = versionA;
 6607499        _lastColliderBContactDependencyVersion = versionB;
 6607500        _surfaceContactChanged = false;
 6607501        _wasTriggerPair = triggerPair;
 6607502    }
 503
 504    private void WakeBodiesForContactChange()
 505    {
 228506        ColliderA.Body?.WakeForContactChange();
 228507        ColliderB.Body?.WakeForContactChange();
 226508    }
 509
 510    internal void WakeSleepingBodiesForCollision()
 511    {
 4627512        SolidBody2D? bodyA = ColliderA.Body;
 4627513        SolidBody2D? bodyB = ColliderB.Body;
 4627514        if (bodyA == null || bodyB == null)
 2532515            return;
 516
 2095517        bool bodyAAwake = !bodyA.IsSleeping;
 2095518        bool bodyBAwake = !bodyB.IsSleeping;
 2095519        if (bodyA.IsSleeping && bodyBAwake)
 2520            bodyA.Wake();
 2095521        if (bodyB.IsSleeping && bodyAAwake)
 2522            bodyB.Wake();
 2095523    }
 524}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Pairs/2D/CollisionPair2D.ReplayHash.cs

#LineLine coverage
 1//=======================================================================
 2// CollisionPair2D.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 FixedMathSharp.Chronicler;
 10using Gravitas.CollisionHandling;
 11using Gravitas.Materials;
 12
 13namespace Gravitas;
 14
 15/// <content>Hashes 2D pair state, retained contact groups, and warm-start impulses.</content>
 16internal sealed partial class CollisionPair2D
 17{
 18    internal void ContributeReplayHash(
 19        ref ChronicleHashWriter writer,
 20        GravitasReplayHashMode mode)
 21    {
 19022        writer.WriteSection("pair.2d", 4);
 19023        writer.WriteInt32(ColliderA.ReplayOrdinal);
 19024        writer.WriteInt32(ColliderB.ReplayOrdinal);
 19025        writer.WriteEnum(CollisionType);
 19026        writer.WriteInt64(LastFrame);
 19027        writer.WriteBool(_isColliding);
 28        // Only an existing contact depends on these stamps; loading may republish noncontact geometry.
 19029        writer.WriteBool(!_isColliding || _lastColliderAContactDependencyVersion == ColliderA.ContactDependencyVersion);
 19030        writer.WriteBool(!_isColliding || _lastColliderBContactDependencyVersion == ColliderB.ContactDependencyVersion);
 31        // Only retained response consumes supplier freshness; omit rebuildable
 32        // snapshot history while preserving a pending borrowed-contact refresh.
 19033        if (_isColliding && (_surfaceContactChanged ||
 19034            _surfaceCollisionLayers.HasValue && _surfaceCollisionLayers != CurrentSurfaceCollisionLayers))
 435            writer.WriteSection("pair.2d.surface", 1);
 19036        writer.WriteBool(_wasTriggerPair);
 19037        ContributeManifoldReplayHash(ref writer, ColliderA.Context, Manifold);
 19038        ContributeWarmStartReplayHash(ref writer, _warmStart);
 19039    }
 40
 41    private static void ContributeManifoldReplayHash(
 42        ref ChronicleHashWriter writer,
 43        GravitasWorldContext context,
 44        ContactManifold2D manifold)
 45    {
 19046        writer.WriteSection("manifold.2d", 6);
 19047        writer.WriteInt64(manifold.LastUpdatedFrame);
 19048        writer.WriteInt32(manifold.Count);
 19049        writer.WriteInt32(manifold.GroupCount);
 77850        for (int g = 0; g < manifold.GroupCount; g++)
 51        {
 19952            ref ContactGroup2D group = ref manifold.GetGroup(g);
 19953            WriteGroupKey(ref writer, context, group.Key);
 19954            writer.WriteInt32(group.Count);
 80455            for (int i = 0; i < group.Count; i++)
 56            {
 20357                ManifoldContact2D contact = group[i];
 20358                writer.WriteUInt64(contact.ContactId);
 20359                writer.WriteInt32(contact.FeatureNamespaceA);
 20360                writer.WriteVector2d(contact.AnchorA.Origin);
 20361                writer.WriteVector2d(contact.AnchorA.LocalPoint);
 20362                writer.WriteVector2d(contact.AnchorA.LocalDisplacement);
 20363                writer.WriteUInt64(contact.AnchorA.GetLocalFeatureHash64());
 20364                writer.WriteFixed64(contact.AnchorA.Rotation);
 20365                writer.WriteInt32(contact.FeatureNamespaceB);
 20366                writer.WriteVector2d(contact.AnchorB.Origin);
 20367                writer.WriteVector2d(contact.AnchorB.LocalPoint);
 20368                writer.WriteVector2d(contact.AnchorB.LocalDisplacement);
 20369                writer.WriteUInt64(contact.AnchorB.GetLocalFeatureHash64());
 20370                writer.WriteFixed64(contact.AnchorB.Rotation);
 20371                writer.WriteFixed64(contact.Depth);
 20372                writer.WriteBool(contact.DepthIsClamped);
 20373                writer.WriteVector2d(contact.Normal);
 20374                writer.WriteBool(contact.HasMaterialOverride);
 20375                if (contact.HasMaterialOverride)
 76                {
 17977                    WriteMaterial(ref writer, contact.MaterialA);
 17978                    WriteMaterial(ref writer, contact.MaterialB);
 79                }
 80            }
 81        }
 19082    }
 83
 84    private static void WriteMaterial(ref ChronicleHashWriter writer, PhysicsMaterial material)
 85    {
 35886        writer.WriteFixed64(material.StaticFriction);
 35887        writer.WriteFixed64(material.DynamicFriction);
 35888        writer.WriteFixed64(material.Restitution);
 35889        writer.WriteEnum(material.FrictionCombine);
 35890        writer.WriteEnum(material.RestitutionCombine);
 35891    }
 92
 93    private void ContributeWarmStartReplayHash(
 94        ref ChronicleHashWriter writer,
 95        ContactWarmStartCache2D warmStart)
 96    {
 19097        writer.WriteSection("warm-start.2d", 2);
 19098        writer.WriteInt32(warmStart.Count);
 19099        writer.WriteInt32(warmStart.GroupCount);
 736100        for (int g = 0; g < warmStart.GroupCount; g++)
 101        {
 178102            ContactWarmStartGroup2D group = warmStart.GetGroup(g);
 178103            WriteGroupKey(ref writer, ColliderA.Context, group.Key);
 178104            writer.WriteInt32(group.Count);
 712105            for (int point = 0; point < group.Count; point++)
 106            {
 178107                writer.WriteUInt64(group.GetContactId(point));
 178108                ContactWarmStartImpulse impulse = group.GetImpulseUnchecked(point);
 178109                writer.WriteVector3d(impulse.Normal);
 178110                writer.WriteFixed64(impulse.NormalImpulse);
 178111                writer.WriteFixed64(impulse.TangentImpulse);
 178112                writer.WriteFixed64(impulse.SecondaryTangentImpulse);
 113            }
 114        }
 190115    }
 116
 117    private static void WriteGroupKey(ref ChronicleHashWriter writer,
 118        GravitasWorldContext context, in ContactGroupKey group)
 119    {
 377120        writer.WriteInt32(group.NamespaceA);
 377121        writer.WriteInt32(group.NamespaceB);
 377122        writer.WriteInt32(group.SurfaceA);
 377123        writer.WriteInt32(group.SurfaceB);
 377124        writer.WriteInt32(group.Region);
 377125        WriteSource(ref writer, context, group.SourceIdA);
 377126        WriteSource(ref writer, context, group.SourceIdB);
 377127    }
 128
 129    private static void WriteSource(ref ChronicleHashWriter writer,
 130        GravitasWorldContext context, int source) =>
 754131        writer.WriteInt32(source == 0 ? 0
 754132            : context.Physics2D.TryGetColliderById(source - 1, out var collider)
 754133                ? collider!.ReplayOrdinal + 1 : -1);
 134}

Methods/Properties

.ctor(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D)
get_IsColliding()
get_IsNotificationInProgress()
get_LifetimeVersion()
get_ContactDependenciesChanged()
get_CurrentSurfaceCollisionLayers()
BeginCollisionLayerUpdate(Gravitas.CollisionHandling.ContactManifold2D)
CompleteCollisionLayerUpdate(Gravitas.CollisionHandling.ContactManifold2D,System.ValueTuple`3<System.Nullable`1<System.UInt64>,Gravitas.CollisionHandling.ContactManifold2D,System.Nullable`1<FixedMathSharp.Vector2d>>)
get_HasRecovery()
get_HasResponse()
ClearRecovery()
SetRecovery(Gravitas.Colliders.LSCollider2D,FixedMathSharp.Vector2d)
ApplyRecovery()
Initialize(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D)
AssignPriority(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D)
ShouldFirstColliderLead(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D)
MarkColliding(System.Int64)
MarkCollidingDeferred(System.Int64)
MarkResting(System.Int64)
MarkSeparated()
StoreWarmStartImpulse(Gravitas.CollisionHandling.ContactGroupKey&,System.UInt64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64)
TryGetWarmStartImpulse(Gravitas.CollisionHandling.ContactGroupKey&,System.UInt64,Gravitas.CollisionHandling.ContactWarmStartImpulse&)
RemoveWarmStartImpulse(Gravitas.CollisionHandling.ContactGroupKey&,System.UInt64)
RetainWarmStart()
ClearResponseSnapshot()
ClearWarmStart()
InvalidateSurfaceContact(Gravitas.Colliders.LSCollider2D,SwiftCollections.SwiftHashSet`1<System.Int32>)
ResetPairState()
ResetCollisionState()
NotifyColliders(System.Boolean,System.Boolean)
EndNotification(Gravitas.Colliders.ColliderLifetimeToken2D&,Gravitas.Colliders.ColliderLifetimeToken2D&,System.Boolean,System.Boolean,System.Boolean)
NotifySeparation(Gravitas.Colliders.ColliderLifetimeToken2D&,Gravitas.Colliders.ColliderLifetimeToken2D&,Gravitas.SolidBody2D,Gravitas.SolidBody2D,System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean)
ClearPendingNotificationState()
MarkCollidingState(System.Int64)
RefreshContactDependencies()
WakeBodiesForContactChange()
WakeSleepingBodiesForCollision()
ContributeReplayHash(Chronicler.Hashing.ChronicleHashWriter&,Gravitas.GravitasReplayHashMode)
ContributeManifoldReplayHash(Chronicler.Hashing.ChronicleHashWriter&,Gravitas.GravitasWorldContext,Gravitas.CollisionHandling.ContactManifold2D)
WriteMaterial(Chronicler.Hashing.ChronicleHashWriter&,Gravitas.Materials.PhysicsMaterial)
ContributeWarmStartReplayHash(Chronicler.Hashing.ChronicleHashWriter&,Gravitas.CollisionHandling.ContactWarmStartCache2D)
WriteGroupKey(Chronicler.Hashing.ChronicleHashWriter&,Gravitas.GravitasWorldContext,Gravitas.CollisionHandling.ContactGroupKey&)
WriteSource(Chronicler.Hashing.ChronicleHashWriter&,Gravitas.GravitasWorldContext,System.Int32)