< Summary

Information
Class: Gravitas.GravitasCollision2DService
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/2D/Services/GravitasCollision2DService.cs
Line coverage
100%
Covered lines: 343
Uncovered lines: 0
Coverable lines: 343
Total lines: 679
Line coverage: 100%
Branch coverage
100%
Covered branches: 128
Total branches: 128
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()100%11100%
.ctor(...)100%11100%
get_Context()100%11100%
get_ActivePartitionCount()100%11100%
get_InactivePartitionCount()100%11100%
get_RetainedPartitionCount()100%11100%
Reset()100%11100%
RefreshColliderPartition(...)100%44100%
RefreshColliderPartitionAfterShapeChange(...)100%22100%
PartitionCollider(...)100%22100%
PartitionCollider(...)100%11100%
PartitionCollider(...)100%44100%
ClearPartitionedCollider(...)100%66100%
RemovePartitionMemberships(...)100%1212100%
RefreshPartitionAwakeState(...)100%1414100%
CheckAndDistributeCollisions()100%44100%
CollectBoundsCandidates(...)100%44100%
CollectMembershipCandidates(...)100%2020100%
IsDuplicateQueryCandidate(...)100%66100%
RefreshDeferredColliderPartitions()100%88100%
RebuildPartitionsAfterWorldChange()100%22100%
CollectCoveredPartitions(...)100%11100%
PartitionCoveredVoxels(...)100%11100%
ScanCoveredQueryPartitions(...)100%11100%
ScanCoveredColliderVoxels(...)100%11100%
VisitPlanarVoxelsForQuery(...)100%88100%
VisitPlanarVoxelsForCollider(...)100%66100%
TryPartitionVoxel(...)100%66100%
GetPlanarCoverageBounds(...)100%11100%
GetMobilityKind(...)100%44100%
GetStoredMobilityKind(...)100%44100%
AddObject(...)100%44100%
RemoveObject(...)100%44100%
DetachRetainedPartitions()100%11100%
TrackRetainedPartition(...)100%11100%
UntrackRetainedPartition(...)100%11100%
RefreshRetainedPartitionEligibility(...)100%11100%
RetireExpiredRetainedPartitions()100%11100%
ActivatePartition(...)100%11100%
DeactivatePartition(...)100%11100%
RentPartition()100%44100%
TryRetireEmptyRetainedPartitionForReuse()100%11100%
ReleasePartition(...)100%11100%
Compare(...)100%11100%
Compare(...)100%11100%

File(s)

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

