< Summary

Information
Class: Gravitas.GravitasCollisionService
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/Core/3D/Services/GravitasCollisionService.cs
Line coverage
100%
Covered lines: 271
Uncovered lines: 0
Coverable lines: 271
Total lines: 507
Line coverage: 100%
Branch coverage
100%
Covered branches: 80
Total branches: 80
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

File(s)

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

#LineLine coverage
 1//=======================================================================
 2// GravitasCollisionService.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.CollisionHandling;
 14using GridForge.Grids;
 15using GridForge.Spatial;
 16using GridForge.Utility;
 17using SwiftCollections;
 18
 19namespace Gravitas;
 20
 21/// <summary>
 22/// Owns collision partitioning state for one <see cref="GravitasWorldContext"/>.
 23/// </summary>
 24public sealed class GravitasCollisionService
 25{
 26    private const int DefaultPartitionPoolCapacity = 1024;
 127    private static readonly PhysicsPartitionOrderComparer PartitionOrderComparer = new();
 28
 29    private readonly GravitasWorldContext _context;
 1019130    private readonly SwiftSlotMap<PhysicsPartition> _activePartitions = new();
 1019131    private readonly SwiftStack<PhysicsPartition> _inactivePartitionPool = new(DefaultPartitionPoolCapacity);
 1019132    private readonly SwiftList<Voxel> _coveredVoxels = new();
 1019133    private readonly SwiftHashSet<WorldVoxelIndex> _nextCoveredCoordinates = new();
 1019134    private readonly GridTraceScratch _traceScratch = new();
 1019135    private readonly SwiftList<PhysicsPartition> _retainedPartitions = new();
 1019136    private readonly SwiftList<PhysicsPartition> _emptyRetainedPartitions = new();
 1019137    private readonly SwiftList<PhysicsPartition> _distributionPartitions = new();
 1019138    private readonly SwiftList<int> _distributionDynamicIds = new();
 1019139    private readonly SwiftList<int> _distributionStaticIds = new();
 1019140    private readonly SwiftList<int> _planarQueryPartitionColliderIds = new();
 1019141    private readonly SwiftHashSet<int> _planarQueryUniqueColliderIds = new();
 1019142    private readonly DynamicCcdCandidateIndex2D _planarQueryCandidates =
 1019143        new(capacity: 0, supportsUpdates: true);
 44    private readonly Action<PhysicsPartition> _releaseRetainedPartition;
 1019145    private readonly object _cullDistributorLock = new();
 46
 47    private int _cullDistributor;
 48    private int _retainedPartitionRetirementCursor;
 49    private uint _planarQueryWorldVersion;
 50
 51    /// <summary>
 52    /// Initializes a new collision service for the supplied context.
 53    /// </summary>
 54    /// <param name="context">The owning world context.</param>
 1019155    public GravitasCollisionService(GravitasWorldContext context)
 56    {
 1019157        ChronicleGuard.ThrowIfNull(context, nameof(context));
 1019158        _context = context;
 1019159        _releaseRetainedPartition = ReleasePartition;
 1019160    }
 61
 62    /// <summary>
 63    /// Gets the owning world context.
 64    /// </summary>
 321619965    public GravitasWorldContext Context => _context;
 66
 67    /// <summary>
 68    /// Gets the collision distribution version for this context.
 69    /// </summary>
 70    public uint Version { get; private set; } = 1;
 71
 72    /// <summary>
 73    /// Gets the number of active partitions in this context.
 74    /// </summary>
 2475    public int ActivePartitionCount => _activePartitions.Count;
 76
 77    /// <summary>
 78    /// Gets the number of inactive partitions currently available for reuse.
 79    /// </summary>
 1880    public int InactivePartitionCount => _inactivePartitionPool.Count;
 81
 2482    internal int RetainedPartitionCount => _retainedPartitions.Count;
 83
 84    internal int CullDistributor
 85    {
 86        get
 87        {
 186688            lock (_cullDistributorLock)
 89            {
 186690                if (_cullDistributor > 1)
 60891                    _cullDistributor = -1;
 92
 186693                return _cullDistributor++;
 94            }
 186695        }
 96    }
 97
 98    /// <summary>
 99    /// Resets transient collision state owned by this context.
 100    /// </summary>
 101    public void Reset()
 102    {
 113103        DetachRetainedPartitions();
 113104        _activePartitions.Clear();
 113105        _coveredVoxels.FastClear();
 113106        _nextCoveredCoordinates.Clear();
 113107        _traceScratch.Clear();
 113108        _distributionPartitions.FastClear();
 113109        _distributionDynamicIds.FastClear();
 113110        _distributionStaticIds.FastClear();
 113111        _planarQueryPartitionColliderIds.FastClear();
 113112        _planarQueryUniqueColliderIds.Clear();
 113113        _planarQueryCandidates.Clear();
 113114        _inactivePartitionPool.Clear();
 113115        Version = 1;
 113116        _cullDistributor = 0;
 113117        _retainedPartitionRetirementCursor = 0;
 113118        _planarQueryWorldVersion = 0;
 113119    }
 120
 137121    private void DetachRetainedPartitions() => RetainedPartitionLifecycle.DetachAll(
 137122        _retainedPartitions,
 137123        _emptyRetainedPartitions,
 137124        _context.World,
 137125        this,
 137126        _releaseRetainedPartition,
 137127        nameof(PhysicsPartition),
 137128        "Unable to detach retained physics partition from its voxel during reset.");
 129
 1159174130    private void TrackRetainedPartition(PhysicsPartition partition) => RetainedPartitionLifecycle.Track(
 1159174131        _retainedPartitions,
 1159174132        _emptyRetainedPartitions,
 1159174133        this,
 1159174134        partition,
 1159174135        nameof(PhysicsPartition));
 136
 1159179137    private void UntrackRetainedPartition(PhysicsPartition partition) => RetainedPartitionLifecycle.Untrack(
 1159179138            _retainedPartitions,
 1159179139        _emptyRetainedPartitions,
 1159179140            this,
 1159179141            partition,
 1159179142            ref _retainedPartitionRetirementCursor);
 143
 144    internal bool IsPartitionRefreshRequired(LSCollider collider) =>
 306503145        !collider.MatchesPartitionGridBounds(collider.BoundsMin, collider.BoundsMax, ResolvePartitionKind(collider));
 146
 147    internal void RebuildPartitionsAfterWorldChange()
 148    {
 24149        DetachRetainedPartitions();
 24150        _planarQueryCandidates.Clear();
 80151        for (int i = 0; i < _context.Physics.ColliderCount; i++)
 152        {
 16153            LSCollider collider = _context.Physics.GetColliderByServiceIndex(i);
 16154            collider.MarkUnpartitioned();
 16155            collider.ClearPartitionCoordinates();
 16156            collider.RepartitionCommittedShape();
 157        }
 24158        _planarQueryWorldVersion = _context.World.Version;
 24159    }
 160
 449039161    internal int ResolvePartitionKind(LSCollider collider) => (int)GetMobilityKind(collider);
 162
 163    internal bool PartitionObject(
 164        LSCollider collider,
 165        ref SwiftList<WorldVoxelIndex> partitionedCoordinates)
 166    {
 143353167        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 143353168        ChronicleGuard.ThrowIfArgument(
 143353169            !ReferenceEquals(collider.Context, _context),
 143353170            nameof(collider),
 143353171            "Collider must belong to this collision service context.");
 172
 143353173        PartitionCoveredVoxels(collider, partitionedCoordinates, GetMobilityKind(collider));
 143353174        if (partitionedCoordinates.Count == 0)
 175        {
 3098176            collider.MarkUnpartitioned();
 3098177            _planarQueryCandidates.Remove(collider.Id);
 3098178            return false;
 179        }
 180
 140255181        _planarQueryCandidates.AddOrUpdate(
 140255182            collider.Id,
 140255183            new DynamicCcdPlanarBounds(
 140255184                collider.BoundsMin.X,
 140255185                collider.BoundsMin.Z,
 140255186                collider.BoundsMax.X,
 140255187                collider.BoundsMax.Z));
 140255188        return true;
 189    }
 190
 191    private void PartitionCoveredVoxels(
 192        LSCollider collider,
 193        SwiftList<WorldVoxelIndex> partitionedCoordinates,
 194        PhysicsMobilityType kind)
 195    {
 143353196        GridWorld world = _context.World;
 143353197        GridTracer.GetCoveredVoxelsInto(
 143353198            world,
 143353199            collider.BoundsMin,
 143353200            collider.BoundsMax,
 143353201            _coveredVoxels,
 143353202            _traceScratch,
 143353203            Fixed64.Half);
 204
 143353205        var traversal = new GridTraversalState(world, GridTraversalPaddingMode.MaxCellEdge);
 143353206        _nextCoveredCoordinates.Clear();
 143353207        int coveredCount = 0;
 16695778208        for (int i = 0; i < _coveredVoxels.Count; i++)
 209        {
 8204536210            Voxel voxel = _coveredVoxels[i];
 8204536211            if (collider.IsPositionInBounds(traversal.GetCellEdge(voxel), voxel.WorldPosition))
 212            {
 5516466213                _nextCoveredCoordinates.Add(voxel.WorldIndex);
 5516466214                _coveredVoxels[coveredCount++] = voxel;
 215            }
 216        }
 217
 218        // Preserve surviving memberships without changing tracer order or raw
 219        // bounds. Idempotent additions below also repair externally removed ones.
 143353220        PhysicsMobilityType previousKind = GetStoredMobilityKind(collider.PartitionKind);
 143353221        RemovePartitionMemberships(collider, partitionedCoordinates, previousKind, previousKind == kind);
 143353222        partitionedCoordinates.FastClear();
 11319638223        for (int i = 0; i < coveredCount; i++)
 5516466224            PartitionVoxel(collider, partitionedCoordinates, _coveredVoxels[i], kind);
 143353225    }
 226
 227    private void PartitionVoxel(
 228        LSCollider collider,
 229        SwiftList<WorldVoxelIndex> partitionedCoordinates,
 230        Voxel voxel,
 231        PhysicsMobilityType kind)
 232    {
 5516466233        if (!voxel.TryGetPartition(out PhysicsPartition? partition))
 234        {
 1159173235            partition = RentPartition();
 1159173236            ChronicleGuard.ThrowIfTrue(
 1159173237                !voxel.TryAddPartition(partition),
 1159173238                nameof(GravitasCollisionService),
 1159173239                "Unable to attach 3D physics partition to voxel.");
 240
 1159173241            TrackRetainedPartition(partition);
 242        }
 243
 5516466244        partitionedCoordinates.Add(voxel.WorldIndex);
 5516466245        AddObject(partition!, collider.Id, kind);
 5516466246        if (kind == PhysicsMobilityType.Dynamic)
 4345403247            partition!.SetDynamicObjectAwake(collider.Id, collider.Body!.IsAwakeForCollision);
 5516466248    }
 249
 250    internal bool ClearPartitionedObject(LSCollider collider, bool force = false)
 251    {
 474252        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 474253        ChronicleGuard.ThrowIfArgument(
 474254            !ReferenceEquals(collider.Context, _context),
 474255            nameof(collider),
 474256            "Collider must belong to this collision service context.");
 257
 474258        if (!collider.IsPartitioned)
 1259            return false;
 260
 473261        PhysicsMobilityType currentKind = GetMobilityKind(collider);
 473262        if (!force && collider.MatchesPartitionGridBounds(collider.BoundsMin, collider.BoundsMax, (int)currentKind))
 1263            return false;
 264
 472265        PhysicsMobilityType partitionKind = GetStoredMobilityKind(collider.PartitionKind);
 472266        _planarQueryCandidates.Remove(collider.Id);
 472267        RemovePartitionMemberships(collider, collider.PartitionCoordinates!, partitionKind, preserveCovered: false);
 268
 472269        collider.MarkUnpartitioned();
 472270        collider.ClearPartitionCoordinates();
 271
 472272        return true;
 273    }
 274
 275    private void RemovePartitionMemberships(
 276        LSCollider collider,
 277        SwiftList<WorldVoxelIndex> coordinates,
 278        PhysicsMobilityType partitionKind,
 279        bool preserveCovered)
 280    {
 143825281        GridWorld world = _context.World;
 8875766282        for (int i = 0; i < coordinates.Count; i++)
 283        {
 4294058284            WorldVoxelIndex coordinate = coordinates[i];
 4294058285            if (preserveCovered && _nextCoveredCoordinates.Contains(coordinate))
 286                continue;
 287
 372532288            if (!world.ActiveGrids.IsAllocated(coordinate.GridIndex)
 372532289                || !world.TryGetVoxel(coordinate, out Voxel? voxel)
 372532290                || !voxel!.TryGetPartition(out PhysicsPartition? partition))
 291            {
 292                continue;
 293            }
 294
 372450295            RemoveObject(partition!, collider.Id, partitionKind);
 296
 297            // Keep the voxel partition attached after it becomes empty. Re-adding
 298            // the same partition type through GridForge carries metadata overhead,
 299            // while an empty PhysicsPartition is inactive and query-invisible.
 300        }
 143825301    }
 302
 303    internal void QueryPlanarColliderCandidates(
 304        DynamicCcdPlanarBounds bounds,
 305        SwiftList<int> results)
 306    {
 52715307        _context.RefreshQueryPartitions();
 52715308        if (_planarQueryWorldVersion != _context.World.Version)
 463309            RebuildPlanarQueryCandidates();
 310
 52715311        _planarQueryCandidates.Query(bounds, results);
 52715312    }
 313
 314    private void RebuildPlanarQueryCandidates()
 315    {
 463316        _planarQueryCandidates.Clear();
 463317        _planarQueryUniqueColliderIds.Clear();
 359146318        for (int partitionIndex = 0; partitionIndex < _retainedPartitions.Count; partitionIndex++)
 319        {
 179110320            _retainedPartitions[partitionIndex].CopyAllColliderIds(_planarQueryPartitionColliderIds);
 821288321            for (int colliderIndex = 0; colliderIndex < _planarQueryPartitionColliderIds.Count; colliderIndex++)
 322            {
 231534323                int colliderId = _planarQueryPartitionColliderIds[colliderIndex];
 231534324                if (!_planarQueryUniqueColliderIds.Add(colliderId)
 231534325                    || !_context.Physics.TryGetColliderById(colliderId, out LSCollider? collider))
 326                {
 327                    continue;
 328                }
 329
 1345330                _planarQueryCandidates.AddOrUpdate(
 1345331                    colliderId,
 1345332                    new DynamicCcdPlanarBounds(
 1345333                        collider!.BoundsMin.X,
 1345334                        collider.BoundsMin.Z,
 1345335                        collider.BoundsMax.X,
 1345336                        collider.BoundsMax.Z));
 337            }
 338        }
 339
 463340        _planarQueryWorldVersion = _context.World.Version;
 463341    }
 342
 343    internal void RefreshPartitionAwakeState(LSCollider collider)
 344    {
 1776345        ChronicleGuard.ThrowIfNull(collider, nameof(collider));
 1776346        ChronicleGuard.ThrowIfArgument(
 1776347            !ReferenceEquals(collider.Context, _context),
 1776348            nameof(collider),
 1776349            "Collider must belong to this collision service context.");
 350
 1776351        SwiftList<WorldVoxelIndex> coordinates = collider.PartitionCoordinates!;
 1776352        SolidBody? body = collider.Body;
 1776353        if (collider.IsStatic || body!.IsKinematic)
 29354            return;
 355
 1747356        bool awake = body.IsAwakeForCollision;
 1747357        GridWorld world = _context.World;
 358
 410386359        for (int i = 0; i < coordinates.Count; i++)
 360        {
 203446361            WorldVoxelIndex coordinate = coordinates[i];
 203446362            if (!world.ActiveGrids.IsAllocated(coordinate.GridIndex)
 203446363                || !world.TryGetVoxel(coordinate, out Voxel? voxel)
 203446364                || !voxel!.TryGetPartition(out PhysicsPartition? partition))
 365            {
 366                continue;
 367            }
 368
 203391369            partition!.SetDynamicObjectAwake(collider.Id, awake);
 370        }
 1747371    }
 372
 373    internal void CheckAndDistributeCollisions()
 374    {
 63063375        Version++;
 376
 63063377        _distributionPartitions.FastClear();
 4149180378        foreach (PhysicsPartition partition in _activePartitions)
 2011527379            _distributionPartitions.Add(partition);
 380
 63063381        _distributionPartitions.SortInPlace(PartitionOrderComparer);
 382
 4149180383        for (int i = 0; i < _distributionPartitions.Count; i++)
 384        {
 2011527385            _distributionPartitions[i].Distribute(
 2011527386                _distributionDynamicIds,
 2011527387                _distributionStaticIds);
 388        }
 63063389    }
 390
 1811824391    internal void RefreshRetainedPartitionEligibility(PhysicsPartition partition) => RetainedPartitionLifecycle.RefreshE
 1811824392        _emptyRetainedPartitions, this, partition);
 393
 63057394    internal void RetireExpiredRetainedPartitions() => RetainedPartitionLifecycle.RetireExpired(
 63057395        _retainedPartitions,
 63057396        _context.World,
 63057397        this,
 63057398        _context.Settings.RetainedPartitionRetirementSweepBudget,
 63057399        _context.FrameCount,
 63057400        _context.Settings.RetainedPartitionTimeToKillFrames,
 63057401        _releaseRetainedPartition,
 63057402        ref _retainedPartitionRetirementCursor);
 403
 404    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 405    private static PhysicsMobilityType GetMobilityKind(LSCollider collider)
 406    {
 592865407        if (collider.IsStatic)
 165377408            return PhysicsMobilityType.Static;
 409
 427488410        SolidBody? body = collider.Body;
 427488411        return body!.IsKinematic ? PhysicsMobilityType.Kinematic : PhysicsMobilityType.Dynamic;
 412    }
 413
 414    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 143825415    private static PhysicsMobilityType GetStoredMobilityKind(int partitionKind) => partitionKind == (int)PhysicsMobility
 143825416        ? PhysicsMobilityType.Kinematic
 143825417        : partitionKind == (int)PhysicsMobilityType.Static
 143825418            ? PhysicsMobilityType.Static
 143825419            : PhysicsMobilityType.Dynamic;
 420
 421    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 422    private static void AddObject(PhysicsPartition partition, int id, PhysicsMobilityType kind)
 423    {
 5516466424        if (kind == PhysicsMobilityType.Static)
 425        {
 790257426            partition.AddStaticObject(id);
 790257427            return;
 428        }
 429
 4726209430        if (kind == PhysicsMobilityType.Kinematic)
 431        {
 380806432            partition.AddKinematicObject(id);
 380806433            return;
 434        }
 435
 4345403436        partition.AddDynamicObject(id);
 4345403437    }
 438
 439    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 440    private static void RemoveObject(PhysicsPartition partition, int id, PhysicsMobilityType kind)
 441    {
 372450442        if (kind == PhysicsMobilityType.Static)
 443        {
 44979444            partition.RemoveStaticObject(id);
 44979445            return;
 446        }
 447
 327471448        if (kind == PhysicsMobilityType.Kinematic)
 449        {
 232282450            partition.RemoveKinematicObject(id);
 232282451            return;
 452        }
 453
 95189454        partition.RemoveDynamicObject(id);
 95189455    }
 456
 457    private sealed class PhysicsPartitionOrderComparer : IComparer<PhysicsPartition>
 458    {
 459        public int Compare(PhysicsPartition? left, PhysicsPartition? right) =>
 8297402460            WorldVoxelIndexOrdering.Compare3D(left!.WorldIndex, right!.WorldIndex);
 461    }
 462
 463    internal int ActivatePartition(PhysicsPartition partition)
 464    {
 537548465        ChronicleGuard.ThrowIfNull(partition, nameof(partition));
 537548466        ChronicleGuard.ThrowIfArgument(
 537548467            !ReferenceEquals(partition.Owner, this),
 537548468            nameof(partition),
 537548469            "Partition must belong to this collision service.");
 470
 537548471        return _activePartitions.Add(partition);
 472    }
 473
 537545474    internal void DeactivatePartition(int activationId) => _activePartitions.TryRemoveAt(activationId);
 475
 476    internal PhysicsPartition RentPartition()
 477    {
 1159183478        if (_inactivePartitionPool.Count == 0)
 1158969479            TryRetireEmptyRetainedPartitionForReuse();
 480
 1159183481        PhysicsPartition partition = _inactivePartitionPool.Count > 0
 1159183482            ? _inactivePartitionPool.Pop()
 1159183483            : new PhysicsPartition();
 1159183484        partition.SetOwner(this);
 1159183485        return partition;
 486    }
 487
 1158969488    private bool TryRetireEmptyRetainedPartitionForReuse() => RetainedPartitionLifecycle.TryRetireEmptyForReuse(
 1158969489            _emptyRetainedPartitions,
 1158969490            _inactivePartitionPool,
 1158969491            _context.World,
 1158969492            this,
 1158969493            _releaseRetainedPartition);
 494
 495    internal void ReleasePartition(PhysicsPartition partition)
 496    {
 1159179497        ChronicleGuard.ThrowIfNull(partition, nameof(partition));
 1159179498        ChronicleGuard.ThrowIfArgument(
 1159179499            !ReferenceEquals(partition.Owner, this),
 1159179500            nameof(partition),
 1159179501            "Partition must be released through its owning collision service.");
 502
 1159179503        UntrackRetainedPartition(partition);
 1159179504        partition.ResetForPool();
 1159179505        _inactivePartitionPool.Push(partition);
 1159179506    }
 507}

