| | | 1 | | //======================================================================= |
| | | 2 | | // PhysicsPartition2D.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 | | |
| | | 8 | | using System.Runtime.CompilerServices; |
| | | 9 | | using Gravitas.Colliders; |
| | | 10 | | using GridForge.Grids; |
| | | 11 | | using GridForge.Spatial; |
| | | 12 | | using SwiftCollections; |
| | | 13 | | |
| | | 14 | | namespace Gravitas; |
| | | 15 | | |
| | | 16 | | /// <summary> |
| | | 17 | | /// Stores the pure 2D collider IDs assigned to one GridForge voxel. |
| | | 18 | | /// </summary> |
| | | 19 | | public sealed class PhysicsPartition2D : IVoxelPartition, IRetainedPhysicsPartition<GravitasCollision2DService> |
| | | 20 | | { |
| | | 21 | | private GravitasCollision2DService? _owner; |
| | 117269 | 22 | | private long _emptySinceFrame = -1; |
| | 117269 | 23 | | private int _retainedIndex = -1; |
| | | 24 | | |
| | | 25 | | /// <summary>Creates an inactive 2D physics partition.</summary> |
| | 117269 | 26 | | public PhysicsPartition2D() |
| | | 27 | | { |
| | 117269 | 28 | | ActivationId = -1; |
| | 117269 | 29 | | } |
| | | 30 | | |
| | | 31 | | /// <summary>Gets or sets the world voxel occupied by this partition.</summary> |
| | | 32 | | public WorldVoxelIndex WorldIndex { get; set; } |
| | | 33 | | |
| | | 34 | | /// <summary>Gets or sets whether this partition is attached to a voxel.</summary> |
| | | 35 | | public bool IsPartitioned { get; set; } |
| | | 36 | | |
| | | 37 | | /// <summary>Stores context-local dynamic collider IDs.</summary> |
| | | 38 | | internal SwiftHashSet<int>? ContainedDynamicObjects; |
| | | 39 | | |
| | | 40 | | /// <summary>Stores the awake subset of the dynamic collider IDs.</summary> |
| | | 41 | | internal SwiftHashSet<int>? ContainedAwakeDynamicObjects; |
| | | 42 | | |
| | | 43 | | /// <summary>Stores context-local kinematic collider IDs.</summary> |
| | | 44 | | internal SwiftHashSet<int>? ContainedKinematicObjects; |
| | | 45 | | |
| | | 46 | | /// <summary>Stores context-local static collider IDs.</summary> |
| | | 47 | | internal SwiftHashSet<int>? ContainedStaticObjects; |
| | | 48 | | |
| | | 49 | | /// <summary>Gets the active-partition slot, or <c>-1</c> when inactive.</summary> |
| | | 50 | | public int ActivationId { get; private set; } |
| | | 51 | | |
| | | 52 | | /// <summary>Gets whether this partition has an active-partition slot.</summary> |
| | 240596 | 53 | | public bool IsAllocated => ActivationId != -1; |
| | | 54 | | |
| | | 55 | | /// <summary>Gets the number of dynamic collider IDs, including sleeping bodies.</summary> |
| | 2013556 | 56 | | public int DynamicObjectCount => ContainedDynamicObjects?.Count ?? 0; |
| | | 57 | | |
| | | 58 | | /// <summary>Gets the number of kinematic collider IDs.</summary> |
| | 1462549 | 59 | | public int KinematicObjectCount => ContainedKinematicObjects?.Count ?? 0; |
| | | 60 | | |
| | | 61 | | /// <summary>Gets the number of static collider IDs.</summary> |
| | 1427393 | 62 | | public int StaticObjectCount => ContainedStaticObjects?.Count ?? 0; |
| | | 63 | | |
| | 2013501 | 64 | | internal bool IsEmpty => DynamicObjectCount == 0 && KinematicObjectCount == 0 && StaticObjectCount == 0; |
| | | 65 | | |
| | 185819 | 66 | | internal long EmptySinceFrame => _emptySinceFrame; |
| | | 67 | | |
| | 541567 | 68 | | internal int RetainedIndex => _retainedIndex; |
| | | 69 | | |
| | | 70 | | internal int EmptyIndex { get; set; } = -1; |
| | | 71 | | |
| | | 72 | | /// <summary>Gets the number of awake dynamic IDs in this partition.</summary> |
| | 124 | 73 | | public int AwakeDynamicObjectCount => ContainedAwakeDynamicObjects?.Count ?? 0; |
| | | 74 | | |
| | | 75 | | /// <summary>Gets the collision service that owns this partition.</summary> |
| | | 76 | | public GravitasCollision2DService Owner |
| | | 77 | | { |
| | | 78 | | get |
| | | 79 | | { |
| | 508637 | 80 | | ChronicleGuard.ThrowIfTrue( |
| | 508637 | 81 | | _owner == null, |
| | 508637 | 82 | | nameof(PhysicsPartition2D), |
| | 508637 | 83 | | "PhysicsPartition2D is missing its owner collision service."); |
| | 508635 | 84 | | return _owner!; |
| | | 85 | | } |
| | | 86 | | } |
| | | 87 | | |
| | | 88 | | /// <summary>Attaches this partition to a voxel.</summary> |
| | | 89 | | public void OnAddToVoxel(Voxel voxel) |
| | | 90 | | { |
| | 123849 | 91 | | ChronicleGuard.ThrowIfTrue( |
| | 123849 | 92 | | _owner == null, |
| | 123849 | 93 | | nameof(PhysicsPartition2D), |
| | 123849 | 94 | | "PhysicsPartition2D is missing its owner collision service."); |
| | 123849 | 95 | | WorldIndex = voxel.WorldIndex; |
| | 123849 | 96 | | IsPartitioned = true; |
| | 123849 | 97 | | } |
| | | 98 | | |
| | | 99 | | internal void Distribute( |
| | | 100 | | SwiftList<int> dynamicIds, |
| | | 101 | | SwiftList<int> staticIds) |
| | | 102 | | { |
| | 91731 | 103 | | int dynamicCount = ContainedDynamicObjects?.Count ?? 0; |
| | 91731 | 104 | | int awakeDynamicCount = ContainedAwakeDynamicObjects?.Count ?? 0; |
| | 91731 | 105 | | if (ContainedDynamicObjects == null || dynamicCount == 0 || ContainedAwakeDynamicObjects == null || awakeDynamic |
| | 8333 | 106 | | return; |
| | | 107 | | |
| | 83398 | 108 | | dynamicIds.FastClear(); |
| | 83398 | 109 | | CopyIds(ContainedDynamicObjects, dynamicIds); |
| | 83398 | 110 | | dynamicIds.SortInPlace(); |
| | 83398 | 111 | | CopyStaticStyleColliderIds(staticIds); |
| | | 112 | | |
| | 340208 | 113 | | for (int j = 0; j < dynamicIds.Count; j++) |
| | | 114 | | { |
| | 86706 | 115 | | int id1 = dynamicIds[j]; |
| | 181330 | 116 | | for (int k = j + 1; k < dynamicIds.Count; k++) |
| | 3959 | 117 | | Owner.Context.Physics2D.ProcessPartitionCandidate(id1, dynamicIds[k], WorldIndex); |
| | | 118 | | |
| | 218876 | 119 | | for (int k = 0; k < staticIds.Count; k++) |
| | 22732 | 120 | | Owner.Context.Physics2D.ProcessPartitionCandidate(id1, staticIds[k], WorldIndex); |
| | | 121 | | } |
| | 83398 | 122 | | } |
| | | 123 | | |
| | | 124 | | /// <summary>Clears and fills caller-owned storage with all collider IDs in ascending order.</summary> |
| | | 125 | | public void CopyAllColliderIds(SwiftList<int> destination) |
| | | 126 | | { |
| | 7 | 127 | | ChronicleGuard.ThrowIfNull(destination, nameof(destination)); |
| | 6 | 128 | | destination.FastClear(); |
| | 6 | 129 | | CopyIds(ContainedDynamicObjects, destination); |
| | 6 | 130 | | CopyIds(ContainedKinematicObjects, destination); |
| | 6 | 131 | | CopyIds(ContainedStaticObjects, destination); |
| | 6 | 132 | | destination.SortInPlace(); |
| | 6 | 133 | | } |
| | | 134 | | |
| | | 135 | | internal void CopyStaticStyleColliderIds(SwiftList<int> destination) |
| | | 136 | | { |
| | 83400 | 137 | | destination.FastClear(); |
| | 83400 | 138 | | CopyIds(ContainedKinematicObjects, destination); |
| | 83400 | 139 | | CopyIds(ContainedStaticObjects, destination); |
| | 83400 | 140 | | destination.SortInPlace(); |
| | 83400 | 141 | | } |
| | | 142 | | |
| | | 143 | | private static void CopyIds(SwiftHashSet<int>? source, SwiftList<int> destination) |
| | | 144 | | { |
| | 250216 | 145 | | if (source == null) |
| | 147291 | 146 | | return; |
| | | 147 | | |
| | 420384 | 148 | | foreach (int id in source) |
| | 107267 | 149 | | destination.Add(id); |
| | 102925 | 150 | | } |
| | | 151 | | |
| | | 152 | | /// <summary>Adds a dynamic collider ID to this partition.</summary> |
| | | 153 | | public void AddDynamicObject(int item) |
| | | 154 | | { |
| | 120907 | 155 | | ChronicleGuard.ThrowIfNegative(item, nameof(item)); |
| | 120906 | 156 | | ContainedDynamicObjects ??= new(); |
| | 120906 | 157 | | if (!ContainedDynamicObjects.Add(item)) |
| | 63929 | 158 | | return; |
| | | 159 | | |
| | 56977 | 160 | | MarkOccupied(); |
| | 56977 | 161 | | SetDynamicObjectAwake(item, IsDynamicObjectAwake(item)); |
| | | 162 | | |
| | 56977 | 163 | | if (ContainedDynamicObjects.Count == 1) |
| | 53329 | 164 | | ActivationId = Owner.ActivatePartition(this); |
| | 56977 | 165 | | } |
| | | 166 | | |
| | | 167 | | /// <summary>Adds a static collider ID to this partition.</summary> |
| | | 168 | | public void AddStaticObject(int item) |
| | | 169 | | { |
| | 79153 | 170 | | ChronicleGuard.ThrowIfNegative(item, nameof(item)); |
| | 79152 | 171 | | ContainedStaticObjects ??= new(); |
| | 79152 | 172 | | if (ContainedStaticObjects.Add(item)) |
| | 78678 | 173 | | MarkOccupied(); |
| | 79152 | 174 | | } |
| | | 175 | | |
| | | 176 | | /// <summary>Adds a kinematic collider ID to this partition.</summary> |
| | | 177 | | public void AddKinematicObject(int item) |
| | | 178 | | { |
| | 11651 | 179 | | ChronicleGuard.ThrowIfNegative(item, nameof(item)); |
| | 11650 | 180 | | ContainedKinematicObjects ??= new(); |
| | 11650 | 181 | | if (ContainedKinematicObjects.Add(item)) |
| | 10522 | 182 | | MarkOccupied(); |
| | 11650 | 183 | | } |
| | | 184 | | |
| | | 185 | | /// <summary>Removes a dynamic collider ID from this partition.</summary> |
| | | 186 | | public void RemoveDynamicObject(int item) |
| | | 187 | | { |
| | 10521 | 188 | | if (ContainedDynamicObjects?.Remove(item) != true) |
| | | 189 | | { |
| | 4 | 190 | | GravitasLogger.DebugChannel.Info($"2D dynamic item not removed - {item}"); |
| | 4 | 191 | | return; |
| | | 192 | | } |
| | | 193 | | |
| | 10517 | 194 | | ContainedAwakeDynamicObjects?.Remove(item); |
| | | 195 | | |
| | 10517 | 196 | | if (ContainedDynamicObjects.Count > 0) |
| | 1732 | 197 | | return; |
| | | 198 | | |
| | 8785 | 199 | | Owner.DeactivatePartition(ActivationId); |
| | 8785 | 200 | | ActivationId = -1; |
| | 8785 | 201 | | MarkEmptyIfUnoccupied(); |
| | 8785 | 202 | | } |
| | | 203 | | |
| | | 204 | | /// <summary>Removes a static collider ID from this partition.</summary> |
| | | 205 | | public void RemoveStaticObject(int item) |
| | | 206 | | { |
| | 4727 | 207 | | if (ContainedStaticObjects?.Remove(item) != true) |
| | | 208 | | { |
| | 5 | 209 | | GravitasLogger.DebugChannel.Info($"2D static item not removed - {item}"); |
| | 5 | 210 | | return; |
| | | 211 | | } |
| | | 212 | | |
| | 4722 | 213 | | MarkEmptyIfUnoccupied(); |
| | 4722 | 214 | | } |
| | | 215 | | |
| | | 216 | | /// <summary>Removes a kinematic collider ID from this partition.</summary> |
| | | 217 | | public void RemoveKinematicObject(int item) |
| | | 218 | | { |
| | 6906 | 219 | | if (ContainedKinematicObjects?.Remove(item) != true) |
| | | 220 | | { |
| | 5 | 221 | | GravitasLogger.DebugChannel.Info($"2D kinematic item not removed - {item}"); |
| | 5 | 222 | | return; |
| | | 223 | | } |
| | | 224 | | |
| | 6901 | 225 | | MarkEmptyIfUnoccupied(); |
| | 6901 | 226 | | } |
| | | 227 | | |
| | | 228 | | /// <summary>Returns whether a dynamic collider ID is marked awake.</summary> |
| | 16 | 229 | | public bool ContainsAwakeDynamicObject(int item) => ContainedAwakeDynamicObjects?.Contains(item) == true; |
| | | 230 | | |
| | | 231 | | /// <summary>Updates the awake state for a dynamic collider in this partition.</summary> |
| | | 232 | | public void SetDynamicObjectAwake(int item, bool awake) |
| | | 233 | | { |
| | 196689 | 234 | | if (ContainedDynamicObjects?.Contains(item) != true) |
| | 2 | 235 | | return; |
| | | 236 | | |
| | 196687 | 237 | | if (awake) |
| | | 238 | | { |
| | 188712 | 239 | | ContainedAwakeDynamicObjects ??= new(); |
| | 188712 | 240 | | ContainedAwakeDynamicObjects.Add(item); |
| | 188712 | 241 | | return; |
| | | 242 | | } |
| | | 243 | | |
| | 7975 | 244 | | ContainedAwakeDynamicObjects?.Remove(item); |
| | 7357 | 245 | | } |
| | | 246 | | |
| | | 247 | | private bool IsDynamicObjectAwake(int item) |
| | | 248 | | { |
| | 56977 | 249 | | if (!Owner.Context.Physics2D.TryGetColliderById(item, out LSCollider2D? collider)) |
| | 291 | 250 | | return true; |
| | | 251 | | |
| | 56686 | 252 | | SolidBody2D? body = collider!.Body; |
| | 56686 | 253 | | return body == null || body.IsAwakeForCollision; |
| | | 254 | | } |
| | | 255 | | |
| | | 256 | | /// <summary>Releases this partition when it is removed from a voxel.</summary> |
| | | 257 | | public void OnRemoveFromVoxel(Voxel voxel) |
| | | 258 | | { |
| | 123849 | 259 | | Owner.ReleasePartition(this); |
| | 123849 | 260 | | } |
| | | 261 | | |
| | | 262 | | internal void SetOwner(GravitasCollision2DService owner) |
| | | 263 | | { |
| | 123869 | 264 | | ChronicleGuard.ThrowIfNull(owner, nameof(owner)); |
| | 123869 | 265 | | ChronicleGuard.ThrowIfArgument( |
| | 123869 | 266 | | _owner != null && !ReferenceEquals(_owner, owner), |
| | 123869 | 267 | | nameof(owner), |
| | 123869 | 268 | | "PhysicsPartition2D is already owned by a different collision service."); |
| | | 269 | | |
| | 123868 | 270 | | _owner = owner; |
| | 123868 | 271 | | } |
| | | 272 | | |
| | 1749191 | 273 | | internal bool IsOwnedBy(GravitasCollision2DService owner) => ReferenceEquals(_owner, owner); |
| | | 274 | | |
| | | 275 | | [MethodImpl(MethodImplOptions.AggressiveInlining)] |
| | | 276 | | internal void SetRetainedIndex(int index) |
| | | 277 | | { |
| | 197825 | 278 | | ChronicleGuard.ThrowIfNegative(index, nameof(index)); |
| | 197825 | 279 | | _retainedIndex = index; |
| | 197825 | 280 | | } |
| | | 281 | | |
| | | 282 | | [MethodImpl(MethodImplOptions.AggressiveInlining)] |
| | 123855 | 283 | | internal void ClearRetainedIndex() => _retainedIndex = -1; |
| | | 284 | | |
| | | 285 | | internal void ResetRetainedMembership() |
| | | 286 | | { |
| | 6 | 287 | | ContainedDynamicObjects?.Clear(); |
| | 6 | 288 | | ContainedAwakeDynamicObjects?.Clear(); |
| | 6 | 289 | | ContainedKinematicObjects?.Clear(); |
| | 6 | 290 | | ContainedStaticObjects?.Clear(); |
| | 6 | 291 | | ActivationId = -1; |
| | 6 | 292 | | MarkEmpty(_owner?.Context.FrameCount ?? 0); |
| | 6 | 293 | | } |
| | | 294 | | |
| | | 295 | | internal void ResetForPool() |
| | | 296 | | { |
| | 123858 | 297 | | ContainedDynamicObjects?.Clear(); |
| | 123858 | 298 | | ContainedAwakeDynamicObjects?.Clear(); |
| | 123858 | 299 | | ContainedKinematicObjects?.Clear(); |
| | 123858 | 300 | | ContainedStaticObjects?.Clear(); |
| | | 301 | | |
| | 123858 | 302 | | if (ActivationId != -1) |
| | 44540 | 303 | | Owner.DeactivatePartition(ActivationId); |
| | | 304 | | |
| | 123858 | 305 | | _owner = null; |
| | 123858 | 306 | | ActivationId = -1; |
| | 123858 | 307 | | IsPartitioned = false; |
| | 123858 | 308 | | _emptySinceFrame = -1; |
| | 123858 | 309 | | _retainedIndex = -1; |
| | 123858 | 310 | | EmptyIndex = -1; |
| | 123858 | 311 | | } |
| | | 312 | | |
| | | 313 | | [MethodImpl(MethodImplOptions.AggressiveInlining)] |
| | | 314 | | private void MarkOccupied() |
| | | 315 | | { |
| | 146177 | 316 | | _emptySinceFrame = -1; |
| | 146177 | 317 | | _owner?.RefreshRetainedPartitionEligibility(this); |
| | 146174 | 318 | | } |
| | | 319 | | |
| | | 320 | | [MethodImpl(MethodImplOptions.AggressiveInlining)] |
| | | 321 | | private void MarkEmptyIfUnoccupied() |
| | | 322 | | { |
| | 20408 | 323 | | if (IsEmpty) |
| | 17279 | 324 | | MarkEmpty(Owner.Context.FrameCount); |
| | 20408 | 325 | | } |
| | | 326 | | |
| | | 327 | | [MethodImpl(MethodImplOptions.AggressiveInlining)] |
| | | 328 | | private void MarkEmpty(long frame) |
| | | 329 | | { |
| | 17285 | 330 | | _emptySinceFrame = frame; |
| | 17285 | 331 | | _owner?.RefreshRetainedPartitionEligibility(this); |
| | 17282 | 332 | | } |
| | | 333 | | |
| | | 334 | | /// <summary>Updates the world voxel index used by this partition.</summary> |
| | 123849 | 335 | | public void SetParentIndex(WorldVoxelIndex parentIndex) => WorldIndex = parentIndex; |
| | | 336 | | |
| | 541566 | 337 | | int IRetainedPhysicsPartition<GravitasCollision2DService>.RetainedIndex => RetainedIndex; |
| | | 338 | | |
| | | 339 | | int IRetainedPhysicsPartition<GravitasCollision2DService>.EmptyIndex |
| | | 340 | | { |
| | 411169 | 341 | | get => EmptyIndex; |
| | 423335 | 342 | | set => EmptyIndex = value; |
| | | 343 | | } |
| | | 344 | | |
| | 1746401 | 345 | | bool IRetainedPhysicsPartition<GravitasCollision2DService>.IsEmpty => IsEmpty; |
| | | 346 | | |
| | 185810 | 347 | | long IRetainedPhysicsPartition<GravitasCollision2DService>.EmptySinceFrame => EmptySinceFrame; |
| | | 348 | | |
| | 1749191 | 349 | | bool IRetainedPhysicsPartition<GravitasCollision2DService>.IsOwnedBy(GravitasCollision2DService owner) => IsOwnedBy( |
| | | 350 | | |
| | 197825 | 351 | | void IRetainedPhysicsPartition<GravitasCollision2DService>.SetRetainedIndex(int index) => SetRetainedIndex(index); |
| | | 352 | | |
| | 123855 | 353 | | void IRetainedPhysicsPartition<GravitasCollision2DService>.ClearRetainedIndex() => ClearRetainedIndex(); |
| | | 354 | | } |