#LineLine coverage
 1//=======================================================================
 2// GravitasCollision2DService.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using System;
 9using System.Collections.Generic;
 10using System.Runtime.CompilerServices;
 11using FixedMathSharp;
 12using Gravitas.Colliders;
 13using Gravitas.Support;
 14using GridForge.Grids;
 15using GridForge.Spatial;
 16using GridForge.Utility;
 17using SwiftCollections;
 18
 19namespace Gravitas;
 20
 21/// <summary>
 22/// Owns GridForge-backed pure 2D collision partitioning state for one context.
 23/// </summary>
 24public sealed class GravitasCollision2DService
 25{
 26    private const int DefaultPartitionPoolCapacity = 1024;
 127    private static readonly PhysicsPartition2DOrderComparer PartitionOrderComparer = new();
 128    private static readonly Collider2DIdComparer ColliderIdComparer = new();
 29
 30    private readonly GravitasWorldContext _context;
 1019131    private readonly SwiftSlotMap<PhysicsPartition2D> _activePartitions = new(DefaultPartitionPoolCapacity);
 1019132    private readonly SwiftStack<PhysicsPartition2D> _inactivePartitionPool = new(DefaultPartitionPoolCapacity);
 1019133    private readonly SwiftList<Voxel> _coveredVoxels = new();
 1019134    private readonly SwiftHashSet<WorldVoxelIndex> _nextCoveredCoordinates = new();
 1019135    private readonly GridTraceScratch _traceScratch = new();
 1019136    private readonly SwiftList<PhysicsPartition2D> _retainedPartitions = new();
 1019137    private readonly SwiftList<PhysicsPartition2D> _emptyRetainedPartitions = new();
 1019138    private readonly SwiftList<PhysicsPartition2D> _distributionPartitions = new();
 1019139    private readonly SwiftList<int> _distributionDynamicIds = new();
 1019140    private readonly SwiftList<int> _distributionStaticIds = new();
 1019141    private readonly SwiftList<PhysicsPartition2D> _queryPartitions = new();
 42    private readonly Action<PhysicsPartition2D> _releaseRetainedPartition;
 1019143    private readonly SwiftSparseSet _deferredPartitionRefreshIds = new();
 44
 45    private int _retainedPartitionRetirementCursor;
 46    private bool _isDistributing;
 47
 48    /// <summary>Creates the pure 2D collision partition service for a world context.</summary>
 1019149    public GravitasCollision2DService(GravitasWorldContext context)
 50    {
 1019151        ChronicleGuard.ThrowIfNull(context, nameof(context));
 1019152        _context = context;
 1019153        _releaseRetainedPartition = ReleasePartition;
 1019154    }
 55
 56    /// <summary>Gets the world context that owns this service.</summary>
 10095057    public GravitasWorldContext Context => _context;
 58
 59    /// <summary>Gets the current partition-distribution pass version.</summary>
 60    public uint Version { get; private set; } = 1;
 61
 62    /// <summary>Gets the number of partitions participating in collision work.</summary>
 1663    public int ActivePartitionCount => _activePartitions.Count;
 64
 65    /// <summary>Gets the number of partitions available for reuse.</summary>
 1166    public int InactivePartitionCount => _inactivePartitionPool.Count;
 67
 2268    internal int RetainedPartitionCount => _retainedPartitions.Count;
 69
 70    /// <summary>Clears all context-local 2D partitioning state.</summary>
 71    public void Reset()
 72    {
 11373        DetachRetainedPartitions();
 11374        _activePartitions.Clear();
 11375        _coveredVoxels.FastClear();
 11376        _nextCoveredCoordinates.Clear();
 11377        _traceScratch.Clear();
 11378        _distributionPartitions.FastClear();
 11379        _distributionDynamicIds.FastClear();
 11380        _distributionStaticIds.FastClear();
 11381        _queryPartitions.FastClear();
 11382        _deferredPartitionRefreshIds.Clear();
 11383        _inactivePartitionPool.Clear();
 11384        Version = 1;
 11385        _retainedPartitionRetirementCursor = 0;
 11386        _isDistributing = false;
 11387    }
 88
 89    internal bool RefreshColliderPartition(LSCollider2D collider)
 90    {
 1490991        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 1490992        ChronicleGuard.ThrowIfArgument(
 1490993            !ReferenceEquals(collider.Context, _context),
 1490994            nameof(collider),
 1490995            "2D collider must belong to this collision service context.");
 96
 1490997        if (!collider.IsActive)
 98        {
 199            ClearPartitionedCollider(collider, force: true);
 1100            collider.MarkUnpartitioned();
 1101            collider.ClearPartitionCoordinates();
 102
 1103            return false;
 104        }
 105
 14908106        GetPlanarCoverageBounds(collider, out Vector2d coverageMin, out Vector2d coverageMax);
 14908107        PhysicsMobilityType kind = GetMobilityKind(collider);
 14908108        if (collider.MatchesPartitionGridBounds(coverageMin, coverageMax, (int)kind))
 579109            return false;
 110
 14329111        return PartitionCollider(collider, coverageMin, coverageMax, kind);
 112    }
 113
 114    internal bool RefreshColliderPartitionAfterShapeChange(LSCollider2D collider)
 115    {
 10918116        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 10918117        if (!_isDistributing)
 118        {
 10915119            _deferredPartitionRefreshIds.Remove(collider.Id);
 120
 10915121            return RefreshColliderPartition(collider);
 122        }
 123
 3124        _deferredPartitionRefreshIds.Add(collider.Id);
 125
 3126        return false;
 127    }
 128
 129    internal bool PartitionCollider(LSCollider2D collider)
 130    {
 9458131        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 9458132        ChronicleGuard.ThrowIfArgument(
 9458133            !ReferenceEquals(collider.Context, _context),
 9458134            nameof(collider),
 9458135            "2D collider must belong to this collision service context.");
 136
 9457137        if (collider.IsPartitioned)
 1138            return false;
 139
 9456140        GetPlanarCoverageBounds(collider, out Vector2d coverageMin, out Vector2d coverageMax);
 9456141        return PartitionCollider(collider, coverageMin, coverageMax);
 142    }
 143
 144    private bool PartitionCollider(LSCollider2D collider, Vector2d coverageMin, Vector2d coverageMax)
 145    {
 9456146        return PartitionCollider(collider, coverageMin, coverageMax, GetMobilityKind(collider));
 147    }
 148
 149    private bool PartitionCollider(
 150        LSCollider2D collider,
 151        Vector2d coverageMin,
 152        Vector2d coverageMax,
 153        PhysicsMobilityType kind)
 154    {
 23785155        if (!collider.IsActive)
 1156            return false;
 157
 23784158        SwiftList<WorldVoxelIndex> partitionedCoordinates = collider.GetOrCreatePartitionCoordinates();
 23784159        PartitionCoveredVoxels(collider, coverageMin, coverageMax, partitionedCoordinates, kind);
 23784160        if (partitionedCoordinates.Count == 0)
 161        {
 1738162            collider.MarkUnpartitioned();
 1738163            return false;
 164        }
 165
 22046166        collider.MarkPartitioned(coverageMin, coverageMax, (int)kind);
 22046167        return true;
 168    }
 169
 170    internal bool ClearPartitionedCollider(LSCollider2D collider, bool force = false)
 171    {
 505172        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 505173        ChronicleGuard.ThrowIfArgument(
 505174            !ReferenceEquals(collider.Context, _context),
 505175            nameof(collider),
 505176            "2D collider must belong to this collision service context.");
 177
 505178        if (!collider.IsPartitioned)
 3179            return false;
 180
 502181        GetPlanarCoverageBounds(collider, out Vector2d coverageMin, out Vector2d coverageMax);
 502182        PhysicsMobilityType currentKind = GetMobilityKind(collider);
 502183        if (!force && collider.MatchesPartitionGridBounds(coverageMin, coverageMax, (int)currentKind))
 5184            return false;
 185
 497186        SwiftList<WorldVoxelIndex> coordinates = collider.PartitionCoordinates!;
 497187        PhysicsMobilityType partitionKind = GetStoredMobilityKind(collider.PartitionKind);
 497188        RemovePartitionMemberships(collider, coordinates, partitionKind, preserveCovered: false);
 189
 497190        collider.MarkUnpartitioned();
 497191        collider.ClearPartitionCoordinates();
 497192        return true;
 193    }
 194
 195    private void RemovePartitionMemberships(
 196        LSCollider2D collider,
 197        SwiftList<WorldVoxelIndex> coordinates,
 198        PhysicsMobilityType partitionKind,
 199        bool preserveCovered)
 200    {
 24281201        GridWorld world = _context.World;
 221524202        for (int i = 0; i < coordinates.Count; i++)
 203        {
 86481204            WorldVoxelIndex coordinate = coordinates[i];
 86481205            if (preserveCovered && _nextCoveredCoordinates.Contains(coordinate))
 206                continue;
 207
 20956208            if (!world.ActiveGrids.IsAllocated(coordinate.GridIndex)
 20956209                || !world.TryGetVoxel(coordinate, out Voxel? voxel)
 20956210                || !voxel!.TryGetPartition(out PhysicsPartition2D? partition))
 211            {
 212                continue;
 213            }
 214
 20928215            RemoveObject(partition!, collider.Id, partitionKind);
 216        }
 24281217    }
 218
 219    internal void RefreshPartitionAwakeState(LSCollider2D collider)
 220    {
 1905221        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 1905222        ChronicleGuard.ThrowIfArgument(
 1905223            !ReferenceEquals(collider.Context, _context),
 1905224            nameof(collider),
 1905225            "2D collider must belong to this collision service context.");
 226
 1905227        if (!collider.IsPartitioned)
 31228            return;
 229
 1874230        SwiftList<WorldVoxelIndex> coordinates = collider.PartitionCoordinates!;
 1874231        SolidBody2D? body = collider.Body;
 1874232        if (collider.IsStatic || body!.IsKinematic)
 30233            return;
 234
 1844235        bool awake = body.IsAwakeForCollision;
 1844236        GridWorld world = _context.World;
 237
 43278238        for (int i = 0; i < coordinates.Count; i++)
 239        {
 19795240            WorldVoxelIndex coordinate = coordinates[i];
 19795241            if (!world.ActiveGrids.IsAllocated(coordinate.GridIndex)
 19795242                || !world.TryGetVoxel(coordinate, out Voxel? voxel)
 19795243                || !voxel!.TryGetPartition(out PhysicsPartition2D? partition))
 244            {
 245                continue;
 246            }
 247
 19776248            partition!.SetDynamicObjectAwake(collider.Id, awake);
 249        }
 1844250    }
 251
 252    internal void CheckAndDistributeCollisions()
 253    {
 24303254        _context.Physics2D.PublishCollisionPositionStates();
 24303255        RefreshDeferredColliderPartitions();
 24303256        Version++;
 257
 24303258        _distributionPartitions.FastClear();
 232042259        foreach (PhysicsPartition2D partition in _activePartitions)
 91718260            _distributionPartitions.Add(partition);
 261
 24303262        _distributionPartitions.SortInPlace(PartitionOrderComparer);
 263
 24303264        _isDistributing = true;
 265        try
 266        {
 232060267            for (int i = 0; i < _distributionPartitions.Count; i++)
 268            {
 91727269                _distributionPartitions[i].Distribute(
 91727270                    _distributionDynamicIds,
 91727271                    _distributionStaticIds);
 272            }
 24303273        }
 274        finally
 275        {
 24303276            _isDistributing = false;
 24303277        }
 24303278    }
 279
 280    internal void CollectBoundsCandidates(
 281        Vector2d min,
 282        Vector2d max,
 283        PhysicsLayerMask layerMask,
 284        uint queryVersion,
 285        bool raycastQuery,
 286        SwiftList<LSCollider2D> candidates,
 287        bool staticStyleOnly = false)
 288    {
 17845289        _context.RefreshQueryPartitions();
 17845290        _context.Physics2D.PublishCollisionPositionStates();
 17845291        RefreshDeferredColliderPartitions();
 17845292        candidates.FastClear();
 293
 17845294        CollectCoveredPartitions(min, max, _queryPartitions);
 295
 296        // Gathering has no callbacks or geometry reduction. Canonicalize once
 297        // after deduplication, before query workers observe any candidate order.
 523402298        for (int i = 0; i < _queryPartitions.Count; i++)
 299        {
 243856300            PhysicsPartition2D partition = _queryPartitions[i];
 243856301            if (!staticStyleOnly)
 131105302                CollectMembershipCandidates(partition.ContainedDynamicObjects,
 131105303                    min, max, layerMask, queryVersion, raycastQuery, candidates);
 243856304            CollectMembershipCandidates(partition.ContainedKinematicObjects,
 243856305                min, max, layerMask, queryVersion, raycastQuery, candidates);
 243856306            CollectMembershipCandidates(partition.ContainedStaticObjects,
 243856307                min, max, layerMask, queryVersion, raycastQuery, candidates);
 308        }
 309
 17845310        candidates.SortInPlace(ColliderIdComparer);
 17845311    }
 312
 313    private void CollectMembershipCandidates(
 314        SwiftHashSet<int>? membership,
 315        Vector2d min,
 316        Vector2d max,
 317        PhysicsLayerMask layerMask,
 318        uint queryVersion,
 319        bool raycastQuery,
 320        SwiftList<LSCollider2D> candidates)
 321    {
 618817322        if (membership == null)
 448681323            return;
 324
 1154996325        foreach (int colliderId in membership)
 326        {
 407362327            if (!_context.Physics2D.TryGetColliderById(colliderId, out LSCollider2D? collider)
 407362328                || !collider!.IsActive
 407362329                || IsDuplicateQueryCandidate(collider, queryVersion, raycastQuery)
 407362330                || !layerMask.Includes(collider.Layer)
 407362331                || collider.MaxX < min.X
 407362332                || collider.MinX > max.X
 407362333                || collider.MaxY < min.Y
 407362334                || collider.MinY > max.Y)
 335            {
 336                continue;
 337            }
 338
 53476339            candidates.Add(collider);
 340        }
 170136341    }
 342
 343    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 344    private static bool IsDuplicateQueryCandidate(LSCollider2D collider, uint queryVersion, bool raycastQuery)
 345    {
 403904346        if (raycastQuery)
 347        {
 173069348            if (collider.RaycastVersion == queryVersion)
 131697349                return true;
 350
 41372351            collider.RaycastVersion = queryVersion;
 41372352            return false;
 353        }
 354
 230835355        if (collider.CircleQueryVersion == queryVersion)
 200344356            return true;
 357
 30491358        collider.CircleQueryVersion = queryVersion;
 30491359        return false;
 360    }
 361
 362    internal void RefreshDeferredColliderPartitions()
 363    {
 211311364        if (_deferredPartitionRefreshIds.Count == 0)
 211309365            return;
 366
 10367        for (int i = 0; i < _deferredPartitionRefreshIds.Count; i++)
 368        {
 3369            int colliderId = _deferredPartitionRefreshIds.DenseKeys[i];
 3370            if (_context.Physics2D.TryGetColliderById(colliderId, out LSCollider2D? collider) && collider!.IsActive)
 1371                RefreshColliderPartition(collider);
 372        }
 373
 2374        _deferredPartitionRefreshIds.Clear();
 2375    }
 376
 377    internal void RebuildPartitionsAfterWorldChange()
 378    {
 24379        DetachRetainedPartitions();
 72380        for (int i = 0; i < _context.Physics2D.ColliderCount; i++)
 381        {
 12382            LSCollider2D collider = _context.Physics2D.GetColliderByServiceIndex(i);
 12383            collider.MarkUnpartitioned();
 12384            collider.ClearPartitionCoordinates();
 12385            RefreshColliderPartition(collider);
 386        }
 24387    }
 388
 389    private void CollectCoveredPartitions(
 390        Vector2d min,
 391        Vector2d max,
 392        SwiftList<PhysicsPartition2D> partitions)
 393    {
 17845394        partitions.FastClear();
 17845395        ScanCoveredQueryPartitions(min, max, min, max, partitions);
 17845396    }
 397
 398    private void PartitionCoveredVoxels(
 399        LSCollider2D collider,
 400        Vector2d coverageMin,
 401        Vector2d coverageMax,
 402        SwiftList<WorldVoxelIndex> partitionedCoordinates,
 403        PhysicsMobilityType kind)
 404    {
 23784405        ScanCoveredColliderVoxels(collider, coverageMin, coverageMax, partitionedCoordinates, kind);
 23784406    }
 407
 408    private void ScanCoveredQueryPartitions(
 409        Vector2d coverageMin,
 410        Vector2d coverageMax,
 411        Vector2d queryMin,
 412        Vector2d queryMax,
 413        SwiftList<PhysicsPartition2D> partitions)
 414    {
 17845415        GridWorld world = _context.World;
 17845416        GridTracer.GetCoveredVoxelsInto(
 17845417            world,
 17845418            coverageMin,
 17845419            coverageMax,
 17845420            _coveredVoxels,
 17845421            _traceScratch,
 17845422            layerY: Fixed64.Zero);
 423
 17845424        VisitPlanarVoxelsForQuery(world, queryMin, queryMax, partitions);
 17845425    }
 426
 427    private void ScanCoveredColliderVoxels(
 428        LSCollider2D collider,
 429        Vector2d coverageMin,
 430        Vector2d coverageMax,
 431        SwiftList<WorldVoxelIndex> partitionedCoordinates,
 432        PhysicsMobilityType kind)
 433    {
 23784434        GridWorld world = _context.World;
 23784435        GridTracer.GetCoveredVoxelsInto(
 23784436            world,
 23784437            coverageMin,
 23784438            coverageMax,
 23784439            _coveredVoxels,
 23784440            _traceScratch,
 23784441            layerY: Fixed64.Zero);
 442
 23784443        VisitPlanarVoxelsForCollider(world, collider, partitionedCoordinates, kind);
 23784444    }
 445
 446    private void VisitPlanarVoxelsForQuery(
 447        GridWorld world,
 448        Vector2d queryMin,
 449        Vector2d queryMax,
 450        SwiftList<PhysicsPartition2D> partitions)
 451    {
 17845452        var traversal = new GridTraversalState(world, GridTraversalPaddingMode.PlanarMaxCellEdge);
 1168296453        for (int i = 0; i < _coveredVoxels.Count; i++)
 454        {
 566303455            Voxel voxel = _coveredVoxels[i];
 456
 566303457            Fixed64 cellEdge = traversal.GetCellEdge(voxel);
 566303458            if (!GridTraversal.IsPlanarPositionInPaddedBounds(queryMin, queryMax, cellEdge, voxel.WorldPosition)
 566303459                || !voxel.TryGetPartition(out PhysicsPartition2D? partition)
 566303460                || partition!.IsEmpty)
 461            {
 462                continue;
 463            }
 464
 243856465            partitions.Add(partition);
 466        }
 17845467    }
 468
 469    private void VisitPlanarVoxelsForCollider(
 470        GridWorld world,
 471        LSCollider2D collider,
 472        SwiftList<WorldVoxelIndex> partitionedCoordinates,
 473        PhysicsMobilityType kind)
 474    {
 23784475        var traversal = new GridTraversalState(world, GridTraversalPaddingMode.PlanarMaxCellEdge);
 23784476        _nextCoveredCoordinates.Clear();
 589384477        for (int i = 0; i < _coveredVoxels.Count; i++)
 478        {
 270908479            Voxel voxel = _coveredVoxels[i];
 270908480            if (collider.IsPositionInPlanarBounds(traversal.GetCellEdge(voxel), voxel.WorldPosition))
 209312481                _nextCoveredCoordinates.Add(voxel.WorldIndex);
 482        }
 483
 484        // Bounds remain exact for versioning. Only memberships shared by both
 485        // coverage sets survive; a mobility change must replace their old role.
 23784486        PhysicsMobilityType previousKind = GetStoredMobilityKind(collider.PartitionKind);
 23784487        RemovePartitionMemberships(collider, partitionedCoordinates, previousKind, previousKind == kind);
 23784488        partitionedCoordinates.FastClear();
 589384489        for (int i = 0; i < _coveredVoxels.Count; i++)
 270908490            TryPartitionVoxel(collider, partitionedCoordinates, _coveredVoxels[i], kind);
 23784491    }
 492
 493    private void TryPartitionVoxel(
 494        LSCollider2D collider,
 495        SwiftList<WorldVoxelIndex> partitionedCoordinates,
 496        Voxel voxel,
 497        PhysicsMobilityType kind)
 498    {
 270908499        if (!_nextCoveredCoordinates.Contains(voxel.WorldIndex))
 61596500            return;
 501
 209312502        if (!voxel.TryGetPartition(out PhysicsPartition2D? partition))
 503        {
 123849504            partition = RentPartition();
 123849505            ChronicleGuard.ThrowIfTrue(
 123849506                !voxel.TryAddPartition(partition),
 123849507                nameof(GravitasCollision2DService),
 123849508                "Unable to attach 2D physics partition to voxel.");
 509
 123849510            TrackRetainedPartition(partition);
 511        }
 512
 209312513        partitionedCoordinates.Add(voxel.WorldIndex);
 209312514        AddObject(partition!, collider.Id, kind);
 515        // A surviving ID bypasses AddDynamicObject's initial awake refresh.
 516        // Solver mobility may have changed without changing its partition role.
 209312517        if (kind == PhysicsMobilityType.Dynamic)
 119930518            partition!.SetDynamicObjectAwake(collider.Id, collider.Body!.IsAwakeForCollision);
 209312519    }
 520
 521    private void GetPlanarCoverageBounds(LSCollider2D collider, out Vector2d coverageMin, out Vector2d coverageMax)
 522    {
 24866523        coverageMin = new Vector2d(collider.MinX, collider.MinY);
 24866524        coverageMax = new Vector2d(collider.MaxX, collider.MaxY);
 24866525    }
 526
 527    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 528    private static PhysicsMobilityType GetMobilityKind(LSCollider2D collider)
 529    {
 24866530        if (collider.IsStatic)
 5173531            return PhysicsMobilityType.Static;
 532
 19693533        SolidBody2D? body = collider.Body;
 19693534        return body!.IsKinematic ? PhysicsMobilityType.Kinematic : PhysicsMobilityType.Dynamic;
 535    }
 536
 537    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 538    private static PhysicsMobilityType GetStoredMobilityKind(int partitionKind)
 539    {
 24281540        return partitionKind == (int)PhysicsMobilityType.Kinematic
 24281541            ? PhysicsMobilityType.Kinematic
 24281542            : partitionKind == (int)PhysicsMobilityType.Static
 24281543                ? PhysicsMobilityType.Static
 24281544                : PhysicsMobilityType.Dynamic;
 545    }
 546
 547    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 548    private static void AddObject(PhysicsPartition2D partition, int id, PhysicsMobilityType kind)
 549    {
 209312550        if (kind == PhysicsMobilityType.Static)
 551        {
 78340552            partition.AddStaticObject(id);
 78340553            return;
 554        }
 555
 130972556        if (kind == PhysicsMobilityType.Kinematic)
 557        {
 11042558            partition.AddKinematicObject(id);
 11042559            return;
 560        }
 561
 119930562        partition.AddDynamicObject(id);
 119930563    }
 564
 565    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 566    private static void RemoveObject(PhysicsPartition2D partition, int id, PhysicsMobilityType kind)
 567    {
 20928568        if (kind == PhysicsMobilityType.Static)
 569        {
 4319570            partition.RemoveStaticObject(id);
 4319571            return;
 572        }
 573
 16609574        if (kind == PhysicsMobilityType.Kinematic)
 575        {
 6499576            partition.RemoveKinematicObject(id);
 6499577            return;
 578        }
 579
 10110580        partition.RemoveDynamicObject(id);
 10110581    }
 582
 137583    private void DetachRetainedPartitions() => RetainedPartitionLifecycle.DetachAll(
 137584        _retainedPartitions,
 137585        _emptyRetainedPartitions,
 137586        _context.World,
 137587        this,
 137588        _releaseRetainedPartition,
 137589        nameof(PhysicsPartition2D),
 137590        "Unable to detach retained 2D physics partition from its voxel during reset.");
 591
 123850592    private void TrackRetainedPartition(PhysicsPartition2D partition) => RetainedPartitionLifecycle.Track(
 123850593        _retainedPartitions,
 123850594        _emptyRetainedPartitions,
 123850595        this,
 123850596        partition,
 123850597        nameof(PhysicsPartition2D));
 598
 123855599    private void UntrackRetainedPartition(PhysicsPartition2D partition) => RetainedPartitionLifecycle.Untrack(
 123855600        _retainedPartitions,
 123855601        _emptyRetainedPartitions,
 123855602        this,
 123855603        partition,
 123855604        ref _retainedPartitionRetirementCursor);
 605
 163456606    internal void RefreshRetainedPartitionEligibility(PhysicsPartition2D partition) => RetainedPartitionLifecycle.Refres
 163456607        _emptyRetainedPartitions, this, partition);
 608
 24302609    internal void RetireExpiredRetainedPartitions() => RetainedPartitionLifecycle.RetireExpired(
 24302610            _retainedPartitions,
 24302611            _context.World,
 24302612            this,
 24302613            _context.Settings.RetainedPartitionRetirementSweepBudget,
 24302614            _context.FrameCount,
 24302615            _context.Settings.RetainedPartitionTimeToKillFrames,
 24302616            _releaseRetainedPartition,
 24302617            ref _retainedPartitionRetirementCursor);
 618
 619    internal int ActivatePartition(PhysicsPartition2D partition)
 620    {
 53329621        ChronicleGuard.ThrowIfNull(partition, nameof(partition));
 53329622        ChronicleGuard.ThrowIfArgument(
 53329623            !ReferenceEquals(partition.Owner, this),
 53329624            nameof(partition),
 53329625            "2D partition must belong to this collision service.");
 626
 53329627        return _activePartitions.Add(partition);
 628    }
 629
 630    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 53326631    internal void DeactivatePartition(int activationId) => _activePartitions.TryRemoveAt(activationId);
 632
 633    internal PhysicsPartition2D RentPartition()
 634    {
 123858635        if (_inactivePartitionPool.Count == 0)
 123807636            TryRetireEmptyRetainedPartitionForReuse();
 637
 123858638        PhysicsPartition2D partition = _inactivePartitionPool.Count > 0
 123858639            ? _inactivePartitionPool.Pop()
 123858640            : new PhysicsPartition2D();
 123858641        partition.SetOwner(this);
 123858642        return partition;
 643    }
 644
 645    private bool TryRetireEmptyRetainedPartitionForReuse()
 646    {
 123807647        return RetainedPartitionLifecycle.TryRetireEmptyForReuse(
 123807648            _emptyRetainedPartitions,
 123807649            _inactivePartitionPool,
 123807650            _context.World,
 123807651            this,
 123807652            _releaseRetainedPartition);
 653    }
 654
 655    internal void ReleasePartition(PhysicsPartition2D partition)
 656    {
 123855657        ChronicleGuard.ThrowIfNull(partition, nameof(partition));
 123855658        ChronicleGuard.ThrowIfArgument(
 123855659            !ReferenceEquals(partition.Owner, this),
 123855660            nameof(partition),
 123855661            "2D partition must be released through its owning collision service.");
 662
 123855663        UntrackRetainedPartition(partition);
 123855664        partition.ResetForPool();
 123855665        _inactivePartitionPool.Push(partition);
 123855666    }
 667
 668    private sealed class PhysicsPartition2DOrderComparer : IComparer<PhysicsPartition2D>
 669    {
 670        public int Compare(PhysicsPartition2D? left, PhysicsPartition2D? right) =>
 162588671            WorldVoxelIndexOrdering.ComparePlanar(left!.WorldIndex, right!.WorldIndex);
 672    }
 673
 674    private sealed class Collider2DIdComparer : IComparer<LSCollider2D>
 675    {
 676        public int Compare(LSCollider2D? left, LSCollider2D? right) =>
 80009677            left!.Id.CompareTo(right!.Id);
 678    }
 679}