Methods/Properties

.cctor()
.ctor(Gravitas.GravitasWorldContext)
get_Context()
get_ActivePartitionCount()
get_InactivePartitionCount()
get_RetainedPartitionCount()
get_CullDistributor()
Reset()
DetachRetainedPartitions()
TrackRetainedPartition(Gravitas.PhysicsPartition)
UntrackRetainedPartition(Gravitas.PhysicsPartition)
IsPartitionRefreshRequired(Gravitas.Colliders.LSCollider)
RebuildPartitionsAfterWorldChange()
ResolvePartitionKind(Gravitas.Colliders.LSCollider)
PartitionObject(Gravitas.Colliders.LSCollider,SwiftCollections.SwiftList`1<GridForge.Spatial.WorldVoxelIndex>&)
PartitionCoveredVoxels(Gravitas.Colliders.LSCollider,SwiftCollections.SwiftList`1<GridForge.Spatial.WorldVoxelIndex>,Gravitas.PhysicsMobilityType)
PartitionVoxel(Gravitas.Colliders.LSCollider,SwiftCollections.SwiftList`1<GridForge.Spatial.WorldVoxelIndex>,GridForge.Grids.Voxel,Gravitas.PhysicsMobilityType)
ClearPartitionedObject(Gravitas.Colliders.LSCollider,System.Boolean)
RemovePartitionMemberships(Gravitas.Colliders.LSCollider,SwiftCollections.SwiftList`1<GridForge.Spatial.WorldVoxelIndex>,Gravitas.PhysicsMobilityType,System.Boolean)
QueryPlanarColliderCandidates(Gravitas.CollisionHandling.DynamicCcdPlanarBounds,SwiftCollections.SwiftList`1<System.Int32>)
RebuildPlanarQueryCandidates()
RefreshPartitionAwakeState(Gravitas.Colliders.LSCollider)
CheckAndDistributeCollisions()
RefreshRetainedPartitionEligibility(Gravitas.PhysicsPartition)
RetireExpiredRetainedPartitions()
GetMobilityKind(Gravitas.Colliders.LSCollider)
GetStoredMobilityKind(System.Int32)
AddObject(Gravitas.PhysicsPartition,System.Int32,Gravitas.PhysicsMobilityType)
RemoveObject(Gravitas.PhysicsPartition,System.Int32,Gravitas.PhysicsMobilityType)
Compare(Gravitas.PhysicsPartition,Gravitas.PhysicsPartition)
ActivatePartition(Gravitas.PhysicsPartition)
DeactivatePartition(System.Int32)
RentPartition()
TryRetireEmptyRetainedPartitionForReuse()
ReleasePartition(Gravitas.PhysicsPartition)