< Summary

Line coverage
100%
Covered lines: 577
Uncovered lines: 0
Coverable lines: 577
Total lines: 1379
Line coverage: 100%
Branch coverage
100%
Covered branches: 176
Total branches: 176
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%22100%
File 1: RaycastAllBatch(...)100%22100%
File 1: OverlapCircleBatch(...)100%22100%
File 1: OverlapCircleAllBatch(...)100%22100%
File 1: OverlapAabbBatch(...)100%22100%
File 1: OverlapAabbAllBatch(...)100%22100%
File 1: OverlapPolygonBatch(...)100%22100%
File 1: OverlapPolygonAllBatch(...)100%22100%
File 1: SweepCircleBatch(...)100%22100%
File 1: SweepCircleAllBatch(...)100%22100%
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 1: ValidatePolygonRequestRanges(...)100%88100%
File 1: ValidateOverlapCircleRequests(...)100%22100%
File 1: ValidateOverlapAabbRequests(...)100%22100%
File 1: ValidateSweepCircleRequests(...)100%22100%
File 2: .ctor(...)100%11100%
File 2: get_Context()100%11100%
File 2: Reset()100%11100%
File 2: EndQuery()100%11100%
File 3: OverlapCircleAll(...)100%11100%
File 3: OverlapCircleAll(...)100%11100%
File 3: OverlapCircleAgainstStaticAll(...)100%11100%
File 3: OverlapCircle(...)100%11100%
File 3: OverlapCircle(...)100%66100%
File 3: OverlapAabb(...)100%11100%
File 3: OverlapAabb(...)100%11100%
File 3: OverlapAabbAll(...)100%11100%
File 3: OverlapAabbAll(...)100%11100%
File 3: OverlapPolygon(...)100%11100%
File 3: OverlapPolygon(...)100%11100%
File 3: OverlapPolygonAll(...)100%11100%
File 3: OverlapPolygonAll(...)100%11100%
File 3: OverlapCircleAllCore(...)100%88100%
File 3: OverlapAreaCore(...)100%66100%
File 3: OverlapAreaAllCore(...)100%44100%
File 4: Raycast(...)100%11100%
File 4: Raycast(...)100%11100%
File 4: RaycastForGrounding(...)100%11100%
File 4: RaycastCore(...)100%1616100%
File 4: RaycastAll(...)100%11100%
File 4: RaycastAll(...)100%1010100%
File 5: EnsureCandidateCapacity()100%22100%
File 5: NextOverlapQueryVersion()100%22100%
File 5: NextRaycastVersion()100%22100%
File 5: ResetColliderOverlapQueryVersions()100%22100%
File 5: ResetColliderRaycastVersions()100%22100%
File 5: CreateMin(...)100%11100%
File 5: CreateMax(...)100%11100%
File 5: CreateSweepMin(...)100%11100%
File 5: CreateSweepMax(...)100%11100%
File 5: CreateAabbVertices(...)100%11100%
File 5: CalculateAreaBounds(...)100%22100%
File 5: IsEligibleSweepCandidate(...)100%1010100%
File 6: QuerySupport(...)100%3232100%
File 7: SweepCircle(...)100%11100%
File 7: SweepCircle(...)100%11100%
File 7: SweepCircleForGrounding(...)100%11100%
File 7: SweepCircleCore(...)100%2020100%
File 7: SweepCircleAll(...)100%11100%
File 7: SweepCircleAll(...)100%11100%
File 7: SweepCircleAgainstStaticAll(...)100%11100%
File 7: SweepCircleAllCore(...)100%1414100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/2D/GravitasQuery2DService.Batch.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQuery2DService.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 SwiftCollections;
 12
 13namespace Gravitas.Queries;
 14
 15/// <content>
 16/// Owns batched pure 2D query behavior for one <see cref="GravitasWorldContext"/>.
 17/// </content>
 18public sealed partial class GravitasQuery2DService
 19{
 1019120    private readonly SwiftList<Physics2DHit> _batch2DHits = new();
 21
 22    /// <summary>
 23    /// Gets the number of requests processed by the last pure 2D batch query call.
 24    /// </summary>
 25    public int LastBatchRequestCount { get; private set; }
 26
 27    /// <summary>
 28    /// Gets the number of hits accepted by the last pure 2D batch query call.
 29    /// </summary>
 30    public int LastBatchHitCount { get; private set; }
 31
 32    /// <summary>
 33    /// Gets the summed candidate count reported by the last pure 2D batch query call.
 34    /// </summary>
 35    public int LastBatchCandidateCount { get; private set; }
 36
 37    /// <summary>
 38    /// Executes multiple pure 2D segment raycasts and writes one closest-hit slot per request.
 39    /// </summary>
 40    public int RaycastBatch(ReadOnlySpan<PhysicsRaycast2DRequest> requests, Span<Physics2DHit> closestHits)
 41    {
 20942        ValidateClosestBatchOutput(requests.Length, closestHits);
 20943        ResetBatchCounters(requests.Length);
 44
 20945        int hitCount = 0;
 125646        for (int i = 0; i < requests.Length; i++)
 47        {
 41948            PhysicsRaycast2DRequest request = requests[i];
 41949            bool found = Raycast(request.Start, request.End, request.LayerMask, out Physics2DHit hit);
 41950            WriteClosestHit(closestHits, i, hit, found, ref hitCount);
 51        }
 52
 20953        LastBatchHitCount = hitCount;
 20954        return hitCount;
 55    }
 56
 57    /// <summary>
 58    /// Executes multiple pure 2D segment raycasts and appends all hits into one caller-owned hit buffer.
 59    /// </summary>
 60    public int RaycastAllBatch(
 61        ReadOnlySpan<PhysicsRaycast2DRequest> requests,
 62        SwiftList<Physics2DHit> hits,
 63        Span<PhysicsQueryHitRange> ranges)
 64    {
 21465        ChronicleGuard.ThrowIfNull(hits, nameof(hits));
 21466        ValidateRangeBatchOutput(requests.Length, ranges);
 21467        ResetBatchCounters(requests.Length);
 21468        hits.Clear();
 69
 128070        for (int i = 0; i < requests.Length; i++)
 71        {
 72            try
 73            {
 42674                PhysicsRaycast2DRequest request = requests[i];
 42675                int count = RaycastAll(request.Start, request.End, request.LayerMask, _batch2DHits);
 42676                AppendRange(hits, ranges, i, count);
 42677            }
 78            finally
 79            {
 42680                _batch2DHits.Clear();
 42681            }
 82        }
 83
 21484        LastBatchHitCount = hits.Count;
 21485        return hits.Count;
 86    }
 87
 88    /// <summary>
 89    /// Executes multiple pure 2D circle overlaps and writes one closest-hit slot per request.
 90    /// </summary>
 91    public int OverlapCircleBatch(ReadOnlySpan<PhysicsOverlapCircle2DRequest> requests, Span<Physics2DHit> closestHits)
 92    {
 21093        ValidateClosestBatchOutput(requests.Length, closestHits);
 21094        ValidateOverlapCircleRequests(requests);
 20995        ResetBatchCounters(requests.Length);
 96
 20997        int hitCount = 0;
 125498        for (int i = 0; i < requests.Length; i++)
 99        {
 418100            PhysicsOverlapCircle2DRequest request = requests[i];
 418101            bool found = OverlapCircle(request.Center, request.Radius, request.LayerMask, out Physics2DHit hit);
 418102            WriteClosestHit(closestHits, i, hit, found, ref hitCount);
 103        }
 104
 209105        LastBatchHitCount = hitCount;
 209106        return hitCount;
 107    }
 108
 109    /// <summary>
 110    /// Executes multiple pure 2D circle overlaps and appends all hits into one caller-owned hit buffer.
 111    /// </summary>
 112    public int OverlapCircleAllBatch(
 113        ReadOnlySpan<PhysicsOverlapCircle2DRequest> requests,
 114        SwiftList<Physics2DHit> hits,
 115        Span<PhysicsQueryHitRange> ranges)
 116    {
 209117        ChronicleGuard.ThrowIfNull(hits, nameof(hits));
 209118        ValidateRangeBatchOutput(requests.Length, ranges);
 209119        ValidateOverlapCircleRequests(requests);
 208120        ResetBatchCounters(requests.Length);
 208121        hits.Clear();
 122
 1248123        for (int i = 0; i < requests.Length; i++)
 124        {
 125            try
 126            {
 416127                PhysicsOverlapCircle2DRequest request = requests[i];
 416128                int count = OverlapCircleAll(request.Center, request.Radius, request.LayerMask, _batch2DHits);
 416129                AppendRange(hits, ranges, i, count);
 416130            }
 131            finally
 132            {
 416133                _batch2DHits.Clear();
 416134            }
 135        }
 136
 208137        LastBatchHitCount = hits.Count;
 208138        return hits.Count;
 139    }
 140
 141    /// <summary>
 142    /// Executes multiple pure 2D AABB overlaps and writes one closest-hit slot per request.
 143    /// </summary>
 144    public int OverlapAabbBatch(ReadOnlySpan<PhysicsOverlapAabb2DRequest> requests, Span<Physics2DHit> closestHits)
 145    {
 209146        ValidateClosestBatchOutput(requests.Length, closestHits);
 209147        ValidateOverlapAabbRequests(requests);
 209148        ResetBatchCounters(requests.Length);
 149
 209150        int hitCount = 0;
 1256151        for (int i = 0; i < requests.Length; i++)
 152        {
 419153            PhysicsOverlapAabb2DRequest request = requests[i];
 419154            bool found = OverlapAabb(request.Center, request.Size, request.LayerMask, out Physics2DHit hit);
 419155            WriteClosestHit(closestHits, i, hit, found, ref hitCount);
 156        }
 157
 209158        LastBatchHitCount = hitCount;
 209159        return hitCount;
 160    }
 161
 162    /// <summary>
 163    /// Executes multiple pure 2D AABB overlaps and appends all hits into one caller-owned hit buffer.
 164    /// </summary>
 165    public int OverlapAabbAllBatch(
 166        ReadOnlySpan<PhysicsOverlapAabb2DRequest> requests,
 167        SwiftList<Physics2DHit> hits,
 168        Span<PhysicsQueryHitRange> ranges)
 169    {
 209170        ChronicleGuard.ThrowIfNull(hits, nameof(hits));
 209171        ValidateRangeBatchOutput(requests.Length, ranges);
 209172        ValidateOverlapAabbRequests(requests);
 209173        ResetBatchCounters(requests.Length);
 209174        hits.Clear();
 175
 1256176        for (int i = 0; i < requests.Length; i++)
 177        {
 178            try
 179            {
 419180                PhysicsOverlapAabb2DRequest request = requests[i];
 419181                int count = OverlapAabbAll(request.Center, request.Size, request.LayerMask, _batch2DHits);
 419182                AppendRange(hits, ranges, i, count);
 419183            }
 184            finally
 185            {
 419186                _batch2DHits.Clear();
 419187            }
 188        }
 189
 209190        LastBatchHitCount = hits.Count;
 209191        return hits.Count;
 192    }
 193
 194    /// <summary>
 195    /// Executes multiple pure 2D convex polygon overlaps and writes one closest-hit slot per request.
 196    /// </summary>
 197    public int OverlapPolygonBatch(
 198        ReadOnlySpan<PhysicsOverlapPolygon2DRequest> requests,
 199        ReadOnlySpan<Vector2d> vertices,
 200        Span<Physics2DHit> closestHits)
 201    {
 5202        ValidateClosestBatchOutput(requests.Length, closestHits);
 5203        ValidatePolygonRequestRanges(requests, vertices);
 1204        ResetBatchCounters(requests.Length);
 205
 1206        int hitCount = 0;
 6207        for (int i = 0; i < requests.Length; i++)
 208        {
 2209            PhysicsOverlapPolygon2DRequest request = requests[i];
 2210            ReadOnlySpan<Vector2d> polygon = vertices.Slice(request.VertexStart, request.VertexCount);
 2211            bool found = OverlapPolygon(polygon, request.LayerMask, out Physics2DHit hit);
 2212            WriteClosestHit(closestHits, i, hit, found, ref hitCount);
 213        }
 214
 1215        LastBatchHitCount = hitCount;
 1216        return hitCount;
 217    }
 218
 219    /// <summary>
 220    /// Executes multiple pure 2D convex polygon overlaps and appends all hits into one caller-owned hit buffer.
 221    /// </summary>
 222    public int OverlapPolygonAllBatch(
 223        ReadOnlySpan<PhysicsOverlapPolygon2DRequest> requests,
 224        ReadOnlySpan<Vector2d> vertices,
 225        SwiftList<Physics2DHit> hits,
 226        Span<PhysicsQueryHitRange> ranges)
 227    {
 1228        ChronicleGuard.ThrowIfNull(hits, nameof(hits));
 1229        ValidateRangeBatchOutput(requests.Length, ranges);
 1230        ValidatePolygonRequestRanges(requests, vertices);
 1231        ResetBatchCounters(requests.Length);
 1232        hits.Clear();
 233
 6234        for (int i = 0; i < requests.Length; i++)
 235        {
 236            try
 237            {
 2238                PhysicsOverlapPolygon2DRequest request = requests[i];
 2239                ReadOnlySpan<Vector2d> polygon = vertices.Slice(request.VertexStart, request.VertexCount);
 2240                int count = OverlapPolygonAll(polygon, request.LayerMask, _batch2DHits);
 2241                AppendRange(hits, ranges, i, count);
 2242            }
 243            finally
 244            {
 2245                _batch2DHits.Clear();
 2246            }
 247        }
 248
 1249        LastBatchHitCount = hits.Count;
 1250        return hits.Count;
 251    }
 252
 253    /// <summary>
 254    /// Executes multiple pure 2D swept-circle queries and writes one closest-hit slot per request.
 255    /// </summary>
 256    public int SweepCircleBatch(ReadOnlySpan<PhysicsSweepCircle2DRequest> requests, Span<Physics2DHit> closestHits)
 257    {
 2258        ValidateClosestBatchOutput(requests.Length, closestHits);
 2259        ValidateSweepCircleRequests(requests);
 2260        ResetBatchCounters(requests.Length);
 261
 2262        int hitCount = 0;
 10263        for (int i = 0; i < requests.Length; i++)
 264        {
 3265            PhysicsSweepCircle2DRequest request = requests[i];
 3266            bool found = SweepCircle(
 3267                request.Start,
 3268                request.End,
 3269                request.Radius,
 3270                request.LayerMask,
 3271                out Physics2DHit hit,
 3272                request.ExcludedCollider,
 3273                request.IncludeTriggers);
 3274            WriteClosestHit(closestHits, i, hit, found, ref hitCount);
 275        }
 276
 2277        LastBatchHitCount = hitCount;
 2278        return hitCount;
 279    }
 280
 281    /// <summary>
 282    /// Executes multiple pure 2D swept-circle queries and appends all hits into one caller-owned hit buffer.
 283    /// </summary>
 284    public int SweepCircleAllBatch(
 285        ReadOnlySpan<PhysicsSweepCircle2DRequest> requests,
 286        SwiftList<Physics2DHit> hits,
 287        Span<PhysicsQueryHitRange> ranges)
 288    {
 210289        ChronicleGuard.ThrowIfNull(hits, nameof(hits));
 210290        ValidateRangeBatchOutput(requests.Length, ranges);
 210291        ValidateSweepCircleRequests(requests);
 210292        ResetBatchCounters(requests.Length);
 210293        hits.Clear();
 294
 842295        for (int i = 0; i < requests.Length; i++)
 296        {
 297            try
 298            {
 211299                PhysicsSweepCircle2DRequest request = requests[i];
 211300                int count = SweepCircleAll(
 211301                    request.Start,
 211302                    request.End,
 211303                    request.Radius,
 211304                    request.LayerMask,
 211305                    _batch2DHits,
 211306                    request.ExcludedCollider,
 211307                    request.IncludeTriggers);
 211308                AppendRange(hits, ranges, i, count);
 211309            }
 310            finally
 311            {
 211312                _batch2DHits.Clear();
 211313            }
 314        }
 315
 210316        LastBatchHitCount = hits.Count;
 210317        return hits.Count;
 318    }
 319
 320    private void WriteClosestHit(Span<Physics2DHit> closestHits, int index, Physics2DHit hit, bool found, ref int hitCou
 321    {
 1261322        if (found)
 323        {
 1050324            closestHits[index] = hit;
 1050325            hitCount++;
 1050326            AccumulateBatchCounters(1);
 327        }
 328        else
 329        {
 211330            closestHits[index] = default;
 211331            AccumulateBatchCounters(0);
 332        }
 211333    }
 334
 335    private void AppendRange(
 336        SwiftList<Physics2DHit> hits,
 337        Span<PhysicsQueryHitRange> ranges,
 338        int index,
 339        int count)
 340    {
 1474341        int start = hits.Count;
 1474342        if (count > 0)
 1261343            hits.AddRange(_batch2DHits.AsReadOnlySpan());
 344
 1474345        ranges[index] = new PhysicsQueryHitRange(start, count);
 1474346        AccumulateBatchCounters(count);
 1474347    }
 348
 349    private void ResetBatchCounters(int requestCount)
 350    {
 1589351        LastBatchRequestCount = requestCount;
 1589352        LastBatchHitCount = 0;
 1589353        LastBatchCandidateCount = 0;
 1589354    }
 355
 356    private void AccumulateBatchCounters(int hitCount)
 357    {
 2735358        LastBatchHitCount += hitCount;
 2735359        LastBatchCandidateCount += LastQueryCandidateCount;
 2735360    }
 361
 362    private static void ValidateClosestBatchOutput(int requestCount, Span<Physics2DHit> closestHits)
 363    {
 635364        ChronicleGuard.ThrowIfArgument(
 635365            closestHits.Length < requestCount,
 635366            nameof(closestHits),
 635367            "Closest-hit output span must contain at least one slot per request.");
 635368    }
 369
 370    private static void ValidateRangeBatchOutput(int requestCount, Span<PhysicsQueryHitRange> ranges)
 371    {
 843372        ChronicleGuard.ThrowIfArgument(
 843373            ranges.Length < requestCount,
 843374            nameof(ranges),
 843375            "Range output span must contain at least one slot per request.");
 843376    }
 377
 378    private static void ValidatePolygonRequestRanges(
 379        ReadOnlySpan<PhysicsOverlapPolygon2DRequest> requests,
 380        ReadOnlySpan<Vector2d> vertices)
 381    {
 20382        for (int i = 0; i < requests.Length; i++)
 383        {
 8384            PhysicsOverlapPolygon2DRequest request = requests[i];
 8385            ChronicleGuard.ThrowIfArgument(
 8386                request.VertexStart < 0
 8387                || request.VertexCount < 0
 8388                || request.VertexStart > vertices.Length
 8389                || request.VertexCount > vertices.Length - request.VertexStart,
 8390                nameof(requests),
 8391                "Polygon batch request vertex range must be contained by the supplied vertex span.");
 392
 4393            QueryDetection2D.ValidateConvexQueryPolygon(vertices.Slice(request.VertexStart, request.VertexCount));
 394        }
 2395    }
 396
 397    private static void ValidateOverlapCircleRequests(ReadOnlySpan<PhysicsOverlapCircle2DRequest> requests)
 398    {
 2510399        for (int i = 0; i < requests.Length; i++)
 400        {
 838401            ChronicleGuard.ThrowIfArgument(
 838402                requests[i].Radius < Fixed64.Zero,
 838403                nameof(requests),
 838404                "2D query radius cannot be negative.");
 838405            ColliderGeometryPolicy.ValidateReach(requests[i].Radius, nameof(requests));
 406        }
 417407    }
 408
 409    private static void ValidateOverlapAabbRequests(ReadOnlySpan<PhysicsOverlapAabb2DRequest> requests)
 410    {
 2512411        for (int i = 0; i < requests.Length; i++)
 838412            QueryDetection2D.ValidateAabbSize(requests[i].Size);
 418413    }
 414
 415    private static void ValidateSweepCircleRequests(ReadOnlySpan<PhysicsSweepCircle2DRequest> requests)
 416    {
 852417        for (int i = 0; i < requests.Length; i++)
 418        {
 214419            ChronicleGuard.ThrowIfArgument(
 214420                requests[i].Radius <= Fixed64.Zero,
 214421                nameof(requests),
 214422                "2D sweep radius must be greater than zero.");
 214423            ColliderGeometryPolicy.ValidateReach(requests[i].Radius, nameof(requests));
 424        }
 212425    }
 426}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/2D/GravitasQuery2DService.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQuery2DService.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 Gravitas.Colliders;
 9using SwiftCollections;
 10
 11namespace Gravitas.Queries;
 12
 13/// <summary>
 14/// Owns pure 2D query buffers and query dispatch for one <see cref="GravitasWorldContext"/>.
 15/// </summary>
 16/// <content>Owns context-local query buffers and their cleanup boundary.</content>
 17public sealed partial class GravitasQuery2DService
 18{
 19    private readonly GravitasWorldContext _context;
 1019120    private readonly SwiftList<LSCollider2D> _queryCandidates = new();
 21    internal uint OverlapQueryVersion { get; set; }
 22    internal uint RaycastVersion { get; set; }
 23
 24    /// <summary>
 25    /// Initializes a pure 2D query service for the supplied context.
 26    /// </summary>
 27    /// <param name="context">The owning world context.</param>
 1019128    public GravitasQuery2DService(GravitasWorldContext context)
 29    {
 1019130        ChronicleGuard.ThrowIfNull(context, nameof(context));
 1019131        _context = context;
 1019132    }
 33
 34    /// <summary>
 35    /// Gets the owning world context.
 36    /// </summary>
 137    public GravitasWorldContext Context => _context;
 38
 39    internal int LastQueryCandidateCount { get; private set; }
 40
 41    /// <summary>
 42    /// Resets context-local pure 2D query buffers.
 43    /// </summary>
 44    public void Reset()
 45    {
 11746        ResetColliderOverlapQueryVersions();
 11747        ResetColliderRaycastVersions();
 11748        EndQuery();
 11749        _batch2DHits.Clear();
 11750        LastQueryCandidateCount = 0;
 11751        ResetBatchCounters(0);
 11752        OverlapQueryVersion = 0;
 11753        RaycastVersion = 0;
 11754    }
 55
 56    private void EndQuery()
 57    {
 58        // Every producer starts empty. Release its live slots now so a later
 59        // smaller FastClear-based gather cannot leave a retained reference tail.
 1479860        _queryCandidates.Clear();
 1479861    }
 62
 63}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/2D/GravitasQuery2DService.Overlap.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQuery2DService.Overlap.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 pure 2D overlap query behavior for one <see cref="GravitasWorldContext"/>.
 18/// </content>
 19public sealed partial class GravitasQuery2DService
 20{
 21    /// <summary>
 22    /// Writes all active pure 2D colliders overlapping the query circle into <paramref name="results"/>.
 23    /// </summary>
 24    /// <returns>The number of hits written to <paramref name="results"/>.</returns>
 25    public int OverlapCircleAll(Vector2d center, Fixed64 radius, SwiftList<Physics2DHit> results)
 26    {
 4527        return OverlapCircleAll(center, radius, PhysicsLayerMask.All, results);
 28    }
 29
 30    /// <summary>
 31    /// Writes all active pure 2D colliders on included layers that overlap the query circle.
 32    /// </summary>
 33    /// <returns>The number of hits written to <paramref name="results"/>.</returns>
 34    public int OverlapCircleAll(
 35        Vector2d center,
 36        Fixed64 radius,
 37        PhysicsLayerMask layerMask,
 38        SwiftList<Physics2DHit> results)
 39    {
 46840        return OverlapCircleAllCore(center, radius, layerMask, results, staticTargetsOnly: false);
 41    }
 42
 43    internal int OverlapCircleAgainstStaticAll(
 44        Vector2d center,
 45        Fixed64 radius,
 46        PhysicsLayerMask layerMask,
 47        SwiftList<Physics2DHit> results,
 48        LSCollider2D? excludedCollider = null,
 49        bool includeTriggers = true)
 50    {
 7851        return OverlapCircleAllCore(
 7852            center,
 7853            radius,
 7854            layerMask,
 7855            results,
 7856            staticTargetsOnly: true,
 7857            excludedCollider: excludedCollider,
 7858            includeTriggers: includeTriggers);
 59    }
 60
 61    /// <summary>
 62    /// Finds the closest active pure 2D collider overlapping the supplied query circle.
 63    /// </summary>
 64    public bool OverlapCircle(Vector2d center, Fixed64 radius, out Physics2DHit hit)
 65    {
 1866        return OverlapCircle(center, radius, PhysicsLayerMask.All, out hit);
 67    }
 68
 69    /// <summary>
 70    /// Finds the closest active pure 2D collider on an included layer overlapping the supplied query circle.
 71    /// </summary>
 72    public bool OverlapCircle(Vector2d center, Fixed64 radius, PhysicsLayerMask layerMask, out Physics2DHit hit)
 73    {
 43774        ChronicleGuard.ThrowIfArgument(radius < Fixed64.Zero, nameof(radius), "2D query radius cannot be negative.");
 43775        ColliderGeometryPolicy.ValidateReach(radius, nameof(radius));
 76
 77        try
 78        {
 43679            EnsureCandidateCapacity();
 43680            uint queryVersion = NextOverlapQueryVersion();
 43681            _context.Collisions2D.CollectBoundsCandidates(
 43682                new Vector2d(center.X - radius, center.Y - radius),
 43683                new Vector2d(center.X + radius, center.Y + radius),
 43684                layerMask,
 43685                queryVersion,
 43686                raycastQuery: false,
 43687                _queryCandidates);
 88
 43689            LastQueryCandidateCount = _queryCandidates.Count;
 43690            bool found = false;
 43691            Physics2DHit closest = default;
 1505492            for (int i = 0; i < _queryCandidates.Count; i++)
 93            {
 709194                if (!QueryDetection2D.TryOverlapCircle(center, radius, _queryCandidates[i], out Physics2DHit candidate)
 709195                    || !PhysicsHitSelectionPolicy.ShouldReplace(candidate, found, closest))
 96                {
 97                    continue;
 98                }
 99
 3761100                closest = candidate;
 3761101                found = true;
 102            }
 103
 436104            hit = closest;
 436105            return found;
 106        }
 107        finally
 108        {
 436109            EndQuery();
 436110        }
 436111    }
 112
 113    /// <summary>
 114    /// Finds the closest active pure 2D collider overlapping the supplied axis-aligned box.
 115    /// </summary>
 116    public bool OverlapAabb(Vector2d center, Vector2d size, out Physics2DHit hit)
 117    {
 5118        return OverlapAabb(center, size, PhysicsLayerMask.All, out hit);
 119    }
 120
 121    /// <summary>
 122    /// Finds the closest active pure 2D collider on an included layer overlapping the supplied axis-aligned box.
 123    /// </summary>
 124    public bool OverlapAabb(Vector2d center, Vector2d size, PhysicsLayerMask layerMask, out Physics2DHit hit)
 125    {
 425126        Vector2d halfExtents = QueryDetection2D.ValidateAabbSize(size);
 423127        Span<Vector2d> vertices = stackalloc Vector2d[4];
 423128        CreateAabbVertices(center, halfExtents, vertices);
 423129        return OverlapAreaCore(
 423130            vertices,
 423131            center,
 423132            center - halfExtents,
 423133            center + halfExtents,
 423134            layerMask,
 423135            out hit);
 136    }
 137
 138    /// <summary>
 139    /// Writes all active pure 2D colliders overlapping the supplied axis-aligned box into <paramref name="results"/>.
 140    /// </summary>
 141    /// <returns>The number of hits written to <paramref name="results"/>.</returns>
 142    public int OverlapAabbAll(Vector2d center, Vector2d size, SwiftList<Physics2DHit> results)
 143    {
 9144        return OverlapAabbAll(center, size, PhysicsLayerMask.All, results);
 145    }
 146
 147    /// <summary>
 148    /// Writes all active pure 2D colliders on included layers that overlap the supplied axis-aligned box.
 149    /// </summary>
 150    /// <returns>The number of hits written to <paramref name="results"/>.</returns>
 151    public int OverlapAabbAll(
 152        Vector2d center,
 153        Vector2d size,
 154        PhysicsLayerMask layerMask,
 155        SwiftList<Physics2DHit> results)
 156    {
 428157        ChronicleGuard.ThrowIfNull(results, nameof(results));
 428158        Vector2d halfExtents = QueryDetection2D.ValidateAabbSize(size);
 425159        Span<Vector2d> vertices = stackalloc Vector2d[4];
 425160        CreateAabbVertices(center, halfExtents, vertices);
 425161        return OverlapAreaAllCore(
 425162            vertices,
 425163            center,
 425164            center - halfExtents,
 425165            center + halfExtents,
 425166            layerMask,
 425167            results);
 168    }
 169
 170    /// <summary>
 171    /// Finds the closest active pure 2D collider overlapping the supplied convex polygon.
 172    /// </summary>
 173    public bool OverlapPolygon(ReadOnlySpan<Vector2d> vertices, out Physics2DHit hit)
 174    {
 19175        return OverlapPolygon(vertices, PhysicsLayerMask.All, out hit);
 176    }
 177
 178    /// <summary>
 179    /// Finds the closest active pure 2D collider on an included layer overlapping the supplied convex polygon.
 180    /// </summary>
 181    public bool OverlapPolygon(ReadOnlySpan<Vector2d> vertices, PhysicsLayerMask layerMask, out Physics2DHit hit)
 182    {
 21183        QueryDetection2D.ValidateConvexQueryPolygon(vertices);
 8184        Vector2d center = QueryDetection2D.CalculateAverageCenter(vertices);
 8185        CalculateAreaBounds(vertices, out Vector2d min, out Vector2d max);
 8186        return OverlapAreaCore(vertices, center, min, max, layerMask, out hit);
 187    }
 188
 189    /// <summary>
 190    /// Writes all active pure 2D colliders overlapping the supplied convex polygon into <paramref name="results"/>.
 191    /// </summary>
 192    /// <returns>The number of hits written to <paramref name="results"/>.</returns>
 193    public int OverlapPolygonAll(ReadOnlySpan<Vector2d> vertices, SwiftList<Physics2DHit> results)
 194    {
 6195        return OverlapPolygonAll(vertices, PhysicsLayerMask.All, results);
 196    }
 197
 198    /// <summary>
 199    /// Writes all active pure 2D colliders on included layers that overlap the supplied convex polygon.
 200    /// </summary>
 201    /// <returns>The number of hits written to <paramref name="results"/>.</returns>
 202    public int OverlapPolygonAll(
 203        ReadOnlySpan<Vector2d> vertices,
 204        PhysicsLayerMask layerMask,
 205        SwiftList<Physics2DHit> results)
 206    {
 8207        ChronicleGuard.ThrowIfNull(results, nameof(results));
 8208        QueryDetection2D.ValidateConvexQueryPolygon(vertices);
 7209        Vector2d center = QueryDetection2D.CalculateAverageCenter(vertices);
 7210        CalculateAreaBounds(vertices, out Vector2d min, out Vector2d max);
 7211        return OverlapAreaAllCore(vertices, center, min, max, layerMask, results);
 212    }
 213
 214    private int OverlapCircleAllCore(
 215        Vector2d center,
 216        Fixed64 radius,
 217        PhysicsLayerMask layerMask,
 218        SwiftList<Physics2DHit> results,
 219        bool staticTargetsOnly,
 220        LSCollider2D? excludedCollider = null,
 221        bool includeTriggers = true)
 222    {
 546223        ChronicleGuard.ThrowIfNull(results, nameof(results));
 546224        ChronicleGuard.ThrowIfArgument(radius < Fixed64.Zero, nameof(radius), "2D query radius cannot be negative.");
 225        // CCD's internal search enclosure includes padding beyond admitted shape reach.
 546226        if (!staticTargetsOnly)
 468227            ColliderGeometryPolicy.ValidateReach(radius, nameof(radius));
 228
 545229        results.Clear();
 230        try
 231        {
 545232            EnsureCandidateCapacity();
 545233            uint queryVersion = NextOverlapQueryVersion();
 545234            _context.Collisions2D.CollectBoundsCandidates(
 545235                new Vector2d(center.X - radius, center.Y - radius),
 545236                new Vector2d(center.X + radius, center.Y + radius),
 545237                layerMask,
 545238                queryVersion,
 545239                raycastQuery: false,
 545240                _queryCandidates,
 545241                staticStyleOnly: staticTargetsOnly);
 242
 545243            LastQueryCandidateCount = _queryCandidates.Count;
 15758244            for (int i = 0; i < _queryCandidates.Count; i++)
 245            {
 7334246                LSCollider2D collider = _queryCandidates[i];
 7334247                if (IsEligibleSweepCandidate(collider, excludedCollider, includeTriggers)
 7334248                    && QueryDetection2D.TryOverlapCircle(center, radius, collider, out Physics2DHit hit))
 249                {
 7285250                    results.Add(hit);
 251                }
 252            }
 253
 545254            Physics2DHitSorter.SortByDistance(results);
 545255            return results.Count;
 256        }
 257        finally
 258        {
 545259            EndQuery();
 545260        }
 545261    }
 262
 263    private bool OverlapAreaCore(
 264        ReadOnlySpan<Vector2d> vertices,
 265        Vector2d center,
 266        Vector2d min,
 267        Vector2d max,
 268        PhysicsLayerMask layerMask,
 269        out Physics2DHit hit)
 270    {
 271        try
 272        {
 431273            EnsureCandidateCapacity();
 431274            uint queryVersion = NextOverlapQueryVersion();
 431275            _context.Collisions2D.CollectBoundsCandidates(
 431276                min,
 431277                max,
 431278                layerMask,
 431279                queryVersion,
 431280                raycastQuery: false,
 431281                _queryCandidates);
 282
 431283            LastQueryCandidateCount = _queryCandidates.Count;
 431284            bool found = false;
 431285            Physics2DHit closest = default;
 8370286            for (int i = 0; i < _queryCandidates.Count; i++)
 287            {
 3754288                if (!QueryDetection2D.TryOverlapPolygon(vertices, center, _queryCandidates[i], out Physics2DHit candidat
 3754289                    || !PhysicsHitSelectionPolicy.ShouldReplace(candidate, found, closest))
 290                {
 291                    continue;
 292                }
 293
 2089294                closest = candidate;
 2089295                found = true;
 296            }
 297
 431298            hit = closest;
 431299            return found;
 300        }
 301        finally
 302        {
 431303            EndQuery();
 431304        }
 431305    }
 306
 307    private int OverlapAreaAllCore(
 308        ReadOnlySpan<Vector2d> vertices,
 309        Vector2d center,
 310        Vector2d min,
 311        Vector2d max,
 312        PhysicsLayerMask layerMask,
 313        SwiftList<Physics2DHit> results)
 314    {
 432315        results.Clear();
 316        try
 317        {
 432318            EnsureCandidateCapacity();
 432319            uint queryVersion = NextOverlapQueryVersion();
 432320            _context.Collisions2D.CollectBoundsCandidates(
 432321                min,
 432322                max,
 432323                layerMask,
 432324                queryVersion,
 432325                raycastQuery: false,
 432326                _queryCandidates);
 327
 432328            LastQueryCandidateCount = _queryCandidates.Count;
 8902329            for (int i = 0; i < _queryCandidates.Count; i++)
 4019330                if (QueryDetection2D.TryOverlapPolygon(vertices, center, _queryCandidates[i], out Physics2DHit hit))
 4018331                    results.Add(hit);
 332
 432333            Physics2DHitSorter.SortByDistance(results);
 432334            return results.Count;
 335        }
 336        finally
 337        {
 432338            EndQuery();
 432339        }
 432340    }
 341
 342}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/2D/GravitasQuery2DService.Raycast.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQuery2DService.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 FixedMathSharp;
 9using Gravitas.Support;
 10using SwiftCollections;
 11
 12namespace Gravitas.Queries;
 13
 14/// <content>
 15/// Owns pure 2D segment raycast query behavior for one <see cref="GravitasWorldContext"/>.
 16/// </content>
 17public sealed partial class GravitasQuery2DService
 18{
 19    /// <summary>
 20    /// Finds the closest pure 2D collider hit by the segment from <paramref name="start"/> to <paramref name="end"/>.
 21    /// </summary>
 22    public bool Raycast(Vector2d start, Vector2d end, out Physics2DHit hit)
 23    {
 152324        return Raycast(start, end, PhysicsLayerMask.All, out hit);
 25    }
 26
 27    /// <summary>
 28    /// Finds the closest pure 2D collider on an included layer hit by the segment.
 29    /// </summary>
 30    public bool Raycast(Vector2d start, Vector2d end, PhysicsLayerMask layerMask, out Physics2DHit hit)
 31    {
 201432        return RaycastCore(start, end, layerMask, out hit, groundingBody: null);
 33    }
 34
 35    internal bool RaycastForGrounding(Vector2d start, Vector2d end, SolidBody2D body, out Physics2DHit hit)
 36    {
 7137        return RaycastCore(start, end, _context.Settings.GroundCheckLayerMask, out hit, body);
 38    }
 39
 40    private bool RaycastCore(
 41        Vector2d start, Vector2d end, PhysicsLayerMask layerMask,
 42        out Physics2DHit hit, SolidBody2D? groundingBody)
 43    {
 208544        if (!Vector2d.TrySubtract(end, start, out Vector2d segment)
 208545            || !Vector2d.TryGetMagnitude(segment, out Fixed64 segmentLength)
 208546            || segmentLength == Fixed64.Zero)
 47        {
 348            LastQueryCandidateCount = 0;
 349            hit = default;
 350            return false;
 51        }
 52
 53        try
 54        {
 208255            EnsureCandidateCapacity();
 208256            uint queryVersion = NextRaycastVersion();
 208257            _context.Collisions2D.CollectBoundsCandidates(
 208258                CreateMin(start, end),
 208259                CreateMax(start, end),
 208260                layerMask,
 208261                queryVersion,
 208262                raycastQuery: true,
 208263                _queryCandidates);
 64
 208265            LastQueryCandidateCount = _queryCandidates.Count;
 208266            bool found = false;
 208267            Physics2DHit closest = default;
 2133068            for (int i = 0; i < _queryCandidates.Count; i++)
 69            {
 70                // Only accepted witnesses enter closest. Ground policy is pure, so
 71                // losing hits need no additional normal normalization or filtering.
 858372                if (!QueryDetection2D.TryRaycast(start, end, segment, segmentLength, _queryCandidates[i], out Physics2DH
 858373                    || !PhysicsHitSelectionPolicy.ShouldReplace(candidate, found, closest)
 858374                    || (groundingBody is not null && !groundingBody.IsValidGroundHit(candidate)))
 75                {
 76                    continue;
 77                }
 78
 202979                closest = candidate;
 202980                found = true;
 81            }
 82
 208283            hit = closest;
 208284            return found;
 85        }
 86        finally
 87        {
 208288            EndQuery();
 208289        }
 208290    }
 91
 92    /// <summary>
 93    /// Writes all pure 2D colliders hit by the segment into <paramref name="results"/>.
 94    /// </summary>
 95    public int RaycastAll(Vector2d start, Vector2d end, SwiftList<Physics2DHit> results)
 96    {
 109697        return RaycastAll(start, end, PhysicsLayerMask.All, results);
 98    }
 99
 100    /// <summary>
 101    /// Writes all pure 2D colliders on included layers hit by the segment into <paramref name="results"/>.
 102    /// </summary>
 103    public int RaycastAll(Vector2d start, Vector2d end, PhysicsLayerMask layerMask, SwiftList<Physics2DHit> results)
 104    {
 1532105        ChronicleGuard.ThrowIfNull(results, nameof(results));
 106
 1532107        results.Clear();
 1532108        if (!Vector2d.TrySubtract(end, start, out Vector2d segment)
 1532109            || !Vector2d.TryGetMagnitude(segment, out Fixed64 segmentLength)
 1532110            || segmentLength == Fixed64.Zero)
 111        {
 4112            LastQueryCandidateCount = 0;
 4113            return 0;
 114        }
 115
 116        try
 117        {
 1528118            EnsureCandidateCapacity();
 1528119            uint queryVersion = NextRaycastVersion();
 1528120            _context.Collisions2D.CollectBoundsCandidates(
 1528121                CreateMin(start, end),
 1528122                CreateMax(start, end),
 1528123                layerMask,
 1528124                queryVersion,
 1528125                raycastQuery: true,
 1528126                _queryCandidates);
 127
 1528128            LastQueryCandidateCount = _queryCandidates.Count;
 19692129            for (int i = 0; i < _queryCandidates.Count; i++)
 8318130                if (QueryDetection2D.TryRaycast(start, end, segment, segmentLength, _queryCandidates[i], out Physics2DHi
 8317131                    results.Add(hit);
 132
 1528133            Physics2DHitSorter.SortByDistance(results);
 1528134            return results.Count;
 135        }
 136        finally
 137        {
 1528138            EndQuery();
 1528139        }
 1528140    }
 141
 142}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/2D/GravitasQuery2DService.Support.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQuery2DService.Support.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using System;
 9using System.Runtime.CompilerServices;
 10using FixedMathSharp;
 11using Gravitas.Colliders;
 12
 13namespace Gravitas.Queries;
 14
 15/// <content>
 16/// Owns pure 2D query scratch, version, and bounds helpers.
 17/// </content>
 18public sealed partial class GravitasQuery2DService
 19{
 20    private void EnsureCandidateCapacity()
 21    {
 1468122        int colliderCount = _context.Physics2D.ColliderCount;
 1468123        if (colliderCount > 0)
 1466724            _queryCandidates.EnsureCapacity(colliderCount);
 1468125    }
 26
 27    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 28    internal uint NextOverlapQueryVersion()
 29    {
 499230        OverlapQueryVersion++;
 499231        if (OverlapQueryVersion == 0)
 32        {
 133            ResetColliderOverlapQueryVersions();
 134            OverlapQueryVersion = 1;
 35        }
 499236        return OverlapQueryVersion;
 37    }
 38
 39    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 40    private uint NextRaycastVersion()
 41    {
 1283742        RaycastVersion++;
 1283743        if (RaycastVersion == 0)
 44        {
 145            ResetColliderRaycastVersions();
 146            RaycastVersion = 1;
 47        }
 1283748        return RaycastVersion;
 49    }
 50
 51    private void ResetColliderOverlapQueryVersions()
 52    {
 24053        for (int i = 0; i < _context.Physics2D.ColliderCount; i++)
 254            _context.Physics2D.GetColliderByServiceIndex(i).CircleQueryVersion = 0;
 11855    }
 56
 57    private void ResetColliderRaycastVersions()
 58    {
 24059        for (int i = 0; i < _context.Physics2D.ColliderCount; i++)
 260            _context.Physics2D.GetColliderByServiceIndex(i).RaycastVersion = 0;
 11861    }
 62
 63    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 64    private static Vector2d CreateMin(Vector2d first, Vector2d second) =>
 361065        new(FixedMath.Min(first.X, second.X), FixedMath.Min(first.Y, second.Y));
 66
 67    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 68    private static Vector2d CreateMax(Vector2d first, Vector2d second) =>
 361069        new(FixedMath.Max(first.X, second.X), FixedMath.Max(first.Y, second.Y));
 70
 71    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 72    private static Vector2d CreateSweepMin(Vector2d first, Vector2d second, Fixed64 radius) =>
 898473        new(FixedMath.Min(first.X, second.X) - radius, FixedMath.Min(first.Y, second.Y) - radius);
 74
 75    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 76    private static Vector2d CreateSweepMax(Vector2d first, Vector2d second, Fixed64 radius) =>
 898477        new(FixedMath.Max(first.X, second.X) + radius, FixedMath.Max(first.Y, second.Y) + radius);
 78
 79    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 80    private static void CreateAabbVertices(Vector2d center, Vector2d halfExtents, Span<Vector2d> vertices)
 81    {
 84882        vertices[0] = center - halfExtents;
 84883        vertices[1] = new Vector2d(center.X + halfExtents.X, center.Y - halfExtents.Y);
 84884        vertices[2] = center + halfExtents;
 84885        vertices[3] = new Vector2d(center.X - halfExtents.X, center.Y + halfExtents.Y);
 84886    }
 87
 88    private static void CalculateAreaBounds(ReadOnlySpan<Vector2d> vertices, out Vector2d min, out Vector2d max)
 89    {
 1590        min = vertices[0];
 1591        max = min;
 11292        for (int i = 1; i < vertices.Length; i++)
 93        {
 4194            Vector2d vertex = vertices[i];
 4195            min = new Vector2d(FixedMath.Min(min.X, vertex.X), FixedMath.Min(min.Y, vertex.Y));
 4196            max = new Vector2d(FixedMath.Max(max.X, vertex.X), FixedMath.Max(max.Y, vertex.Y));
 97        }
 1598    }
 99
 100    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 101    private static bool IsEligibleSweepCandidate(LSCollider2D collider, LSCollider2D? excludedCollider, bool includeTrig
 102    {
 16446103        if (!includeTriggers && collider.IsTrigger)
 52104            return false;
 105
 16394106        return excludedCollider == null
 16394107            || (!ReferenceEquals(collider, excludedCollider)
 16394108                && !ReferenceEquals(collider.AgentOrNull, excludedCollider.AgentOrNull)
 16394109                && !collider.IsSibling(excludedCollider));
 110    }
 111}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/2D/GravitasQuery2DService.SupportQuery.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQuery2DService.SupportQuery.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;
 10
 11namespace Gravitas.Queries;
 12
 13/// <content>Finds planar support for a registered collider under the physical collision filtering rules.</content>
 14public sealed partial class GravitasQuery2DService
 15{
 16    /// <summary>Finds the nearest eligible physical support at a stable between-frame boundary.</summary>
 17    /// <remarks>
 18    /// Excludes triggers, dynamic carriers, and pairs disabled by physical filters.
 19    /// Filters compound parts before selecting the nearest surface. Candidate storage may grow;
 20    /// this synchronous operation has no caller work ceiling. All non-Found results clear support.
 21    /// </remarks>
 22    public Physics2DSupportQueryStatus QuerySupport(in Physics2DSupportQuery request, out Physics2DSupportHit support)
 23    {
 25024        support = default;
 25025        LastQueryCandidateCount = 0;
 25026        ChronicleGuard.ThrowIfNull(request.Source, nameof(request));
 24927        ChronicleGuard.ThrowIfArgument(!request.Source.IsActive
 24928            || !_context.Physics2D.TryGetColliderById(request.Source.Id, out var registered)
 24929            || !ReferenceEquals(registered, request.Source), nameof(request),
 24930            "Support source must be an active collider registered in this context.");
 24831        if (!_context.RefreshQueryPartitions())
 132            return Physics2DSupportQueryStatus.WorldNotReady;
 33
 24734        Vector2d direction = -request.Up;
 24735        if (!Fixed64.TryMultiplyAdd(direction.X, request.Distance, request.Center.X, out Fixed64 endX)
 24736            || !Fixed64.TryMultiplyAdd(direction.Y, request.Distance, request.Center.Y, out Fixed64 endY))
 237            return Physics2DSupportQueryStatus.Unrepresentable;
 24538        Vector2d end = new(endX, endY);
 24539        Vector2d padding = new(request.Radius, request.Radius);
 24540        Vector2d centerMin = new(FixedMath.Min(request.Center.X, end.X), FixedMath.Min(request.Center.Y, end.Y));
 24541        Vector2d centerMax = new(FixedMath.Max(request.Center.X, end.X), FixedMath.Max(request.Center.Y, end.Y));
 24542        if (!Vector2d.TrySubtract(centerMin, padding, out Vector2d min)
 24543            || !Vector2d.TryAdd(centerMax, padding, out Vector2d max))
 244            return Physics2DSupportQueryStatus.Unrepresentable;
 45
 46        try
 47        {
 24348            EnsureCandidateCapacity();
 24349            _context.Collisions2D.CollectBoundsCandidates(min, max, request.Layers,
 24350                NextRaycastVersion(), raycastQuery: true, _queryCandidates);
 24351            LastQueryCandidateCount = _queryCandidates.Count;
 24352            bool found = false;
 24353            Physics2DHit closest = default;
 98854            for (int i = 0; i < _queryCandidates.Count; i++)
 55            {
 25156                LSCollider2D collider = _queryCandidates[i];
 25157                if (ReferenceEquals(collider, request.Source) || collider.IsTrigger
 25158                    || collider.Body?.MotionType == PhysicsMobilityType.Dynamic
 25159                    || !_context.Physics2D.RequireCollisionPair(request.Source, collider)
 25160                    || !QueryDetection2D.TryFindSupport(request, end, collider, out Physics2DHit candidate)
 25161                    || !PhysicsHitSelectionPolicy.ShouldReplace(candidate, found, closest))
 62                    continue;
 24063                closest = candidate;
 24064                found = true;
 65            }
 24366            if (!found)
 467                return Physics2DSupportQueryStatus.NoSupport;
 23968            support = new Physics2DSupportHit(closest, _context.FrameCount);
 23969            return Physics2DSupportQueryStatus.Found;
 70        }
 71        finally
 72        {
 24373            EndQuery();
 24374        }
 24375    }
 76}
 77// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 78// See LICENSE file in the project root for full license information.

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/2D/GravitasQuery2DService.Sweep.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQuery2DService.Sweep.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 Gravitas.Support;
 11using SwiftCollections;
 12
 13namespace Gravitas.Queries;
 14
 15/// <content>
 16/// Owns pure 2D swept-circle query behavior for one <see cref="GravitasWorldContext"/>.
 17/// </content>
 18public sealed partial class GravitasQuery2DService
 19{
 20    /// <summary>
 21    /// Finds the closest pure 2D collider hit by sweeping a circle from <paramref name="start"/> to <paramref name="end
 22    /// </summary>
 23    public bool SweepCircle(Vector2d start, Vector2d end, Fixed64 radius, out Physics2DHit hit)
 24    {
 8625        return SweepCircle(start, end, radius, PhysicsLayerMask.All, out hit);
 26    }
 27
 28    /// <summary>
 29    /// Finds the closest pure 2D collider on an included layer hit by sweeping a circle.
 30    /// </summary>
 31    public bool SweepCircle(
 32        Vector2d start,
 33        Vector2d end,
 34        Fixed64 radius,
 35        PhysicsLayerMask layerMask,
 36        out Physics2DHit hit,
 37        LSCollider2D? excludedCollider = null,
 38        bool includeTriggers = true)
 39    {
 9140        return SweepCircleCore(start, end, radius, layerMask, out hit, excludedCollider, includeTriggers, groundingBody:
 41    }
 42
 43    internal bool SweepCircleForGrounding(
 44        Vector2d start, Vector2d end, Fixed64 radius, SolidBody2D body, out Physics2DHit hit)
 45    {
 750446        return SweepCircleCore(start, end, radius, _context.Settings.GroundCheckLayerMask,
 750447            out hit, body.Collider, includeTriggers: false, body);
 48    }
 49
 50    private bool SweepCircleCore(
 51        Vector2d start, Vector2d end, Fixed64 radius, PhysicsLayerMask layerMask,
 52        out Physics2DHit hit, LSCollider2D? excludedCollider, bool includeTriggers, SolidBody2D? groundingBody)
 53    {
 759554        ChronicleGuard.ThrowIfArgument(radius <= Fixed64.Zero, nameof(radius), "2D sweep radius must be greater than zer
 759555        if (groundingBody is null)
 9156            ColliderGeometryPolicy.ValidateReach(radius, nameof(radius));
 57
 759458        if (!Vector2d.TrySubtract(end, start, out Vector2d segment)
 759459            || !Vector2d.TryGetMagnitude(segment, out Fixed64 segmentLength)
 759460            || segmentLength <= Fixed64.Epsilon)
 61        {
 862            LastQueryCandidateCount = 0;
 863            hit = default;
 864            return false;
 65        }
 66
 67        try
 68        {
 758669            EnsureCandidateCapacity();
 758670            uint queryVersion = NextRaycastVersion();
 758671            _context.Collisions2D.CollectBoundsCandidates(
 758672                CreateSweepMin(start, end, radius),
 758673                CreateSweepMax(start, end, radius),
 758674                layerMask,
 758675                queryVersion,
 758676                raycastQuery: true,
 758677                _queryCandidates,
 758678                staticStyleOnly: groundingBody is not null);
 79
 758680            LastQueryCandidateCount = _queryCandidates.Count;
 758681            bool found = false;
 758682            Physics2DHit closest = default;
 1758483            for (int i = 0; i < _queryCandidates.Count; i++)
 84            {
 120685                LSCollider2D collider = _queryCandidates[i];
 86                // Reduce compound parts before body policy; a rejected owner cannot
 87                // contribute a later part just because that part has a support normal.
 120688                if (!IsEligibleSweepCandidate(collider, excludedCollider, includeTriggers)
 120689                    || !QueryDetection2D.TrySweepCircle(start, end, segment, segmentLength, radius, collider, out Physic
 120690                    || !PhysicsHitSelectionPolicy.ShouldReplace(candidate, found, closest)
 120691                    || (groundingBody is not null && !groundingBody.IsValidGroundHit(candidate)))
 92                {
 93                    continue;
 94                }
 95
 39496                closest = candidate;
 39497                found = true;
 98            }
 99
 7586100            hit = closest;
 7586101            return found;
 102        }
 103        finally
 104        {
 7586105            EndQuery();
 7586106        }
 7586107    }
 108
 109    /// <summary>
 110    /// Writes all pure 2D colliders hit by sweeping a circle into <paramref name="results"/>.
 111    /// </summary>
 112    public int SweepCircleAll(Vector2d start, Vector2d end, Fixed64 radius, SwiftList<Physics2DHit> results)
 113    {
 52114        return SweepCircleAll(start, end, radius, PhysicsLayerMask.All, results);
 115    }
 116
 117    /// <summary>
 118    /// Writes all pure 2D colliders on included layers hit by sweeping a circle into <paramref name="results"/>.
 119    /// </summary>
 120    public int SweepCircleAll(
 121        Vector2d start,
 122        Vector2d end,
 123        Fixed64 radius,
 124        PhysicsLayerMask layerMask,
 125        SwiftList<Physics2DHit> results,
 126        LSCollider2D? excludedCollider = null,
 127        bool includeTriggers = true)
 128    {
 267129        return SweepCircleAllCore(
 267130            start,
 267131            end,
 267132            radius,
 267133            layerMask,
 267134            results,
 267135            excludedCollider,
 267136            includeTriggers,
 267137            staticTargetsOnly: false);
 138    }
 139
 140    internal int SweepCircleAgainstStaticAll(
 141        Vector2d start,
 142        Vector2d end,
 143        Fixed64 radius,
 144        PhysicsLayerMask layerMask,
 145        SwiftList<Physics2DHit> results,
 146        LSCollider2D? excludedCollider = null,
 147        bool includeTriggers = true)
 148    {
 1138149        return SweepCircleAllCore(
 1138150            start,
 1138151            end,
 1138152            radius,
 1138153            layerMask,
 1138154            results,
 1138155            excludedCollider,
 1138156            includeTriggers,
 1138157            staticTargetsOnly: true);
 158    }
 159
 160    private int SweepCircleAllCore(
 161        Vector2d start,
 162        Vector2d end,
 163        Fixed64 radius,
 164        PhysicsLayerMask layerMask,
 165        SwiftList<Physics2DHit> results,
 166        LSCollider2D? excludedCollider,
 167        bool includeTriggers,
 168        bool staticTargetsOnly)
 169    {
 1405170        ChronicleGuard.ThrowIfNull(results, nameof(results));
 1405171        ChronicleGuard.ThrowIfArgument(radius <= Fixed64.Zero, nameof(radius), "2D sweep radius must be greater than zer
 1405172        if (!staticTargetsOnly)
 267173            ColliderGeometryPolicy.ValidateReach(radius, nameof(radius));
 174
 1404175        results.Clear();
 1404176        if (!Vector2d.TrySubtract(end, start, out Vector2d segment)
 1404177            || !Vector2d.TryGetMagnitude(segment, out Fixed64 segmentLength)
 1404178            || segmentLength <= Fixed64.Epsilon)
 179        {
 6180            LastQueryCandidateCount = 0;
 6181            return 0;
 182        }
 183
 184        try
 185        {
 1398186            EnsureCandidateCapacity();
 1398187            uint queryVersion = NextRaycastVersion();
 1398188            _context.Collisions2D.CollectBoundsCandidates(
 1398189                CreateSweepMin(start, end, radius),
 1398190                CreateSweepMax(start, end, radius),
 1398191                layerMask,
 1398192                queryVersion,
 1398193                raycastQuery: true,
 1398194                _queryCandidates,
 1398195                staticStyleOnly: staticTargetsOnly);
 196
 1398197            LastQueryCandidateCount = _queryCandidates.Count;
 18608198            for (int i = 0; i < _queryCandidates.Count; i++)
 199            {
 7906200                LSCollider2D collider = _queryCandidates[i];
 7906201                if (IsEligibleSweepCandidate(collider, excludedCollider, includeTriggers)
 7906202                    && QueryDetection2D.TrySweepCircle(start, end, segment, segmentLength, radius, collider, out Physics
 203                {
 7745204                    results.Add(hit);
 205                }
 206            }
 207
 1398208            Physics2DHitSorter.SortByDistance(results);
 1398209            return results.Count;
 210        }
 211        finally
 212        {
 1398213            EndQuery();
 1398214        }
 1398215    }
 216
 217}

Methods/Properties

.ctor(Gravitas.GravitasWorldContext)
RaycastBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsRaycast2DRequest>,System.Span`1<Gravitas.Queries.Physics2DHit>)
RaycastAllBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsRaycast2DRequest>,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
OverlapCircleBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsOverlapCircle2DRequest>,System.Span`1<Gravitas.Queries.Physics2DHit>)
OverlapCircleAllBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsOverlapCircle2DRequest>,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
OverlapAabbBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsOverlapAabb2DRequest>,System.Span`1<Gravitas.Queries.Physics2DHit>)
OverlapAabbAllBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsOverlapAabb2DRequest>,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
OverlapPolygonBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsOverlapPolygon2DRequest>,System.ReadOnlySpan`1<FixedMathSharp.Vector2d>,System.Span`1<Gravitas.Queries.Physics2DHit>)
OverlapPolygonAllBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsOverlapPolygon2DRequest>,System.ReadOnlySpan`1<FixedMathSharp.Vector2d>,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
SweepCircleBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepCircle2DRequest>,System.Span`1<Gravitas.Queries.Physics2DHit>)
SweepCircleAllBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepCircle2DRequest>,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
WriteClosestHit(System.Span`1<Gravitas.Queries.Physics2DHit>,System.Int32,Gravitas.Queries.Physics2DHit,System.Boolean,System.Int32&)
AppendRange(SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>,System.Int32,System.Int32)
ResetBatchCounters(System.Int32)
AccumulateBatchCounters(System.Int32)
ValidateClosestBatchOutput(System.Int32,System.Span`1<Gravitas.Queries.Physics2DHit>)
ValidateRangeBatchOutput(System.Int32,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
ValidatePolygonRequestRanges(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsOverlapPolygon2DRequest>,System.ReadOnlySpan`1<FixedMathSharp.Vector2d>)
ValidateOverlapCircleRequests(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsOverlapCircle2DRequest>)
ValidateOverlapAabbRequests(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsOverlapAabb2DRequest>)
ValidateSweepCircleRequests(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepCircle2DRequest>)
.ctor(Gravitas.GravitasWorldContext)
get_Context()
Reset()
EndQuery()
OverlapCircleAll(FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>)
OverlapCircleAll(FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>)
OverlapCircleAgainstStaticAll(FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>,Gravitas.Colliders.LSCollider2D,System.Boolean)
OverlapCircle(FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,Gravitas.Queries.Physics2DHit&)
OverlapCircle(FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,Gravitas.Queries.Physics2DHit&)
OverlapAabb(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,Gravitas.Queries.Physics2DHit&)
OverlapAabb(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,Gravitas.Support.PhysicsLayerMask,Gravitas.Queries.Physics2DHit&)
OverlapAabbAll(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>)
OverlapAabbAll(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>)
OverlapPolygon(System.ReadOnlySpan`1<FixedMathSharp.Vector2d>,Gravitas.Queries.Physics2DHit&)
OverlapPolygon(System.ReadOnlySpan`1<FixedMathSharp.Vector2d>,Gravitas.Support.PhysicsLayerMask,Gravitas.Queries.Physics2DHit&)
OverlapPolygonAll(System.ReadOnlySpan`1<FixedMathSharp.Vector2d>,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>)
OverlapPolygonAll(System.ReadOnlySpan`1<FixedMathSharp.Vector2d>,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>)
OverlapCircleAllCore(FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>,System.Boolean,Gravitas.Colliders.LSCollider2D,System.Boolean)
OverlapAreaCore(System.ReadOnlySpan`1<FixedMathSharp.Vector2d>,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,Gravitas.Support.PhysicsLayerMask,Gravitas.Queries.Physics2DHit&)
OverlapAreaAllCore(System.ReadOnlySpan`1<FixedMathSharp.Vector2d>,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>)
Raycast(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,Gravitas.Queries.Physics2DHit&)
Raycast(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,Gravitas.Support.PhysicsLayerMask,Gravitas.Queries.Physics2DHit&)
RaycastForGrounding(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,Gravitas.SolidBody2D,Gravitas.Queries.Physics2DHit&)
RaycastCore(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,Gravitas.Support.PhysicsLayerMask,Gravitas.Queries.Physics2DHit&,Gravitas.SolidBody2D)
RaycastAll(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>)
RaycastAll(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>)
EnsureCandidateCapacity()
NextOverlapQueryVersion()
NextRaycastVersion()
ResetColliderOverlapQueryVersions()
ResetColliderRaycastVersions()
CreateMin(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d)
CreateMax(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d)
CreateSweepMin(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64)
CreateSweepMax(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64)
CreateAabbVertices(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,System.Span`1<FixedMathSharp.Vector2d>)
CalculateAreaBounds(System.ReadOnlySpan`1<FixedMathSharp.Vector2d>,FixedMathSharp.Vector2d&,FixedMathSharp.Vector2d&)
IsEligibleSweepCandidate(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D,System.Boolean)
QuerySupport(Gravitas.Queries.Physics2DSupportQuery&,Gravitas.Queries.Physics2DSupportHit&)
SweepCircle(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,Gravitas.Queries.Physics2DHit&)
SweepCircle(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,Gravitas.Queries.Physics2DHit&,Gravitas.Colliders.LSCollider2D,System.Boolean)
SweepCircleForGrounding(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,Gravitas.SolidBody2D,Gravitas.Queries.Physics2DHit&)
SweepCircleCore(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,Gravitas.Queries.Physics2DHit&,Gravitas.Colliders.LSCollider2D,System.Boolean,Gravitas.SolidBody2D)
SweepCircleAll(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>)
SweepCircleAll(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>,Gravitas.Colliders.LSCollider2D,System.Boolean)
SweepCircleAgainstStaticAll(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>,Gravitas.Colliders.LSCollider2D,System.Boolean)
SweepCircleAllCore(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.Physics2DHit>,Gravitas.Colliders.LSCollider2D,System.Boolean,System.Boolean)