Methods/Properties

.cctor()
.ctor(Gravitas.GravitasWorldContext)
get_Context()
get_ActivePartitionCount()
get_InactivePartitionCount()
get_RetainedPartitionCount()
Reset()
RefreshColliderPartition(Gravitas.Colliders.LSCollider2D)
RefreshColliderPartitionAfterShapeChange(Gravitas.Colliders.LSCollider2D)
PartitionCollider(Gravitas.Colliders.LSCollider2D)
PartitionCollider(Gravitas.Colliders.LSCollider2D,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d)
PartitionCollider(Gravitas.Colliders.LSCollider2D,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,Gravitas.PhysicsMobilityType)
ClearPartitionedCollider(Gravitas.Colliders.LSCollider2D,System.Boolean)
RemovePartitionMemberships(Gravitas.Colliders.LSCollider2D,SwiftCollections.SwiftList`1<GridForge.Spatial.WorldVoxelIndex>,Gravitas.PhysicsMobilityType,System.Boolean)
RefreshPartitionAwakeState(Gravitas.Colliders.LSCollider2D)
CheckAndDistributeCollisions()
CollectBoundsCandidates(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,Gravitas.Support.PhysicsLayerMask,System.UInt32,System.Boolean,SwiftCollections.SwiftList`1<Gravitas.Colliders.LSCollider2D>,System.Boolean)
CollectMembershipCandidates(SwiftCollections.SwiftHashSet`1<System.Int32>,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,Gravitas.Support.PhysicsLayerMask,System.UInt32,System.Boolean,SwiftCollections.SwiftList`1<Gravitas.Colliders.LSCollider2D>)
IsDuplicateQueryCandidate(Gravitas.Colliders.LSCollider2D,System.UInt32,System.Boolean)
RefreshDeferredColliderPartitions()
RebuildPartitionsAfterWorldChange()
CollectCoveredPartitions(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,SwiftCollections.SwiftList`1<Gravitas.PhysicsPartition2D>)
PartitionCoveredVoxels(Gravitas.Colliders.LSCollider2D,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,SwiftCollections.SwiftList`1<GridForge.Spatial.WorldVoxelIndex>,Gravitas.PhysicsMobilityType)
ScanCoveredQueryPartitions(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,SwiftCollections.SwiftList`1<Gravitas.PhysicsPartition2D>)
ScanCoveredColliderVoxels(Gravitas.Colliders.LSCollider2D,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,SwiftCollections.SwiftList`1<GridForge.Spatial.WorldVoxelIndex>,Gravitas.PhysicsMobilityType)
VisitPlanarVoxelsForQuery(GridForge.Grids.GridWorld,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,SwiftCollections.SwiftList`1<Gravitas.PhysicsPartition2D>)
VisitPlanarVoxelsForCollider(GridForge.Grids.GridWorld,Gravitas.Colliders.LSCollider2D,SwiftCollections.SwiftList`1<GridForge.Spatial.WorldVoxelIndex>,Gravitas.PhysicsMobilityType)
TryPartitionVoxel(Gravitas.Colliders.LSCollider2D,SwiftCollections.SwiftList`1<GridForge.Spatial.WorldVoxelIndex>,GridForge.Grids.Voxel,Gravitas.PhysicsMobilityType)
GetPlanarCoverageBounds(Gravitas.Colliders.LSCollider2D,FixedMathSharp.Vector2d&,FixedMathSharp.Vector2d&)
GetMobilityKind(Gravitas.Colliders.LSCollider2D)
GetStoredMobilityKind(System.Int32)
AddObject(Gravitas.PhysicsPartition2D,System.Int32,Gravitas.PhysicsMobilityType)
RemoveObject(Gravitas.PhysicsPartition2D,System.Int32,Gravitas.PhysicsMobilityType)
DetachRetainedPartitions()
TrackRetainedPartition(Gravitas.PhysicsPartition2D)
UntrackRetainedPartition(Gravitas.PhysicsPartition2D)
RefreshRetainedPartitionEligibility(Gravitas.PhysicsPartition2D)
RetireExpiredRetainedPartitions()
ActivatePartition(Gravitas.PhysicsPartition2D)
DeactivatePartition(System.Int32)
RentPartition()
TryRetireEmptyRetainedPartitionForReuse()
ReleasePartition(Gravitas.PhysicsPartition2D)
Compare(Gravitas.PhysicsPartition2D,Gravitas.PhysicsPartition2D)
Compare(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D)