< Summary

Line coverage
100%
Covered lines: 1641
Uncovered lines: 0
Coverable lines: 1641
Total lines: 3493
Line coverage: 100%
Branch coverage
100%
Covered branches: 434
Total branches: 434
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: RaycastBatch(...)100%44100%
File 1: RaycastAllBatch(...)100%22100%
File 1: SweepSphereBatch(...)100%22100%
File 1: SweepSphereAllBatch(...)100%22100%
File 1: SweepCapsuleBatch(...)100%22100%
File 1: SweepCapsuleAllBatch(...)100%22100%
File 1: SweepCuboidBatch(...)100%22100%
File 1: SweepCuboidAllBatch(...)100%22100%
File 1: SweepCylinderBatch(...)100%22100%
File 1: SweepCylinderAllBatch(...)100%22100%
File 1: SweepConeBatch(...)100%22100%
File 1: SweepConeAllBatch(...)100%22100%
File 1: SweepConvexMeshBatch(...)100%22100%
File 1: SweepConvexMeshAllBatch(...)100%22100%
File 1: SweepCompoundBatch(...)100%22100%
File 1: SweepCompoundAllBatch(...)100%22100%
File 1: OverlapCircleBatch(...)100%22100%
File 1: OverlapCircleAllBatch(...)100%22100%
File 1: OverlapConeBatch(...)100%22100%
File 1: OverlapConeAllBatch(...)100%22100%
File 1: OverlapCircleInDirectionBatch(...)100%22100%
File 1: TryRaycastBatchRequest(...)100%66100%
File 1: RaycastAllBatchRequest(...)100%66100%
File 1: SweepSphereAllBatchRequest(...)100%88100%
File 1: TrySweepSourceBatchRequest(...)100%44100%
File 1: SweepSourceAllBatchRequest(...)100%44100%
File 1: PrepareBatchConvexSweepSource(...)100%44100%
File 1: TryOverlapCircleBatchRequest(...)100%11100%
File 1: OverlapCircleAllBatchRequest(...)100%11100%
File 1: TryOverlapCircleInDirectionBatchRequest(...)100%22100%
File 1: TryOverlapConeBatchRequest(...)100%11100%
File 1: ValidateOverlapCircleRequests(...)100%22100%
File 1: ValidateOverlapCircleRequests(...)100%22100%
File 1: ValidateSweepSphereRequests(...)100%22100%
File 1: ValidateOverlapConeEnvelopes(...)100%66100%
File 1: OverlapConeAllBatchRequest(...)100%11100%
File 1: WriteClosestHit(...)100%22100%
File 1: AppendRange(...)100%22100%
File 1: ResetBatchCounters(...)100%11100%
File 1: AccumulateBatchCounters(...)100%11100%
File 1: ValidateClosestBatchOutput(...)100%11100%
File 1: ValidateRangeBatchOutput(...)100%11100%
File 2: OverlapCircle(...)100%11100%
File 2: OverlapCircleInDirection(...)100%11100%
File 2: OverlapCircleAll(...)100%22100%
File 2: OverlapSphereAgainstStaticAll(...)100%66100%
File 2: ProcessPartitionForAllSphereHits(...)100%11100%
File 2: ProcessColliderListForAllSphereHits(...)100%66100%
File 2: TryBuildOverlapSphereHit(...)100%2222100%
File 2: TraceCircleForClosestHit(...)100%66100%
File 2: TraceCircleForDirectionalHit(...)100%1414100%
File 2: TraceCircleForAllHits(...)100%44100%
File 2: GetPlanarCircleCandidates(...)100%11100%
File 2: TryBuildOverlapHit(...)100%22100%
File 2: TryBuildPlanarOverlapHit(...)100%22100%
File 2: TryBuildSurfaceOverlapHit(...)100%1010100%
File 2: GetClosestSurfacePoint(...)100%44100%
File 3: OverlapCone(...)100%11100%
File 3: OverlapConeAll(...)100%22100%
File 3: TraceConeForClosestHit(...)100%44100%
File 3: TraceConeForAllHits(...)100%44100%
File 3: ProcessConePartitionForClosestHit(...)100%11100%
File 3: ProcessConePartitionForAllHits(...)100%11100%
File 3: ProcessConeColliderListForClosestHit(...)100%88100%
File 3: ProcessConeColliderListForAllHits(...)100%66100%
File 3: TryBuildOverlapConeHit(...)100%88100%
File 3: TryBuildConeHitForCollider(...)100%1818100%
File 3: TryBuildConeHitForConcaveMesh(...)100%1212100%
File 3: TryBuildConeHitForCompound(...)100%88100%
File 3: IsPointInsideConeVolume(...)100%22100%
File 3: GetClosestPointOnConeAxis(...)100%11100%
File 3: GetConeQueryBounds(...)100%11100%
File 3: ValidateConeQuery(...)100%11100%
File 4: .ctor(...)100%11100%
File 4: get_Context()100%11100%
File 4: Reset()100%11100%
File 4: Raycast(...)100%66100%
File 4: RaycastAll(...)100%88100%
File 4: SweepSphere(...)100%66100%
File 4: SweepSphereAll(...)100%11100%
File 4: SweepSphereAgainstStaticAll(...)100%11100%
File 4: SweepExactSourceAgainstStaticAll(...)100%11100%
File 4: SweepCapsule(...)100%11100%
File 4: SweepCapsuleAll(...)100%11100%
File 4: SweepCuboid(...)100%11100%
File 4: SweepCuboidAll(...)100%11100%
File 4: SweepCylinder(...)100%11100%
File 4: SweepCylinderAll(...)100%11100%
File 4: SweepCone(...)100%11100%
File 4: SweepConeAll(...)100%11100%
File 4: SweepConvexMesh(...)100%11100%
File 4: SweepConvexMeshAll(...)100%11100%
File 4: SweepCompound(...)100%11100%
File 4: SweepCompoundAll(...)100%11100%
File 4: SweepSphereAllCore(...)100%1212100%
File 4: SweepRegisteredSource(...)100%44100%
File 4: SweepRegisteredSourceAll(...)100%66100%
File 4: EndQuery()100%11100%
File 4: BeginConvexSweepTrace(...)100%11100%
File 4: BeginRaycastTrace(...)100%11100%
File 4: BeginSweepTrace(...)100%11100%
File 4: SweepSphere(...)100%88100%
File 4: TryFindClosestSweepHit(...)100%11100%
File 4: TryFindClosestHit(...)100%11100%
File 4: AddAllHits(...)100%11100%
File 4: AddAllSweepHits(...)100%11100%
File 4: TryFindClosestConvexSweepHit(...)100%11100%
File 4: AddAllConvexSweepHits(...)100%11100%
File 4: TryBuildHitForCollider(...)100%44100%
File 4: TryBuildSweepHitForCollider(...)100%44100%
File 4: TryBuildConvexSweepHitForCollider(...)100%88100%
File 4: TryBuildHit(...)100%66100%
File 4: TryBuildSweepHit(...)100%22100%
File 4: ResetLastQueryCounters()100%11100%
File 4: NextRaycastVersion()100%22100%
File 4: NextCircleVersion()100%22100%
File 4: ResetColliderRaycastVersions()100%22100%
File 4: ResetColliderCircleVersions()100%22100%
File 4: DoesCurrentColliderIntersectRay(...)100%66100%
File 4: IsSweepCandidate(...)100%2020100%
File 4: IsExcludedByCurrentSweepSource(...)100%66100%
File 4: EnsureSourceBelongsToContext(...)100%11100%
File 4: PrepareConvexSweepSource(...)100%44100%
File 4: IsStaticStyleSweepTarget(...)100%22100%
File 5: TraceLineForClosestHit(...)100%22100%
File 5: TraceLineForAllHits(...)100%22100%
File 5: TraceSweepForClosestHit(...)100%22100%
File 5: TraceSweepForAllHits(...)100%22100%
File 5: TraceConvexSweepForClosestHit(...)100%22100%
File 5: TraceConvexSweepForAllHits(...)100%22100%
File 5: PrepareSweepBounds(...)100%11100%
File 5: PrepareConvexSweepBounds(...)100%11100%
File 5: ProcessTraceVoxelForClosestHit(...)100%22100%
File 5: ProcessTraceVoxelForAllHits(...)100%22100%
File 5: ProcessSweepVoxelForClosestHit(...)100%22100%
File 5: ProcessSweepVoxelForAllHits(...)100%22100%
File 5: ProcessConvexSweepVoxelForClosestHit(...)100%22100%
File 5: ProcessConvexSweepVoxelForAllHits(...)100%22100%
File 5: ProcessPartitionForClosestHit(...)100%11100%
File 5: ProcessColliderListForClosestHit(...)100%88100%
File 5: ProcessPartitionForAllHits(...)100%11100%
File 5: ProcessColliderListForAllHits(...)100%66100%
File 5: ProcessPartitionForClosestSweepHit(...)100%11100%
File 5: ProcessColliderListForClosestSweepHit(...)100%88100%
File 5: ProcessPartitionForAllSweepHits(...)100%22100%
File 5: ProcessPartitionForClosestConvexSweepHit(...)100%11100%
File 5: ProcessPartitionForAllConvexSweepHits(...)100%22100%
File 5: ProcessColliderListForAllSweepHits(...)100%66100%
File 5: ProcessColliderListForClosestConvexSweepHit(...)100%88100%
File 5: ProcessColliderListForAllConvexSweepHits(...)100%66100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/3D/GravitasQuery3DService.Batch.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQuery3DService.Batch.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.Support;
 12using SwiftCollections;
 13
 14namespace Gravitas.Queries;
 15
 16/// <content>
 17/// Owns batched 3D query behavior for one <see cref="GravitasWorldContext"/>.
 18/// </content>
 19public sealed partial class GravitasQuery3DService
 20{
 1019121    private readonly SwiftList<Physics3DHit> _batch3DHits = new();
 22
 23    /// <summary>
 24    /// Gets the number of requests processed by the last 3D batch query call.
 25    /// </summary>
 26    public int LastBatchRequestCount { get; private set; }
 27
 28    /// <summary>
 29    /// Gets the number of hits accepted by the last 3D batch query call.
 30    /// </summary>
 31    public int LastBatchHitCount { get; private set; }
 32
 33    /// <summary>
 34    /// Gets the summed candidate count reported by the last 3D batch query call.
 35    /// </summary>
 36    public int LastBatchCandidateCount { get; private set; }
 37
 38    /// <summary>
 39    /// Executes multiple 3D segment raycasts and writes one closest-hit slot per request.
 40    /// </summary>
 41    /// <returns>The number of requests that produced a hit.</returns>
 42    public int RaycastBatch(ReadOnlySpan<PhysicsRaycast3DRequest> requests, Span<Physics3DHit> closestHits)
 43    {
 21544        ValidateClosestBatchOutput(requests.Length, closestHits);
 21445        ResetBatchCounters(requests.Length);
 46
 21447        int hitCount = 0;
 127848        for (int i = 0; i < requests.Length; i++)
 49        {
 42550            PhysicsRaycast3DRequest request = requests[i];
 42551            bool found = TryRaycastBatchRequest(request, out Physics3DHit hit);
 42552            if (found)
 53            {
 21454                closestHits[i] = hit;
 21455                hitCount++;
 56            }
 57            else
 58            {
 21159                closestHits[i] = default;
 60            }
 61
 42562            AccumulateBatchCounters(found ? 1 : 0);
 63        }
 64
 21465        LastBatchHitCount = hitCount;
 21466        return hitCount;
 67    }
 68
 69    /// <summary>
 70    /// Executes multiple 3D segment raycasts and appends all hits into one caller-owned hit buffer.
 71    /// </summary>
 72    /// <returns>The number of hits written to <paramref name="hits"/>.</returns>
 73    public int RaycastAllBatch(
 74        ReadOnlySpan<PhysicsRaycast3DRequest> requests,
 75        SwiftList<Physics3DHit> hits,
 76        Span<PhysicsQueryHitRange> ranges)
 77    {
 21778        ChronicleGuard.ThrowIfNull(hits, nameof(hits));
 21779        ValidateRangeBatchOutput(requests.Length, ranges);
 21780        ResetBatchCounters(requests.Length);
 21781        hits.Clear();
 82
 129683        for (int i = 0; i < requests.Length; i++)
 84        {
 85            try
 86            {
 43187                PhysicsRaycast3DRequest request = requests[i];
 43188                int count = RaycastAllBatchRequest(request, _batch3DHits);
 43189                AppendRange(hits, ranges, i, count);
 43190            }
 91            finally
 92            {
 43193                _batch3DHits.Clear();
 43194            }
 95        }
 96
 21797        LastBatchHitCount = hits.Count;
 21798        return hits.Count;
 99    }
 100
 101    /// <summary>
 102    /// Executes multiple 3D swept-sphere queries and writes one closest-hit slot per request.
 103    /// </summary>
 104    public int SweepSphereBatch(ReadOnlySpan<PhysicsSweepSphere3DRequest> requests, Span<Physics3DHit> closestHits)
 105    {
 5106        ValidateClosestBatchOutput(requests.Length, closestHits);
 5107        ValidateSweepSphereRequests(requests);
 4108        ResetBatchCounters(requests.Length);
 109
 4110        int hitCount = 0;
 24111        for (int i = 0; i < requests.Length; i++)
 112        {
 8113            PhysicsSweepSphere3DRequest request = requests[i];
 8114            bool found = SweepSphere(
 8115                request.Start,
 8116                request.End,
 8117                request.Radius,
 8118                request.LayerMask,
 8119                request.ExcludedCollider,
 8120                out Physics3DHit hit);
 8121            WriteClosestHit(closestHits, i, hit, found, ref hitCount);
 122        }
 123
 4124        LastBatchHitCount = hitCount;
 4125        return hitCount;
 126    }
 127
 128    /// <summary>
 129    /// Executes multiple 3D swept-sphere queries and appends all hits into one caller-owned hit buffer.
 130    /// </summary>
 131    public int SweepSphereAllBatch(
 132        ReadOnlySpan<PhysicsSweepSphere3DRequest> requests,
 133        SwiftList<Physics3DHit> hits,
 134        Span<PhysicsQueryHitRange> ranges)
 135    {
 5136        ChronicleGuard.ThrowIfNull(hits, nameof(hits));
 5137        ValidateRangeBatchOutput(requests.Length, ranges);
 5138        ValidateSweepSphereRequests(requests);
 4139        ResetBatchCounters(requests.Length);
 4140        hits.Clear();
 141
 24142        for (int i = 0; i < requests.Length; i++)
 143        {
 144            try
 145            {
 8146                PhysicsSweepSphere3DRequest request = requests[i];
 8147                int count = SweepSphereAllBatchRequest(request, _batch3DHits);
 8148                AppendRange(hits, ranges, i, count);
 8149            }
 150            finally
 151            {
 8152                _batch3DHits.Clear();
 8153            }
 154        }
 155
 4156        LastBatchHitCount = hits.Count;
 4157        return hits.Count;
 158    }
 159
 160    /// <summary>
 161    /// Executes multiple registered capsule-source sweeps and writes one closest-hit slot per request.
 162    /// </summary>
 163    public int SweepCapsuleBatch(ReadOnlySpan<PhysicsSweepCapsule3DRequest> requests, Span<Physics3DHit> closestHits)
 164    {
 1165        ValidateClosestBatchOutput(requests.Length, closestHits);
 1166        ResetBatchCounters(requests.Length);
 167
 168        try
 169        {
 1170            int hitCount = 0;
 1171            LSCollider? preparedSource = null;
 1172            Vector3d preparedDisplacement = default;
 6173            for (int i = 0; i < requests.Length; i++)
 174            {
 2175                PhysicsSweepCapsule3DRequest request = requests[i];
 2176                bool found = TrySweepSourceBatchRequest(
 2177                    request.Source,
 2178                    request.Displacement,
 2179                    request.LayerMask,
 2180                    request.ExcludedCollider,
 2181                    request.IncludeTriggers,
 2182                    ref preparedSource,
 2183                    ref preparedDisplacement,
 2184                    out Physics3DHit hit);
 2185                WriteClosestHit(closestHits, i, hit, found, ref hitCount);
 186            }
 187
 1188            LastBatchHitCount = hitCount;
 1189            return hitCount;
 190        }
 191        finally
 192        {
 1193            EndQuery();
 1194        }
 1195    }
 196
 197    /// <summary>
 198    /// Executes multiple registered capsule-source sweeps and appends all hits into one caller-owned hit buffer.
 199    /// </summary>
 200    public int SweepCapsuleAllBatch(
 201        ReadOnlySpan<PhysicsSweepCapsule3DRequest> requests,
 202        SwiftList<Physics3DHit> hits,
 203        Span<PhysicsQueryHitRange> ranges)
 204    {
 1205        ChronicleGuard.ThrowIfNull(hits, nameof(hits));
 1206        ValidateRangeBatchOutput(requests.Length, ranges);
 1207        ResetBatchCounters(requests.Length);
 1208        hits.Clear();
 209
 210        try
 211        {
 1212            LSCollider? preparedSource = null;
 1213            Vector3d preparedDisplacement = default;
 6214            for (int i = 0; i < requests.Length; i++)
 215            {
 216                try
 217                {
 2218                    PhysicsSweepCapsule3DRequest request = requests[i];
 2219                    int count = SweepSourceAllBatchRequest(
 2220                        request.Source,
 2221                        request.Displacement,
 2222                        request.LayerMask,
 2223                        request.ExcludedCollider,
 2224                        request.IncludeTriggers,
 2225                        ref preparedSource,
 2226                        ref preparedDisplacement,
 2227                        _batch3DHits);
 2228                    AppendRange(hits, ranges, i, count);
 2229                }
 230                finally
 231                {
 2232                    _batch3DHits.Clear();
 2233                }
 234            }
 235
 1236            LastBatchHitCount = hits.Count;
 1237            return hits.Count;
 238        }
 239        finally
 240        {
 1241            EndQuery();
 1242        }
 1243    }
 244
 245    /// <summary>
 246    /// Executes multiple registered cuboid-source sweeps and writes one closest-hit slot per request.
 247    /// </summary>
 248    public int SweepCuboidBatch(ReadOnlySpan<PhysicsSweepCuboid3DRequest> requests, Span<Physics3DHit> closestHits)
 249    {
 5250        ValidateClosestBatchOutput(requests.Length, closestHits);
 5251        ResetBatchCounters(requests.Length);
 252
 253        try
 254        {
 5255            int hitCount = 0;
 5256            LSCollider? preparedSource = null;
 5257            Vector3d preparedDisplacement = default;
 28258            for (int i = 0; i < requests.Length; i++)
 259            {
 10260                PhysicsSweepCuboid3DRequest request = requests[i];
 10261                bool found = TrySweepSourceBatchRequest(
 10262                    request.Source,
 10263                    request.Displacement,
 10264                    request.LayerMask,
 10265                    request.ExcludedCollider,
 10266                    request.IncludeTriggers,
 10267                    ref preparedSource,
 10268                    ref preparedDisplacement,
 10269                    out Physics3DHit hit);
 9270                WriteClosestHit(closestHits, i, hit, found, ref hitCount);
 271            }
 272
 4273            LastBatchHitCount = hitCount;
 4274            return hitCount;
 275        }
 276        finally
 277        {
 5278            EndQuery();
 5279        }
 4280    }
 281
 282    /// <summary>
 283    /// Executes multiple registered cuboid-source sweeps and appends all hits into one caller-owned hit buffer.
 284    /// </summary>
 285    public int SweepCuboidAllBatch(
 286        ReadOnlySpan<PhysicsSweepCuboid3DRequest> requests,
 287        SwiftList<Physics3DHit> hits,
 288        Span<PhysicsQueryHitRange> ranges)
 289    {
 5290        ChronicleGuard.ThrowIfNull(hits, nameof(hits));
 5291        ValidateRangeBatchOutput(requests.Length, ranges);
 5292        ResetBatchCounters(requests.Length);
 5293        hits.Clear();
 294
 295        try
 296        {
 5297            LSCollider? preparedSource = null;
 5298            Vector3d preparedDisplacement = default;
 28299            for (int i = 0; i < requests.Length; i++)
 300            {
 301                try
 302                {
 10303                    PhysicsSweepCuboid3DRequest request = requests[i];
 10304                    int count = SweepSourceAllBatchRequest(
 10305                        request.Source,
 10306                        request.Displacement,
 10307                        request.LayerMask,
 10308                        request.ExcludedCollider,
 10309                        request.IncludeTriggers,
 10310                        ref preparedSource,
 10311                        ref preparedDisplacement,
 10312                        _batch3DHits);
 9313                    AppendRange(hits, ranges, i, count);
 9314                }
 315                finally
 316                {
 10317                    _batch3DHits.Clear();
 10318                }
 319            }
 320
 4321            LastBatchHitCount = hits.Count;
 4322            return hits.Count;
 323        }
 324        finally
 325        {
 5326            EndQuery();
 5327        }
 4328    }
 329
 330    /// <summary>
 331    /// Executes multiple registered cylinder-source sweeps and writes one closest-hit slot per request.
 332    /// </summary>
 333    public int SweepCylinderBatch(ReadOnlySpan<PhysicsSweepCylinder3DRequest> requests, Span<Physics3DHit> closestHits)
 334    {
 1335        ValidateClosestBatchOutput(requests.Length, closestHits);
 1336        ResetBatchCounters(requests.Length);
 337
 338        try
 339        {
 1340            int hitCount = 0;
 1341            LSCollider? preparedSource = null;
 1342            Vector3d preparedDisplacement = default;
 6343            for (int i = 0; i < requests.Length; i++)
 344            {
 2345                PhysicsSweepCylinder3DRequest request = requests[i];
 2346                bool found = TrySweepSourceBatchRequest(
 2347                    request.Source,
 2348                    request.Displacement,
 2349                    request.LayerMask,
 2350                    request.ExcludedCollider,
 2351                    request.IncludeTriggers,
 2352                    ref preparedSource,
 2353                    ref preparedDisplacement,
 2354                    out Physics3DHit hit);
 2355                WriteClosestHit(closestHits, i, hit, found, ref hitCount);
 356            }
 357
 1358            LastBatchHitCount = hitCount;
 1359            return hitCount;
 360        }
 361        finally
 362        {
 1363            EndQuery();
 1364        }
 1365    }
 366
 367    /// <summary>
 368    /// Executes multiple registered cylinder-source sweeps and appends all hits into one caller-owned hit buffer.
 369    /// </summary>
 370    public int SweepCylinderAllBatch(
 371        ReadOnlySpan<PhysicsSweepCylinder3DRequest> requests,
 372        SwiftList<Physics3DHit> hits,
 373        Span<PhysicsQueryHitRange> ranges)
 374    {
 1375        ChronicleGuard.ThrowIfNull(hits, nameof(hits));
 1376        ValidateRangeBatchOutput(requests.Length, ranges);
 1377        ResetBatchCounters(requests.Length);
 1378        hits.Clear();
 379
 380        try
 381        {
 1382            LSCollider? preparedSource = null;
 1383            Vector3d preparedDisplacement = default;
 6384            for (int i = 0; i < requests.Length; i++)
 385            {
 386                try
 387                {
 2388                    PhysicsSweepCylinder3DRequest request = requests[i];
 2389                    int count = SweepSourceAllBatchRequest(
 2390                        request.Source,
 2391                        request.Displacement,
 2392                        request.LayerMask,
 2393                        request.ExcludedCollider,
 2394                        request.IncludeTriggers,
 2395                        ref preparedSource,
 2396                        ref preparedDisplacement,
 2397                        _batch3DHits);
 2398                    AppendRange(hits, ranges, i, count);
 2399                }
 400                finally
 401                {
 2402                    _batch3DHits.Clear();
 2403                }
 404            }
 405
 1406            LastBatchHitCount = hits.Count;
 1407            return hits.Count;
 408        }
 409        finally
 410        {
 1411            EndQuery();
 1412        }
 1413    }
 414
 415    /// <summary>
 416    /// Executes multiple registered cone-source sweeps and writes one closest-hit slot per request.
 417    /// </summary>
 418    public int SweepConeBatch(ReadOnlySpan<PhysicsSweepCone3DRequest> requests, Span<Physics3DHit> closestHits)
 419    {
 1420        ValidateClosestBatchOutput(requests.Length, closestHits);
 1421        ResetBatchCounters(requests.Length);
 422
 423        try
 424        {
 1425            int hitCount = 0;
 1426            LSCollider? preparedSource = null;
 1427            Vector3d preparedDisplacement = default;
 6428            for (int i = 0; i < requests.Length; i++)
 429            {
 2430                PhysicsSweepCone3DRequest request = requests[i];
 2431                bool found = TrySweepSourceBatchRequest(
 2432                    request.Source,
 2433                    request.Displacement,
 2434                    request.LayerMask,
 2435                    request.ExcludedCollider,
 2436                    request.IncludeTriggers,
 2437                    ref preparedSource,
 2438                    ref preparedDisplacement,
 2439                    out Physics3DHit hit);
 2440                WriteClosestHit(closestHits, i, hit, found, ref hitCount);
 441            }
 442
 1443            LastBatchHitCount = hitCount;
 1444            return hitCount;
 445        }
 446        finally
 447        {
 1448            EndQuery();
 1449        }
 1450    }
 451
 452    /// <summary>
 453    /// Executes multiple registered cone-source sweeps and appends all hits into one caller-owned hit buffer.
 454    /// </summary>
 455    public int SweepConeAllBatch(
 456        ReadOnlySpan<PhysicsSweepCone3DRequest> requests,
 457        SwiftList<Physics3DHit> hits,
 458        Span<PhysicsQueryHitRange> ranges)
 459    {
 1460        ChronicleGuard.ThrowIfNull(hits, nameof(hits));
 1461        ValidateRangeBatchOutput(requests.Length, ranges);
 1462        ResetBatchCounters(requests.Length);
 1463        hits.Clear();
 464
 465        try
 466        {
 1467            LSCollider? preparedSource = null;
 1468            Vector3d preparedDisplacement = default;
 6469            for (int i = 0; i < requests.Length; i++)
 470            {
 471                try
 472                {
 2473                    PhysicsSweepCone3DRequest request = requests[i];
 2474                    int count = SweepSourceAllBatchRequest(
 2475                        request.Source,
 2476                        request.Displacement,
 2477                        request.LayerMask,
 2478                        request.ExcludedCollider,
 2479                        request.IncludeTriggers,
 2480                        ref preparedSource,
 2481                        ref preparedDisplacement,
 2482                        _batch3DHits);
 2483                    AppendRange(hits, ranges, i, count);
 2484                }
 485                finally
 486                {
 2487                    _batch3DHits.Clear();
 2488                }
 489            }
 490
 1491            LastBatchHitCount = hits.Count;
 1492            return hits.Count;
 493        }
 494        finally
 495        {
 1496            EndQuery();
 1497        }
 1498    }
 499
 500    /// <summary>
 501    /// Executes multiple registered convex mesh-source sweeps and writes one closest-hit slot per request.
 502    /// </summary>
 503    public int SweepConvexMeshBatch(ReadOnlySpan<PhysicsSweepConvexMesh3DRequest> requests, Span<Physics3DHit> closestHi
 504    {
 1505        ValidateClosestBatchOutput(requests.Length, closestHits);
 1506        ResetBatchCounters(requests.Length);
 507
 508        try
 509        {
 1510            int hitCount = 0;
 1511            LSCollider? preparedSource = null;
 1512            Vector3d preparedDisplacement = default;
 6513            for (int i = 0; i < requests.Length; i++)
 514            {
 2515                PhysicsSweepConvexMesh3DRequest request = requests[i];
 2516                bool found = TrySweepSourceBatchRequest(
 2517                    request.Source,
 2518                    request.Displacement,
 2519                    request.LayerMask,
 2520                    request.ExcludedCollider,
 2521                    request.IncludeTriggers,
 2522                    ref preparedSource,
 2523                    ref preparedDisplacement,
 2524                    out Physics3DHit hit);
 2525                WriteClosestHit(closestHits, i, hit, found, ref hitCount);
 526            }
 527
 1528            LastBatchHitCount = hitCount;
 1529            return hitCount;
 530        }
 531        finally
 532        {
 1533            EndQuery();
 1534        }
 1535    }
 536
 537    /// <summary>
 538    /// Executes multiple registered convex mesh-source sweeps and appends all hits into one caller-owned hit buffer.
 539    /// </summary>
 540    public int SweepConvexMeshAllBatch(
 541        ReadOnlySpan<PhysicsSweepConvexMesh3DRequest> requests,
 542        SwiftList<Physics3DHit> hits,
 543        Span<PhysicsQueryHitRange> ranges)
 544    {
 1545        ChronicleGuard.ThrowIfNull(hits, nameof(hits));
 1546        ValidateRangeBatchOutput(requests.Length, ranges);
 1547        ResetBatchCounters(requests.Length);
 1548        hits.Clear();
 549
 550        try
 551        {
 1552            LSCollider? preparedSource = null;
 1553            Vector3d preparedDisplacement = default;
 6554            for (int i = 0; i < requests.Length; i++)
 555            {
 556                try
 557                {
 2558                    PhysicsSweepConvexMesh3DRequest request = requests[i];
 2559                    int count = SweepSourceAllBatchRequest(
 2560                        request.Source,
 2561                        request.Displacement,
 2562                        request.LayerMask,
 2563                        request.ExcludedCollider,
 2564                        request.IncludeTriggers,
 2565                        ref preparedSource,
 2566                        ref preparedDisplacement,
 2567                        _batch3DHits);
 2568                    AppendRange(hits, ranges, i, count);
 2569                }
 570                finally
 571                {
 2572                    _batch3DHits.Clear();
 2573                }
 574            }
 575
 1576            LastBatchHitCount = hits.Count;
 1577            return hits.Count;
 578        }
 579        finally
 580        {
 1581            EndQuery();
 1582        }
 1583    }
 584
 585    /// <summary>
 586    /// Executes multiple registered compound-source sweeps and writes one closest-hit slot per request.
 587    /// </summary>
 588    public int SweepCompoundBatch(ReadOnlySpan<PhysicsSweepCompound3DRequest> requests, Span<Physics3DHit> closestHits)
 589    {
 1590        ValidateClosestBatchOutput(requests.Length, closestHits);
 1591        ResetBatchCounters(requests.Length);
 592
 593        try
 594        {
 1595            int hitCount = 0;
 1596            LSCollider? preparedSource = null;
 1597            Vector3d preparedDisplacement = default;
 6598            for (int i = 0; i < requests.Length; i++)
 599            {
 2600                PhysicsSweepCompound3DRequest request = requests[i];
 2601                bool found = TrySweepSourceBatchRequest(
 2602                    request.Source,
 2603                    request.Displacement,
 2604                    request.LayerMask,
 2605                    request.ExcludedCollider,
 2606                    request.IncludeTriggers,
 2607                    ref preparedSource,
 2608                    ref preparedDisplacement,
 2609                    out Physics3DHit hit);
 2610                WriteClosestHit(closestHits, i, hit, found, ref hitCount);
 611            }
 612
 1613            LastBatchHitCount = hitCount;
 1614            return hitCount;
 615        }
 616        finally
 617        {
 1618            EndQuery();
 1619        }
 1620    }
 621
 622    /// <summary>
 623    /// Executes multiple registered compound-source sweeps and appends all hits into one caller-owned hit buffer.
 624    /// </summary>
 625    public int SweepCompoundAllBatch(
 626        ReadOnlySpan<PhysicsSweepCompound3DRequest> requests,
 627        SwiftList<Physics3DHit> hits,
 628        Span<PhysicsQueryHitRange> ranges)
 629    {
 1630        ChronicleGuard.ThrowIfNull(hits, nameof(hits));
 1631        ValidateRangeBatchOutput(requests.Length, ranges);
 1632        ResetBatchCounters(requests.Length);
 1633        hits.Clear();
 634
 635        try
 636        {
 1637            LSCollider? preparedSource = null;
 1638            Vector3d preparedDisplacement = default;
 6639            for (int i = 0; i < requests.Length; i++)
 640            {
 641                try
 642                {
 2643                    PhysicsSweepCompound3DRequest request = requests[i];
 2644                    int count = SweepSourceAllBatchRequest(
 2645                        request.Source,
 2646                        request.Displacement,
 2647                        request.LayerMask,
 2648                        request.ExcludedCollider,
 2649                        request.IncludeTriggers,
 2650                        ref preparedSource,
 2651                        ref preparedDisplacement,
 2652                        _batch3DHits);
 2653                    AppendRange(hits, ranges, i, count);
 2654                }
 655                finally
 656                {
 2657                    _batch3DHits.Clear();
 2658                }
 659            }
 660
 1661            LastBatchHitCount = hits.Count;
 1662            return hits.Count;
 663        }
 664        finally
 665        {
 1666            EndQuery();
 1667        }
 1668    }
 669
 670    /// <summary>
 671    /// Executes multiple 3D X/Z circle overlaps and writes one closest-hit slot per request.
 672    /// </summary>
 673    public int OverlapCircleBatch(ReadOnlySpan<PhysicsOverlapCircle3DRequest> requests, Span<Physics3DHit> closestHits)
 674    {
 2675        ValidateClosestBatchOutput(requests.Length, closestHits);
 2676        ValidateOverlapCircleRequests(requests);
 1677        ResetBatchCounters(requests.Length);
 678
 1679        int hitCount = 0;
 8680        for (int i = 0; i < requests.Length; i++)
 681        {
 3682            PhysicsOverlapCircle3DRequest request = requests[i];
 3683            bool found = TryOverlapCircleBatchRequest(request, out Physics3DHit hit);
 3684            WriteClosestHit(closestHits, i, hit, found, ref hitCount);
 685        }
 686
 1687        LastBatchHitCount = hitCount;
 1688        return hitCount;
 689    }
 690
 691    /// <summary>
 692    /// Executes multiple 3D X/Z circle overlaps and appends all hits into one caller-owned hit buffer.
 693    /// </summary>
 694    public int OverlapCircleAllBatch(
 695        ReadOnlySpan<PhysicsOverlapCircle3DRequest> requests,
 696        SwiftList<Physics3DHit> hits,
 697        Span<PhysicsQueryHitRange> ranges)
 698    {
 2699        ChronicleGuard.ThrowIfNull(hits, nameof(hits));
 2700        ValidateRangeBatchOutput(requests.Length, ranges);
 2701        ValidateOverlapCircleRequests(requests);
 1702        ResetBatchCounters(requests.Length);
 1703        hits.Clear();
 704
 8705        for (int i = 0; i < requests.Length; i++)
 706        {
 707            try
 708            {
 3709                PhysicsOverlapCircle3DRequest request = requests[i];
 3710                int count = OverlapCircleAllBatchRequest(request, _batch3DHits);
 3711                AppendRange(hits, ranges, i, count);
 3712            }
 713            finally
 714            {
 3715                _batch3DHits.Clear();
 3716            }
 717        }
 718
 1719        LastBatchHitCount = hits.Count;
 1720        return hits.Count;
 721    }
 722
 723    /// <summary>
 724    /// Executes multiple directional cone-volume overlaps and writes one closest-hit slot per request.
 725    /// </summary>
 726    public int OverlapConeBatch(ReadOnlySpan<PhysicsOverlapCone3DRequest> requests, Span<Physics3DHit> closestHits)
 727    {
 3728        ValidateClosestBatchOutput(requests.Length, closestHits);
 3729        ValidateOverlapConeEnvelopes(requests);
 2730        ResetBatchCounters(requests.Length);
 731
 2732        int hitCount = 0;
 12733        for (int i = 0; i < requests.Length; i++)
 734        {
 4735            PhysicsOverlapCone3DRequest request = requests[i];
 4736            bool found = TryOverlapConeBatchRequest(request, out Physics3DHit hit);
 4737            WriteClosestHit(closestHits, i, hit, found, ref hitCount);
 738        }
 739
 2740        LastBatchHitCount = hitCount;
 2741        return hitCount;
 742    }
 743
 744    /// <summary>
 745    /// Executes multiple directional cone-volume overlaps and appends all hits into one caller-owned hit buffer.
 746    /// </summary>
 747    public int OverlapConeAllBatch(
 748        ReadOnlySpan<PhysicsOverlapCone3DRequest> requests,
 749        SwiftList<Physics3DHit> hits,
 750        Span<PhysicsQueryHitRange> ranges)
 751    {
 6752        ChronicleGuard.ThrowIfNull(hits, nameof(hits));
 6753        ValidateRangeBatchOutput(requests.Length, ranges);
 6754        ValidateOverlapConeEnvelopes(requests);
 5755        ResetBatchCounters(requests.Length);
 5756        hits.Clear();
 757
 24758        for (int i = 0; i < requests.Length; i++)
 759        {
 760            try
 761            {
 10762                PhysicsOverlapCone3DRequest request = requests[i];
 10763                int count = OverlapConeAllBatchRequest(request, _batch3DHits);
 7764                AppendRange(hits, ranges, i, count);
 7765            }
 766            finally
 767            {
 10768                _batch3DHits.Clear();
 10769            }
 770        }
 771
 2772        LastBatchHitCount = hits.Count;
 2773        return hits.Count;
 774    }
 775
 776    /// <summary>
 777    /// Executes multiple directional 3D X/Z projected-circle overlaps and writes one closest-hit slot per request.
 778    /// </summary>
 779    public int OverlapCircleInDirectionBatch(
 780        ReadOnlySpan<PhysicsOverlapCircleInDirection3DRequest> requests,
 781        Span<Physics3DHit> closestHits)
 782    {
 2783        ValidateClosestBatchOutput(requests.Length, closestHits);
 2784        ValidateOverlapCircleRequests(requests);
 1785        ResetBatchCounters(requests.Length);
 786
 1787        int hitCount = 0;
 10788        for (int i = 0; i < requests.Length; i++)
 789        {
 4790            PhysicsOverlapCircleInDirection3DRequest request = requests[i];
 4791            bool found = TryOverlapCircleInDirectionBatchRequest(request, out Physics3DHit hit);
 4792            WriteClosestHit(closestHits, i, hit, found, ref hitCount);
 793        }
 794
 1795        LastBatchHitCount = hitCount;
 1796        return hitCount;
 797    }
 798
 799    private bool TryRaycastBatchRequest(PhysicsRaycast3DRequest request, out Physics3DHit hit)
 800    {
 425801        _currentLayerMask = request.LayerMask;
 425802        if (!Vector3d.TrySubtract(request.End, request.Start, out Vector3d segment)
 425803            || !Vector3d.TryGetMagnitude(segment, out Fixed64 segmentLength)
 425804            || segmentLength == Fixed64.Zero)
 805        {
 3806            ResetLastQueryCounters();
 3807            hit = default;
 3808            return false;
 809        }
 810
 422811        Vector3d direction = segment.Normalized;
 422812        BeginRaycastTrace(request.Start, request.End);
 422813        return TryFindClosestHit(request.Start, request.End, direction, out hit);
 814    }
 815
 816    private int RaycastAllBatchRequest(PhysicsRaycast3DRequest request, SwiftList<Physics3DHit> results)
 817    {
 431818        _currentLayerMask = request.LayerMask;
 431819        results.Clear();
 431820        if (!Vector3d.TrySubtract(request.End, request.Start, out Vector3d segment)
 431821            || !Vector3d.TryGetMagnitude(segment, out Fixed64 segmentLength)
 431822            || segmentLength == Fixed64.Zero)
 823        {
 3824            ResetLastQueryCounters();
 3825            return 0;
 826        }
 827
 428828        BeginRaycastTrace(request.Start, request.End);
 428829        AddAllHits(request.Start, request.End, segment.Normalized, results);
 428830        Physics3DHitSorter.SortByDistance(results);
 428831        return results.Count;
 832    }
 833
 834    private int SweepSphereAllBatchRequest(PhysicsSweepSphere3DRequest request, SwiftList<Physics3DHit> results)
 835    {
 8836        results.Clear();
 8837        if (!Vector3d.TrySubtract(request.End, request.Start, out Vector3d segment)
 8838            || !Vector3d.TryGetMagnitude(segment, out Fixed64 segmentLength)
 8839            || segmentLength <= Fixed64.Epsilon
 8840            || request.Radius <= Fixed64.Zero)
 841        {
 5842            ResetLastQueryCounters();
 5843            return 0;
 844        }
 845
 846        try
 847        {
 3848            BeginSweepTrace(
 3849                request.Start,
 3850                request.End,
 3851                request.Radius,
 3852                request.LayerMask,
 3853                request.ExcludedCollider);
 3854            AddAllSweepHits(request.Start, request.End, segment.Normalized, request.Radius, results);
 3855            Physics3DHitSorter.SortByDistance(results);
 3856            return results.Count;
 857        }
 858        finally
 859        {
 3860            EndQuery();
 3861        }
 3862    }
 863
 864    private bool TrySweepSourceBatchRequest(
 865        LSCollider? source,
 866        Vector3d displacement,
 867        PhysicsLayerMask layerMask,
 868        LSCollider? excludedCollider,
 869        bool includeTriggers,
 870        ref LSCollider? preparedSource,
 871        ref Vector3d preparedDisplacement,
 872        out Physics3DHit hit)
 873    {
 20874        PrepareBatchConvexSweepSource(source, displacement, ref preparedSource, ref preparedDisplacement);
 19875        LSCollider prepared = preparedSource!;
 19876        if (!Vector3d.TryGetMagnitude(displacement, out Fixed64 displacementLength)
 19877            || displacementLength <= Fixed64.Epsilon)
 878        {
 8879            ResetLastQueryCounters();
 8880            hit = default;
 8881            return false;
 882        }
 883
 11884        BeginConvexSweepTrace(prepared, layerMask, excludedCollider, includeTriggers);
 11885        return TryFindClosestConvexSweepHit(prepared, displacement, out hit);
 886    }
 887
 888    private int SweepSourceAllBatchRequest(
 889        LSCollider? source,
 890        Vector3d displacement,
 891        PhysicsLayerMask layerMask,
 892        LSCollider? excludedCollider,
 893        bool includeTriggers,
 894        ref LSCollider? preparedSource,
 895        ref Vector3d preparedDisplacement,
 896        SwiftList<Physics3DHit> results)
 897    {
 20898        results.Clear();
 20899        PrepareBatchConvexSweepSource(source, displacement, ref preparedSource, ref preparedDisplacement);
 19900        LSCollider prepared = preparedSource!;
 19901        if (!Vector3d.TryGetMagnitude(displacement, out Fixed64 displacementLength)
 19902            || displacementLength <= Fixed64.Epsilon)
 903        {
 8904            ResetLastQueryCounters();
 8905            return 0;
 906        }
 907
 11908        BeginConvexSweepTrace(prepared, layerMask, excludedCollider, includeTriggers);
 11909        AddAllConvexSweepHits(prepared, displacement, results);
 11910        Physics3DHitSorter.SortByDistance(results);
 11911        return results.Count;
 912    }
 913
 914    private void PrepareBatchConvexSweepSource(
 915        LSCollider? source,
 916        Vector3d displacement,
 917        ref LSCollider? preparedSource,
 918        ref Vector3d preparedDisplacement)
 919    {
 40920        ChronicleGuard.ThrowIfNull(source, nameof(source));
 38921        EnsureSourceBelongsToContext(source!);
 922
 38923        if (ReferenceEquals(source, preparedSource) && displacement.Equals(preparedDisplacement))
 6924            return;
 925
 32926        PrepareConvexSweepSource(source!, displacement);
 32927        preparedSource = source;
 32928        preparedDisplacement = displacement;
 32929    }
 930
 931    private bool TryOverlapCircleBatchRequest(PhysicsOverlapCircle3DRequest request, out Physics3DHit hit)
 932    {
 3933        _currentLayerMask = request.LayerMask;
 3934        ResetLastQueryCounters();
 935
 3936        bool found = false;
 3937        Physics3DHit closest = default;
 3938        TraceCircleForClosestHit(
 3939            request.Position,
 3940            request.Radius,
 3941            ref found,
 3942            ref closest);
 943
 3944        hit = closest;
 3945        return found;
 946    }
 947
 948    private int OverlapCircleAllBatchRequest(PhysicsOverlapCircle3DRequest request, SwiftList<Physics3DHit> results)
 949    {
 3950        _currentLayerMask = request.LayerMask;
 3951        ResetLastQueryCounters();
 3952        results.Clear();
 953
 3954        TraceCircleForAllHits(request.Position, request.Radius, results);
 3955        Physics3DHitSorter.SortByDistance(results);
 3956        return results.Count;
 957    }
 958
 959    private bool TryOverlapCircleInDirectionBatchRequest(
 960        PhysicsOverlapCircleInDirection3DRequest request,
 961        out Physics3DHit hit)
 962    {
 4963        _currentLayerMask = request.LayerMask;
 4964        ResetLastQueryCounters();
 965
 4966        var direction = new Vector2d(
 4967            request.Direction.X,
 4968            request.Direction.Z);
 4969        bool found = false;
 4970        Physics3DHit closest = default;
 4971        TraceCircleForDirectionalHit(
 4972            request.Position,
 4973            request.Radius,
 4974            direction,
 4975            request.MaxDistance,
 4976            ref found,
 4977            ref closest);
 978
 4979        hit = found ? closest : default;
 4980        return found;
 981    }
 982
 983    private bool TryOverlapConeBatchRequest(PhysicsOverlapCone3DRequest request, out Physics3DHit hit) =>
 4984        OverlapCone(
 4985            request.Origin,
 4986            request.Direction,
 4987            request.Length,
 4988            request.EndRadius,
 4989            out hit,
 4990            request.LayerMask);
 991
 992    private static void ValidateOverlapCircleRequests(ReadOnlySpan<PhysicsOverlapCircle3DRequest> requests)
 993    {
 24994        for (int i = 0; i < requests.Length; i++)
 995        {
 10996            ChronicleGuard.ThrowIfArgument(
 10997                requests[i].Radius < Fixed64.Zero,
 10998                nameof(requests),
 10999                "3D query radius cannot be negative.");
 81000            ColliderGeometryPolicy.ValidateReach(requests[i].Radius, nameof(requests));
 1001        }
 21002    }
 1003
 1004    private static void ValidateOverlapCircleRequests(
 1005        ReadOnlySpan<PhysicsOverlapCircleInDirection3DRequest> requests)
 1006    {
 141007        for (int i = 0; i < requests.Length; i++)
 1008        {
 61009            ChronicleGuard.ThrowIfArgument(
 61010                requests[i].Radius < Fixed64.Zero,
 61011                nameof(requests),
 61012                "3D query radius cannot be negative.");
 51013            ColliderGeometryPolicy.ValidateReach(requests[i].Radius, nameof(requests));
 1014        }
 11015    }
 1016
 1017    private static void ValidateSweepSphereRequests(ReadOnlySpan<PhysicsSweepSphere3DRequest> requests)
 1018    {
 1019        // Nonpositive radii retain the existing 3D miss contract.
 561020        for (int i = 0; i < requests.Length; i++)
 201021            ChronicleGuard.ThrowIfArgument(requests[i].Radius > ColliderGeometryPolicy.MaximumGeometryReach,
 201022                nameof(requests), "Effective geometry reach must not exceed 4,096 world units.");
 81023    }
 1024
 1025    private static void ValidateOverlapConeEnvelopes(ReadOnlySpan<PhysicsOverlapCone3DRequest> requests)
 1026    {
 501027        for (int i = 0; i < requests.Length; i++)
 1028        {
 1029            // Existing sign/direction/endpoint errors retain their per-request behavior.
 181030            if (requests[i].Length > Fixed64.Zero && requests[i].EndRadius > Fixed64.Zero)
 161031                ColliderGeometryPolicy.ValidateFiniteAxisReach(requests[i].EndRadius, requests[i].Length, nameof(request
 1032        }
 71033    }
 1034
 1035    private int OverlapConeAllBatchRequest(PhysicsOverlapCone3DRequest request, SwiftList<Physics3DHit> results) =>
 101036        OverlapConeAll(
 101037            request.Origin,
 101038            request.Direction,
 101039            request.Length,
 101040            request.EndRadius,
 101041            request.LayerMask,
 101042            results);
 1043
 1044    private void WriteClosestHit(Span<Physics3DHit> closestHits, int index, Physics3DHit hit, bool found, ref int hitCou
 1045    {
 381046        if (found)
 1047        {
 181048            closestHits[index] = hit;
 181049            hitCount++;
 181050            AccumulateBatchCounters(1);
 1051        }
 1052        else
 1053        {
 201054            closestHits[index] = default;
 201055            AccumulateBatchCounters(0);
 1056        }
 201057    }
 1058
 1059    private void AppendRange(
 1060        SwiftList<Physics3DHit> hits,
 1061        Span<PhysicsQueryHitRange> ranges,
 1062        int index,
 1063        int count)
 1064    {
 4681065        int start = hits.Count;
 4681066        if (count > 0)
 2341067            hits.AddRange(_batch3DHits.AsReadOnlySpan());
 1068
 4681069        ranges[index] = new PhysicsQueryHitRange(start, count);
 4681070        AccumulateBatchCounters(count);
 4681071    }
 1072
 1073    private void ResetBatchCounters(int requestCount)
 1074    {
 5831075        LastBatchRequestCount = requestCount;
 5831076        LastBatchHitCount = 0;
 5831077        LastBatchCandidateCount = 0;
 5831078    }
 1079
 1080    private void AccumulateBatchCounters(int hitCount)
 1081    {
 9311082        LastBatchHitCount += hitCount;
 9311083        LastBatchCandidateCount += LastQueryCandidateCount;
 9311084    }
 1085
 1086    private static void ValidateClosestBatchOutput(int requestCount, Span<Physics3DHit> closestHits)
 1087    {
 2371088        ChronicleGuard.ThrowIfArgument(
 2371089            closestHits.Length < requestCount,
 2371090            nameof(closestHits),
 2371091            "Closest-hit output span must contain at least one slot per request.");
 2361092    }
 1093
 1094    private static void ValidateRangeBatchOutput(int requestCount, Span<PhysicsQueryHitRange> ranges)
 1095    {
 2401096        ChronicleGuard.ThrowIfArgument(
 2401097            ranges.Length < requestCount,
 2401098            nameof(ranges),
 2401099            "Range output span must contain at least one slot per request.");
 2401100    }
 1101}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/3D/GravitasQuery3DService.Circle.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQuery3DService.Circle.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using FixedMathSharp;
 9using FixedMathSharp.Geometry;
 10using Gravitas.Colliders;
 11using Gravitas.CollisionHandling;
 12using Gravitas.Support;
 13using GridForge.Grids;
 14using GridForge.Utility;
 15using SwiftCollections;
 16
 17namespace Gravitas.Queries;
 18
 19/// <content>
 20/// Owns 3D X/Z circle overlap query behavior for one <see cref="GravitasWorldContext"/>.
 21/// </content>
 22public sealed partial class GravitasQuery3DService
 23{
 24    /// <summary>
 25    /// Finds the closest collider whose complete X/Z projection overlaps the supplied circle.
 26    /// The query position's Y component does not affect classification.
 27    /// </summary>
 28    public bool OverlapCircle(
 29        Vector3d position,
 30        Fixed64 radius,
 31        out Physics3DHit raycastHit,
 32        PhysicsLayerMask layerMask)
 33    {
 1734        ChronicleGuard.ThrowIfArgument(
 1735            radius < Fixed64.Zero,
 1736            nameof(radius),
 1737            "3D query radius cannot be negative.");
 1638        ColliderGeometryPolicy.ValidateReach(radius, nameof(radius));
 39
 1440        _currentLayerMask = layerMask;
 1441        ResetLastQueryCounters();
 42
 1443        Physics3DHit closestHit = default;
 1444        bool found = false;
 45
 1446        TraceCircleForClosestHit(position, radius, ref found, ref closestHit);
 47
 1448        raycastHit = closestHit;
 1449        _context.Diagnostics.EmitCircleQuery(
 1450            position,
 1451            radius,
 1452            Vector3d.Zero,
 1453            Fixed64.Zero,
 1454            layerMask.Bits,
 1455            found,
 1456            found ? 1 : 0,
 1457            closestHit);
 58
 1459        return found;
 60    }
 61
 62    /// <summary>
 63    /// Finds the closest projected-circle overlap whose exact separation lies in the supplied X/Z
 64    /// direction and whose rounded distance is within the supplied limit. Containment is admitted in
 65    /// every direction, and the query position's Y component is ignored.
 66    /// </summary>
 67    public bool OverlapCircleInDirection(
 68        Vector3d position,
 69        Fixed64 radius,
 70        Vector3d direction,
 71        out Physics3DHit raycastHit,
 72        Fixed64 maxDistance,
 73        PhysicsLayerMask layerMask)
 74    {
 1375        ChronicleGuard.ThrowIfArgument(
 1376            radius < Fixed64.Zero,
 1377            nameof(radius),
 1378            "3D query radius cannot be negative.");
 1279        ColliderGeometryPolicy.ValidateReach(radius, nameof(radius));
 80
 1181        _currentLayerMask = layerMask;
 1182        ResetLastQueryCounters();
 83
 1184        var planarDirection = new Vector2d(direction.X, direction.Z);
 1185        Vector2d normalizedPlanarDirection = Vector2d.GetNormalized(planarDirection);
 1186        var normalizedDirection = new Vector3d(
 1187            normalizedPlanarDirection.X,
 1188            Fixed64.Zero,
 1189            normalizedPlanarDirection.Y);
 1190        Physics3DHit closestHit = default;
 1191        bool found = false;
 92
 1193        TraceCircleForDirectionalHit(
 1194            position,
 1195            radius,
 1196            planarDirection,
 1197            maxDistance,
 1198            ref found,
 1199            ref closestHit);
 100
 11101        raycastHit = closestHit;
 11102        _context.Diagnostics.EmitCircleQuery(
 11103            position,
 11104            radius,
 11105            normalizedDirection,
 11106            maxDistance,
 11107            layerMask.Bits,
 11108            found,
 11109            found ? 1 : 0,
 11110            closestHit);
 111
 11112        return found;
 113    }
 114
 115    /// <summary>
 116    /// Finds all colliders whose complete X/Z projections overlap the supplied circle. The query
 117    /// position's Y component does not affect classification.
 118    /// </summary>
 119    public int OverlapCircleAll(
 120        Vector3d position,
 121        Fixed64 radius,
 122        PhysicsLayerMask layerMask,
 123        SwiftList<Physics3DHit> results)
 124    {
 16125        ChronicleGuard.ThrowIfNull(results, nameof(results));
 16126        ChronicleGuard.ThrowIfArgument(
 16127            radius < Fixed64.Zero,
 16128            nameof(radius),
 16129            "3D query radius cannot be negative.");
 15130        ColliderGeometryPolicy.ValidateReach(radius, nameof(radius));
 131
 14132        _currentLayerMask = layerMask;
 14133        ResetLastQueryCounters();
 134
 14135        results.Clear();
 136
 14137        TraceCircleForAllHits(position, radius, results);
 138
 14139        Physics3DHitSorter.SortByDistance(results);
 14140        Physics3DHit firstHit = results.Count > 0 ? results[0] : default;
 14141        _context.Diagnostics.EmitCircleQuery(
 14142            position,
 14143            radius,
 14144            Vector3d.Zero,
 14145            Fixed64.Zero,
 14146            layerMask.Bits,
 14147            results.Count > 0,
 14148            results.Count,
 14149            firstHit);
 150
 14151        return results.Count;
 152    }
 153
 154    internal int OverlapSphereAgainstStaticAll(
 155        Vector3d position,
 156        Fixed64 radius,
 157        PhysicsLayerMask layerMask,
 158        SwiftList<Physics3DHit> results,
 159        LSCollider? excludedCollider = null,
 160        bool includeTriggers = true)
 161    {
 173162        ChronicleGuard.ThrowIfNull(results, nameof(results));
 163
 173164        results.Clear();
 173165        if (radius <= Fixed64.Zero)
 166        {
 1167            ResetLastQueryCounters();
 1168            return 0;
 169        }
 170
 171        try
 172        {
 172173            _currentLayerMask = layerMask;
 172174            _currentExcludedCollider = excludedCollider;
 172175            _currentIncludeTriggers = includeTriggers;
 172176            _currentStaticSweepTargetsOnly = true;
 172177            NextCircleVersion();
 172178            ResetLastQueryCounters();
 172179            _redundantColliderCheck.Clear();
 172180            _redundantVoxelCheck.Clear();
 181
 172182            Vector3d min = new(position.X - radius, position.Y - radius, position.Z - radius);
 172183            Vector3d max = new(position.X + radius, position.Y + radius, position.Z + radius);
 172184            GridTracer.GetCoveredVoxelsInto(_context.World, min, max, _coveredVoxels, _traceScratch);
 288684185            for (int i = 0; i < _coveredVoxels.Count; i++)
 186            {
 144170187                Voxel voxel = _coveredVoxels[i];
 144170188                if (!GridTraversal.TryGetUniquePartition(voxel, _redundantVoxelCheck, out PhysicsPartition? partition))
 189                    continue;
 190
 15963191                ProcessPartitionForAllSphereHits(partition!, position, radius, results);
 192            }
 193
 172194            Physics3DHitSorter.SortByDistance(results);
 172195            return results.Count;
 196        }
 197        finally
 198        {
 172199            EndQuery();
 172200        }
 172201    }
 202
 203    private void ProcessPartitionForAllSphereHits(
 204        PhysicsPartition partition,
 205        Vector3d position,
 206        Fixed64 radius,
 207        SwiftList<Physics3DHit> results)
 208    {
 15963209        ProcessColliderListForAllSphereHits(partition.ContainedKinematicObjects, position, radius, results);
 15963210        ProcessColliderListForAllSphereHits(partition.ContainedStaticObjects, position, radius, results);
 15963211    }
 212
 213    private void ProcessColliderListForAllSphereHits(
 214        SwiftHashSet<int>? colliderIds,
 215        Vector3d position,
 216        Fixed64 radius,
 217        SwiftList<Physics3DHit> results)
 218    {
 31926219        if (colliderIds == null)
 19451220            return;
 221
 48598222        foreach (int colliderId in colliderIds)
 11824223            if (TryBuildOverlapSphereHit(colliderId, position, radius, out Physics3DHit hitInfo))
 74224                results.Add(hitInfo);
 12475225    }
 226
 227    private bool TryBuildOverlapSphereHit(int colliderId, Vector3d position, Fixed64 radius, out Physics3DHit hit)
 228    {
 11824229        hit = default;
 11824230        if (!_context.Physics.TryGetColliderById(colliderId, out LSCollider? current))
 27231            return false;
 232
 11797233        LSCollider collider = current!;
 11797234        if (ReferenceEquals(collider, _currentExcludedCollider)
 11797235            || (_currentExcludedCollider != null
 11797236                && _context.Constraints3D.ShouldExcludeLinkedCollision(_currentExcludedCollider, collider))
 11797237            || !_currentLayerMask.Includes(collider.Layer)
 11797238            || collider.CircleQueryVersion == CircleVersion
 11797239            || (!_currentIncludeTriggers && collider.IsTrigger)
 11797240            || (_currentStaticSweepTargetsOnly && !IsStaticStyleSweepTarget(collider)))
 241        {
 11718242            return false;
 243        }
 244
 79245        collider.CircleQueryVersion = CircleVersion;
 79246        LastQueryCandidateCount++;
 247
 79248        Fixed64 broadDistance = collider.ScaledRadius + radius;
 79249        if ((collider.Center - position).MagnitudeSquared > broadDistance * broadDistance)
 1250            return false;
 251
 78252        return TryBuildSurfaceOverlapHit(
 78253            collider,
 78254            position,
 78255            radius,
 78256            out hit);
 257    }
 258
 259    private void TraceCircleForClosestHit(
 260        Vector3d position,
 261        Fixed64 radius,
 262        ref bool found,
 263        ref Physics3DHit closestHit)
 264    {
 17265        GetPlanarCircleCandidates(position, radius);
 66266        for (int i = 0; i < _planarCircleCandidates.Count; i++)
 267        {
 16268            if (!TryBuildOverlapHit(
 16269                    _planarCircleCandidates[i],
 16270                    position,
 16271                    radius,
 16272                    out Physics3DHit hitInfo,
 16273                    out _)
 16274                || !PhysicsHitSelectionPolicy.ShouldReplace(hitInfo, found, closestHit))
 275                continue;
 276
 14277            found = true;
 14278            closestHit = hitInfo;
 279        }
 17280    }
 281
 282    private void TraceCircleForDirectionalHit(
 283        Vector3d position,
 284        Fixed64 radius,
 285        Vector2d direction,
 286        Fixed64 maxDistance,
 287        ref bool found,
 288        ref Physics3DHit closestHit)
 289    {
 15290        if (direction == Vector2d.Zero)
 3291            return;
 292
 12293        GetPlanarCircleCandidates(position, radius);
 56294        for (int i = 0; i < _planarCircleCandidates.Count; i++)
 295        {
 16296            if (!TryBuildOverlapHit(
 16297                    _planarCircleCandidates[i],
 16298                    position,
 16299                    radius,
 16300                    out Physics3DHit hitInfo,
 16301                    out ProjectedSurfaceRelation relation)
 16302                || hitInfo.Distance > maxDistance
 16303                || (!relation.IsContained
 16304                    && WideGeometry.GetDifferenceDotProduct2D(
 16305                        relation.Direction.X,
 16306                        Fixed64.Zero,
 16307                        relation.Direction.Y,
 16308                        Fixed64.Zero,
 16309                        direction.X,
 16310                        Fixed64.Zero,
 16311                        direction.Y,
 16312                        Fixed64.Zero).Sign <= 0)
 16313                || !PhysicsHitSelectionPolicy.ShouldReplace(hitInfo, found, closestHit))
 314            {
 315                continue;
 316            }
 317
 9318            found = true;
 9319            closestHit = hitInfo;
 320        }
 12321    }
 322
 323    private void TraceCircleForAllHits(Vector3d position, Fixed64 radius, SwiftList<Physics3DHit> results)
 324    {
 17325        GetPlanarCircleCandidates(position, radius);
 82326        for (int i = 0; i < _planarCircleCandidates.Count; i++)
 24327            if (TryBuildOverlapHit(
 24328                    _planarCircleCandidates[i],
 24329                    position,
 24330                    radius,
 24331                    out Physics3DHit hitInfo,
 24332                    out _))
 21333                results.Add(hitInfo);
 17334    }
 335
 336    private void GetPlanarCircleCandidates(Vector3d position, Fixed64 radius)
 337    {
 46338        var center = new Vector2d(position.X, position.Z);
 46339        _context.Collisions.QueryPlanarColliderCandidates(
 46340            DynamicCcdCandidateIndex2D.CreateBoundsBetween(
 46341                center,
 46342                center,
 46343                radius),
 46344            _planarCircleCandidates);
 46345    }
 346
 347    private bool TryBuildOverlapHit(
 348        int colliderId,
 349        Vector3d position,
 350        Fixed64 radius,
 351        out Physics3DHit raycastHit,
 352        out ProjectedSurfaceRelation relation)
 353    {
 56354        raycastHit = default;
 56355        relation = default;
 56356        ChronicleGuard.ThrowIfTrue(
 56357            !_context.Physics.TryGetColliderById(colliderId, out LSCollider? current),
 56358            nameof(GravitasQuery3DService),
 56359            "Planar query index contained an unregistered collider.");
 56360        LSCollider collider = current!;
 56361        if (!_currentLayerMask.Includes(collider.Layer))
 2362            return false;
 363
 54364        LastQueryCandidateCount++;
 365
 54366        return TryBuildPlanarOverlapHit(
 54367            collider,
 54368            position,
 54369            radius,
 54370            out raycastHit,
 54371            out relation);
 372    }
 373
 374    private static bool TryBuildPlanarOverlapHit(
 375        LSCollider collider,
 376        Vector3d position,
 377        Fixed64 radius,
 378        out Physics3DHit hit,
 379        out ProjectedSurfaceRelation relation)
 380    {
 54381        if (!ColliderPlanarProjection.TryGetRelation(
 54382                collider,
 54383                new Vector2d(position.X, position.Z),
 54384                radius,
 54385                out relation))
 386        {
 3387            hit = default;
 3388            return false;
 389        }
 390
 51391        hit = new Physics3DHit(
 51392            collider,
 51393            new ContactAnchor(relation.ContactAnchor),
 51394            relation.OutwardNormal,
 51395            relation.Distance,
 51396            new Vector3d(
 51397                relation.Offset.X,
 51398                Fixed64.Zero,
 51399                relation.Offset.Y));
 51400        return true;
 401    }
 402
 403    internal static bool TryBuildSurfaceOverlapHit(
 404        LSCollider collider,
 405        Vector3d position,
 406        Fixed64 radius,
 407        out Physics3DHit hit)
 408    {
 409        ContactAnchor anchor;
 410        Vector3d toPoint;
 411        Vector3d normal;
 81412        if (collider is LSCuboidCollider cuboid)
 413        {
 7414            anchor = new ContactAnchor(
 7415                cuboid.OrientedBox.GetClosestPointAnchor(position));
 7416            if (!anchor.TryGetOffsetFrom(position, out toPoint))
 417            {
 1418                hit = default;
 1419                return false;
 420            }
 6421            normal = cuboid.OrientedBox.GetNearestFaceNormal(position);
 422        }
 423        else
 424        {
 74425            Vector3d point = GetClosestSurfacePoint(collider, position);
 74426            if (!Vector3d.TrySubtract(point, position, out toPoint))
 427            {
 1428                hit = default;
 1429                return false;
 430            }
 73431            anchor = ContactAnchor.FromWorldPoint(point);
 73432            normal = collider.GetNormalAtPoint(point);
 433        }
 434
 79435        if (!Vector3d.TryGetMagnitude(toPoint, out Fixed64 distance)
 79436            || distance > radius)
 437        {
 5438            hit = default;
 5439            return false;
 440        }
 441
 74442        hit = new Physics3DHit(
 74443            collider,
 74444            anchor,
 74445            normal,
 74446            distance,
 74447            toPoint);
 74448        return true;
 449    }
 450
 451    private static Vector3d GetClosestSurfacePoint(LSCollider collider, Vector3d position)
 452    {
 564453        if (position == collider.Center && collider is not LSMeshCollider)
 231454            return collider.Center + Vector3d.Right * collider.ScaledRadius;
 455
 333456        return collider.ClosestPointOnSurface(position);
 457    }
 458}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/3D/GravitasQuery3DService.Cone.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQuery3DService.Cone.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using FixedMathSharp;
 9using FixedMathSharp.Geometry;
 10using Gravitas.Colliders;
 11using Gravitas.CollisionHandling;
 12using Gravitas.Support;
 13using GridForge.Grids;
 14using GridForge.Utility;
 15using SwiftCollections;
 16using SwiftCollections.Query;
 17
 18namespace Gravitas.Queries;
 19
 20/// <content>
 21/// Owns apex-origin 3D cone-volume overlap query behavior.
 22/// </content>
 23public sealed partial class GravitasQuery3DService
 24{
 25    /// <summary>
 26    /// Finds the closest collider whose surface intersects an apex-origin
 27    /// directional cone volume.
 28    /// </summary>
 29    public bool OverlapCone(
 30        Vector3d origin,
 31        Vector3d direction,
 32        Fixed64 length,
 33        Fixed64 endRadius,
 34        out Physics3DHit hit,
 35        PhysicsLayerMask layerMask)
 36    {
 7237        Vector3d normalizedDirection = ValidateConeQuery(origin, direction, length, endRadius, out Vector3d end);
 6638        _currentLayerMask = layerMask;
 6639        NextCircleVersion();
 6640        ResetLastQueryCounters();
 6641        _redundantColliderCheck.Clear();
 6642        _redundantVoxelCheck.Clear();
 43
 6644        bool found = false;
 6645        Physics3DHit closestHit = default;
 6646        Fixed64 closestDistance = Fixed64.MaxValue;
 6647        TraceConeForClosestHit(
 6648            origin,
 6649            end,
 6650            normalizedDirection,
 6651            length,
 6652            endRadius,
 6653            ref found,
 6654            ref closestHit,
 6655            ref closestDistance);
 56
 6657        hit = closestHit;
 6658        _context.Diagnostics.EmitRayQuery(
 6659            origin,
 6660            end,
 6661            endRadius,
 6662            layerMask.Bits,
 6663            found,
 6664            found ? 1 : 0,
 6665            closestHit);
 6666        return found;
 67    }
 68
 69    /// <summary>
 70    /// Writes all colliders whose surfaces intersect an apex-origin
 71    /// directional cone volume into caller-owned storage.
 72    /// </summary>
 73    public int OverlapConeAll(
 74        Vector3d origin,
 75        Vector3d direction,
 76        Fixed64 length,
 77        Fixed64 endRadius,
 78        PhysicsLayerMask layerMask,
 79        SwiftList<Physics3DHit> results)
 80    {
 46981        ChronicleGuard.ThrowIfNull(results, nameof(results));
 46982        Vector3d normalizedDirection = ValidateConeQuery(origin, direction, length, endRadius, out Vector3d end);
 46583        _currentLayerMask = layerMask;
 46584        NextCircleVersion();
 46585        ResetLastQueryCounters();
 46586        results.Clear();
 46587        _redundantColliderCheck.Clear();
 46588        _redundantVoxelCheck.Clear();
 89
 46590        TraceConeForAllHits(origin, end, normalizedDirection, length, endRadius, results);
 46591        Physics3DHitSorter.SortByDistance(results);
 92
 46593        _context.Diagnostics.EmitRayQuery(
 46594            origin,
 46595            end,
 46596            endRadius,
 46597            layerMask.Bits,
 46598            results.Count > 0,
 46599            results.Count,
 465100            results.Count > 0 ? results[0] : default);
 465101        return results.Count;
 102    }
 103
 104    private void TraceConeForClosestHit(
 105        Vector3d origin,
 106        Vector3d baseCenter,
 107        Vector3d direction,
 108        Fixed64 length,
 109        Fixed64 endRadius,
 110        ref bool found,
 111        ref Physics3DHit closestHit,
 112        ref Fixed64 closestDistance)
 113    {
 66114        GetConeQueryBounds(origin, baseCenter, direction, endRadius, out Vector3d min, out Vector3d max);
 115        try
 116        {
 66117            GridTracer.GetCoveredVoxelsInto(_context.World, min, max, _coveredVoxels, _traceScratch);
 19632118            for (int i = 0; i < _coveredVoxels.Count; i++)
 119            {
 9750120                Voxel voxel = _coveredVoxels[i];
 9750121                if (!GridTraversal.TryGetUniquePartition(voxel, _redundantVoxelCheck, out PhysicsPartition? partition))
 122                    continue;
 123
 1948124                ProcessConePartitionForClosestHit(
 1948125                    partition!,
 1948126                    origin,
 1948127                    baseCenter,
 1948128                    direction,
 1948129                    length,
 1948130                    endRadius,
 1948131                    ref found,
 1948132                    ref closestHit,
 1948133                    ref closestDistance);
 134            }
 66135        }
 136        finally
 137        {
 66138            EndQuery();
 66139        }
 66140    }
 141
 142    private void TraceConeForAllHits(
 143        Vector3d origin,
 144        Vector3d baseCenter,
 145        Vector3d direction,
 146        Fixed64 length,
 147        Fixed64 endRadius,
 148        SwiftList<Physics3DHit> results)
 149    {
 465150        GetConeQueryBounds(origin, baseCenter, direction, endRadius, out Vector3d min, out Vector3d max);
 151        try
 152        {
 465153            GridTracer.GetCoveredVoxelsInto(_context.World, min, max, _coveredVoxels, _traceScratch);
 103384154            for (int i = 0; i < _coveredVoxels.Count; i++)
 155            {
 51227156                Voxel voxel = _coveredVoxels[i];
 51227157                if (!GridTraversal.TryGetUniquePartition(voxel, _redundantVoxelCheck, out PhysicsPartition? partition))
 158                    continue;
 159
 19890160                ProcessConePartitionForAllHits(partition!, origin, baseCenter, direction, length, endRadius, results);
 161            }
 465162        }
 163        finally
 164        {
 465165            EndQuery();
 465166        }
 465167    }
 168
 169    private void ProcessConePartitionForClosestHit(
 170        PhysicsPartition partition,
 171        Vector3d origin,
 172        Vector3d baseCenter,
 173        Vector3d direction,
 174        Fixed64 length,
 175        Fixed64 endRadius,
 176        ref bool found,
 177        ref Physics3DHit closestHit,
 178        ref Fixed64 closestDistance)
 179    {
 1948180        ProcessConeColliderListForClosestHit(partition.ContainedDynamicObjects, origin, baseCenter, direction, length, e
 1948181        ProcessConeColliderListForClosestHit(partition.ContainedKinematicObjects, origin, baseCenter, direction, length,
 1948182        ProcessConeColliderListForClosestHit(partition.ContainedStaticObjects, origin, baseCenter, direction, length, en
 1948183    }
 184
 185    private void ProcessConePartitionForAllHits(
 186        PhysicsPartition partition,
 187        Vector3d origin,
 188        Vector3d baseCenter,
 189        Vector3d direction,
 190        Fixed64 length,
 191        Fixed64 endRadius,
 192        SwiftList<Physics3DHit> results)
 193    {
 19890194        ProcessConeColliderListForAllHits(partition.ContainedDynamicObjects, origin, baseCenter, direction, length, endR
 19890195        ProcessConeColliderListForAllHits(partition.ContainedKinematicObjects, origin, baseCenter, direction, length, en
 19890196        ProcessConeColliderListForAllHits(partition.ContainedStaticObjects, origin, baseCenter, direction, length, endRa
 19890197    }
 198
 199    private void ProcessConeColliderListForClosestHit(
 200        SwiftHashSet<int>? colliderIds,
 201        Vector3d origin,
 202        Vector3d baseCenter,
 203        Vector3d direction,
 204        Fixed64 length,
 205        Fixed64 endRadius,
 206        ref bool found,
 207        ref Physics3DHit closestHit,
 208        ref Fixed64 closestDistance)
 209    {
 5844210        if (colliderIds == null)
 3896211            return;
 212
 7858213        foreach (int colliderId in colliderIds)
 214        {
 1981215            if (!TryBuildOverlapConeHit(colliderId, origin, baseCenter, direction, length, endRadius, out Physics3DHit h
 1981216                || !PhysicsHitSelectionPolicy.ShouldReplace(hit, found, closestHit))
 217            {
 218                continue;
 219            }
 220
 34221            found = true;
 34222            closestHit = hit;
 34223            closestDistance = hit.Distance;
 224        }
 1948225    }
 226
 227    private void ProcessConeColliderListForAllHits(
 228        SwiftHashSet<int>? colliderIds,
 229        Vector3d origin,
 230        Vector3d baseCenter,
 231        Vector3d direction,
 232        Fixed64 length,
 233        Fixed64 endRadius,
 234        SwiftList<Physics3DHit> results)
 235    {
 59670236        if (colliderIds == null)
 39756237            return;
 238
 94776239        foreach (int colliderId in colliderIds)
 240        {
 27474241            if (TryBuildOverlapConeHit(colliderId, origin, baseCenter, direction, length, endRadius, out Physics3DHit hi
 866242                results.Add(hit);
 243        }
 19914244    }
 245
 246    private bool TryBuildOverlapConeHit(
 247        int colliderId,
 248        Vector3d origin,
 249        Vector3d baseCenter,
 250        Vector3d direction,
 251        Fixed64 length,
 252        Fixed64 endRadius,
 253        out Physics3DHit hit)
 254    {
 29455255        hit = default;
 29455256        if (!_context.Physics.TryGetColliderById(colliderId, out LSCollider? current))
 54257            return false;
 258
 29401259        LSCollider collider = current!;
 29401260        if (!_currentLayerMask.Includes(collider.Layer)
 29401261            || collider.CircleQueryVersion == CircleVersion
 29401262            || !_redundantColliderCheck.Add(collider.Id))
 263        {
 28445264            return false;
 265        }
 266
 956267        collider.CircleQueryVersion = CircleVersion;
 956268        LastQueryCandidateCount++;
 956269        return TryBuildConeHitForCollider(collider, origin, baseCenter, direction, length, endRadius, out hit);
 270    }
 271
 272    private bool TryBuildConeHitForCollider(
 273        LSCollider collider,
 274        Vector3d origin,
 275        Vector3d baseCenter,
 276        Vector3d direction,
 277        Fixed64 length,
 278        Fixed64 endRadius,
 279        out Physics3DHit hit)
 280    {
 962281        if (collider is LSCompoundCollider compound)
 3282            return TryBuildConeHitForCompound(compound, origin, baseCenter, direction, length, endRadius, out hit);
 283
 959284        if (collider is LSMeshCollider { Mode: MeshColliderMode.Concave } concaveMesh)
 434285            return TryBuildConeHitForConcaveMesh(concaveMesh, origin, baseCenter, direction, length, endRadius, out hit)
 286
 525287        bool supportedConvexTarget = ConvexColliderSupport.IsSupported(collider);
 525288        if (supportedConvexTarget
 525289            && !ConvexColliderSupport.IntersectsConeVolume(collider, origin, baseCenter, direction, endRadius))
 290        {
 48291            hit = default;
 48292            return false;
 293        }
 294
 477295        Vector3d axisPoint = GetClosestPointOnConeAxis(origin, direction, length, collider.Center);
 477296        Vector3d point = GetClosestSurfacePoint(collider, axisPoint);
 477297        if (!IsPointInsideConeVolume(origin, direction, length, endRadius, point, out Fixed64 axialDistance))
 298        {
 9299            Vector3d supportTowardAxis = collider.Center == axisPoint
 9300                ? GetClosestSurfacePoint(collider, origin)
 9301                : GetClosestSurfacePoint(collider, axisPoint);
 9302            if (!IsPointInsideConeVolume(origin, direction, length, endRadius, supportTowardAxis, out axialDistance))
 303            {
 5304                if (!supportedConvexTarget)
 305                {
 1306                    hit = default;
 1307                    return false;
 308                }
 309
 4310                point = GetClosestSurfacePoint(collider, origin);
 4311                axialDistance = FixedMath.Min(
 4312                    Vector3d.ProjectNonNegativeDifferenceParameter(point, origin, direction),
 4313                    length);
 314            }
 315            else
 316            {
 4317                point = supportTowardAxis;
 318            }
 319        }
 320
 476321        Vector3d toPoint = point - origin;
 476322        Vector3d normal = collider.GetNormalAtPoint(point);
 476323        hit = new Physics3DHit(collider, point, normal, axialDistance, toPoint);
 476324        return true;
 325    }
 326
 327    private bool TryBuildConeHitForConcaveMesh(
 328        LSMeshCollider mesh,
 329        Vector3d origin,
 330        Vector3d baseCenter,
 331        Vector3d direction,
 332        Fixed64 length,
 333        Fixed64 endRadius,
 334        out Physics3DHit hit)
 335    {
 434336        GetConeQueryBounds(origin, baseCenter, direction, endRadius, out Vector3d min, out Vector3d max);
 434337        mesh.GetTrianglesInBounds(new FixedBoundVolume(min, max), _meshTriangleCandidates);
 434338        LastMeshTriangleCandidateCount += _meshTriangleCandidates.Count;
 339
 434340        bool found = false;
 434341        Fixed64 bestDistance = Fixed64.MaxValue;
 434342        int bestTriangleIndex = int.MaxValue;
 434343        Physics3DHit best = default;
 434344        var queryOriginAnchor = new FixedPointAnchor(
 434345            origin,
 434346            FixedQuaternion.Identity,
 434347            Vector3d.Zero);
 348
 1742349        for (int i = 0; i < _meshTriangleCandidates.Count; i++)
 350        {
 437351            int triangleIndex = _meshTriangleCandidates[i];
 437352            mesh.Mesh.GetGeometryTriangleVertices(
 437353                triangleIndex,
 437354                out Vector3d first,
 437355                out Vector3d second,
 437356                out Vector3d third);
 437357            Vector3d normal = mesh.Mesh.GetFaceNormalWorld(triangleIndex);
 437358            if (!WideTriangleConeIntersection.TryGetMinimumAxialPoint(new FixedTriangle(first, second, third),
 437359                    mesh.Mesh.GeometryFrame, origin, direction, length, endRadius, out FixedPointAnchor pointAnchor))
 360            {
 361                continue;
 362            }
 363
 433364            Fixed64 axialDistance = FixedMath.Min(
 433365                pointAnchor.ProjectNonNegativeOffsetFrom(
 433366                    queryOriginAnchor,
 433367                    direction),
 433368                length);
 369
 433370            if (found
 433371                && (axialDistance > bestDistance
 433372                    || (axialDistance == bestDistance && triangleIndex >= bestTriangleIndex)))
 373            {
 374                continue;
 375            }
 376
 431377            _ = pointAnchor.TryGetOffsetFrom(
 431378                queryOriginAnchor,
 431379                out Vector3d toPoint);
 431380            best = new Physics3DHit(
 431381                mesh,
 431382                new ContactAnchor(pointAnchor),
 431383                normal,
 431384                axialDistance,
 431385                toPoint);
 431386            bestDistance = axialDistance;
 431387            bestTriangleIndex = triangleIndex;
 431388            found = true;
 389        }
 390
 434391        hit = best;
 434392        return found;
 393    }
 394
 395    private bool TryBuildConeHitForCompound(
 396        LSCompoundCollider compound,
 397        Vector3d origin,
 398        Vector3d baseCenter,
 399        Vector3d direction,
 400        Fixed64 length,
 401        Fixed64 endRadius,
 402        out Physics3DHit hit)
 403    {
 3404        bool found = false;
 3405        Physics3DHit best = default;
 18406        for (int i = 0; i < compound.PartCount; i++)
 407        {
 6408            if (!TryBuildConeHitForCollider(compound.GetPartCollider(i), origin, baseCenter, direction, length, endRadiu
 6409                || !PhysicsHitSelectionPolicy.ShouldReplace(partHit, found, best))
 410            {
 411                continue;
 412            }
 413
 2414            best = new Physics3DHit(compound, partHit.Anchor, partHit.Normal, partHit.Distance, partHit.Direction);
 2415            found = true;
 416        }
 417
 3418        hit = found ? best : default;
 3419        return found;
 420    }
 421
 422    private static bool IsPointInsideConeVolume(
 423        Vector3d origin,
 424        Vector3d direction,
 425        Fixed64 length,
 426        Fixed64 endRadius,
 427        Vector3d point,
 428        out Fixed64 axialDistance)
 429    {
 486430        if (!FixedSegment.ContainsPointInFiniteCone(
 486431                point,
 486432                origin,
 486433                direction,
 486434                length,
 486435                endRadius))
 436        {
 14437            axialDistance = default;
 14438            return false;
 439        }
 440
 472441        axialDistance = Vector3d.ProjectNonNegativeDifferenceParameter(point, origin, direction);
 472442        return true;
 443    }
 444
 445    private static Vector3d GetClosestPointOnConeAxis(
 446        Vector3d origin,
 447        Vector3d direction,
 448        Fixed64 length,
 449        Vector3d point)
 450    {
 477451        Fixed64 axial = FixedMath.Min(
 477452            Vector3d.ProjectNonNegativeDifferenceParameter(point, origin, direction),
 477453            length);
 477454        return new FixedRay(origin, direction).GetPoint(axial);
 455    }
 456
 457    private static void GetConeQueryBounds(
 458        Vector3d origin,
 459        Vector3d baseCenter,
 460        Vector3d direction,
 461        Fixed64 endRadius,
 462        out Vector3d min,
 463        out Vector3d max)
 464    {
 965465        ConeGeometry.CreateFiniteConeBounds(origin, baseCenter, direction, endRadius, out min, out max);
 965466    }
 467
 468    private static Vector3d ValidateConeQuery(
 469        Vector3d origin,
 470        Vector3d direction,
 471        Fixed64 length,
 472        Fixed64 endRadius,
 473        out Vector3d end)
 474    {
 541475        ChronicleGuard.ThrowIfArgument(
 541476            direction == Vector3d.Zero,
 541477            nameof(direction),
 541478            "Cone query direction must be non-zero.");
 539479        ChronicleGuard.ThrowIfArgument(
 539480            length <= Fixed64.Zero,
 539481            nameof(length),
 539482            "Cone query length must be greater than zero.");
 537483        ChronicleGuard.ThrowIfArgument(
 537484            endRadius <= Fixed64.Zero,
 537485            nameof(endRadius),
 537486            "Cone query end radius must be greater than zero.");
 487
 536488        Vector3d normalizedDirection = direction.Normalized;
 536489        ChronicleGuard.ThrowIfArgument(
 536490            !new FixedRay(origin, normalizedDirection).TryGetPoint(length, out end),
 536491            nameof(length),
 536492            "Cone query endpoint must be representable without fixed-point saturation.");
 534493        ColliderGeometryPolicy.ValidateFiniteAxisReach(endRadius, length, nameof(endRadius));
 531494        return normalizedDirection;
 495    }
 496}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/3D/GravitasQuery3DService.Raycast.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQuery3DService.Raycast.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using System.Runtime.CompilerServices;
 9using FixedMathSharp;
 10using Gravitas.Colliders;
 11using Gravitas.CollisionHandling;
 12using Gravitas.Support;
 13using GridForge.Grids;
 14using GridForge.Spatial;
 15using SwiftCollections;
 16
 17namespace Gravitas.Queries;
 18
 19/// <summary>
 20/// Owns 3D raycast, swept-sphere, and X/Z circle query buffers for one <see cref="GravitasWorldContext"/>.
 21/// </summary>
 22/// <content>Owns query services, shared buffers, raycasts and swept-source preparation.</content>
 23public sealed partial class GravitasQuery3DService
 24{
 25    private readonly GravitasWorldContext _context;
 1019126    private readonly RaycastSegmentWorker _worker = new();
 1019127    private readonly SweptSphereQueryWorker _sweepWorker = new();
 1019128    private readonly ConvexSweepQueryWorker _convexSweepWorker = new();
 1019129    private SwiftList<Vector3d> _bufferIntersectionPoints = new();
 1019130    private readonly SwiftList<int> _meshTriangleCandidates = new(16);
 1019131    private readonly SwiftList<int> _planarCircleCandidates = new();
 1019132    private readonly SwiftHashSet<int> _redundantColliderCheck = new();
 1019133    private readonly SwiftHashSet<WorldVoxelIndex> _redundantVoxelCheck = new();
 1019134    private readonly SwiftList<Voxel> _coveredVoxels = new();
 1019135    private readonly GridTraceScratch _traceScratch = new();
 36
 37    private PhysicsLayerMask _currentLayerMask;
 38    private LSCollider? _currentExcludedCollider;
 39    private LSCollider? _currentSweepSourceCollider;
 40    private ContinuousSurfaceTriangleAdmission? _currentSurfaceAdmission;
 41    private bool _currentStaticSweepTargetsOnly;
 42    private bool _currentIncludeTriggers;
 43
 44    /// <summary>
 45    /// Initializes a new raycast service for the supplied context.
 46    /// </summary>
 47    /// <param name="context">The owning world context.</param>
 1019148    public GravitasQuery3DService(GravitasWorldContext context)
 49    {
 1019150        ChronicleGuard.ThrowIfNull(context, nameof(context));
 1019151        _context = context;
 1019152    }
 53
 54    /// <summary>
 55    /// Gets the owning world context.
 56    /// </summary>
 157    public GravitasWorldContext Context => _context;
 58
 59    /// <summary>
 60    /// Gets the context-local raycast/sweep query version.
 61    /// </summary>
 62    public uint RaycastVersion { get; internal set; }
 63
 64    /// <summary>
 65    /// Gets the context-local partition-traversed sphere/cone deduplication version.
 66    /// </summary>
 67    public uint CircleVersion { get; internal set; }
 68
 69    internal int LastQueryCandidateCount { get; private set; }
 70
 71    internal int LastMeshTriangleCandidateCount { get; private set; }
 72
 73    /// <summary>
 74    /// Resets context-local raycast query buffers.
 75    /// </summary>
 76    public void Reset()
 77    {
 11478        EndQuery();
 11479        ResetColliderRaycastVersions();
 11480        ResetColliderCircleVersions();
 11481        RaycastVersion = 0;
 11482        CircleVersion = 0;
 11483        ResetLastQueryCounters();
 11484        ResetBatchCounters(0);
 11485        _bufferIntersectionPoints.FastClear();
 11486        _meshTriangleCandidates.FastClear();
 11487        _planarCircleCandidates.FastClear();
 11488        _batch3DHits.Clear();
 11489        _redundantColliderCheck.Clear();
 11490        _redundantVoxelCheck.Clear();
 11491    }
 92
 93    /// <summary>
 94    /// Performs a raycast from an origin in a direction up to a maximum distance.
 95    /// </summary>
 96    public bool Raycast(
 97        Vector3d origin,
 98        Vector3d direction,
 99        Fixed64 maxDistance,
 100        out Physics3DHit raycastHit,
 101        PhysicsLayerMask layerMask)
 102    {
 521103        _currentLayerMask = layerMask;
 521104        if (direction == Vector3d.Zero || maxDistance <= Fixed64.Zero)
 105        {
 3106            ResetLastQueryCounters();
 3107            raycastHit = default;
 3108            return false;
 109        }
 110
 518111        Vector3d rayDirection = direction.Normalized;
 518112        Vector3d requestedDisplacement = rayDirection * maxDistance;
 518113        if (!Vector3d.TryAdd(origin, requestedDisplacement, out Vector3d end))
 114        {
 1115            ResetLastQueryCounters();
 1116            raycastHit = default;
 1117            return false;
 118        }
 119
 517120        BeginRaycastTrace(origin, end);
 517121        bool hit = TryFindClosestHit(origin, end, rayDirection, out raycastHit);
 517122        _context.Diagnostics.EmitRayQuery(
 517123            origin,
 517124            end,
 517125            Fixed64.Zero,
 517126            layerMask.Bits,
 517127            hit,
 517128            hit ? 1 : 0,
 517129            raycastHit);
 517130        return hit;
 131    }
 132
 133    /// <summary>
 134    /// Executes a raycast between two points and writes hits from closest to farthest into caller-owned storage.
 135    /// </summary>
 136    public int RaycastAll(
 137        Vector3d start3d,
 138        Vector3d end3d,
 139        PhysicsLayerMask layerMask,
 140        SwiftList<Physics3DHit> results)
 141    {
 1892142        ChronicleGuard.ThrowIfNull(results, nameof(results));
 143
 1892144        _currentLayerMask = layerMask;
 1892145        results.Clear();
 146
 1892147        if (!Vector3d.TrySubtract(end3d, start3d, out Vector3d segment)
 1892148            || !Vector3d.TryGetMagnitude(segment, out Fixed64 segmentLength)
 1892149            || segmentLength == Fixed64.Zero)
 150        {
 82151            ResetLastQueryCounters();
 82152            return 0;
 153        }
 154
 1810155        BeginRaycastTrace(start3d, end3d);
 1810156        AddAllHits(start3d, end3d, segment.Normalized, results);
 1810157        Physics3DHitSorter.SortByDistance(results);
 1810158        _context.Diagnostics.EmitRayQuery(
 1810159            start3d,
 1810160            end3d,
 1810161            Fixed64.Zero,
 1810162            layerMask.Bits,
 1810163            results.Count > 0,
 1810164            results.Count,
 1810165            results.Count > 0 ? results[0] : default);
 1810166        return results.Count;
 167    }
 168
 169    /// <summary>
 170    /// Sweeps a sphere from an origin in a direction up to a maximum distance and returns the closest hit.
 171    /// </summary>
 172    public bool SweepSphere(
 173        Vector3d origin,
 174        Fixed64 radius,
 175        Vector3d direction,
 176        Fixed64 maxDistance,
 177        out Physics3DHit sweepHit,
 178        PhysicsLayerMask layerMask,
 179        LSCollider? excludedCollider = null)
 180    {
 1836181        ChronicleGuard.ThrowIfArgument(radius > ColliderGeometryPolicy.MaximumGeometryReach,
 1836182            nameof(radius), "Effective geometry reach must not exceed 4,096 world units.");
 1834183        if (direction == Vector3d.Zero || maxDistance <= Fixed64.Zero)
 184        {
 3185            ResetLastQueryCounters();
 3186            sweepHit = default;
 3187            return false;
 188        }
 189
 1831190        Vector3d sweepDirection = direction.Normalized;
 1831191        Vector3d requestedDisplacement = sweepDirection * maxDistance;
 1831192        if (!Vector3d.TryAdd(origin, requestedDisplacement, out Vector3d end))
 193        {
 1194            ResetLastQueryCounters();
 1195            sweepHit = default;
 1196            return false;
 197        }
 1830198        bool hit = SweepSphere(origin, end, radius, layerMask, excludedCollider, out sweepHit);
 1830199        _context.Diagnostics.EmitRayQuery(
 1830200            origin,
 1830201            end,
 1830202            radius,
 1830203            layerMask.Bits,
 1830204            hit,
 1830205            hit ? 1 : 0,
 1830206            sweepHit);
 1830207        return hit;
 208    }
 209
 210    /// <summary>
 211    /// Sweeps a sphere between two points and writes hits from closest to farthest into caller-owned storage.
 212    /// </summary>
 213    public int SweepSphereAll(
 214        Vector3d start3d,
 215        Vector3d end3d,
 216        Fixed64 radius,
 217        PhysicsLayerMask layerMask,
 218        SwiftList<Physics3DHit> results,
 219        LSCollider? excludedCollider = null)
 220    {
 12691221        return SweepSphereAllCore(
 12691222            start3d,
 12691223            end3d,
 12691224            radius,
 12691225            layerMask,
 12691226            results,
 12691227            excludedCollider,
 12691228            includeTriggers: true,
 12691229            staticTargetsOnly: false);
 230    }
 231
 232    internal int SweepSphereAgainstStaticAll(
 233        Vector3d start3d,
 234        Vector3d end3d,
 235        Fixed64 radius,
 236        PhysicsLayerMask layerMask,
 237        SwiftList<Physics3DHit> results,
 238        LSCollider? excludedCollider = null,
 239        bool includeTriggers = true)
 240    {
 7224241        return SweepSphereAllCore(
 7224242            start3d,
 7224243            end3d,
 7224244            radius,
 7224245            layerMask,
 7224246            results,
 7224247            excludedCollider,
 7224248            includeTriggers,
 7224249            staticTargetsOnly: true);
 250    }
 251
 252    internal int SweepExactSourceAgainstStaticAll(
 253        LSCollider source,
 254        Vector3d displacement,
 255        PhysicsLayerMask layerMask,
 256        SwiftList<Physics3DHit> results,
 257        LSCollider? excludedCollider = null,
 258        bool includeTriggers = true,
 259        ContinuousSurfaceTriangleAdmission? surfaceAdmission = null)
 260    {
 578261        ChronicleGuard.ThrowIfNull(source, nameof(source));
 578262        ChronicleGuard.ThrowIfNull(results, nameof(results));
 578263        return SweepRegisteredSourceAll(
 578264            source,
 578265            displacement,
 578266            layerMask,
 578267            results,
 578268            excludedCollider,
 578269            includeTriggers,
 578270            staticTargetsOnly: true,
 578271            surfaceAdmission: surfaceAdmission);
 272    }
 273
 274    /// <summary>
 275    /// Sweeps a capsule source by <paramref name="displacement"/> and returns the closest 3D target hit.
 276    /// </summary>
 277    public bool SweepCapsule(
 278        LSCapsuleCollider source,
 279        Vector3d displacement,
 280        PhysicsLayerMask layerMask,
 281        out Physics3DHit sweepHit,
 282        LSCollider? excludedCollider = null,
 283        bool includeTriggers = true)
 284    {
 85285        ChronicleGuard.ThrowIfNull(source, nameof(source));
 85286        return SweepRegisteredSource(source, displacement, layerMask, out sweepHit, excludedCollider, includeTriggers);
 287    }
 288
 289    /// <summary>
 290    /// Writes all 3D targets hit by sweeping a capsule source into caller-owned storage.
 291    /// </summary>
 292    public int SweepCapsuleAll(
 293        LSCapsuleCollider source,
 294        Vector3d displacement,
 295        PhysicsLayerMask layerMask,
 296        SwiftList<Physics3DHit> results,
 297        LSCollider? excludedCollider = null,
 298        bool includeTriggers = true)
 299    {
 96300        ChronicleGuard.ThrowIfNull(source, nameof(source));
 96301        ChronicleGuard.ThrowIfNull(results, nameof(results));
 96302        return SweepRegisteredSourceAll(source, displacement, layerMask, results, excludedCollider, includeTriggers);
 303    }
 304
 305    /// <summary>
 306    /// Sweeps a cuboid source by <paramref name="displacement"/> and returns the closest 3D target hit.
 307    /// </summary>
 308    public bool SweepCuboid(
 309        LSCuboidCollider source,
 310        Vector3d displacement,
 311        PhysicsLayerMask layerMask,
 312        out Physics3DHit sweepHit,
 313        LSCollider? excludedCollider = null,
 314        bool includeTriggers = true)
 315    {
 726316        ChronicleGuard.ThrowIfNull(source, nameof(source));
 726317        return SweepRegisteredSource(source, displacement, layerMask, out sweepHit, excludedCollider, includeTriggers);
 318    }
 319
 320    /// <summary>
 321    /// Writes all 3D targets hit by sweeping a cuboid source into caller-owned storage.
 322    /// </summary>
 323    public int SweepCuboidAll(
 324        LSCuboidCollider source,
 325        Vector3d displacement,
 326        PhysicsLayerMask layerMask,
 327        SwiftList<Physics3DHit> results,
 328        LSCollider? excludedCollider = null,
 329        bool includeTriggers = true)
 330    {
 707331        ChronicleGuard.ThrowIfNull(source, nameof(source));
 707332        ChronicleGuard.ThrowIfNull(results, nameof(results));
 707333        return SweepRegisteredSourceAll(source, displacement, layerMask, results, excludedCollider, includeTriggers);
 334    }
 335
 336    /// <summary>
 337    /// Sweeps a finite-cylinder source by <paramref name="displacement"/> and returns the closest 3D target hit.
 338    /// </summary>
 339    public bool SweepCylinder(
 340        LSCylinderCollider source,
 341        Vector3d displacement,
 342        PhysicsLayerMask layerMask,
 343        out Physics3DHit sweepHit,
 344        LSCollider? excludedCollider = null,
 345        bool includeTriggers = true)
 346    {
 30347        ChronicleGuard.ThrowIfNull(source, nameof(source));
 30348        return SweepRegisteredSource(source, displacement, layerMask, out sweepHit, excludedCollider, includeTriggers);
 349    }
 350
 351    /// <summary>
 352    /// Writes all 3D targets hit by sweeping a finite-cylinder source into caller-owned storage.
 353    /// </summary>
 354    public int SweepCylinderAll(
 355        LSCylinderCollider source,
 356        Vector3d displacement,
 357        PhysicsLayerMask layerMask,
 358        SwiftList<Physics3DHit> results,
 359        LSCollider? excludedCollider = null,
 360        bool includeTriggers = true)
 361    {
 1362        ChronicleGuard.ThrowIfNull(source, nameof(source));
 1363        ChronicleGuard.ThrowIfNull(results, nameof(results));
 1364        return SweepRegisteredSourceAll(source, displacement, layerMask, results, excludedCollider, includeTriggers);
 365    }
 366
 367    /// <summary>
 368    /// Sweeps a finite-cone source by <paramref name="displacement"/> and returns the closest 3D target hit.
 369    /// </summary>
 370    public bool SweepCone(
 371        LSConeCollider source,
 372        Vector3d displacement,
 373        PhysicsLayerMask layerMask,
 374        out Physics3DHit sweepHit,
 375        LSCollider? excludedCollider = null,
 376        bool includeTriggers = true)
 377    {
 25378        ChronicleGuard.ThrowIfNull(source, nameof(source));
 25379        return SweepRegisteredSource(source, displacement, layerMask, out sweepHit, excludedCollider, includeTriggers);
 380    }
 381
 382    /// <summary>
 383    /// Writes all 3D targets hit by sweeping a finite-cone source into caller-owned storage.
 384    /// </summary>
 385    public int SweepConeAll(
 386        LSConeCollider source,
 387        Vector3d displacement,
 388        PhysicsLayerMask layerMask,
 389        SwiftList<Physics3DHit> results,
 390        LSCollider? excludedCollider = null,
 391        bool includeTriggers = true)
 392    {
 1393        ChronicleGuard.ThrowIfNull(source, nameof(source));
 1394        ChronicleGuard.ThrowIfNull(results, nameof(results));
 1395        return SweepRegisteredSourceAll(source, displacement, layerMask, results, excludedCollider, includeTriggers);
 396    }
 397
 398    /// <summary>
 399    /// Sweeps a convex mesh source by <paramref name="displacement"/> and returns the closest 3D target hit.
 400    /// </summary>
 401    public bool SweepConvexMesh(
 402        LSMeshCollider source,
 403        Vector3d displacement,
 404        PhysicsLayerMask layerMask,
 405        out Physics3DHit sweepHit,
 406        LSCollider? excludedCollider = null,
 407        bool includeTriggers = true)
 408    {
 15409        ChronicleGuard.ThrowIfNull(source, nameof(source));
 15410        return SweepRegisteredSource(source, displacement, layerMask, out sweepHit, excludedCollider, includeTriggers);
 411    }
 412
 413    /// <summary>
 414    /// Writes all 3D targets hit by sweeping a convex mesh source into caller-owned storage.
 415    /// </summary>
 416    public int SweepConvexMeshAll(
 417        LSMeshCollider source,
 418        Vector3d displacement,
 419        PhysicsLayerMask layerMask,
 420        SwiftList<Physics3DHit> results,
 421        LSCollider? excludedCollider = null,
 422        bool includeTriggers = true)
 423    {
 56424        ChronicleGuard.ThrowIfNull(source, nameof(source));
 56425        ChronicleGuard.ThrowIfNull(results, nameof(results));
 56426        return SweepRegisteredSourceAll(source, displacement, layerMask, results, excludedCollider, includeTriggers);
 427    }
 428
 429    /// <summary>
 430    /// Sweeps an authored compound source by <paramref name="displacement"/> and returns the closest 3D target hit.
 431    /// </summary>
 432    public bool SweepCompound(
 433        LSCompoundCollider source,
 434        Vector3d displacement,
 435        PhysicsLayerMask layerMask,
 436        out Physics3DHit sweepHit,
 437        LSCollider? excludedCollider = null,
 438        bool includeTriggers = true)
 439    {
 10440        ChronicleGuard.ThrowIfNull(source, nameof(source));
 10441        return SweepRegisteredSource(source, displacement, layerMask, out sweepHit, excludedCollider, includeTriggers);
 442    }
 443
 444    /// <summary>
 445    /// Writes all 3D targets hit by sweeping an authored compound source into caller-owned storage.
 446    /// </summary>
 447    public int SweepCompoundAll(
 448        LSCompoundCollider source,
 449        Vector3d displacement,
 450        PhysicsLayerMask layerMask,
 451        SwiftList<Physics3DHit> results,
 452        LSCollider? excludedCollider = null,
 453        bool includeTriggers = true)
 454    {
 1455        ChronicleGuard.ThrowIfNull(source, nameof(source));
 1456        ChronicleGuard.ThrowIfNull(results, nameof(results));
 1457        return SweepRegisteredSourceAll(source, displacement, layerMask, results, excludedCollider, includeTriggers);
 458    }
 459
 460    private int SweepSphereAllCore(
 461        Vector3d start3d,
 462        Vector3d end3d,
 463        Fixed64 radius,
 464        PhysicsLayerMask layerMask,
 465        SwiftList<Physics3DHit> results,
 466        LSCollider? excludedCollider,
 467        bool includeTriggers,
 468        bool staticTargetsOnly)
 469    {
 19915470        ChronicleGuard.ThrowIfNull(results, nameof(results));
 19915471        ChronicleGuard.ThrowIfArgument(!staticTargetsOnly && radius > ColliderGeometryPolicy.MaximumGeometryReach,
 19915472            nameof(radius), "Effective geometry reach must not exceed 4,096 world units.");
 473
 19914474        results.Clear();
 19914475        if (!Vector3d.TrySubtract(end3d, start3d, out Vector3d segment)
 19914476            || !Vector3d.TryGetMagnitude(segment, out Fixed64 segmentLength)
 19914477            || segmentLength <= Fixed64.Epsilon
 19914478            || radius <= Fixed64.Zero)
 479        {
 133480            ResetLastQueryCounters();
 133481            return 0;
 482        }
 483
 484        try
 485        {
 19781486            BeginSweepTrace(start3d, end3d, radius, layerMask, excludedCollider, includeTriggers, staticTargetsOnly);
 19781487            AddAllSweepHits(start3d, end3d, segment.Normalized, radius, results);
 19781488            Physics3DHitSorter.SortByDistance(results);
 19781489            _context.Diagnostics.EmitRayQuery(
 19781490                start3d,
 19781491                end3d,
 19781492                radius,
 19781493                layerMask.Bits,
 19781494                results.Count > 0,
 19781495                results.Count,
 19781496                results.Count > 0 ? results[0] : default);
 19781497            return results.Count;
 498        }
 499        finally
 500        {
 19781501            EndQuery();
 19781502        }
 19781503    }
 504
 505    private bool SweepRegisteredSource(
 506        LSCollider source,
 507        Vector3d displacement,
 508        PhysicsLayerMask layerMask,
 509        out Physics3DHit sweepHit,
 510        LSCollider? excludedCollider,
 511        bool includeTriggers)
 512    {
 891513        EnsureSourceBelongsToContext(source);
 514        try
 515        {
 891516            PrepareConvexSweepSource(source, displacement);
 890517            sweepHit = default;
 890518            if (!Vector3d.TryGetMagnitude(displacement, out Fixed64 displacementLength)
 890519                || displacementLength <= Fixed64.Epsilon)
 520            {
 3521                ResetLastQueryCounters();
 3522                return false;
 523            }
 524
 887525            BeginConvexSweepTrace(source, layerMask, excludedCollider, includeTriggers);
 887526            bool hit = TryFindClosestConvexSweepHit(source, displacement, out sweepHit);
 887527            _context.Diagnostics.EmitRayQuery(
 887528                source.Center,
 887529                source.Center + displacement,
 887530                source.ScaledRadius,
 887531                layerMask.Bits,
 887532                hit,
 887533                hit ? 1 : 0,
 887534                sweepHit);
 887535            return hit;
 536        }
 537        finally
 538        {
 891539            EndQuery();
 891540        }
 890541    }
 542
 543    private int SweepRegisteredSourceAll(
 544        LSCollider source,
 545        Vector3d displacement,
 546        PhysicsLayerMask layerMask,
 547        SwiftList<Physics3DHit> results,
 548        LSCollider? excludedCollider,
 549        bool includeTriggers,
 550        bool staticTargetsOnly = false,
 551        ContinuousSurfaceTriangleAdmission? surfaceAdmission = null)
 552    {
 1440553        EnsureSourceBelongsToContext(source);
 554        try
 555        {
 1440556            _currentSurfaceAdmission = surfaceAdmission;
 1440557            PrepareConvexSweepSource(source, displacement);
 1440558            results.Clear();
 1440559            if (!Vector3d.TryGetMagnitude(displacement, out Fixed64 displacementLength)
 1440560                || displacementLength <= Fixed64.Epsilon)
 561            {
 3562                ResetLastQueryCounters();
 3563                return 0;
 564            }
 565
 1437566            BeginConvexSweepTrace(source, layerMask, excludedCollider, includeTriggers, staticTargetsOnly);
 1437567            AddAllConvexSweepHits(source, displacement, results);
 1437568            Physics3DHitSorter.SortByDistance(results);
 1437569            _context.Diagnostics.EmitRayQuery(
 1437570                source.Center,
 1437571                source.Center + displacement,
 1437572                source.ScaledRadius,
 1437573                layerMask.Bits,
 1437574                results.Count > 0,
 1437575                results.Count,
 1437576                results.Count > 0 ? results[0] : default);
 1437577            return results.Count;
 578        }
 579        finally
 580        {
 1440581            EndQuery();
 1440582        }
 1440583    }
 584
 585    private void EndQuery()
 586    {
 587        // Completed queries must not keep retired host object graphs alive.
 27961588        _currentExcludedCollider = null;
 27961589        _currentSweepSourceCollider = null;
 27961590        _currentSurfaceAdmission = null;
 27961591        _convexSweepWorker.ClearSource();
 27961592        _coveredVoxels.Clear();
 27961593        _traceScratch.Clear();
 27961594    }
 595
 596    private void BeginConvexSweepTrace(
 597        LSCollider source,
 598        PhysicsLayerMask layerMask,
 599        LSCollider? excludedCollider,
 600        bool includeTriggers,
 601        bool staticTargetsOnly = false)
 602    {
 2346603        _currentLayerMask = layerMask;
 2346604        _currentExcludedCollider = excludedCollider;
 2346605        _currentSweepSourceCollider = source;
 2346606        _currentIncludeTriggers = includeTriggers;
 2346607        _currentStaticSweepTargetsOnly = staticTargetsOnly;
 2346608        _redundantColliderCheck.Clear();
 2346609        _redundantVoxelCheck.Clear();
 2346610        ResetLastQueryCounters();
 2346611        NextRaycastVersion();
 2346612    }
 613
 614    private void BeginRaycastTrace(Vector3d start, Vector3d end)
 615    {
 3177616        _redundantColliderCheck.Clear();
 3177617        _redundantVoxelCheck.Clear();
 3177618        _bufferIntersectionPoints.FastClear();
 3177619        _currentExcludedCollider = null;
 3177620        _currentSweepSourceCollider = null;
 3177621        _currentStaticSweepTargetsOnly = false;
 3177622        _currentIncludeTriggers = true;
 3177623        ResetLastQueryCounters();
 3177624        NextRaycastVersion();
 3177625        _worker.PrepareSegmentCheck(start, end);
 3177626    }
 627
 628    private void BeginSweepTrace(
 629        Vector3d start,
 630        Vector3d end,
 631        Fixed64 radius,
 632        PhysicsLayerMask layerMask,
 633        LSCollider? excludedCollider,
 634        bool includeTriggers = true,
 635        bool staticTargetsOnly = false)
 636    {
 21616637        _currentLayerMask = layerMask;
 21616638        _currentExcludedCollider = excludedCollider;
 21616639        _currentSweepSourceCollider = null;
 21616640        _currentIncludeTriggers = includeTriggers;
 21616641        _currentStaticSweepTargetsOnly = staticTargetsOnly;
 21616642        _redundantColliderCheck.Clear();
 21616643        _redundantVoxelCheck.Clear();
 21616644        ResetLastQueryCounters();
 21616645        NextRaycastVersion();
 21616646        _sweepWorker.Prepare(start, end, radius);
 21616647    }
 648
 649    private bool SweepSphere(
 650        Vector3d start,
 651        Vector3d end,
 652        Fixed64 radius,
 653        PhysicsLayerMask layerMask,
 654        LSCollider? excludedCollider,
 655        out Physics3DHit sweepHit)
 656    {
 1838657        ChronicleGuard.ThrowIfArgument(radius > ColliderGeometryPolicy.MaximumGeometryReach,
 1838658            nameof(radius), "Effective geometry reach must not exceed 4,096 world units.");
 1838659        sweepHit = default;
 1838660        if (radius <= Fixed64.Zero)
 661        {
 2662            ResetLastQueryCounters();
 2663            return false;
 664        }
 665
 1836666        if (!Vector3d.TrySubtract(end, start, out Vector3d segment)
 1836667            || !Vector3d.TryGetMagnitude(segment, out Fixed64 segmentLength)
 1836668            || segmentLength <= Fixed64.Epsilon)
 669        {
 4670            ResetLastQueryCounters();
 4671            return false;
 672        }
 673
 1832674        Vector3d direction = segment.Normalized;
 675        try
 676        {
 1832677            BeginSweepTrace(start, end, radius, layerMask, excludedCollider);
 1832678            return TryFindClosestSweepHit(start, end, radius, direction, out sweepHit);
 679        }
 680        finally
 681        {
 1832682            EndQuery();
 1832683        }
 1832684    }
 685
 686    private bool TryFindClosestSweepHit(
 687        Vector3d start,
 688        Vector3d end,
 689        Fixed64 radius,
 690        Vector3d direction,
 691        out Physics3DHit sweepHit)
 692    {
 1832693        bool found = false;
 1832694        Physics3DHit closestHit = default;
 695
 1832696        TraceSweepForClosestHit(start, end, radius, direction, ref found, ref closestHit);
 697
 1832698        sweepHit = closestHit;
 1832699        return found;
 700    }
 701
 702    private bool TryFindClosestHit(Vector3d start, Vector3d end, Vector3d direction, out Physics3DHit raycastHit)
 703    {
 939704        bool found = false;
 939705        Physics3DHit closestHit = default;
 706
 939707        TraceLineForClosestHit(start, end, direction, ref found, ref closestHit);
 708
 939709        raycastHit = closestHit;
 939710        return found;
 711    }
 712
 713    private void AddAllHits(Vector3d start, Vector3d end, Vector3d direction, SwiftList<Physics3DHit> results)
 714    {
 2238715        TraceLineForAllHits(start, end, direction, results);
 2238716    }
 717
 718    private void AddAllSweepHits(
 719        Vector3d start,
 720        Vector3d end,
 721        Vector3d direction,
 722        Fixed64 radius,
 723        SwiftList<Physics3DHit> results)
 724    {
 19784725        TraceSweepForAllHits(start, end, radius, direction, results);
 19784726    }
 727
 728    private bool TryFindClosestConvexSweepHit(
 729        LSCollider source,
 730        Vector3d displacement,
 731        out Physics3DHit sweepHit)
 732    {
 898733        bool found = false;
 898734        Physics3DHit closestHit = default;
 735
 898736        TraceConvexSweepForClosestHit(source, displacement, ref found, ref closestHit);
 737
 898738        sweepHit = closestHit;
 898739        return found;
 740    }
 741
 742    private void AddAllConvexSweepHits(
 743        LSCollider source,
 744        Vector3d displacement,
 745        SwiftList<Physics3DHit> results)
 746    {
 1448747        TraceConvexSweepForAllHits(source, displacement, results);
 1448748    }
 749
 750    private bool TryBuildHitForCollider(
 751        int colliderId,
 752        Vector3d origin,
 753        Vector3d direction,
 754        out Physics3DHit hit)
 755    {
 9244756        hit = default;
 9244757        return _context.Physics.TryGetColliderById(colliderId, out LSCollider? current)
 9244758            && DoesCurrentColliderIntersectRay(current!)
 9244759            && TryBuildHit(current!, origin, direction, out hit);
 760    }
 761
 762    private bool TryBuildSweepHitForCollider(
 763        int colliderId,
 764        Vector3d origin,
 765        Vector3d direction,
 766        out Physics3DHit hit)
 767    {
 1083024768        hit = default;
 1083024769        return _context.Physics.TryGetColliderById(colliderId, out LSCollider? current)
 1083024770            && IsSweepCandidate(current!)
 1083024771            && TryBuildSweepHit(current!, origin, direction, out hit);
 772    }
 773
 774    private bool TryBuildConvexSweepHitForCollider(int colliderId, out Physics3DHit hit)
 775    {
 104673776        hit = default;
 104673777        if (!_context.Physics.TryGetColliderById(colliderId, out LSCollider? current)
 104673778            || !IsSweepCandidate(current!))
 779        {
 102389780            return false;
 781        }
 782
 2284783        bool found = _convexSweepWorker.TrySweepPreparedSource(current!, out hit,
 2284784            requireClosingInitialContact: _currentStaticSweepTargetsOnly,
 2284785            admitTriangle: current is LSMeshCollider { StaticSurface: not null } ? _currentSurfaceAdmission : null);
 2284786        LastMeshTriangleCandidateCount += _convexSweepWorker.LastMeshTriangleCandidateCount;
 2284787        return found;
 788    }
 789
 790    private bool TryBuildHit(
 791        LSCollider collider,
 792        Vector3d origin,
 793        Vector3d direction,
 794        out Physics3DHit raycastHit)
 795    {
 3507796        Fixed64 closestDistance = Fixed64.MaxValue;
 3507797        Vector3d closestIntersection = Vector3d.Zero;
 798
 18744799        for (int i = _bufferIntersectionPoints.Count - 1; i >= 0; i--)
 800        {
 5865801            Fixed64 dist = Vector3d.Distance(_bufferIntersectionPoints[i], origin);
 5865802            if (dist < closestDistance)
 803            {
 5837804                closestDistance = dist;
 5837805                closestIntersection = _bufferIntersectionPoints[i];
 806            }
 807        }
 808
 3507809        if (closestDistance == Fixed64.MaxValue)
 810        {
 2811            raycastHit = default;
 2812            return false;
 813        }
 814
 3505815        Vector3d normal = collider.GetNormalAtPoint(closestIntersection);
 3505816        raycastHit = new Physics3DHit(collider, closestIntersection, normal, closestDistance, direction);
 3505817        return true;
 818    }
 819
 820    private bool TryBuildSweepHit(
 821        LSCollider collider,
 822        Vector3d origin,
 823        Vector3d direction,
 824        out Physics3DHit sweepHit)
 825    {
 19102826        sweepHit = default;
 19102827        bool found = _sweepWorker.TrySweep(collider, out Vector3d sweepCenter, out Fixed64 distance);
 19102828        LastMeshTriangleCandidateCount += _sweepWorker.LastMeshTriangleCandidateCount;
 19102829        if (!found)
 6717830            return false;
 831
 832        // Admitted source/target reach bounds a hit's surface separation even at world limits.
 12385833        bool resolved = ContinuousCollisionContactPolicy.TryResolveSweptSphereContact(
 12385834                collider,
 12385835                sweepCenter,
 12385836                direction,
 12385837                out ContactAnchor anchor,
 12385838                out Vector3d normal);
 839        System.Diagnostics.Debug.Assert(resolved);
 840
 12385841        sweepHit = new Physics3DHit(collider, anchor, normal, distance, direction);
 12385842        return true;
 843    }
 844
 845    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 846    private void ResetLastQueryCounters()
 847    {
 28268848        LastQueryCandidateCount = 0;
 28268849        LastMeshTriangleCandidateCount = 0;
 28268850    }
 851
 852    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 853    private uint NextRaycastVersion()
 854    {
 27139855        _context.RefreshQueryPartitions();
 27139856        RaycastVersion++;
 27139857        if (RaycastVersion == 0)
 858        {
 1859            ResetColliderRaycastVersions();
 1860            RaycastVersion = 1;
 861        }
 862
 27139863        return RaycastVersion;
 864    }
 865
 866    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 867    private uint NextCircleVersion()
 868    {
 703869        _context.RefreshQueryPartitions();
 703870        CircleVersion++;
 703871        if (CircleVersion == 0)
 872        {
 1873            ResetColliderCircleVersions();
 1874            CircleVersion = 1;
 875        }
 876
 703877        return CircleVersion;
 878    }
 879
 880    private void ResetColliderRaycastVersions()
 881    {
 234882        for (int i = 0; i < _context.Physics.ColliderCount; i++)
 2883            _context.Physics.GetColliderByServiceIndex(i).RaycastVersion = 0;
 115884    }
 885
 886    private void ResetColliderCircleVersions()
 887    {
 234888        for (int i = 0; i < _context.Physics.ColliderCount; i++)
 2889            _context.Physics.GetColliderByServiceIndex(i).CircleQueryVersion = 0;
 115890    }
 891
 892    private bool DoesCurrentColliderIntersectRay(LSCollider current)
 893    {
 9244894        if (!_currentLayerMask.Includes(current.Layer)
 9244895            || current.RaycastVersion == RaycastVersion
 9244896            || !_redundantColliderCheck.Add(current.Id))
 897        {
 5181898            return false;
 899        }
 900
 4063901        current.RaycastVersion = RaycastVersion;
 4063902        _bufferIntersectionPoints.FastClear();
 4063903        return current.ColliderOverlapsRay(_worker, ref _bufferIntersectionPoints);
 904    }
 905
 906    private bool IsSweepCandidate(LSCollider current)
 907    {
 1187670908        if (ReferenceEquals(current, _currentExcludedCollider)
 1187670909            || ReferenceEquals(current, _currentSweepSourceCollider)
 1187670910            || IsExcludedByCurrentSweepSource(current)
 1187670911            || !_currentLayerMask.Includes(current.Layer)
 1187670912            || current.RaycastVersion == RaycastVersion
 1187670913            || !_redundantColliderCheck.Add(current.Id))
 914        {
 1166281915            return false;
 916        }
 917
 21389918        if (!_currentIncludeTriggers && current.IsTrigger)
 2919            return false;
 920
 21387921        if (_currentStaticSweepTargetsOnly && !IsStaticStyleSweepTarget(current))
 1922            return false;
 923
 21386924        current.RaycastVersion = RaycastVersion;
 21386925        LastQueryCandidateCount++;
 21386926        return true;
 927    }
 928
 929    private bool IsExcludedByCurrentSweepSource(LSCollider current)
 930    {
 471365931        if (_currentSweepSourceCollider != null
 471365932            && _context.Constraints3D.ShouldExcludeLinkedCollision(_currentSweepSourceCollider, current))
 933        {
 27934            return true;
 935        }
 936
 471338937        return _currentExcludedCollider != null
 471338938            && _context.Constraints3D.ShouldExcludeLinkedCollision(_currentExcludedCollider, current);
 939    }
 940
 941    private void EnsureSourceBelongsToContext(LSCollider source)
 942    {
 2369943        ChronicleGuard.ThrowIfArgument(
 2369944            !ReferenceEquals(source.Context, _context),
 2369945            nameof(source),
 2369946            "Sweep source collider must belong to this query service context.");
 2369947    }
 948
 949    private void PrepareConvexSweepSource(LSCollider source, Vector3d displacement)
 950    {
 951        switch (source)
 952        {
 953            case LSMeshCollider mesh:
 87954                _convexSweepWorker.PrepareConvexMeshSource(mesh, displacement);
 86955                return;
 956            case LSCompoundCollider compound:
 23957                _convexSweepWorker.PrepareCompoundSource(compound, displacement);
 23958                return;
 959            default:
 2253960                _convexSweepWorker.PreparePrimitiveSource(source, displacement);
 2253961                return;
 962        }
 963    }
 964
 965    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 966    private static bool IsStaticStyleSweepTarget(LSCollider collider)
 967    {
 7595968        SolidBody? body = collider.Body;
 7595969        return collider.IsStatic || body!.IsKinematic;
 970    }
 971
 972}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/3D/GravitasQuery3DService.Raycast.Traversal.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQuery3DService.Raycast.Traversal.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using FixedMathSharp;
 9using Gravitas.Colliders;
 10using GridForge.Grids;
 11using GridForge.Utility;
 12using SwiftCollections;
 13
 14namespace Gravitas.Queries;
 15
 16/// <content>
 17/// Owns partition traversal for 3D raycasts, swept spheres, and registered-source sweeps.
 18/// </content>
 19public sealed partial class GravitasQuery3DService
 20{
 21    private void TraceLineForClosestHit(
 22        Vector3d start,
 23        Vector3d end,
 24        Vector3d direction,
 25        ref bool found,
 26        ref Physics3DHit closestHit)
 27    {
 28        try
 29        {
 93930            GridTracer.TraceLineInto(_context.World, start, end, _coveredVoxels, _traceScratch);
 1296431            for (int i = 0; i < _coveredVoxels.Count; i++)
 554332                ProcessTraceVoxelForClosestHit(
 554333                    _coveredVoxels[i],
 554334                    start,
 554335                    direction,
 554336                    ref found,
 554337                    ref closestHit);
 93938        }
 39        finally
 40        {
 93941            EndQuery();
 93942        }
 93943    }
 44
 45    private void TraceLineForAllHits(
 46        Vector3d start,
 47        Vector3d end,
 48        Vector3d direction,
 49        SwiftList<Physics3DHit> results)
 50    {
 51        try
 52        {
 223853            GridTracer.TraceLineInto(_context.World, start, end, _coveredVoxels, _traceScratch);
 1775054            for (int i = 0; i < _coveredVoxels.Count; i++)
 663755                ProcessTraceVoxelForAllHits(_coveredVoxels[i], start, direction, results);
 223856        }
 57        finally
 58        {
 223859            EndQuery();
 223860        }
 223861    }
 62
 63    private void TraceSweepForClosestHit(
 64        Vector3d start,
 65        Vector3d end,
 66        Fixed64 radius,
 67        Vector3d direction,
 68        ref bool found,
 69        ref Physics3DHit closestHit)
 70    {
 183271        PrepareSweepBounds(start, end, radius, out Vector3d coverageMin, out Vector3d coverageMax);
 183272        GridTracer.GetCoveredVoxelsInto(_context.World, coverageMin, coverageMax, _coveredVoxels, _traceScratch);
 11320473        for (int i = 0; i < _coveredVoxels.Count; i++)
 5477074            ProcessSweepVoxelForClosestHit(
 5477075                _coveredVoxels[i],
 5477076                start,
 5477077                direction,
 5477078                ref found,
 5477079                ref closestHit);
 183280    }
 81
 82    private void TraceSweepForAllHits(
 83        Vector3d start,
 84        Vector3d end,
 85        Fixed64 radius,
 86        Vector3d direction,
 87        SwiftList<Physics3DHit> results)
 88    {
 1978489        PrepareSweepBounds(start, end, radius, out Vector3d coverageMin, out Vector3d coverageMax);
 1978490        GridTracer.GetCoveredVoxelsInto(_context.World, coverageMin, coverageMax, _coveredVoxels, _traceScratch);
 227003091        for (int i = 0; i < _coveredVoxels.Count; i++)
 111523192            ProcessSweepVoxelForAllHits(_coveredVoxels[i], start, direction, results);
 1978493    }
 94
 95    private void TraceConvexSweepForClosestHit(
 96        LSCollider source,
 97        Vector3d displacement,
 98        ref bool found,
 99        ref Physics3DHit closestHit)
 100    {
 898101        PrepareConvexSweepBounds(source, displacement, out Vector3d coverageMin, out Vector3d coverageMax);
 898102        GridTracer.GetCoveredVoxelsInto(_context.World, coverageMin, coverageMax, _coveredVoxels, _traceScratch);
 71700103        for (int i = 0; i < _coveredVoxels.Count; i++)
 34952104            ProcessConvexSweepVoxelForClosestHit(
 34952105                _coveredVoxels[i],
 34952106                ref found,
 34952107                ref closestHit);
 898108    }
 109
 110    private void TraceConvexSweepForAllHits(
 111        LSCollider source,
 112        Vector3d displacement,
 113        SwiftList<Physics3DHit> results)
 114    {
 1448115        PrepareConvexSweepBounds(source, displacement, out Vector3d coverageMin, out Vector3d coverageMax);
 1448116        GridTracer.GetCoveredVoxelsInto(_context.World, coverageMin, coverageMax, _coveredVoxels, _traceScratch);
 140492117        for (int i = 0; i < _coveredVoxels.Count; i++)
 68798118            ProcessConvexSweepVoxelForAllHits(_coveredVoxels[i], results);
 1448119    }
 120
 121    private void PrepareSweepBounds(
 122        Vector3d start,
 123        Vector3d end,
 124        Fixed64 radius,
 125        out Vector3d coverageMin,
 126        out Vector3d coverageMax)
 127    {
 21616128        Vector3d radiusExtents = Vector3d.One * radius;
 21616129        coverageMin = Vector3d.Min(start, end) - radiusExtents;
 21616130        coverageMax = Vector3d.Max(start, end) + radiusExtents;
 21616131    }
 132
 133    private static void PrepareConvexSweepBounds(
 134        LSCollider source,
 135        Vector3d displacement,
 136        out Vector3d coverageMin,
 137        out Vector3d coverageMax)
 138    {
 2346139        coverageMin = Vector3d.Min(source.BoundsMin, source.BoundsMin + displacement);
 2346140        coverageMax = Vector3d.Max(source.BoundsMax, source.BoundsMax + displacement);
 2346141    }
 142
 143    private void ProcessTraceVoxelForClosestHit(
 144        Voxel voxel,
 145        Vector3d origin,
 146        Vector3d direction,
 147        ref bool found,
 148        ref Physics3DHit closestHit)
 149    {
 5543150        if (!GridTraversal.TryGetUniquePartition(voxel, _redundantVoxelCheck, out PhysicsPartition? partition))
 151        {
 2690152            return;
 153        }
 154
 2853155        ProcessPartitionForClosestHit(
 2853156            partition!,
 2853157            origin,
 2853158            direction,
 2853159            ref found,
 2853160            ref closestHit);
 2853161    }
 162
 163    private void ProcessTraceVoxelForAllHits(
 164        Voxel voxel,
 165        Vector3d origin,
 166        Vector3d direction,
 167        SwiftList<Physics3DHit> results)
 168    {
 6637169        if (!GridTraversal.TryGetUniquePartition(voxel, _redundantVoxelCheck, out PhysicsPartition? partition))
 170        {
 2409171            return;
 172        }
 173
 4228174        ProcessPartitionForAllHits(partition!, origin, direction, results);
 4228175    }
 176
 177    private void ProcessSweepVoxelForClosestHit(
 178        Voxel voxel,
 179        Vector3d origin,
 180        Vector3d direction,
 181        ref bool found,
 182        ref Physics3DHit closestHit)
 183    {
 54770184        if (!GridTraversal.TryGetUniquePartition(voxel, _redundantVoxelCheck, out PhysicsPartition? partition))
 185        {
 16933186            return;
 187        }
 188
 37837189        ProcessPartitionForClosestSweepHit(
 37837190            partition!,
 37837191            origin,
 37837192            direction,
 37837193            ref found,
 37837194            ref closestHit);
 37837195    }
 196
 197    private void ProcessSweepVoxelForAllHits(
 198        Voxel voxel,
 199        Vector3d origin,
 200        Vector3d direction,
 201        SwiftList<Physics3DHit> results)
 202    {
 1115231203        if (!GridTraversal.TryGetUniquePartition(voxel, _redundantVoxelCheck, out PhysicsPartition? partition))
 204        {
 230808205            return;
 206        }
 207
 884423208        ProcessPartitionForAllSweepHits(partition!, origin, direction, results);
 884423209    }
 210
 211    private void ProcessConvexSweepVoxelForClosestHit(
 212        Voxel voxel,
 213        ref bool found,
 214        ref Physics3DHit closestHit)
 215    {
 34952216        if (!GridTraversal.TryGetUniquePartition(voxel, _redundantVoxelCheck, out PhysicsPartition? partition))
 217        {
 8296218            return;
 219        }
 220
 26656221        ProcessPartitionForClosestConvexSweepHit(
 26656222            partition!,
 26656223            ref found,
 26656224            ref closestHit);
 26656225    }
 226
 227    private void ProcessConvexSweepVoxelForAllHits(
 228        Voxel voxel,
 229        SwiftList<Physics3DHit> results)
 230    {
 68798231        if (!GridTraversal.TryGetUniquePartition(voxel, _redundantVoxelCheck, out PhysicsPartition? partition))
 232        {
 19088233            return;
 234        }
 235
 49710236        ProcessPartitionForAllConvexSweepHits(partition!, results);
 49710237    }
 238
 239    private void ProcessPartitionForClosestHit(
 240        PhysicsPartition partition,
 241        Vector3d origin,
 242        Vector3d direction,
 243        ref bool found,
 244        ref Physics3DHit closestHit)
 245    {
 2853246        ProcessColliderListForClosestHit(
 2853247            partition.ContainedDynamicObjects,
 2853248            origin,
 2853249            direction,
 2853250            ref found,
 2853251            ref closestHit);
 252
 2853253        ProcessColliderListForClosestHit(
 2853254            partition.ContainedKinematicObjects,
 2853255            origin,
 2853256            direction,
 2853257            ref found,
 2853258            ref closestHit);
 259
 2853260        ProcessColliderListForClosestHit(
 2853261            partition.ContainedStaticObjects,
 2853262            origin,
 2853263            direction,
 2853264            ref found,
 2853265            ref closestHit);
 2853266    }
 267
 268    private void ProcessColliderListForClosestHit(
 269        SwiftHashSet<int>? colliderIds,
 270        Vector3d origin,
 271        Vector3d direction,
 272        ref bool found,
 273        ref Physics3DHit closestHit)
 274    {
 8559275        if (colliderIds == null)
 5046276            return;
 277
 14396278        foreach (int colliderId in colliderIds)
 279        {
 3685280            if (!TryBuildHitForCollider(colliderId, origin, direction, out Physics3DHit hit)
 3685281                || !PhysicsHitSelectionPolicy.ShouldReplace(hit, found, closestHit))
 282            {
 283                continue;
 284            }
 285
 720286            found = true;
 720287            closestHit = hit;
 288        }
 3513289    }
 290
 291    private void ProcessPartitionForAllHits(
 292        PhysicsPartition partition,
 293        Vector3d origin,
 294        Vector3d direction,
 295        SwiftList<Physics3DHit> results)
 296    {
 4228297        ProcessColliderListForAllHits(partition.ContainedDynamicObjects, origin, direction, results);
 4228298        ProcessColliderListForAllHits(partition.ContainedKinematicObjects, origin, direction, results);
 4228299        ProcessColliderListForAllHits(partition.ContainedStaticObjects, origin, direction, results);
 4228300    }
 301
 302    private void ProcessColliderListForAllHits(
 303        SwiftHashSet<int>? colliderIds,
 304        Vector3d origin,
 305        Vector3d direction,
 306        SwiftList<Physics3DHit> results)
 307    {
 12684308        if (colliderIds == null)
 7933309            return;
 310
 20620311        foreach (int colliderId in colliderIds)
 312        {
 5559313            if (TryBuildHitForCollider(colliderId, origin, direction, out Physics3DHit hit))
 2353314                results.Add(hit);
 315        }
 4751316    }
 317
 318    private void ProcessPartitionForClosestSweepHit(
 319        PhysicsPartition partition,
 320        Vector3d origin,
 321        Vector3d direction,
 322        ref bool found,
 323        ref Physics3DHit closestHit)
 324    {
 37837325        ProcessColliderListForClosestSweepHit(
 37837326            partition.ContainedDynamicObjects,
 37837327            origin,
 37837328            direction,
 37837329            ref found,
 37837330            ref closestHit);
 331
 37837332        ProcessColliderListForClosestSweepHit(
 37837333            partition.ContainedKinematicObjects,
 37837334            origin,
 37837335            direction,
 37837336            ref found,
 37837337            ref closestHit);
 338
 37837339        ProcessColliderListForClosestSweepHit(
 37837340            partition.ContainedStaticObjects,
 37837341            origin,
 37837342            direction,
 37837343            ref found,
 37837344            ref closestHit);
 37837345    }
 346
 347    private void ProcessColliderListForClosestSweepHit(
 348        SwiftHashSet<int>? colliderIds,
 349        Vector3d origin,
 350        Vector3d direction,
 351        ref bool found,
 352        ref Physics3DHit closestHit)
 353    {
 113511354        if (colliderIds == null)
 75488355            return;
 356
 152542357        foreach (int colliderId in colliderIds)
 358        {
 38248359            if (!TryBuildSweepHitForCollider(colliderId, origin, direction, out Physics3DHit hit)
 38248360                || !PhysicsHitSelectionPolicy.ShouldReplace(hit, found, closestHit))
 361            {
 362                continue;
 363            }
 364
 1827365            found = true;
 1827366            closestHit = hit;
 367        }
 38023368    }
 369
 370    private void ProcessPartitionForAllSweepHits(
 371        PhysicsPartition partition,
 372        Vector3d origin,
 373        Vector3d direction,
 374        SwiftList<Physics3DHit> results)
 375    {
 884423376        if (!_currentStaticSweepTargetsOnly)
 516558377            ProcessColliderListForAllSweepHits(partition.ContainedDynamicObjects, origin, direction, results);
 378
 884423379        ProcessColliderListForAllSweepHits(partition.ContainedKinematicObjects, origin, direction, results);
 884423380        ProcessColliderListForAllSweepHits(partition.ContainedStaticObjects, origin, direction, results);
 884423381    }
 382
 383    private void ProcessPartitionForClosestConvexSweepHit(
 384        PhysicsPartition partition,
 385        ref bool found,
 386        ref Physics3DHit closestHit)
 387    {
 26656388        ProcessColliderListForClosestConvexSweepHit(
 26656389            partition.ContainedDynamicObjects,
 26656390            ref found,
 26656391            ref closestHit);
 392
 26656393        ProcessColliderListForClosestConvexSweepHit(
 26656394            partition.ContainedKinematicObjects,
 26656395            ref found,
 26656396            ref closestHit);
 397
 26656398        ProcessColliderListForClosestConvexSweepHit(
 26656399            partition.ContainedStaticObjects,
 26656400            ref found,
 26656401            ref closestHit);
 26656402    }
 403
 404    private void ProcessPartitionForAllConvexSweepHits(
 405        PhysicsPartition partition,
 406        SwiftList<Physics3DHit> results)
 407    {
 49710408        if (!_currentStaticSweepTargetsOnly)
 28374409            ProcessColliderListForAllConvexSweepHits(partition.ContainedDynamicObjects, results);
 410
 49710411        ProcessColliderListForAllConvexSweepHits(partition.ContainedKinematicObjects, results);
 49710412        ProcessColliderListForAllConvexSweepHits(partition.ContainedStaticObjects, results);
 49710413    }
 414
 415    private void ProcessColliderListForAllSweepHits(
 416        SwiftHashSet<int>? colliderIds,
 417        Vector3d origin,
 418        Vector3d direction,
 419        SwiftList<Physics3DHit> results)
 420    {
 2285404421        if (colliderIds == null)
 1260942422            return;
 423
 4138476424        foreach (int colliderId in colliderIds)
 425        {
 1044776426            if (TryBuildSweepHitForCollider(colliderId, origin, direction, out Physics3DHit hit))
 10552427                results.Add(hit);
 428        }
 1024462429    }
 430
 431    private void ProcessColliderListForClosestConvexSweepHit(
 432        SwiftHashSet<int>? colliderIds,
 433        ref bool found,
 434        ref Physics3DHit closestHit)
 435    {
 79968436        if (colliderIds == null)
 47804437            return;
 438
 155698439        foreach (int colliderId in colliderIds)
 440        {
 45685441            if (!TryBuildConvexSweepHitForCollider(colliderId, out Physics3DHit hit)
 45685442                || !PhysicsHitSelectionPolicy.ShouldReplace(hit, found, closestHit))
 443            {
 444                continue;
 445            }
 446
 890447            found = true;
 890448            closestHit = hit;
 449        }
 32164450    }
 451
 452    private void ProcessColliderListForAllConvexSweepHits(
 453        SwiftHashSet<int>? colliderIds,
 454        SwiftList<Physics3DHit> results)
 455    {
 127794456        if (colliderIds == null)
 85000457            return;
 458
 203564459        foreach (int colliderId in colliderIds)
 460        {
 58988461            if (TryBuildConvexSweepHitForCollider(colliderId, out Physics3DHit hit))
 1029462                results.Add(hit);
 463        }
 42794464    }
 465
 466}

Methods/Properties

.ctor(Gravitas.GravitasWorldContext)
RaycastBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsRaycast3DRequest>,System.Span`1<Gravitas.Queries.Physics3DHit>)
RaycastAllBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsRaycast3DRequest>,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
SweepSphereBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepSphere3DRequest>,System.Span`1<Gravitas.Queries.Physics3DHit>)
SweepSphereAllBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepSphere3DRequest>,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
SweepCapsuleBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepCapsule3DRequest>,System.Span`1<Gravitas.Queries.Physics3DHit>)
SweepCapsuleAllBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepCapsule3DRequest>,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
SweepCuboidBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepCuboid3DRequest>,System.Span`1<Gravitas.Queries.Physics3DHit>)
SweepCuboidAllBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepCuboid3DRequest>,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
SweepCylinderBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepCylinder3DRequest>,System.Span`1<Gravitas.Queries.Physics3DHit>)
SweepCylinderAllBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepCylinder3DRequest>,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
SweepConeBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepCone3DRequest>,System.Span`1<Gravitas.Queries.Physics3DHit>)
SweepConeAllBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepCone3DRequest>,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
SweepConvexMeshBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepConvexMesh3DRequest>,System.Span`1<Gravitas.Queries.Physics3DHit>)
SweepConvexMeshAllBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepConvexMesh3DRequest>,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
SweepCompoundBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepCompound3DRequest>,System.Span`1<Gravitas.Queries.Physics3DHit>)
SweepCompoundAllBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepCompound3DRequest>,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
OverlapCircleBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsOverlapCircle3DRequest>,System.Span`1<Gravitas.Queries.Physics3DHit>)
OverlapCircleAllBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsOverlapCircle3DRequest>,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
OverlapConeBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsOverlapCone3DRequest>,System.Span`1<Gravitas.Queries.Physics3DHit>)
OverlapConeAllBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsOverlapCone3DRequest>,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
OverlapCircleInDirectionBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsOverlapCircleInDirection3DRequest>,System.Span`1<Gravitas.Queries.Physics3DHit>)
TryRaycastBatchRequest(Gravitas.Queries.PhysicsRaycast3DRequest,Gravitas.Queries.Physics3DHit&)
RaycastAllBatchRequest(Gravitas.Queries.PhysicsRaycast3DRequest,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
SweepSphereAllBatchRequest(Gravitas.Queries.PhysicsSweepSphere3DRequest,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
TrySweepSourceBatchRequest(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,Gravitas.Colliders.LSCollider,System.Boolean,Gravitas.Colliders.LSCollider&,FixedMathSharp.Vector3d&,Gravitas.Queries.Physics3DHit&)
SweepSourceAllBatchRequest(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,Gravitas.Colliders.LSCollider,System.Boolean,Gravitas.Colliders.LSCollider&,FixedMathSharp.Vector3d&,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
PrepareBatchConvexSweepSource(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,Gravitas.Colliders.LSCollider&,FixedMathSharp.Vector3d&)
TryOverlapCircleBatchRequest(Gravitas.Queries.PhysicsOverlapCircle3DRequest,Gravitas.Queries.Physics3DHit&)
OverlapCircleAllBatchRequest(Gravitas.Queries.PhysicsOverlapCircle3DRequest,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
TryOverlapCircleInDirectionBatchRequest(Gravitas.Queries.PhysicsOverlapCircleInDirection3DRequest,Gravitas.Queries.Physics3DHit&)
TryOverlapConeBatchRequest(Gravitas.Queries.PhysicsOverlapCone3DRequest,Gravitas.Queries.Physics3DHit&)
ValidateOverlapCircleRequests(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsOverlapCircle3DRequest>)
ValidateOverlapCircleRequests(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsOverlapCircleInDirection3DRequest>)
ValidateSweepSphereRequests(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepSphere3DRequest>)
ValidateOverlapConeEnvelopes(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsOverlapCone3DRequest>)
OverlapConeAllBatchRequest(Gravitas.Queries.PhysicsOverlapCone3DRequest,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
WriteClosestHit(System.Span`1<Gravitas.Queries.Physics3DHit>,System.Int32,Gravitas.Queries.Physics3DHit,System.Boolean,System.Int32&)
AppendRange(SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>,System.Int32,System.Int32)
ResetBatchCounters(System.Int32)
AccumulateBatchCounters(System.Int32)
ValidateClosestBatchOutput(System.Int32,System.Span`1<Gravitas.Queries.Physics3DHit>)
ValidateRangeBatchOutput(System.Int32,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
OverlapCircle(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Queries.Physics3DHit&,Gravitas.Support.PhysicsLayerMask)
OverlapCircleInDirection(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,Gravitas.Queries.Physics3DHit&,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask)
OverlapCircleAll(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
OverlapSphereAgainstStaticAll(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,Gravitas.Colliders.LSCollider,System.Boolean)
ProcessPartitionForAllSphereHits(Gravitas.PhysicsPartition,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
ProcessColliderListForAllSphereHits(SwiftCollections.SwiftHashSet`1<System.Int32>,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
TryBuildOverlapSphereHit(System.Int32,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Queries.Physics3DHit&)
TraceCircleForClosestHit(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,System.Boolean&,Gravitas.Queries.Physics3DHit&)
TraceCircleForDirectionalHit(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,System.Boolean&,Gravitas.Queries.Physics3DHit&)
TraceCircleForAllHits(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
GetPlanarCircleCandidates(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64)
TryBuildOverlapHit(System.Int32,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Queries.Physics3DHit&,Gravitas.Queries.ProjectedSurfaceRelation&)
TryBuildPlanarOverlapHit(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Queries.Physics3DHit&,Gravitas.Queries.ProjectedSurfaceRelation&)
TryBuildSurfaceOverlapHit(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Queries.Physics3DHit&)
GetClosestSurfacePoint(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d)
OverlapCone(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Queries.Physics3DHit&,Gravitas.Support.PhysicsLayerMask)
OverlapConeAll(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
TraceConeForClosestHit(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,System.Boolean&,Gravitas.Queries.Physics3DHit&,FixedMathSharp.Fixed64&)
TraceConeForAllHits(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
ProcessConePartitionForClosestHit(Gravitas.PhysicsPartition,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,System.Boolean&,Gravitas.Queries.Physics3DHit&,FixedMathSharp.Fixed64&)
ProcessConePartitionForAllHits(Gravitas.PhysicsPartition,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
ProcessConeColliderListForClosestHit(SwiftCollections.SwiftHashSet`1<System.Int32>,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,System.Boolean&,Gravitas.Queries.Physics3DHit&,FixedMathSharp.Fixed64&)
ProcessConeColliderListForAllHits(SwiftCollections.SwiftHashSet`1<System.Int32>,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
TryBuildOverlapConeHit(System.Int32,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Queries.Physics3DHit&)
TryBuildConeHitForCollider(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Queries.Physics3DHit&)
TryBuildConeHitForConcaveMesh(Gravitas.Colliders.LSMeshCollider,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Queries.Physics3DHit&)
TryBuildConeHitForCompound(Gravitas.Colliders.LSCompoundCollider,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Queries.Physics3DHit&)
IsPointInsideConeVolume(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64&)
GetClosestPointOnConeAxis(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d)
GetConeQueryBounds(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d&,FixedMathSharp.Vector3d&)
ValidateConeQuery(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d&)
.ctor(Gravitas.GravitasWorldContext)
get_Context()
Reset()
Raycast(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Queries.Physics3DHit&,Gravitas.Support.PhysicsLayerMask)
RaycastAll(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
SweepSphere(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Queries.Physics3DHit&,Gravitas.Support.PhysicsLayerMask,Gravitas.Colliders.LSCollider)
SweepSphereAll(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,Gravitas.Colliders.LSCollider)
SweepSphereAgainstStaticAll(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,Gravitas.Colliders.LSCollider,System.Boolean)
SweepExactSourceAgainstStaticAll(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,Gravitas.Colliders.LSCollider,System.Boolean,Gravitas.Queries.ContinuousSurfaceTriangleAdmission)
SweepCapsule(Gravitas.Colliders.LSCapsuleCollider,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,Gravitas.Queries.Physics3DHit&,Gravitas.Colliders.LSCollider,System.Boolean)
SweepCapsuleAll(Gravitas.Colliders.LSCapsuleCollider,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,Gravitas.Colliders.LSCollider,System.Boolean)
SweepCuboid(Gravitas.Colliders.LSCuboidCollider,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,Gravitas.Queries.Physics3DHit&,Gravitas.Colliders.LSCollider,System.Boolean)
SweepCuboidAll(Gravitas.Colliders.LSCuboidCollider,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,Gravitas.Colliders.LSCollider,System.Boolean)
SweepCylinder(Gravitas.Colliders.LSCylinderCollider,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,Gravitas.Queries.Physics3DHit&,Gravitas.Colliders.LSCollider,System.Boolean)
SweepCylinderAll(Gravitas.Colliders.LSCylinderCollider,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,Gravitas.Colliders.LSCollider,System.Boolean)
SweepCone(Gravitas.Colliders.LSConeCollider,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,Gravitas.Queries.Physics3DHit&,Gravitas.Colliders.LSCollider,System.Boolean)
SweepConeAll(Gravitas.Colliders.LSConeCollider,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,Gravitas.Colliders.LSCollider,System.Boolean)
SweepConvexMesh(Gravitas.Colliders.LSMeshCollider,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,Gravitas.Queries.Physics3DHit&,Gravitas.Colliders.LSCollider,System.Boolean)
SweepConvexMeshAll(Gravitas.Colliders.LSMeshCollider,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,Gravitas.Colliders.LSCollider,System.Boolean)
SweepCompound(Gravitas.Colliders.LSCompoundCollider,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,Gravitas.Queries.Physics3DHit&,Gravitas.Colliders.LSCollider,System.Boolean)
SweepCompoundAll(Gravitas.Colliders.LSCompoundCollider,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,Gravitas.Colliders.LSCollider,System.Boolean)
SweepSphereAllCore(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,Gravitas.Colliders.LSCollider,System.Boolean,System.Boolean)
SweepRegisteredSource(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,Gravitas.Queries.Physics3DHit&,Gravitas.Colliders.LSCollider,System.Boolean)
SweepRegisteredSourceAll(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>,Gravitas.Colliders.LSCollider,System.Boolean,System.Boolean,Gravitas.Queries.ContinuousSurfaceTriangleAdmission)
EndQuery()
BeginConvexSweepTrace(Gravitas.Colliders.LSCollider,Gravitas.Support.PhysicsLayerMask,Gravitas.Colliders.LSCollider,System.Boolean,System.Boolean)
BeginRaycastTrace(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d)
BeginSweepTrace(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,Gravitas.Colliders.LSCollider,System.Boolean,System.Boolean)
SweepSphere(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,Gravitas.Colliders.LSCollider,Gravitas.Queries.Physics3DHit&)
TryFindClosestSweepHit(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,Gravitas.Queries.Physics3DHit&)
TryFindClosestHit(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,Gravitas.Queries.Physics3DHit&)
AddAllHits(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
AddAllSweepHits(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
TryFindClosestConvexSweepHit(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,Gravitas.Queries.Physics3DHit&)
AddAllConvexSweepHits(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
TryBuildHitForCollider(System.Int32,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,Gravitas.Queries.Physics3DHit&)
TryBuildSweepHitForCollider(System.Int32,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,Gravitas.Queries.Physics3DHit&)
TryBuildConvexSweepHitForCollider(System.Int32,Gravitas.Queries.Physics3DHit&)
TryBuildHit(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,Gravitas.Queries.Physics3DHit&)
TryBuildSweepHit(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,Gravitas.Queries.Physics3DHit&)
ResetLastQueryCounters()
NextRaycastVersion()
NextCircleVersion()
ResetColliderRaycastVersions()
ResetColliderCircleVersions()
DoesCurrentColliderIntersectRay(Gravitas.Colliders.LSCollider)
IsSweepCandidate(Gravitas.Colliders.LSCollider)
IsExcludedByCurrentSweepSource(Gravitas.Colliders.LSCollider)
EnsureSourceBelongsToContext(Gravitas.Colliders.LSCollider)
PrepareConvexSweepSource(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d)
IsStaticStyleSweepTarget(Gravitas.Colliders.LSCollider)
TraceLineForClosestHit(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,System.Boolean&,Gravitas.Queries.Physics3DHit&)
TraceLineForAllHits(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
TraceSweepForClosestHit(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,System.Boolean&,Gravitas.Queries.Physics3DHit&)
TraceSweepForAllHits(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
TraceConvexSweepForClosestHit(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,System.Boolean&,Gravitas.Queries.Physics3DHit&)
TraceConvexSweepForAllHits(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
PrepareSweepBounds(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d&,FixedMathSharp.Vector3d&)
PrepareConvexSweepBounds(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d&,FixedMathSharp.Vector3d&)
ProcessTraceVoxelForClosestHit(GridForge.Grids.Voxel,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,System.Boolean&,Gravitas.Queries.Physics3DHit&)
ProcessTraceVoxelForAllHits(GridForge.Grids.Voxel,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
ProcessSweepVoxelForClosestHit(GridForge.Grids.Voxel,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,System.Boolean&,Gravitas.Queries.Physics3DHit&)
ProcessSweepVoxelForAllHits(GridForge.Grids.Voxel,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
ProcessConvexSweepVoxelForClosestHit(GridForge.Grids.Voxel,System.Boolean&,Gravitas.Queries.Physics3DHit&)
ProcessConvexSweepVoxelForAllHits(GridForge.Grids.Voxel,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
ProcessPartitionForClosestHit(Gravitas.PhysicsPartition,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,System.Boolean&,Gravitas.Queries.Physics3DHit&)
ProcessColliderListForClosestHit(SwiftCollections.SwiftHashSet`1<System.Int32>,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,System.Boolean&,Gravitas.Queries.Physics3DHit&)
ProcessPartitionForAllHits(Gravitas.PhysicsPartition,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
ProcessColliderListForAllHits(SwiftCollections.SwiftHashSet`1<System.Int32>,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
ProcessPartitionForClosestSweepHit(Gravitas.PhysicsPartition,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,System.Boolean&,Gravitas.Queries.Physics3DHit&)
ProcessColliderListForClosestSweepHit(SwiftCollections.SwiftHashSet`1<System.Int32>,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,System.Boolean&,Gravitas.Queries.Physics3DHit&)
ProcessPartitionForAllSweepHits(Gravitas.PhysicsPartition,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
ProcessPartitionForClosestConvexSweepHit(Gravitas.PhysicsPartition,System.Boolean&,Gravitas.Queries.Physics3DHit&)
ProcessPartitionForAllConvexSweepHits(Gravitas.PhysicsPartition,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
ProcessColliderListForAllSweepHits(SwiftCollections.SwiftHashSet`1<System.Int32>,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)
ProcessColliderListForClosestConvexSweepHit(SwiftCollections.SwiftHashSet`1<System.Int32>,System.Boolean&,Gravitas.Queries.Physics3DHit&)
ProcessColliderListForAllConvexSweepHits(SwiftCollections.SwiftHashSet`1<System.Int32>,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics3DHit>)