< Summary

Line coverage
100%
Covered lines: 1522
Uncovered lines: 0
Coverable lines: 1522
Total lines: 2846
Line coverage: 100%
Branch coverage
100%
Covered branches: 458
Total branches: 458
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: SweepSphereAgainst2DBatch(...)100%22100%
File 1: SweepSphereAgainst2DAllBatch(...)100%22100%
File 1: SweepCircleAgainst3DBatch(...)100%22100%
File 1: SweepCircleAgainst3DAllBatch(...)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: ValidateSweepSphereAgainst2DRequests(...)100%22100%
File 1: ValidateSweepCircleAgainst3DRequests(...)100%22100%
File 2: TrySweepCircleAgainst3DCollider(...)100%44100%
File 2: TrySweepCircleAgainst3DColliderCore(...)100%1414100%
File 2: TrySweepCircleAgainstCuboid(...)100%22100%
File 2: TrySweepCircleAgainstCapsule(...)100%22100%
File 2: TrySweepCircleAgainstCylinder(...)100%22100%
File 2: BuildCircleAgainstProjectedFiniteSlabHit(...)100%11100%
File 2: TrySweepCircleAgainstCone(...)100%22100%
File 2: TrySweepCircleAgainstMesh(...)100%9898100%
File 2: TrySweepCircleAgainstCompound3D(...)100%88100%
File 3: TrySweepCircleAgainstSphere(...)100%44100%
File 3: TrySweepPointInPlane(...)100%11100%
File 4: .ctor(...)100%11100%
File 4: get_Context()100%11100%
File 4: Reset()100%11100%
File 4: EndQuery()100%11100%
File 5: EmitMixedSweepDiagnostics(...)100%22100%
File 5: TrySweepSphereAgainst2DCandidate(...)100%2222100%
File 5: TrySweepCircleAgainst3DCandidate(...)100%1616100%
File 5: TryGetInitialMixedCcdHit(...)100%1616100%
File 5: RecordAttempt(...)100%22100%
File 5: RecordAccepted()100%11100%
File 5: RecordRejected(...)100%22100%
File 6: TryResolveExactSphereSourceFor2D(...)100%2626100%
File 6: TrySweepSphereAgainst2D(...)100%44100%
File 6: TrySweepSphereAgainst2DCore(...)100%1010100%
File 6: TrySweepSphereAgainstCompound2D(...)100%88100%
File 6: TrySweepSphereAgainstCapsuleSlab(...)100%88100%
File 6: IsSphereOverlappingCapsuleSlabCapCore(...)100%1010100%
File 6: TrySweepSphereAgainstConvexSlab(...)100%1010100%
File 6: TrySweepConvexSlabCapFace(...)100%1010100%
File 6: TrySweepConvexSlabSideFaces(...)100%2020100%
File 6: TrySweepConvexSlabEdges(...)100%22100%
File 6: TrySweepCapsuleSlabCapFace(...)100%1010100%
File 6: TrySweepCapsuleSlabSide(...)100%66100%
File 6: TrySweepCapsuleSlabBoundaryEdges(...)100%44100%
File 6: TryKeepCapsuleSlabStraightRimSweep(...)100%11100%
File 6: DoesSphereOverlapConvexSlab(...)100%44100%
File 6: TryGetConvexSlabLocalSweep(...)100%11100%
File 6: TrySweepPointAgainstSegmentCapsule3D(...)100%11100%
File 6: GetCapDistance(...)100%11100%
File 6: TryKeepEarlierSweep(...)100%66100%
File 7: TrySweepSphereAgainstCircleSlab(...)100%22100%
File 8: BuildSphereAgainst2DHit(...)100%1010100%
File 8: BuildCircleAgainst3DHit(...)100%1212100%
File 8: BuildCircleAgainst3DHit(...)100%1010100%
File 8: Resolve3DTo2DFallback(...)100%22100%
File 8: ResetLastQueryCounters()100%11100%
File 8: IsEligible2DTarget(...)100%88100%
File 8: IsEligible3DTarget(...)100%88100%
File 8: CreateSweepBounds(...)100%11100%
File 8: CreateCircleSlabSweepBounds(...)100%11100%
File 9: SweepCircleAgainst3D(...)100%11100%
File 9: SweepCircleAgainst3DAll(...)100%11100%
File 9: SweepCircleAgainstStatic3DAll(...)100%11100%
File 9: SweepCircleAgainst3DClosestCore(...)100%1414100%
File 9: SweepCircleAgainst3DAllCore(...)100%1414100%
File 10: SweepSphereAgainst2D(...)100%11100%
File 10: SweepSphereAgainst2DAll(...)100%11100%
File 10: SweepSphereAgainstStatic2DAll(...)100%11100%
File 10: SweepSphereAgainst2DClosestCore(...)100%1414100%
File 10: SweepSphereAgainst2DAllCore(...)100%1414100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/Mixed/GravitasQueryMixedService.Batch.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQueryMixedService.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 mixed 3D/2D query behavior for one <see cref="GravitasWorldContext"/>.
 17/// </content>
 18public sealed partial class GravitasQueryMixedService
 19{
 1019120    private readonly SwiftList<PhysicsMixedHit> _batchMixedHits = new();
 21
 22    /// <summary>
 23    /// Gets the number of requests processed by the last mixed 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 mixed batch query call.
 29    /// </summary>
 30    public int LastBatchHitCount { get; private set; }
 31
 32    /// <summary>
 33    /// Gets the summed top-level candidate count reported by the last mixed batch query call.
 34    /// </summary>
 35    public int LastBatchCandidateCount { get; private set; }
 36
 37    /// <summary>
 38    /// Gets the summed mesh-triangle candidate count reported by the last mixed batch query call.
 39    /// </summary>
 40    public int LastBatchMeshTriangleCandidateCount { get; private set; }
 41
 42    /// <summary>
 43    /// Executes multiple mixed swept-sphere-against-2D queries and writes one closest-hit slot per request.
 44    /// </summary>
 45    public int SweepSphereAgainst2DBatch(
 46        ReadOnlySpan<PhysicsSweepSphereAgainst2DRequest> requests,
 47        Span<PhysicsMixedHit> closestHits)
 48    {
 20949        ValidateClosestBatchOutput(requests.Length, closestHits);
 20950        ValidateSweepSphereAgainst2DRequests(requests);
 20951        ResetBatchCounters(requests.Length);
 52
 20953        int hitCount = 0;
 83854        for (int i = 0; i < requests.Length; i++)
 55        {
 21056            PhysicsSweepSphereAgainst2DRequest request = requests[i];
 21057            bool found = SweepSphereAgainst2D(
 21058                request.Start,
 21059                request.End,
 21060                request.Radius,
 21061                request.LayerMask,
 21062                out PhysicsMixedHit hit,
 21063                request.ExcludedCollider,
 21064                request.IncludeTriggers);
 21065            WriteClosestHit(closestHits, i, hit, found, ref hitCount);
 66        }
 67
 20968        LastBatchHitCount = hitCount;
 20969        return hitCount;
 70    }
 71
 72    /// <summary>
 73    /// Executes multiple mixed swept-sphere-against-2D queries and appends all hits into one caller-owned hit buffer.
 74    /// </summary>
 75    public int SweepSphereAgainst2DAllBatch(
 76        ReadOnlySpan<PhysicsSweepSphereAgainst2DRequest> requests,
 77        SwiftList<PhysicsMixedHit> hits,
 78        Span<PhysicsQueryHitRange> ranges)
 79    {
 21680        ChronicleGuard.ThrowIfNull(hits, nameof(hits));
 21681        ValidateRangeBatchOutput(requests.Length, ranges);
 21682        ValidateSweepSphereAgainst2DRequests(requests);
 21683        ResetBatchCounters(requests.Length);
 21684        hits.Clear();
 85
 87286        for (int i = 0; i < requests.Length; i++)
 87        {
 88            try
 89            {
 22190                PhysicsSweepSphereAgainst2DRequest request = requests[i];
 22191                int count = SweepSphereAgainst2DAll(
 22192                    request.Start,
 22193                    request.End,
 22194                    request.Radius,
 22195                    request.LayerMask,
 22196                    _batchMixedHits,
 22197                    request.ExcludedCollider,
 22198                    request.IncludeTriggers);
 22099                AppendRange(hits, ranges, i, count);
 220100            }
 101            finally
 102            {
 221103                _batchMixedHits.Clear();
 221104            }
 105        }
 106
 215107        LastBatchHitCount = hits.Count;
 215108        return hits.Count;
 109    }
 110
 111    /// <summary>
 112    /// Executes multiple mixed swept-circle-against-3D queries and writes one closest-hit slot per request.
 113    /// </summary>
 114    public int SweepCircleAgainst3DBatch(
 115        ReadOnlySpan<PhysicsSweepCircleAgainst3DRequest> requests,
 116        Span<PhysicsMixedHit> closestHits)
 117    {
 209118        ValidateClosestBatchOutput(requests.Length, closestHits);
 209119        ValidateSweepCircleAgainst3DRequests(requests);
 209120        ResetBatchCounters(requests.Length);
 121
 209122        int hitCount = 0;
 838123        for (int i = 0; i < requests.Length; i++)
 124        {
 210125            PhysicsSweepCircleAgainst3DRequest request = requests[i];
 210126            bool found = SweepCircleAgainst3D(
 210127                request.Start,
 210128                request.End,
 210129                request.Radius,
 210130                request.SlabCenterY,
 210131                request.HalfThickness,
 210132                request.LayerMask,
 210133                out PhysicsMixedHit hit,
 210134                request.ExcludedCollider,
 210135                request.IncludeTriggers);
 210136            WriteClosestHit(closestHits, i, hit, found, ref hitCount);
 137        }
 138
 209139        LastBatchHitCount = hitCount;
 209140        return hitCount;
 141    }
 142
 143    /// <summary>
 144    /// Executes multiple mixed swept-circle-against-3D queries and appends all hits into one caller-owned hit buffer.
 145    /// </summary>
 146    public int SweepCircleAgainst3DAllBatch(
 147        ReadOnlySpan<PhysicsSweepCircleAgainst3DRequest> requests,
 148        SwiftList<PhysicsMixedHit> hits,
 149        Span<PhysicsQueryHitRange> ranges)
 150    {
 214151        ChronicleGuard.ThrowIfNull(hits, nameof(hits));
 214152        ValidateRangeBatchOutput(requests.Length, ranges);
 214153        ValidateSweepCircleAgainst3DRequests(requests);
 214154        ResetBatchCounters(requests.Length);
 214155        hits.Clear();
 156
 862157        for (int i = 0; i < requests.Length; i++)
 158        {
 159            try
 160            {
 217161                PhysicsSweepCircleAgainst3DRequest request = requests[i];
 217162                int count = SweepCircleAgainst3DAll(
 217163                    request.Start,
 217164                    request.End,
 217165                    request.Radius,
 217166                    request.SlabCenterY,
 217167                    request.HalfThickness,
 217168                    request.LayerMask,
 217169                    _batchMixedHits,
 217170                    request.ExcludedCollider,
 217171                    request.IncludeTriggers);
 217172                AppendRange(hits, ranges, i, count);
 217173            }
 174            finally
 175            {
 217176                _batchMixedHits.Clear();
 217177            }
 178        }
 179
 214180        LastBatchHitCount = hits.Count;
 214181        return hits.Count;
 182    }
 183
 184    private void WriteClosestHit(Span<PhysicsMixedHit> closestHits, int index, PhysicsMixedHit hit, bool found, ref int 
 185    {
 420186        if (found)
 187        {
 418188            closestHits[index] = hit;
 418189            hitCount++;
 418190            AccumulateBatchCounters(1);
 191        }
 192        else
 193        {
 2194            closestHits[index] = default;
 2195            AccumulateBatchCounters(0);
 196        }
 2197    }
 198
 199    private void AppendRange(
 200        SwiftList<PhysicsMixedHit> hits,
 201        Span<PhysicsQueryHitRange> ranges,
 202        int index,
 203        int count)
 204    {
 437205        int start = hits.Count;
 437206        if (count > 0)
 428207            hits.AddRange(_batchMixedHits.AsReadOnlySpan());
 208
 437209        ranges[index] = new PhysicsQueryHitRange(start, count);
 437210        AccumulateBatchCounters(count);
 437211    }
 212
 213    private void ResetBatchCounters(int requestCount)
 214    {
 964215        LastBatchRequestCount = requestCount;
 964216        LastBatchHitCount = 0;
 964217        LastBatchCandidateCount = 0;
 964218        LastBatchMeshTriangleCandidateCount = 0;
 964219    }
 220
 221    private void AccumulateBatchCounters(int hitCount)
 222    {
 857223        LastBatchHitCount += hitCount;
 857224        LastBatchCandidateCount += LastQueryCandidateCount;
 857225        LastBatchMeshTriangleCandidateCount += LastMeshTriangleCandidateCount;
 857226    }
 227
 228    private static void ValidateClosestBatchOutput(int requestCount, Span<PhysicsMixedHit> closestHits)
 229    {
 418230        ChronicleGuard.ThrowIfArgument(
 418231            closestHits.Length < requestCount,
 418232            nameof(closestHits),
 418233            "Closest-hit output span must contain at least one slot per request.");
 418234    }
 235
 236    private static void ValidateRangeBatchOutput(int requestCount, Span<PhysicsQueryHitRange> ranges)
 237    {
 430238        ChronicleGuard.ThrowIfArgument(
 430239            ranges.Length < requestCount,
 430240            nameof(ranges),
 430241            "Range output span must contain at least one slot per request.");
 430242    }
 243
 244    private static void ValidateSweepSphereAgainst2DRequests(ReadOnlySpan<PhysicsSweepSphereAgainst2DRequest> requests)
 245    {
 1712246        for (int i = 0; i < requests.Length; i++)
 247        {
 431248            ChronicleGuard.ThrowIfArgument(
 431249                requests[i].Radius <= Fixed64.Zero,
 431250                nameof(requests),
 431251                "Mixed swept sphere radius must be greater than zero.");
 431252            ColliderGeometryPolicy.ValidateReach(requests[i].Radius, nameof(requests));
 253        }
 425254    }
 255
 256    private static void ValidateSweepCircleAgainst3DRequests(ReadOnlySpan<PhysicsSweepCircleAgainst3DRequest> requests)
 257    {
 1700258        for (int i = 0; i < requests.Length; i++)
 259        {
 427260            ChronicleGuard.ThrowIfArgument(
 427261                requests[i].Radius <= Fixed64.Zero,
 427262                nameof(requests),
 427263                "Mixed swept circle radius must be greater than zero.");
 427264            ChronicleGuard.ThrowIfArgument(
 427265                requests[i].HalfThickness <= Fixed64.Zero,
 427266                nameof(requests),
 427267                "Mixed swept circle half-thickness must be greater than zero.");
 427268            ColliderGeometryPolicy.ValidateReach(new Vector2d(requests[i].Radius, requests[i].HalfThickness), nameof(req
 269        }
 423270    }
 271}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/Mixed/GravitasQueryMixedService.CircleAgainst3DReducers.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQueryMixedService.CircleAgainst3DReducers.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 FixedMathSharp.Geometry;
 11using Gravitas.Colliders;
 12using Gravitas.CollisionHandling;
 13using SwiftCollections.Query;
 14
 15namespace Gravitas.Queries;
 16
 17/// <content>
 18/// Owns mixed swept-circle reducers against 3D collider targets.
 19/// </content>
 20public sealed partial class GravitasQueryMixedService
 21{
 22    internal bool TrySweepCircleAgainst3DCollider(
 23        LSCollider collider, Vector2d start, Vector2d end, Vector2d direction2D,
 24        Fixed64 length, Fixed64 radius, Fixed64 slabCenterY, Fixed64 halfThickness,
 25        Vector3d direction3D, LSCollider2D? sourceCollider, out PhysicsMixedHit hit,
 26        bool requireClosingContact = false)
 27    {
 182828        return TrySweepCircleAgainst3DColliderCore(collider, start, end, direction2D, length,
 182829                radius, slabCenterY, halfThickness, direction3D, sourceCollider, requireClosingContact, out hit)
 182830            && (!requireClosingContact
 182831                || MixedContact.IsClosingProjection(ExactContactLever2D.ToSpatial(end - start), hit.Normal3DTo2D));
 32    }
 33
 34    private bool TrySweepCircleAgainst3DColliderCore(
 35        LSCollider collider,
 36        Vector2d start,
 37        Vector2d end,
 38        Vector2d direction2D,
 39        Fixed64 length,
 40        Fixed64 radius,
 41        Fixed64 slabCenterY,
 42        Fixed64 halfThickness,
 43        Vector3d direction3D,
 44        LSCollider2D? sourceCollider,
 45        bool requireClosingContact,
 46        out PhysicsMixedHit hit)
 47    {
 182848        if (collider is LSSphereCollider sphere)
 49        {
 53950            return TrySweepCircleAgainstSphere(
 53951                start,
 53952                end,
 53953                length,
 53954                radius,
 53955                slabCenterY,
 53956                halfThickness,
 53957                direction3D,
 53958                sphere,
 53959                sourceCollider,
 53960                out hit);
 61        }
 62
 128963        if (collider is LSCuboidCollider cuboid)
 64        {
 26165            return TrySweepCircleAgainstCuboid(
 26166                start,
 26167                end,
 26168                length,
 26169                radius,
 26170                slabCenterY,
 26171                halfThickness,
 26172                direction3D,
 26173                cuboid,
 26174                sourceCollider,
 26175                out hit);
 76        }
 77
 102878        if (collider is LSCapsuleCollider capsule)
 18179            return TrySweepCircleAgainstCapsule(
 18180                start,
 18181                end,
 18182                direction2D,
 18183                length,
 18184                radius,
 18185                slabCenterY,
 18186                halfThickness,
 18187                direction3D,
 18188                capsule,
 18189                sourceCollider,
 18190                out hit);
 91
 84792        if (collider is LSCylinderCollider cylinder)
 17193            return TrySweepCircleAgainstCylinder(
 17194                start,
 17195                end,
 17196                direction2D,
 17197                length,
 17198                radius,
 17199                slabCenterY,
 171100                halfThickness,
 171101                direction3D,
 171102                cylinder,
 171103                sourceCollider,
 171104                out hit);
 105
 676106        if (collider is LSConeCollider cone)
 165107            return TrySweepCircleAgainstCone(start, end, direction2D, length, radius, slabCenterY, halfThickness, direct
 108
 511109        if (collider is LSMeshCollider mesh)
 496110            return TrySweepCircleAgainstMesh(start, end, length, radius, slabCenterY, halfThickness, direction3D, mesh, 
 111
 15112        if (collider is LSCompoundCollider compound)
 14113            return TrySweepCircleAgainstCompound3D(start, end, direction2D, length, radius, slabCenterY, halfThickness, 
 114
 1115        hit = default;
 1116        return false;
 117    }
 118
 119    private static bool TrySweepCircleAgainstCuboid(
 120        Vector2d start,
 121        Vector2d end,
 122        Fixed64 length,
 123        Fixed64 radius,
 124        Fixed64 slabCenterY,
 125        Fixed64 halfThickness,
 126        Vector3d direction3D,
 127        LSCuboidCollider cuboid,
 128        LSCollider2D? sourceCollider,
 129        out PhysicsMixedHit hit)
 130    {
 261131        if (!cuboid.OrientedBox.TryGetCircleSlabSweepDistance(
 261132            new FixedSegment2d(start, end),
 261133            length,
 261134            slabCenterY,
 261135            halfThickness,
 261136            radius,
 261137            out Fixed64 distance))
 138        {
 32139            hit = default;
 32140            return false;
 141        }
 142
 229143        hit = BuildCircleAgainstProjectedFiniteSlabHit(
 229144            start,
 229145            end,
 229146            length,
 229147            distance,
 229148            radius,
 229149            slabCenterY,
 229150            halfThickness,
 229151            direction3D,
 229152            cuboid,
 229153            sourceCollider);
 229154        return true;
 155    }
 156
 157    private static bool TrySweepCircleAgainstCapsule(
 158        Vector2d start,
 159        Vector2d end,
 160        Vector2d direction,
 161        Fixed64 length,
 162        Fixed64 radius,
 163        Fixed64 slabCenterY,
 164        Fixed64 halfThickness,
 165        Vector3d direction3D,
 166        LSCapsuleCollider capsule,
 167        LSCollider2D? sourceCollider,
 168        out PhysicsMixedHit hit)
 169    {
 181170        Fixed64 slabMinY = slabCenterY - halfThickness;
 181171        Fixed64 slabMaxY = slabCenterY + halfThickness;
 181172        if (!FiniteSlabProjectionSweep.TrySweepCircleAgainstCapsule(
 181173            start,
 181174            end,
 181175            direction,
 181176            length,
 181177            radius,
 181178            slabMinY,
 181179            slabMaxY,
 181180            capsule,
 181181            out Fixed64 distance))
 182        {
 7183            hit = default;
 7184            return false;
 185        }
 186
 174187        hit = BuildCircleAgainstProjectedFiniteSlabHit(
 174188            start,
 174189            end,
 174190            length,
 174191            distance,
 174192            radius,
 174193            slabCenterY,
 174194            halfThickness,
 174195            direction3D,
 174196            capsule,
 174197            sourceCollider);
 174198        return true;
 199    }
 200
 201    private static bool TrySweepCircleAgainstCylinder(
 202        Vector2d start,
 203        Vector2d end,
 204        Vector2d direction,
 205        Fixed64 length,
 206        Fixed64 radius,
 207        Fixed64 slabCenterY,
 208        Fixed64 halfThickness,
 209        Vector3d direction3D,
 210        LSCylinderCollider cylinder,
 211        LSCollider2D? sourceCollider,
 212        out PhysicsMixedHit hit)
 213    {
 171214        Fixed64 slabMinY = slabCenterY - halfThickness;
 171215        Fixed64 slabMaxY = slabCenterY + halfThickness;
 171216        if (!FiniteSlabProjectionSweep.TrySweepCircleAgainstCylinder(
 171217            start,
 171218            end,
 171219            direction,
 171220            length,
 171221            radius,
 171222            slabMinY,
 171223            slabMaxY,
 171224            cylinder,
 171225            out Fixed64 distance))
 226        {
 7227            hit = default;
 7228            return false;
 229        }
 230
 164231        hit = BuildCircleAgainstProjectedFiniteSlabHit(
 164232            start,
 164233            end,
 164234            length,
 164235            distance,
 164236            radius,
 164237            slabCenterY,
 164238            halfThickness,
 164239            direction3D,
 164240            cylinder,
 164241            sourceCollider);
 164242        return true;
 243    }
 244
 245    private static PhysicsMixedHit BuildCircleAgainstProjectedFiniteSlabHit(
 246        Vector2d start,
 247        Vector2d end,
 248        Fixed64 length,
 249        Fixed64 distance,
 250        Fixed64 radius,
 251        Fixed64 slabCenterY,
 252        Fixed64 halfThickness,
 253        Vector3d direction3D,
 254        LSCollider collider,
 255        LSCollider2D? sourceCollider)
 256    {
 726257        Vector2d center2D = new FixedSegment2d(start, end)
 726258            .GetPointAtDistance(distance, length);
 726259        Vector3d sweepCenter = new(center2D.X, slabCenterY, center2D.Y);
 726260        return BuildCircleAgainst3DHit(
 726261            collider,
 726262            sweepCenter,
 726263            direction3D,
 726264            radius,
 726265            slabCenterY,
 726266            halfThickness,
 726267            PhysicsQueryReducerKind.Exact,
 726268            distance,
 726269            sourceCollider);
 270    }
 271
 272    private static bool TrySweepCircleAgainstCone(
 273        Vector2d start,
 274        Vector2d end,
 275        Vector2d direction,
 276        Fixed64 length,
 277        Fixed64 radius,
 278        Fixed64 slabCenterY,
 279        Fixed64 halfThickness,
 280        Vector3d direction3D,
 281        LSConeCollider cone,
 282        LSCollider2D? sourceCollider,
 283        out PhysicsMixedHit hit)
 284    {
 165285        Fixed64 slabMinY = slabCenterY - halfThickness;
 165286        Fixed64 slabMaxY = slabCenterY + halfThickness;
 165287        if (!FiniteSlabProjectionSweep.TrySweepCircleAgainstCone(
 165288            start,
 165289            end,
 165290            direction,
 165291            length,
 165292            radius,
 165293            slabMinY,
 165294            slabMaxY,
 165295            cone,
 165296            out Fixed64 distance))
 297        {
 6298            hit = default;
 6299            return false;
 300        }
 301
 159302        hit = BuildCircleAgainstProjectedFiniteSlabHit(
 159303            start,
 159304            end,
 159305            length,
 159306            distance,
 159307            radius,
 159308            slabCenterY,
 159309            halfThickness,
 159310            direction3D,
 159311            cone,
 159312            sourceCollider);
 159313        return true;
 314    }
 315
 316    private bool TrySweepCircleAgainstMesh(
 317        Vector2d start,
 318        Vector2d end,
 319        Fixed64 length,
 320        Fixed64 radius,
 321        Fixed64 slabCenterY,
 322        Fixed64 halfThickness,
 323        Vector3d direction3D,
 324        LSMeshCollider mesh,
 325        LSCollider2D? sourceCollider,
 326        bool requireClosingContact,
 327        out PhysicsMixedHit hit)
 328    {
 496329        ContactManifold initial = _context.CollisionScratch.MeshSurfaceManifold;
 496330        initial.BeginUpdate(_context.FrameCount);
 331        // Initial admission should not pay exact section tests for triangles
 332        // reached only later in the sweep. Keep the full list for impact search.
 496333        CreateCircleSlabSweepBounds(start, start, radius, slabCenterY, halfThickness,
 496334            out Vector3d min, out Vector3d max);
 496335        var initialTriangles = _context.CollisionScratch.MeshTriangleCandidatesA;
 496336        mesh.GetTrianglesInBounds(new FixedBoundVolume(min, max), initialTriangles);
 496337        bool initiallyOverlapping = CollisionDetectionMixed.AppendMeshCircleSlabContacts(mesh,
 496338            new Vector3d(start.X, slabCenterY, start.Y), radius, halfThickness,
 496339            initialTriangles.AsReadOnlySpan(), initial);
 496340        if (initiallyOverlapping)
 341        {
 342            // Initial overlap is geometric, so motion cannot turn a filled face into an authored seam.
 204343            ManifoldContact row = initial.PrimaryContact;
 204344            ContactAnchor center = ContactAnchor.FromWorldPoint(Vector3d.Zero);
 204345            MixedContact closing = default;
 204346            if (!requireClosingContact || MixedContact.TrySelectClosingContact(initial, center,
 204347                    Vector3d.Zero, Vector3d.Zero, center, end - start, Fixed64.Zero, out closing))
 348            {
 66349                if (requireClosingContact) row = closing.ToManifoldContact();
 65350                hit = new PhysicsMixedHit(mesh, sourceCollider, row.AnchorA, row.AnchorB, row.Normal,
 65351                    PhysicsQueryReducerKind.Exact, Fixed64.Zero, direction3D);
 65352                return true;
 353            }
 354        }
 355
 431356        CreateCircleSlabSweepBounds(start, end, radius, slabCenterY, halfThickness, out min, out max);
 431357        mesh.GetTrianglesInBounds(new FixedBoundVolume(min, max), _meshTriangleCandidates);
 431358        LastMeshTriangleCandidateCount += _meshTriangleCandidates.Count;
 431359        bool usePatch = false;
 431360        FixedTriangle patchTriangle = default;
 862361        Vector3d patchPoint = default, patchNormal = default;
 431362        if (!requireClosingContact && _meshTriangleCandidates.Count > 2
 431363            && _meshTriangleCandidates.Count == mesh.Mesh.TriangleCount && mesh.Mesh.HasSingleConvexCoplanarPatch)
 364        {
 72365            CreateCircleSlabSweepBounds(start, start, radius, slabCenterY, halfThickness, out min, out max);
 72366            if (!SweepBoundsUtility.OverlapsInclusive(min, max, mesh.Bounds.Min, mesh.Bounds.Max))
 367            {
 71368                ReadOnlySpan<int> corners = mesh.Mesh.GetConvexCoplanarPatchCornerVertexIndices(0);
 71369                ReadOnlySpan<Vector3d> vertices = mesh.Mesh.GeometryVertices;
 71370                var planeTriangle = new FixedTriangle(vertices[corners[0]], vertices[corners[1]], vertices[corners[2]]);
 71371                WideDirection3d plane = WideTriangleRelations.GetScaledTriangleLocalNormal(planeTriangle, mesh.Mesh.Geom
 71372                    .Transform(mesh.Mesh.GeometryFrame.GeometryBasis);
 71373                Vector2d displacement = end - start;
 71374                var motion = new WideAxis3(Signed320.ExtendValue(Signed192.Raw(displacement.X)), default,
 71375                    Signed320.ExtendValue(Signed192.Raw(displacement.Y)));
 71376                var tangent = new WideAxis3(motion.Z, default, WideArithmetic.SubtractSigned320(default, motion.X));
 71377                int approach = WideDirection3d.Dot(plane, motion).Sign;
 378                // An aligned radial support follows the cap-center chord; finite crossing proves plane entry is attaine
 71379                if (approach != 0 && WideDirection3d.Dot(plane, tangent).IsZero)
 380                {
 50381                    patchNormal = plane.GetNormal(false) * (Fixed64)(-approach);
 50382                    if (patchNormal.X != Fixed64.Zero || patchNormal.Z != Fixed64.Zero)
 383                    {
 49384                        int cap = approach * plane.Y.Sign;
 49385                        Fixed64 y = cap > 0 ? max.Y : cap < 0 ? min.Y : slabCenterY;
 49386                        var chord = new FixedSegment(new Vector3d(start.X, y, start.Y), new Vector3d(end.X, y, end.Y));
 108387                        for (int corner = 1; corner < corners.Length - 1; corner++)
 388                        {
 53389                            var carrier = new FixedTriangle(vertices[corners[0]], vertices[corners[corner]], vertices[co
 53390                            if (!WideTriangleRelations.TryGetSegmentIntersection(carrier, mesh.Mesh.GeometryFrame, chord
 53391                                    out patchPoint, out _)) continue;
 48392                            patchTriangle = carrier;
 48393                            usePatch = true;
 48394                            break;
 395                        }
 396                    }
 397                }
 398            }
 399        }
 431400        bool found = false;
 431401        Fixed64 bestDistance = Fixed64.MaxValue;
 431402        int bestTriangleIndex = int.MaxValue;
 431403        PhysicsMixedHit best = default;
 404
 862405        bool hasPreviousTriangle = false, previousSwept = false;
 431406        FixedTriangle previousTriangle = default;
 431407        Fixed64 previousDistance = default;
 431408        FixedPointAnchor previousContact = default;
 409        // A declined carrier sweep falls through to the unchanged authored reduction.
 3138410        for (int i = usePatch ? -1 : 0; i < _meshTriangleCandidates.Count; i++)
 411        {
 1186412            int triangleIndex = i < 0 ? -1 : _meshTriangleCandidates[i];
 413            Vector3d first, second, third;
 1186414            if (i < 0)
 415            {
 144416                first = patchTriangle.A; second = patchTriangle.B; third = patchTriangle.C;
 417            }
 1138418            else mesh.Mesh.GetGeometryTriangleVertices(triangleIndex, out first, out second, out third);
 1186419            bool rigid = mesh.Mesh.GeometryFrame.IsRigid;
 1186420            Vector3d triangleOrigin = rigid ? mesh.Mesh.GeometryFrame.RigidOrigin : mesh.Mesh.Origin;
 1186421            FixedQuaternion triangleRotation = rigid ? mesh.Mesh.GeometryFrame.Rotation : FixedQuaternion.Identity;
 1186422            var triangle = new FixedTriangle(first, second, third);
 423            bool swept;
 424            Fixed64 distance;
 425            FixedPointAnchor triangleContact;
 1186426            if (!requireClosingContact && hasPreviousTriangle && triangle == previousTriangle)
 427            {
 428                // Reuse only the kernel result; every authored index still participates in tie reduction.
 53429                swept = previousSwept;
 53430                distance = previousDistance;
 53431                triangleContact = previousContact;
 432            }
 433            else
 434            {
 1133435                FixedTriangle input = triangle;
 1133436                bool exactLattice = rigid;
 1133437                if (!rigid && mesh.Mesh.GeometryFrame.GetPoint(first).TryGetExactLocalPointIn(triangleOrigin, triangleRo
 1133438                    && mesh.Mesh.GeometryFrame.GetPoint(second).TryGetExactLocalPointIn(triangleOrigin, triangleRotation
 1133439                    && mesh.Mesh.GeometryFrame.GetPoint(third).TryGetExactLocalPointIn(triangleOrigin, triangleRotation,
 440                {
 2441                    triangle = new FixedTriangle(localFirst, localSecond, localThird);
 2442                    exactLattice = true;
 443                }
 1133444                swept = exactLattice
 1133445                    ? triangle.TryGetFiniteSlabProjectedCircleSweep(triangleOrigin, triangleRotation,
 1133446                        new FixedSegment2d(start, end), length, radius, slabCenterY, halfThickness,
 1133447                        out distance, out triangleContact)
 1133448                    : WideOrientedBox.TryGetFiniteSlabProjectedCircleSweep(triangle, mesh.Mesh.GeometryFrame, triangleOr
 1133449                        new FixedSegment2d(start, end), length, radius, slabCenterY, halfThickness,
 1133450                        out distance, out triangleContact);
 1133451                if (!requireClosingContact)
 452                {
 429453                    previousTriangle = input;
 429454                    previousSwept = swept;
 429455                    previousDistance = distance;
 429456                    previousContact = triangleContact;
 429457                    hasPreviousTriangle = true;
 458                }
 459            }
 1186460            if (!swept) continue;
 705461            if (i < 0)
 462            {
 48463                ContactAnchor point = ContactAnchor.FromWorldPoint(patchPoint);
 48464                hit = new PhysicsMixedHit(mesh, sourceCollider, point, point, patchNormal,
 48465                    PhysicsQueryReducerKind.Exact, distance, direction3D);
 48466                return true;
 467            }
 468
 657469            if (found
 657470                && (distance > bestDistance
 657471                    || (distance == bestDistance && triangleIndex >= bestTriangleIndex)))
 472            {
 473                continue;
 474            }
 475
 476            // Every genuine initial region was inspected above. An overlapping
 477            // triangle's arbitrary point normal must not fabricate a closing
 478            // seam or prevent a later independent wall from being considered.
 590479            if (requireClosingContact && initiallyOverlapping && distance == Fixed64.Zero)
 480                continue;
 481
 374482            Vector2d center2D = new FixedSegment2d(start, end)
 374483                .GetPointAtDistance(distance, length);
 374484            Vector3d sweepCenter = new(center2D.X, slabCenterY, center2D.Y);
 374485            PhysicsMixedHit candidate = default;
 374486            bool filledHit = false;
 374487            if (requireClosingContact)
 488            {
 489                // A triangle can be first reached through an authored diagonal.
 490                // Certify its candidate against the filled local region before
 491                // reducing distance, so a nonclosing seam cannot hide a later wall.
 207492                CreateCircleSlabSweepBounds(center2D, center2D, radius, slabCenterY, halfThickness,
 207493                    out Vector3d localMin, out Vector3d localMax);
 207494                var localTriangles = _context.CollisionScratch.MeshTriangleCandidatesA;
 207495                mesh.GetTrianglesInBounds(new FixedBoundVolume(localMin, localMax), localTriangles);
 207496                initial.BeginUpdate(_context.FrameCount);
 207497                if (CollisionDetectionMixed.AppendMeshCircleSlabContacts(mesh, sweepCenter, radius,
 207498                        halfThickness, localTriangles.AsReadOnlySpan(), initial))
 499                {
 188500                    ContactAnchor center = ContactAnchor.FromWorldPoint(Vector3d.Zero);
 188501                    if (!MixedContact.TrySelectClosingContact(initial, center, Vector3d.Zero,
 188502                            Vector3d.Zero, center, end - start, Fixed64.Zero, out MixedContact closing))
 503                        continue;
 128504                    candidate = new PhysicsMixedHit(mesh, sourceCollider, closing.Anchor3D,
 128505                        closing.Anchor2D, closing.Normal3DTo2D, PhysicsQueryReducerKind.Exact,
 128506                        distance, direction3D);
 128507                    filledHit = true;
 508                }
 509            }
 314510            if (!filledHit)
 186511                candidate = BuildCircleAgainst3DHit(mesh, triangleContact, sweepCenter, direction3D,
 186512                    radius, slabCenterY, halfThickness, PhysicsQueryReducerKind.Exact, distance, sourceCollider);
 314513            if (requireClosingContact && mesh.StaticSurface is { } surface)
 514            {
 515                // Internal CCD admission always supplies its registered source.
 516                System.Diagnostics.Debug.Assert(sourceCollider != null);
 7517                if (!surface.AdmitContinuousWitness(null, sourceCollider, sweepCenter, mesh, triangleIndex,
 7518                    candidate.Anchor3D, circleSlabHalfThickness: filledHit ? null : halfThickness)) continue;
 519            }
 312520            if (requireClosingContact
 312521                && !MixedContact.IsClosingProjection(ExactContactLever2D.ToSpatial(end - start), candidate.Normal3DTo2D)
 522                continue;
 310523            best = candidate;
 310524            bestDistance = distance;
 310525            bestTriangleIndex = triangleIndex;
 310526            found = true;
 527        }
 528
 383529        hit = best;
 383530        return found;
 531    }
 532
 533    private bool TrySweepCircleAgainstCompound3D(
 534        Vector2d start,
 535        Vector2d end,
 536        Vector2d direction,
 537        Fixed64 length,
 538        Fixed64 radius,
 539        Fixed64 slabCenterY,
 540        Fixed64 halfThickness,
 541        Vector3d direction3D,
 542        LSCompoundCollider compound,
 543        LSCollider2D? sourceCollider,
 544        bool requireClosingContact,
 545        out PhysicsMixedHit hit)
 546    {
 14547        bool found = false;
 14548        Fixed64 bestDistance = Fixed64.MaxValue;
 14549        PhysicsMixedHit best = default;
 550
 88551        for (int i = 0; i < compound.PartCount; i++)
 552        {
 30553            LSCollider part = compound.GetPartCollider(i);
 30554            if (!TrySweepCircleAgainst3DCollider(
 30555                part,
 30556                start,
 30557                end,
 30558                direction,
 30559                length,
 30560                radius,
 30561                slabCenterY,
 30562                halfThickness,
 30563                direction3D,
 30564                sourceCollider,
 30565                out PhysicsMixedHit candidate,
 30566                requireClosingContact))
 567            {
 568                continue;
 569            }
 570
 13571            if (!PhysicsHitSelectionPolicy.ShouldReplaceDistance(candidate.Distance, found, bestDistance))
 572                continue;
 573
 9574            best = candidate;
 9575            bestDistance = candidate.Distance;
 9576            found = true;
 577        }
 578
 14579        if (!found)
 580        {
 5581            hit = default;
 5582            return false;
 583        }
 584
 9585        hit = new PhysicsMixedHit(
 9586            compound,
 9587            sourceCollider,
 9588            best.Anchor3D,
 9589            best.Anchor2D,
 9590            best.Normal3DTo2D,
 9591            best.ReducerKind,
 9592            best.Distance,
 9593            best.Direction3D);
 9594        return true;
 595    }
 596
 597}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/Mixed/GravitasQueryMixedService.CircleGeometry.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQueryMixedService.CircleGeometry.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;
 11
 12namespace Gravitas.Queries;
 13
 14/// <content>
 15/// Owns shared projected-circle sweep geometry helpers for mixed query reducers.
 16/// </content>
 17public sealed partial class GravitasQueryMixedService
 18{
 19    internal static bool TrySweepCircleAgainstSphere(
 20        Vector2d start,
 21        Vector2d end,
 22        Fixed64 length,
 23        Fixed64 radius,
 24        Fixed64 slabCenterY,
 25        Fixed64 halfThickness,
 26        Vector3d direction3D,
 27        LSSphereCollider sphere,
 28        LSCollider2D? sourceCollider,
 29        out PhysicsMixedHit hit)
 30    {
 54231        Fixed64 sphereRadius = sphere.ScaledRadius;
 54232        if (!FixedMath.TryGetSphereSlabCrossSectionRadius(
 54233                sphere.Center.Y,
 54234                sphereRadius,
 54235                slabCenterY,
 54236                halfThickness,
 54237                out Fixed64 planarSphereRadius))
 38        {
 239            hit = default;
 240            return false;
 41        }
 42
 54043        Vector2d sphereCenter = new(sphere.Center.X, sphere.Center.Z);
 54044        if (!TrySweepPointInPlane(
 54045            start,
 54046            end,
 54047            length,
 54048            sphereCenter,
 54049            planarSphereRadius,
 54050            radius,
 54051            out Fixed64 distance))
 52        {
 853            hit = default;
 854            return false;
 55        }
 56
 53257        Vector2d center2D = new FixedSegment2d(start, end)
 53258            .GetPointAtDistance(distance, length);
 53259        Vector3d sweepCenter = new(
 53260            center2D.X,
 53261            slabCenterY,
 53262            center2D.Y);
 53263        hit = BuildCircleAgainst3DHit(
 53264            sphere,
 53265            sweepCenter,
 53266            direction3D,
 53267            radius,
 53268            slabCenterY,
 53269            halfThickness,
 53270            PhysicsQueryReducerKind.Exact,
 53271            distance,
 53272            sourceCollider);
 53273        return true;
 74    }
 75
 76    private static bool TrySweepPointInPlane(
 77        Vector2d start,
 78        Vector2d end,
 79        Fixed64 length,
 80        Vector2d point,
 81        Fixed64 radius,
 82        Fixed64 radiusExpansion,
 83        out Fixed64 distance) =>
 54084        new FixedSegment2d(start, end)
 54085            .TryGetCircleIntersectionDistanceInterval(
 54086                new FixedBoundCircle(point, radius),
 54087                radiusExpansion,
 54088                length,
 54089                out distance,
 54090                out _,
 54091                out _,
 54092                out _);
 93}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/Mixed/GravitasQueryMixedService.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQueryMixedService.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 explicit mixed 3D/2D query buffers for one <see cref="GravitasWorldContext"/>.
 15/// </summary>
 16/// <content>Owns mixed query dispatch and reusable candidate storage.</content>
 17public sealed partial class GravitasQueryMixedService
 18{
 19    private readonly GravitasWorldContext _context;
 1019120    private readonly SwiftList<LSCollider2D> _candidates2D = new();
 1019121    private readonly SwiftList<LSCollider> _candidates3D = new();
 1019122    private readonly SwiftList<int> _meshTriangleCandidates = new();
 23
 24    /// <summary>
 25    /// Creates a mixed query service owned by the specified world context.
 26    /// </summary>
 1019127    public GravitasQueryMixedService(GravitasWorldContext context)
 28    {
 1019129        ChronicleGuard.ThrowIfNull(context, nameof(context));
 1019130        _context = context;
 1019131    }
 32
 33    /// <summary>
 34    /// Gets the world context that owns this query service.
 35    /// </summary>
 136    public GravitasWorldContext Context => _context;
 37
 38    internal int LastQueryCandidateCount { get; private set; }
 39
 40    internal int LastMeshTriangleCandidateCount { get; private set; }
 41
 42    /// <summary>
 43    /// Clears reusable mixed-query buffers and diagnostic counters.
 44    /// </summary>
 45    public void Reset()
 46    {
 11647        EndQuery();
 11648        _meshTriangleCandidates.FastClear();
 11649        _batchMixedHits.Clear();
 11650        ResetLastQueryCounters();
 11651        ResetBatchCounters(0);
 11652    }
 53
 54    private void EndQuery()
 55    {
 56        // Release populated references before any shorter query can hide a tail.
 278557        _candidates2D.Clear();
 278558        _candidates3D.Clear();
 278559    }
 60
 61}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/Mixed/GravitasQueryMixedService.Diagnostics.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQueryMixedService.Diagnostics.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.CollisionHandling;
 11using Gravitas.Diagnostics;
 12
 13namespace Gravitas.Queries;
 14
 15/// <content>
 16/// Owns mixed query diagnostics, candidate accounting, and reducer counters.
 17/// </content>
 18public sealed partial class GravitasQueryMixedService
 19{
 20    private void EmitMixedSweepDiagnostics(
 21        GravitasColliderDimension sourceDimension,
 22        GravitasColliderDimension targetDimension,
 23        Vector3d start,
 24        Vector3d end,
 25        Fixed64 radius,
 26        int layerMaskBits,
 27        bool found,
 28        int hitCount,
 29        PhysicsMixedHit hit,
 30        bool captureReducerDiagnostics,
 31        QueryReducerCounters reducerCounters)
 32    {
 265933        _context.Diagnostics.EmitMixedQuery(
 265934            start,
 265935            end,
 265936            radius,
 265937            layerMaskBits,
 265938            found,
 265939            hitCount,
 265940            hit);
 41
 265942        if (!captureReducerDiagnostics)
 265543            return;
 44
 445        _context.Diagnostics.EmitQuerySummary(
 446            sourceDimension,
 447            targetDimension,
 448            start,
 449            end,
 450            reducerCounters.ExactReducerAttempts,
 451            reducerCounters.AcceptedHits,
 452            fallbackHits: 0,
 453            rejectedConservativeCandidates:
 454                reducerCounters.RejectedConservativeCandidates);
 455    }
 56
 57    private bool TrySweepSphereAgainst2DCandidate(
 58        Vector3d start,
 59        Vector3d end,
 60        Vector3d direction,
 61        Fixed64 length,
 62        Fixed64 radius,
 63        LSCollider2D collider,
 64        LSCollider? excludedCollider,
 65        bool includeTriggers,
 66        bool staticTargetsOnly,
 67        bool captureReducerDiagnostics,
 68        ref QueryReducerCounters reducerCounters,
 69        out PhysicsMixedHit candidate,
 70        bool requireClosingContact = false)
 71    {
 121972        if (!IsEligible2DTarget(collider, excludedCollider, includeTriggers, staticTargetsOnly))
 73        {
 274            candidate = default;
 275            return false;
 76        }
 77
 121778        PhysicsQueryReducerKind reducerKind = default;
 121779        if (captureReducerDiagnostics)
 80        {
 281            reducerKind = MixedQueryReducerClassifier.ClassifySweepSphereAgainst2D(collider);
 282            reducerCounters.RecordAttempt(reducerKind);
 83        }
 84
 121785        candidate = default;
 121786        if (requireClosingContact && staticTargetsOnly && excludedCollider != null
 121787            && TryResolveExactSphereSourceFor2D(excludedCollider, collider, end - start,
 121788                out Vector3d exactStart, out Vector3d exactEnd, out Fixed64 exactRadius))
 89        {
 90            // The outer query remains a conservative broad phase. Refine in
 91            // the actual source chart before an initial proxy cut can win.
 139892            start = exactStart; end = exactEnd; radius = exactRadius;
 93        }
 121794        bool initialClosing = requireClosingContact && excludedCollider != null
 121795            && TryGetInitialMixedCcdHit(excludedCollider, collider, direction, source3D: true, out candidate);
 121796        if (!initialClosing && !TrySweepSphereAgainst2D(start, end, direction, length, radius, collider,
 121797                out candidate, requireClosingContact))
 98        {
 34699            if (captureReducerDiagnostics)
 1100                reducerCounters.RecordRejected(reducerKind);
 346101            return false;
 102        }
 103
 870104        if (captureReducerDiagnostics)
 1105            reducerCounters.RecordAccepted();
 870106        return true;
 107    }
 108
 109    private bool TrySweepCircleAgainst3DCandidate(
 110        LSCollider collider,
 111        Vector2d start,
 112        Vector2d end,
 113        Vector2d direction2D,
 114        Fixed64 length,
 115        Fixed64 radius,
 116        Fixed64 slabCenterY,
 117        Fixed64 halfThickness,
 118        Vector3d direction3D,
 119        LSCollider2D? excludedCollider,
 120        bool includeTriggers,
 121        bool staticTargetsOnly,
 122        bool captureReducerDiagnostics,
 123        ref QueryReducerCounters reducerCounters,
 124        out PhysicsMixedHit candidate,
 125        bool requireClosingContact = false)
 126    {
 1780127        if (!IsEligible3DTarget(collider, excludedCollider, includeTriggers, staticTargetsOnly))
 128        {
 2129            candidate = default;
 2130            return false;
 131        }
 132
 1778133        PhysicsQueryReducerKind reducerKind = default;
 1778134        if (captureReducerDiagnostics)
 135        {
 3136            reducerKind = MixedQueryReducerClassifier.ClassifySweepCircleAgainst3D(collider);
 3137            reducerCounters.RecordAttempt(reducerKind);
 138        }
 139
 1778140        candidate = default;
 1778141        bool initialClosing = requireClosingContact && excludedCollider != null
 1778142            && TryGetInitialMixedCcdHit(collider, excludedCollider, direction3D, source3D: false, out candidate);
 1778143        if (!initialClosing && !TrySweepCircleAgainst3DCollider(
 1778144            collider,
 1778145            start,
 1778146            end,
 1778147            direction2D,
 1778148            length,
 1778149            radius,
 1778150            slabCenterY,
 1778151            halfThickness,
 1778152            direction3D,
 1778153            excludedCollider,
 1778154            out candidate,
 1778155            requireClosingContact))
 156        {
 314157            if (captureReducerDiagnostics)
 1158                reducerCounters.RecordRejected(reducerKind);
 314159            return false;
 160        }
 161
 1464162        if (captureReducerDiagnostics)
 2163            reducerCounters.RecordAccepted();
 1464164        return true;
 165    }
 166
 167    private bool TryGetInitialMixedCcdHit(LSCollider collider3D, LSCollider2D collider2D,
 168        Vector3d direction, bool source3D, out PhysicsMixedHit hit)
 169    {
 943170        hit = default;
 171        // A proxy's representative may hide an independent closing leaf. Keep
 172        // primitive analytic paths cheap; complex owners must inspect real rows.
 943173        if (collider3D is not (LSCompoundCollider or LSMeshCollider)
 943174            && collider2D is not LSCompoundCollider2D)
 579175            return false;
 364176        ContactManifold manifold = _context.CollisionScratch.MixedManifold;
 364177        if (!CollisionDetectionMixed.TryBuildManifold(collider3D, collider2D, manifold))
 80178            return false;
 284179        ContactAnchor center = ContactAnchor.FromWorldPoint(Vector3d.Zero);
 284180        if (!MixedContact.TrySelectClosingContact(manifold, center,
 284181                source3D ? direction : Vector3d.Zero, Vector3d.Zero,
 284182                center, source3D ? Vector2d.Zero : direction.ToVector2d(), Fixed64.Zero,
 284183                out MixedContact contact))
 141184            return false;
 143185        hit = new PhysicsMixedHit(collider3D, collider2D, contact.Anchor3D, contact.Anchor2D,
 143186            contact.Normal3DTo2D, PhysicsQueryReducerKind.Exact, Fixed64.Zero, direction);
 143187        return true;
 188    }
 189
 190
 191    private struct QueryReducerCounters
 192    {
 193        public int ExactReducerAttempts;
 194        public int AcceptedHits;
 195        public int RejectedConservativeCandidates;
 196
 197        public void RecordAttempt(PhysicsQueryReducerKind reducerKind)
 198        {
 5199            if (reducerKind == PhysicsQueryReducerKind.Exact)
 4200                ExactReducerAttempts++;
 5201        }
 202
 3203        public void RecordAccepted() => AcceptedHits++;
 204
 205        public void RecordRejected(PhysicsQueryReducerKind reducerKind)
 206        {
 2207            if (reducerKind == PhysicsQueryReducerKind.ConservativeFallback)
 1208                RejectedConservativeCandidates++;
 2209        }
 210    }
 211}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/Mixed/GravitasQueryMixedService.SphereAgainst2DReducers.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQueryMixedService.SphereAgainst2DReducers.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 FixedMathSharp.Geometry;
 11using Gravitas.Colliders;
 12using Gravitas.CollisionHandling;
 13
 14namespace Gravitas.Queries;
 15
 16/// <content>
 17/// Owns mixed swept-sphere reducers against embedded 2D collider targets.
 18/// </content>
 19public sealed partial class GravitasQueryMixedService
 20{
 21    internal static bool TryResolveExactSphereSourceFor2D(LSCollider source, LSCollider2D target,
 22        Vector3d displacement, out Vector3d start, out Vector3d end, out Fixed64 radius)
 23    {
 137024        start = source.Center; radius = source.ScaledRadius;
 68625        if (!Vector3d.TryAdd(start, displacement, out end)) return false;
 26        // Tiny angular arcs can deliberately fall back to the linear arbiter.
 27        // Refine only unchanged geometry, including a kinematic host's goal.
 68428        if (source.Body is { HasRotationInvariantCollider: false } body
 68429            && (body.AngularVelocity != Vector3d.Zero
 68430                || body.SampleContinuousCollisionAngularVelocity(Fixed64.Zero) != Vector3d.Zero
 68731                || body.IsKinematic && body.Agent.Transform.WorldRotation != body.Rotation)) return false;
 104632        if (source is LSSphereCollider) return true;
 36333        if (source is not LSCapsuleCollider capsule) return false;
 27034        if (capsule.AxisLength == Fixed64.Zero) return true;
 26835        var basis = new WideRationalBasis3d(capsule.Rotation);
 36        // A vertical core and a center inside the target's finite Y band
 37        // supply exactly the same X/Z disk as this true-radius sphere.
 38        // Check the complete chord; arbitrary/inflated proxies remain unknown.
 26839        return basis.Yx.IsZero && basis.Yz.IsZero
 26840            && MixedEmbedded2DGeometry.ContainsPointInSlab(target, start.Y)
 26841            && MixedEmbedded2DGeometry.ContainsPointInSlab(target, end.Y);
 42    }
 43
 44    private static bool TrySweepSphereAgainst2D(
 45        Vector3d start, Vector3d end, Vector3d direction, Fixed64 length,
 46        Fixed64 radius, LSCollider2D collider, out PhysicsMixedHit hit,
 47        bool requireClosingContact = false)
 48    {
 129449        return TrySweepSphereAgainst2DCore(start, end, direction, length, radius, collider,
 129450                requireClosingContact, out hit)
 129451            && (!requireClosingContact
 129452                || MixedContact.IsClosingProjection(end - start, hit.NormalFor3DSource));
 53    }
 54
 55    private static bool TrySweepSphereAgainst2DCore(
 56        Vector3d start,
 57        Vector3d end,
 58        Vector3d direction,
 59        Fixed64 length,
 60        Fixed64 radius,
 61        LSCollider2D collider,
 62        bool requireClosingContact,
 63        out PhysicsMixedHit hit)
 64    {
 129465        if (collider is LSCompoundCollider2D compound)
 4166            return TrySweepSphereAgainstCompound2D(start, end, direction, length, radius, compound, requireClosingContac
 67
 125368        if (collider is LSCircleCollider2D circle)
 7769            return TrySweepSphereAgainstCircleSlab(start, end, direction, length, radius, circle, out hit);
 70
 117671        if (collider is LSCapsuleCollider2D capsule)
 1872            return TrySweepSphereAgainstCapsuleSlab(start, end, direction, length, radius, capsule, out hit);
 73
 115874        if (collider is LSAABBoxCollider2D || collider is LSPolygonCollider2D)
 115775            return TrySweepSphereAgainstConvexSlab(start, end, direction, length, radius, collider, out hit);
 76
 177        throw new InvalidOperationException(
 178            "The embedded 2D collider type is not supported by mixed queries.");
 79    }
 80
 81    private static bool TrySweepSphereAgainstCompound2D(
 82        Vector3d start,
 83        Vector3d end,
 84        Vector3d direction,
 85        Fixed64 length,
 86        Fixed64 radius,
 87        LSCompoundCollider2D compound,
 88        bool requireClosingContact,
 89        out PhysicsMixedHit hit)
 90    {
 4191        bool found = false;
 4192        Fixed64 bestDistance = Fixed64.MaxValue;
 4193        PhysicsMixedHit best = default;
 94
 24495        for (int i = 0; i < compound.PartCount; i++)
 96        {
 8197            LSCollider2D part = compound.GetPartCollider(i);
 8198            if (!TrySweepSphereAgainst2D(start, end, direction, length, radius, part, out PhysicsMixedHit candidate, req
 99                continue;
 100
 79101            if (!PhysicsHitSelectionPolicy.ShouldReplaceDistance(candidate.Distance, found, bestDistance))
 102                continue;
 103
 41104            best = candidate;
 41105            bestDistance = candidate.Distance;
 41106            found = true;
 107        }
 108
 41109        if (!found)
 110        {
 1111            hit = default;
 1112            return false;
 113        }
 114
 40115        hit = new PhysicsMixedHit(
 40116            null,
 40117            compound,
 40118            best.Anchor3D,
 40119            best.Anchor2D,
 40120            best.Normal3DTo2D,
 40121            best.ReducerKind,
 40122            best.Distance,
 40123            best.Direction3D);
 40124        return true;
 125    }
 126
 127    internal static bool TrySweepSphereAgainstCapsuleSlab(
 128        Vector3d start,
 129        Vector3d end,
 130        Vector3d direction,
 131        Fixed64 length,
 132        Fixed64 radius,
 133        LSCapsuleCollider2D capsule,
 134        out PhysicsMixedHit hit)
 135    {
 25136        if (IsSphereOverlappingCapsuleSlabCapCore(start, radius, capsule))
 137        {
 1138            hit = BuildSphereAgainst2DHit(
 1139                capsule,
 1140                start,
 1141                radius,
 1142                PhysicsQueryReducerKind.Exact,
 1143                Fixed64.Zero,
 1144                direction);
 1145            return true;
 146        }
 147
 24148        Fixed64 slabMinY = capsule.MixedBounds3D.Min.Y;
 24149        Fixed64 slabMaxY = capsule.MixedBounds3D.Max.Y;
 24150        SweepCandidate best = default;
 151
 24152        if (Fixed64.TryAdd(slabMaxY, radius, out Fixed64 expandedMaxY))
 153        {
 23154            TrySweepCapsuleSlabCapFace(
 23155                start,
 23156                end,
 23157                length,
 23158                capsule,
 23159                expandedMaxY,
 23160                requireStartBeyondPlane: true,
 23161                -Vector3d.Up,
 23162                ref best);
 163        }
 164
 24165        if (Fixed64.TrySubtract(slabMinY, radius, out Fixed64 expandedMinY))
 166        {
 23167            TrySweepCapsuleSlabCapFace(
 23168                start,
 23169                end,
 23170                length,
 23171                capsule,
 23172                expandedMinY,
 23173                requireStartBeyondPlane: false,
 23174                Vector3d.Up,
 23175                ref best);
 176        }
 177
 24178        TrySweepCapsuleSlabSide(
 24179            start,
 24180            end,
 24181            length,
 24182            capsule,
 24183            capsule.ScaledRadius,
 24184            radius,
 24185            slabMinY,
 24186            slabMaxY,
 24187            ref best);
 24188        TrySweepCapsuleSlabBoundaryEdges(
 24189            start,
 24190            end,
 24191            length,
 24192            capsule,
 24193            capsule.ScaledRadius,
 24194            radius,
 24195            slabMinY,
 24196            slabMaxY,
 24197            ref best);
 198
 24199        if (!best.Found)
 200        {
 10201            hit = default;
 10202            return false;
 203        }
 204
 14205        Vector3d sweepCenter = new FixedSegment(start, end).GetPointAtDistance(best.Distance, length);
 14206        hit = BuildSphereAgainst2DHit(
 14207            capsule,
 14208            sweepCenter,
 14209            radius,
 14210            PhysicsQueryReducerKind.Exact,
 14211            best.Distance,
 14212            direction,
 14213            best.FeatureNormal);
 14214        return true;
 215    }
 216
 217    private static bool IsSphereOverlappingCapsuleSlabCapCore(
 218        Vector3d center,
 219        Fixed64 radius,
 220        LSCapsuleCollider2D capsule)
 221    {
 25222        Fixed64 slabMinY = capsule.MixedBounds3D.Min.Y;
 25223        Fixed64 slabMaxY = capsule.MixedBounds3D.Max.Y;
 224        Fixed64 verticalExcess;
 25225        if (center.Y > slabMaxY)
 226        {
 10227            if (!Fixed64.TrySubtract(center.Y, slabMaxY, out verticalExcess))
 1228                return false;
 229        }
 15230        else if (center.Y < slabMinY)
 231        {
 3232            if (!Fixed64.TrySubtract(slabMinY, center.Y, out verticalExcess))
 1233                return false;
 234        }
 235        else
 12236            return false;
 237
 11238        return verticalExcess <= radius
 11239            && capsule.ContainsPoint(new Vector2d(center.X, center.Z));
 240    }
 241
 242    internal static bool TrySweepSphereAgainstConvexSlab(
 243        Vector3d start,
 244        Vector3d end,
 245        Vector3d direction,
 246        Fixed64 length,
 247        Fixed64 radius,
 248        LSCollider2D collider,
 249        out PhysicsMixedHit hit)
 250    {
 1163251        if (DoesSphereOverlapConvexSlab(start, radius, collider))
 252        {
 388253            hit = BuildSphereAgainst2DHit(
 388254                collider,
 388255                start,
 388256                radius,
 388257                PhysicsQueryReducerKind.Exact,
 388258                Fixed64.Zero,
 388259                direction);
 388260            return true;
 261        }
 262
 775263        Fixed64 slabMinY = collider.MixedBounds3D.Min.Y;
 775264        Fixed64 slabMaxY = collider.MixedBounds3D.Max.Y;
 775265        SweepCandidate best = default;
 266
 775267        if (Fixed64.TryAdd(slabMaxY, radius, out Fixed64 expandedMaxY))
 268        {
 774269            TrySweepConvexSlabCapFace(
 774270                start,
 774271                end,
 774272                length,
 774273                collider,
 774274                expandedMaxY,
 774275                requireStartBeyondPlane: true,
 774276                -Vector3d.Up,
 774277                ref best);
 278        }
 279
 775280        if (Fixed64.TrySubtract(slabMinY, radius, out Fixed64 expandedMinY))
 281        {
 774282            TrySweepConvexSlabCapFace(
 774283                start,
 774284                end,
 774285                length,
 774286                collider,
 774287                expandedMinY,
 774288                requireStartBeyondPlane: false,
 774289                Vector3d.Up,
 774290                ref best);
 291        }
 292
 775293        if (TryGetConvexSlabLocalSweep(
 775294                start,
 775295                end,
 775296                collider,
 775297                out Vector3d localStart,
 775298                out Vector3d localEnd))
 299        {
 774300            Fixed64 localSlabMinY = -collider.MixedHalfThickness;
 774301            Fixed64 localSlabMaxY = collider.MixedHalfThickness;
 774302            TrySweepConvexSlabSideFaces(
 774303                localStart,
 774304                localEnd,
 774305                length,
 774306                radius,
 774307                collider,
 774308                localSlabMinY,
 774309                localSlabMaxY,
 774310                ref best);
 774311            TrySweepConvexSlabEdges(
 774312                localStart,
 774313                localEnd,
 774314                length,
 774315                radius,
 774316                collider,
 774317                localSlabMinY,
 774318                localSlabMaxY,
 774319                ref best);
 320        }
 321
 775322        if (!best.Found)
 323        {
 131324            hit = default;
 131325            return false;
 326        }
 327
 644328        Vector3d sweepCenter = new FixedSegment(start, end).GetPointAtDistance(best.Distance, length);
 644329        hit = BuildSphereAgainst2DHit(
 644330            collider,
 644331            sweepCenter,
 644332            radius,
 644333            PhysicsQueryReducerKind.Exact,
 644334            best.Distance,
 644335            direction,
 644336            best.FeatureNormal);
 644337        return true;
 338    }
 339
 340    private static void TrySweepConvexSlabCapFace(
 341        Vector3d start,
 342        Vector3d end,
 343        Fixed64 length,
 344        LSCollider2D collider,
 345        Fixed64 planeY,
 346        bool requireStartBeyondPlane,
 347        Vector3d featureNormal,
 348        ref SweepCandidate best)
 349    {
 1548350        bool canReach = requireStartBeyondPlane
 1548351            ? start.Y > planeY && end.Y <= planeY
 1548352            : start.Y < planeY && end.Y >= planeY;
 1548353        if (!canReach)
 1121354            return;
 355
 427356        Fixed64 distance = GetCapDistance(start.Y, end.Y, planeY, length);
 427357        Vector3d point = new FixedSegment(start, end).GetPointAtDistance(distance, length);
 427358        if (!collider.ContainsPoint(new Vector2d(point.X, point.Z)))
 2359            return;
 360
 425361        TryKeepEarlierSweep(true, distance, featureNormal, ref best);
 425362    }
 363
 364    private static void TrySweepConvexSlabSideFaces(
 365        Vector3d start,
 366        Vector3d end,
 367        Fixed64 length,
 368        Fixed64 radius,
 369        LSCollider2D collider,
 370        Fixed64 slabMinY,
 371        Fixed64 slabMaxY,
 372        ref SweepCandidate best)
 373    {
 774374        Vector2d planarStart = new(start.X, start.Z);
 774375        Vector2d planarDisplacement = new(end.X - start.X, end.Z - start.Z);
 774376        Vector2d polygonCenter = Vector2d.Zero;
 774377        int vertexCount = collider.VertexCount;
 378
 7740379        for (int i = 0; i < vertexCount; i++)
 380        {
 3096381            Vector2d first = collider.GetScaledLocalVertexUnchecked(i);
 3096382            Vector2d second = collider.GetScaledLocalVertexUnchecked((i + 1) % vertexCount);
 3096383            Vector2d edge = second - first;
 3096384            Fixed64 edgeLength = edge.Magnitude;
 3096385            Vector2d edgeDirection = edge / edgeLength;
 3096386            Vector2d outward = new(edge.Y, -edge.X);
 3096387            if (Vector2d.Dot(polygonCenter - first, outward) > Fixed64.Zero)
 304388                outward = -outward;
 3096389            outward /= outward.Magnitude;
 3096390            Fixed64 signedStart = Vector2d.Dot(planarStart - first, outward);
 3096391            Fixed64 signedDirection = Vector2d.Dot(planarDisplacement, outward);
 3096392            if (signedStart <= radius || signedDirection >= Fixed64.Zero)
 393                continue;
 394
 395            // One fused ratio retains physical-distance precision without
 396            // changing the authored segment through direction normalization.
 312397            if (!Fixed64.TryMultiplyDivide(radius - signedStart, length,
 312398                    signedDirection, out Fixed64 distance)
 312399                || distance > length)
 400                continue;
 401
 294402            Vector3d sweepCenter = new FixedSegment(start, end).GetPointAtDistance(distance, length);
 294403            if (sweepCenter.Y < slabMinY || sweepCenter.Y > slabMaxY)
 404                continue;
 405
 290406            Vector2d planarPoint = new(sweepCenter.X, sweepCenter.Z);
 290407            Fixed64 projection = Vector2d.Dot(planarPoint - first, edgeDirection);
 290408            if (projection < Fixed64.Zero || projection > edgeLength)
 409                continue;
 410
 125411            TryKeepEarlierSweep(true, distance, default, ref best);
 412        }
 774413    }
 414
 415    private static void TrySweepConvexSlabEdges(
 416        Vector3d start,
 417        Vector3d end,
 418        Fixed64 length,
 419        Fixed64 radius,
 420        LSCollider2D collider,
 421        Fixed64 slabMinY,
 422        Fixed64 slabMaxY,
 423        ref SweepCandidate best)
 424    {
 774425        int vertexCount = collider.VertexCount;
 7740426        for (int i = 0; i < vertexCount; i++)
 427        {
 3096428            Vector2d first = collider.GetScaledLocalVertexUnchecked(i);
 3096429            Vector2d second = collider.GetScaledLocalVertexUnchecked((i + 1) % vertexCount);
 3096430            Vector3d bottomFirst = new(first.X, slabMinY, first.Y);
 3096431            Vector3d topFirst = new(first.X, slabMaxY, first.Y);
 3096432            Vector3d bottomSecond = new(second.X, slabMinY, second.Y);
 3096433            Vector3d topSecond = new(second.X, slabMaxY, second.Y);
 434
 3096435            TryKeepEarlierSweep(
 3096436                TrySweepPointAgainstSegmentCapsule3D(
 3096437                    start,
 3096438                    end,
 3096439                    length,
 3096440                    bottomFirst,
 3096441                    topFirst,
 3096442                    Fixed64.Zero,
 3096443                    radius,
 3096444                    out Fixed64 verticalDistance),
 3096445                verticalDistance,
 3096446                default,
 3096447                ref best);
 3096448            TryKeepEarlierSweep(
 3096449                TrySweepPointAgainstSegmentCapsule3D(
 3096450                    start,
 3096451                    end,
 3096452                    length,
 3096453                    bottomFirst,
 3096454                    bottomSecond,
 3096455                    Fixed64.Zero,
 3096456                    radius,
 3096457                    out Fixed64 bottomDistance),
 3096458                bottomDistance,
 3096459                default,
 3096460                ref best);
 3096461            TryKeepEarlierSweep(
 3096462                TrySweepPointAgainstSegmentCapsule3D(
 3096463                    start,
 3096464                    end,
 3096465                    length,
 3096466                    topFirst,
 3096467                    topSecond,
 3096468                    Fixed64.Zero,
 3096469                    radius,
 3096470                    out Fixed64 topDistance),
 3096471                topDistance,
 3096472                default,
 3096473                ref best);
 474        }
 774475    }
 476
 477    private static void TrySweepCapsuleSlabCapFace(
 478        Vector3d start,
 479        Vector3d end,
 480        Fixed64 length,
 481        LSCapsuleCollider2D capsule,
 482        Fixed64 planeY,
 483        bool requireStartBeyondPlane,
 484        Vector3d featureNormal,
 485        ref SweepCandidate best)
 486    {
 46487        bool canReach = requireStartBeyondPlane
 46488            ? start.Y > planeY && end.Y <= planeY
 46489            : start.Y < planeY && end.Y >= planeY;
 46490        if (!canReach)
 40491            return;
 492
 6493        Fixed64 distance = GetCapDistance(start.Y, end.Y, planeY, length);
 6494        Vector3d point = new FixedSegment(start, end).GetPointAtDistance(distance, length);
 6495        if (!capsule.ContainsPoint(new Vector2d(point.X, point.Z)))
 2496            return;
 497
 4498        TryKeepEarlierSweep(true, distance, featureNormal, ref best);
 4499    }
 500
 501    private static void TrySweepCapsuleSlabSide(
 502        Vector3d start,
 503        Vector3d end,
 504        Fixed64 length,
 505        LSCapsuleCollider2D capsule,
 506        Fixed64 targetRadius,
 507        Fixed64 radiusExpansion,
 508        Fixed64 slabMinY,
 509        Fixed64 slabMaxY,
 510        ref SweepCandidate best)
 511    {
 24512        var planarSegment = new FixedSegment2d(
 24513            new Vector2d(start.X, start.Z),
 24514            new Vector2d(end.X, end.Z));
 24515        if (!planarSegment.TryGetCapsuleIntersectionDistanceInterval(
 24516                capsule.Center,
 24517                capsule.Rotation,
 24518                capsule.AxisLength,
 24519                targetRadius,
 24520                radiusExpansion,
 24521                length,
 24522                out Fixed64 distance,
 24523                out _,
 24524                out _,
 24525                out _))
 526        {
 5527            return;
 528        }
 529
 19530        Fixed64 y = new FixedSegment(start, end).GetPointAtDistance(distance, length).Y;
 19531        if (y < slabMinY || y > slabMaxY)
 10532            return;
 533
 9534        TryKeepEarlierSweep(true, distance, default, ref best);
 9535    }
 536
 537    private static void TrySweepCapsuleSlabBoundaryEdges(
 538        Vector3d start,
 539        Vector3d end,
 540        Fixed64 length,
 541        LSCapsuleCollider2D capsule,
 542        Fixed64 targetRadius,
 543        Fixed64 radiusExpansion,
 544        Fixed64 slabMinY,
 545        Fixed64 slabMaxY,
 546        ref SweepCandidate best)
 547    {
 24548        Vector2d capsuleAxis = new(
 24549            -FixedMath.Sin(capsule.Rotation),
 24550            FixedMath.Cos(capsule.Rotation));
 24551        if (!FixedSegment2d.TryGetCenteredAxisEndpoint(
 24552                capsule.Center,
 24553                capsuleAxis,
 24554                capsule.AxisLength,
 24555                positive: false,
 24556                out Vector2d firstEndpoint)
 24557            || !FixedSegment2d.TryGetCenteredAxisEndpoint(
 24558                capsule.Center,
 24559                capsuleAxis,
 24560                capsule.AxisLength,
 24561                positive: true,
 24562                out Vector2d secondEndpoint))
 563        {
 2564            return;
 565        }
 566
 22567        Vector2d outward =
 22568            new Vector2d(capsuleAxis.Y, -capsuleAxis.X)
 22569            * targetRadius;
 22570        Vector2d firstSideStart = firstEndpoint + outward;
 22571        Vector2d firstSideEnd = secondEndpoint + outward;
 22572        Vector2d secondSideStart = firstEndpoint - outward;
 22573        Vector2d secondSideEnd = secondEndpoint - outward;
 574
 22575        TryKeepCapsuleSlabStraightRimSweep(
 22576            start, end, length, firstSideStart, firstSideEnd, slabMinY, radiusExpansion, ref best);
 22577        TryKeepCapsuleSlabStraightRimSweep(
 22578            start, end, length, firstSideStart, firstSideEnd, slabMaxY, radiusExpansion, ref best);
 22579        TryKeepCapsuleSlabStraightRimSweep(
 22580            start, end, length, secondSideStart, secondSideEnd, slabMinY, radiusExpansion, ref best);
 22581        TryKeepCapsuleSlabStraightRimSweep(
 22582            start, end, length, secondSideStart, secondSideEnd, slabMaxY, radiusExpansion, ref best);
 583
 22584        Fixed64 slabCenterY = capsule.MixedSlabCenterY;
 22585        Fixed64 slabHalfThickness = capsule.MixedHalfThickness;
 22586        TryKeepEarlierSweep(
 22587            new FixedSegment(start, end).TryGetSweptSphereFiniteCylinderIntersectionDistance(
 22588                new Vector3d(firstEndpoint.X, slabCenterY, firstEndpoint.Y),
 22589                Vector3d.Up,
 22590                slabHalfThickness,
 22591                targetRadius,
 22592                radiusExpansion,
 22593                length,
 22594                out Fixed64 firstVerticalDistance),
 22595            firstVerticalDistance,
 22596            default,
 22597            ref best);
 22598        TryKeepEarlierSweep(
 22599            new FixedSegment(start, end).TryGetSweptSphereFiniteCylinderIntersectionDistance(
 22600                new Vector3d(secondEndpoint.X, slabCenterY, secondEndpoint.Y),
 22601                Vector3d.Up,
 22602                slabHalfThickness,
 22603                targetRadius,
 22604                radiusExpansion,
 22605                length,
 22606                out Fixed64 secondVerticalDistance),
 22607            secondVerticalDistance,
 22608            default,
 22609            ref best);
 22610    }
 611
 612    private static void TryKeepCapsuleSlabStraightRimSweep(
 613        Vector3d start,
 614        Vector3d end,
 615        Fixed64 length,
 616        Vector2d planarStart,
 617        Vector2d planarEnd,
 618        Fixed64 y,
 619        Fixed64 radiusExpansion,
 620        ref SweepCandidate best)
 621    {
 88622        TryKeepEarlierSweep(
 88623            TrySweepPointAgainstSegmentCapsule3D(
 88624                start,
 88625                end,
 88626                length,
 88627                new Vector3d(planarStart.X, y, planarStart.Y),
 88628                new Vector3d(planarEnd.X, y, planarEnd.Y),
 88629                Fixed64.Zero,
 88630                radiusExpansion,
 88631                out Fixed64 distance),
 88632            distance,
 88633            default,
 88634            ref best);
 88635    }
 636
 637    private static bool DoesSphereOverlapConvexSlab(
 638        Vector3d center,
 639        Fixed64 radius,
 640        LSCollider2D collider)
 641    {
 1163642        if (!FixedMath.TryGetSphereSlabCrossSectionRadius(
 1163643                center.Y,
 1163644                radius,
 1163645                collider.MixedSlabCenterY,
 1163646                collider.MixedHalfThickness,
 1163647                out Fixed64 planarRadius))
 648        {
 428649            return false;
 650        }
 651
 735652        Vector2d planarPoint = new(center.X, center.Z);
 735653        if (collider.ContainsPoint(planarPoint))
 7654            return true;
 655
 656        // The convex reducer admits boxes and polygons, which always provide a conceptual boundary.
 728657        bool hasBoundary = collider.TryGetClosestBoundaryAnchor(planarPoint, out FixedPointAnchor2d boundary);
 658        System.Diagnostics.Debug.Assert(hasBoundary);
 659
 660        // Admission is a geometric comparison; vector magnitude's unit-vector
 661        // shortcut must not turn a positive separation into an initial overlap.
 728662        var queryCenter = new FixedPointAnchor2d(planarPoint, Fixed64.Zero, Vector2d.Zero);
 728663        var radiusPoint = new FixedPointAnchor2d(planarPoint, Fixed64.Zero,
 728664            new Vector2d(planarRadius, Fixed64.Zero));
 728665        return WidePointAnchor2d.CompareSquaredDistances(queryCenter, boundary, radiusPoint) <= 0;
 666    }
 667
 668    private static bool TryGetConvexSlabLocalSweep(
 669        Vector3d start,
 670        Vector3d end,
 671        LSCollider2D collider,
 672        out Vector3d localStart,
 673        out Vector3d localEnd)
 674    {
 775675        var frameOrigin = new Vector3d(
 775676            collider.Center.X,
 775677            collider.MixedSlabCenterY,
 775678            collider.Center.Y);
 775679        FixedQuaternion frameRotation =
 775680            FixedQuaternion.FromAxisAngle(
 775681                Vector3d.Up,
 775682                -collider.ConvexRotation);
 775683        var startAnchor = new FixedPointAnchor(
 775684            start,
 775685            FixedQuaternion.Identity,
 775686            Vector3d.Zero);
 775687        var endAnchor = new FixedPointAnchor(
 775688            end,
 775689            FixedQuaternion.Identity,
 775690            Vector3d.Zero);
 775691        bool representable = startAnchor.TryGetLocalPointIn(
 775692                frameOrigin,
 775693                frameRotation,
 775694                out localStart)
 775695            & endAnchor.TryGetLocalPointIn(
 775696                frameOrigin,
 775697                frameRotation,
 775698                out localEnd);
 775699        return representable;
 700    }
 701
 702    private static bool TrySweepPointAgainstSegmentCapsule3D(
 703        Vector3d start,
 704        Vector3d end,
 705        Fixed64 length,
 706        Vector3d segmentStart,
 707        Vector3d segmentEnd,
 708        Fixed64 radius,
 709        Fixed64 radiusExpansion,
 710        out Fixed64 distance)
 711    {
 9376712        return new FixedSegment(start, end).TryGetCapsuleIntersectionDistanceInterval(
 9376713                new FixedSegment(segmentStart, segmentEnd),
 9376714                radius,
 9376715                radiusExpansion,
 9376716                length,
 9376717                out distance,
 9376718                out _,
 9376719                out _,
 9376720                out _);
 721    }
 722
 723    private static Fixed64 GetCapDistance(
 724        Fixed64 start,
 725        Fixed64 end,
 726        Fixed64 plane,
 727        Fixed64 length)
 728    {
 729        // Cap admission proves that plane lies between start and end. The public
 730        // sweep contract has already proved the segment displacement and length
 731        // representable, so the fused result is bounded by length and cannot fail.
 433732        Fixed64 verticalSpan = end - start;
 433733        Fixed64 capOffset = plane - start;
 433734        _ = Fixed64.TryMultiplyDivide(length, capOffset, verticalSpan, out Fixed64 distance);
 433735        return distance;
 736    }
 737
 738    private static void TryKeepEarlierSweep(
 739        bool candidateFound,
 740        Fixed64 candidateDistance,
 741        Vector3d candidateFeatureNormal,
 742        ref SweepCandidate best)
 743    {
 9983744        if (!candidateFound)
 8131745            return;
 746
 1852747        if (best.Found && candidateDistance >= best.Distance)
 967748            return;
 749
 885750        best.Found = true;
 885751        best.Distance = candidateDistance;
 885752        best.FeatureNormal = candidateFeatureNormal;
 885753    }
 754
 755    private struct SweepCandidate
 756    {
 757        public bool Found;
 758        public Fixed64 Distance;
 759        public Vector3d FeatureNormal;
 760    }
 761
 762}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/Mixed/GravitasQueryMixedService.SphereSlab.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQueryMixedService.SphereSlab.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;
 11
 12namespace Gravitas.Queries;
 13
 14/// <content>
 15/// Owns mixed swept-sphere slab and prism helper reducers.
 16/// </content>
 17public sealed partial class GravitasQueryMixedService
 18{
 19    /// <summary>
 20    /// Reduces a prepared spatial-distance sphere sweep against one embedded circle slab.
 21    /// The direction must match the authored start/end segment and the length must use the same parameterization.
 22    /// </summary>
 23    internal static bool TrySweepSphereAgainstCircleSlab(
 24        Vector3d start,
 25        Vector3d end,
 26        Vector3d direction,
 27        Fixed64 length,
 28        Fixed64 radius,
 29        LSCircleCollider2D circle,
 30        out PhysicsMixedHit hit)
 31    {
 8832        Vector2d planarCenter = circle.Center;
 8833        var center = new Vector3d(planarCenter.X, circle.MixedSlabCenterY, planarCenter.Y);
 8834        var segment = new FixedSegment(start, end);
 8835        if (!segment
 8836            .TryGetSweptSphereCenteredFiniteCylinderIntersectionDistanceFromHalfAxisLength(
 8837                center,
 8838                Vector3d.Up,
 8839                circle.MixedHalfThickness,
 8840                circle.ScaledRadius,
 8841                radius,
 8842                length,
 8843                out Fixed64 distance))
 44        {
 645            hit = default;
 646            return false;
 47        }
 48
 8249        Vector3d sweepCenter = segment.GetPointAtDistance(distance, length);
 8250        hit = BuildSphereAgainst2DHit(
 8251            circle,
 8252            sweepCenter,
 8253            radius,
 8254            PhysicsQueryReducerKind.Exact,
 8255            distance,
 8256            direction);
 8257        return true;
 58    }
 59
 60}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/Mixed/GravitasQueryMixedService.Support.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQueryMixedService.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.Runtime.CompilerServices;
 9using FixedMathSharp;
 10using FixedMathSharp.Geometry;
 11using Gravitas.Colliders;
 12using Gravitas.CollisionHandling;
 13
 14namespace Gravitas.Queries;
 15
 16/// <content>
 17/// Owns mixed query hit construction, eligibility, bounds, and shared support helpers.
 18/// </content>
 19public sealed partial class GravitasQueryMixedService
 20{
 21    private static PhysicsMixedHit BuildSphereAgainst2DHit(
 22        LSCollider2D collider,
 23        Vector3d sweepCenter,
 24        Fixed64 radius,
 25        PhysicsQueryReducerKind reducerKind,
 26        Fixed64 distance,
 27        Vector3d direction,
 28        Vector3d featureNormal = default)
 29    {
 112930        ContactAnchor anchor2D =
 112931            MixedEmbedded2DGeometry.GetClosestAnchorOnEmbeddedVolume(
 112932                collider,
 112933                sweepCenter);
 34        // Exact reducers bound each anchor component by the admitted sphere
 35        // expansion.
 112936        _ = anchor2D.TryGetOffsetFrom(
 112937            sweepCenter,
 112938            out Vector3d to2D);
 39        Vector3d normal3DTo2D;
 112940        if (featureNormal != Vector3d.Zero)
 41        {
 42942            normal3DTo2D = featureNormal;
 43        }
 70044        else if (to2D.Y != Fixed64.Zero
 70045                 && new Vector2d(to2D.X, to2D.Z).MagnitudeSquared <= Fixed64.Epsilon)
 46        {
 1947            normal3DTo2D = to2D.Y > Fixed64.Zero
 1948                ? Vector3d.Up
 1949                : -Vector3d.Up;
 50        }
 51        else
 52        {
 68153            normal3DTo2D = to2D.MagnitudeSquared > Fixed64.Epsilon
 68154                ? to2D.Normalized
 68155                : Resolve3DTo2DFallback(collider, sweepCenter, direction);
 56        }
 112957        var anchor3D = new ContactAnchor(
 112958            sweepCenter,
 112959            normal3DTo2D * radius);
 112960        return new PhysicsMixedHit(
 112961            null,
 112962            collider,
 112963            anchor3D,
 112964            anchor2D,
 112965            normal3DTo2D,
 112966            reducerKind,
 112967            distance,
 112968            direction);
 69    }
 70
 71    private static PhysicsMixedHit BuildCircleAgainst3DHit(
 72        LSCollider collider,
 73        Vector3d sweepCenter,
 74        Vector3d direction,
 75        Fixed64 radius,
 76        Fixed64 slabCenterY,
 77        Fixed64 halfThickness,
 78        PhysicsQueryReducerKind reducerKind,
 79        Fixed64 distance,
 80        LSCollider2D? sourceCollider)
 81    {
 125882        FixedPointAnchor surface = collider.GetClosestSurfaceAnchor(
 125883            sweepCenter, out Vector3d outwardNormal, out bool contained);
 84        // These owners already resolve radial, cap and corner separation. The
 85        // cone's exterior apex/rim needs the direction from its selected witness.
 125886        Vector3d normal = contained
 125887            || collider is LSSphereCollider or LSCapsuleCollider or LSCylinderCollider or LSCuboidCollider
 125888            ? outwardNormal
 125889            : ContinuousCollisionContactPolicy.ResolveSurfaceNormal(surface, sweepCenter, outwardNormal);
 125890        return BuildCircleAgainst3DHit(
 125891            collider,
 125892            surface,
 125893            sweepCenter,
 125894            direction,
 125895            radius,
 125896            slabCenterY,
 125897            halfThickness,
 125898            reducerKind,
 125899            distance,
 1258100            sourceCollider,
 1258101            normal);
 102    }
 103
 104    private static PhysicsMixedHit BuildCircleAgainst3DHit(
 105        LSCollider collider,
 106        FixedPointAnchor point3D,
 107        Vector3d sweepCenter,
 108        Vector3d direction,
 109        Fixed64 radius,
 110        Fixed64 slabCenterY,
 111        Fixed64 halfThickness,
 112        PhysicsQueryReducerKind reducerKind,
 113        Fixed64 distance,
 114        LSCollider2D? sourceCollider,
 115        Vector3d featureNormal = default)
 116    {
 1444117        var anchor3D = new ContactAnchor(point3D);
 118        // Contained starts retain the solid's actual boundary, which can lie
 119        // beyond the small source slab; clamp only the slab's vertical witness.
 1444120        var center = new FixedPointAnchor(sweepCenter, FixedQuaternion.Identity, Vector3d.Zero);
 1444121        Vector3d normal3DTo2D = featureNormal != Vector3d.Zero ? featureNormal
 1444122            : ContinuousCollisionContactPolicy.ResolveSurfaceNormal(point3D, sweepCenter, -direction);
 1444123        Vector2d planarNormal = new(
 1444124            normal3DTo2D.X,
 1444125            normal3DTo2D.Z);
 1444126        Vector2d planarOffset = planarNormal.MagnitudeSquared > Fixed64.Epsilon
 1444127            ? -planarNormal.Normalized * radius
 1444128            : Vector2d.Zero;
 129        // Use the compact relative offset when available. Otherwise project Y
 130        // independently so X/Z overflow cannot erase it; Y overflow clamps its cap.
 1444131        bool hasY = point3D.TryGetOffsetFrom(center, out Vector3d offset);
 1444132        Fixed64 y = offset.Y;
 1448133        if (!hasY) hasY = point3D.TryGetProjectedOffsetFrom(center, Vector3d.Up, out y);
 1444134        Fixed64 verticalOffset = hasY
 1444135            ? FixedMath.Clamp(y, -halfThickness, halfThickness)
 1444136            : point3D.ProjectNonNegativeOffsetFrom(center, Vector3d.Up) > Fixed64.Zero
 1444137                ? halfThickness : -halfThickness;
 1444138        var anchor2D = new ContactAnchor(
 1444139            sweepCenter,
 1444140            new Vector3d(
 1444141                planarOffset.X,
 1444142                verticalOffset,
 1444143                planarOffset.Y));
 1444144        return new PhysicsMixedHit(
 1444145            collider,
 1444146            sourceCollider,
 1444147            anchor3D,
 1444148            anchor2D,
 1444149            normal3DTo2D,
 1444150            reducerKind,
 1444151            distance,
 1444152            direction);
 153    }
 154
 155    private static Vector3d Resolve3DTo2DFallback(LSCollider2D collider, Vector3d sweepCenter, Vector3d direction)
 156    {
 8157        Vector3d embeddedCenter = new(collider.Center.X, collider.MixedSlabCenterY, collider.Center.Y);
 8158        Vector3d to2D = embeddedCenter - sweepCenter;
 8159        if (to2D.MagnitudeSquared > Fixed64.Epsilon)
 7160            return to2D.Normalized;
 161
 1162        return direction;
 163    }
 164
 165    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 166    private void ResetLastQueryCounters()
 167    {
 132168        LastQueryCandidateCount = 0;
 132169        LastMeshTriangleCandidateCount = 0;
 132170    }
 171
 172    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 173    private static bool IsEligible2DTarget(
 174        LSCollider2D collider,
 175        LSCollider? excludedCollider,
 176        bool includeTriggers,
 177        bool staticTargetsOnly)
 178    {
 1219179        if (!includeTriggers && collider.IsTrigger)
 1180            return false;
 181
 1218182        return excludedCollider == null
 1218183            || (!ReferenceEquals(collider.AgentOrNull, excludedCollider.AgentOrNull)
 1218184                && !excludedCollider.ExcludesMixedCollisionWith(collider));
 185    }
 186
 187    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 188    private static bool IsEligible3DTarget(
 189        LSCollider collider,
 190        LSCollider2D? excludedCollider,
 191        bool includeTriggers,
 192        bool staticTargetsOnly)
 193    {
 1780194        if (!includeTriggers && collider.IsTrigger)
 1195            return false;
 196
 1779197        return excludedCollider == null
 1779198            || (!ReferenceEquals(collider.AgentOrNull, excludedCollider.AgentOrNull)
 1779199                && !collider.ExcludesMixedCollisionWith(excludedCollider));
 200    }
 201
 202    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 203    private static void CreateSweepBounds(Vector3d start, Vector3d end, Fixed64 radius, out Vector3d min, out Vector3d m
 204    {
 1067205        Vector3d radiusExtents = Vector3d.One * radius;
 1067206        min = Vector3d.Min(start, end) - radiusExtents;
 1067207        max = Vector3d.Max(start, end) + radiusExtents;
 1067208    }
 209
 210    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 211    private static void CreateCircleSlabSweepBounds(
 212        Vector2d start,
 213        Vector2d end,
 214        Fixed64 radius,
 215        Fixed64 slabCenterY,
 216        Fixed64 halfThickness,
 217        out Vector3d min,
 218        out Vector3d max)
 219    {
 2808220        min = new Vector3d(
 2808221            FixedMath.Min(start.X, end.X) - radius,
 2808222            slabCenterY - halfThickness,
 2808223            FixedMath.Min(start.Y, end.Y) - radius);
 2808224        max = new Vector3d(
 2808225            FixedMath.Max(start.X, end.X) + radius,
 2808226            slabCenterY + halfThickness,
 2808227            FixedMath.Max(start.Y, end.Y) + radius);
 2808228    }
 229
 230}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/Mixed/GravitasQueryMixedService.SweepCircle3D.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQueryMixedService.SweepCircle3D.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.Diagnostics;
 11using Gravitas.Support;
 12using SwiftCollections;
 13
 14namespace Gravitas.Queries;
 15
 16/// <content>
 17/// Owns mixed 2D-circle against 3D-collider sweep query behavior.
 18/// </content>
 19public sealed partial class GravitasQueryMixedService
 20{
 21    /// <summary>
 22    /// Sweeps a 2D circle embedded in a finite mixed slab against 3D colliders and returns the closest hit.
 23    /// </summary>
 24    public bool SweepCircleAgainst3D(
 25        Vector2d start,
 26        Vector2d end,
 27        Fixed64 radius,
 28        Fixed64 slabCenterY,
 29        Fixed64 halfThickness,
 30        PhysicsLayerMask layerMask,
 31        out PhysicsMixedHit hit,
 32        LSCollider2D? excludedCollider = null,
 33        bool includeTriggers = true)
 34    {
 46835        return SweepCircleAgainst3DClosestCore(
 46836            start,
 46837            end,
 46838            radius,
 46839            slabCenterY,
 46840            halfThickness,
 46841            layerMask,
 46842            excludedCollider,
 46843            includeTriggers,
 46844            staticTargetsOnly: false,
 46845            cacheTargetPartitions: false,
 46846            out hit);
 47    }
 48
 49    /// <summary>
 50    /// Sweeps a 2D circle embedded in a finite mixed slab against 3D colliders and writes hits from closest to farthest
 51    /// </summary>
 52    public int SweepCircleAgainst3DAll(
 53        Vector2d start,
 54        Vector2d end,
 55        Fixed64 radius,
 56        Fixed64 slabCenterY,
 57        Fixed64 halfThickness,
 58        PhysicsLayerMask layerMask,
 59        SwiftList<PhysicsMixedHit> results,
 60        LSCollider2D? excludedCollider = null,
 61        bool includeTriggers = true)
 62    {
 61963        return SweepCircleAgainst3DAllCore(
 61964            start,
 61965            end,
 61966            radius,
 61967            slabCenterY,
 61968            halfThickness,
 61969            layerMask,
 61970            results,
 61971            excludedCollider,
 61972            includeTriggers,
 61973            staticTargetsOnly: false);
 74    }
 75
 76    internal int SweepCircleAgainstStatic3DAll(
 77        Vector2d start,
 78        Vector2d end,
 79        Fixed64 radius,
 80        Fixed64 slabCenterY,
 81        Fixed64 halfThickness,
 82        PhysicsLayerMask layerMask,
 83        SwiftList<PhysicsMixedHit> results,
 84        LSCollider2D? excludedCollider = null,
 85        bool includeTriggers = true,
 86        bool cacheTargetPartitions = false,
 87        bool requireClosingContact = false)
 88    {
 52389        return SweepCircleAgainst3DAllCore(
 52390            start,
 52391            end,
 52392            radius,
 52393            slabCenterY,
 52394            halfThickness,
 52395            layerMask,
 52396            results,
 52397            excludedCollider,
 52398            includeTriggers,
 52399            staticTargetsOnly: true,
 523100            cacheTargetPartitions,
 523101            requireClosingContact);
 102    }
 103
 104    private bool SweepCircleAgainst3DClosestCore(
 105        Vector2d start,
 106        Vector2d end,
 107        Fixed64 radius,
 108        Fixed64 slabCenterY,
 109        Fixed64 halfThickness,
 110        PhysicsLayerMask layerMask,
 111        LSCollider2D? excludedCollider,
 112        bool includeTriggers,
 113        bool staticTargetsOnly,
 114        bool cacheTargetPartitions,
 115        out PhysicsMixedHit hit)
 116    {
 468117        ChronicleGuard.ThrowIfArgument(radius <= Fixed64.Zero, nameof(radius), "Mixed swept circle radius must be greate
 468118        ChronicleGuard.ThrowIfArgument(halfThickness <= Fixed64.Zero, nameof(halfThickness), "Mixed swept circle half-th
 468119        ColliderGeometryPolicy.ValidateReach(new Vector2d(radius, halfThickness), nameof(radius));
 120
 467121        if (!Vector2d.TrySubtract(end, start, out Vector2d segment)
 467122            || !Vector2d.TryGetMagnitude(segment, out Fixed64 length)
 467123            || length <= Fixed64.Epsilon)
 124        {
 3125            ResetLastQueryCounters();
 3126            hit = default;
 3127            return false;
 128        }
 129
 464130        Vector3d start3D = new(start.X, slabCenterY, start.Y);
 464131        Vector3d end3D = new(end.X, slabCenterY, end.Y);
 464132        Vector2d direction2D = segment.Normalized;
 464133        Vector3d direction = new(direction2D.X, Fixed64.Zero, direction2D.Y);
 464134        CreateCircleSlabSweepBounds(start, end, radius, slabCenterY, halfThickness, out Vector3d min, out Vector3d max);
 135        try
 136        {
 464137            _context.MixedCollisions.Collect3DCandidatesInMixedBounds(
 464138                min,
 464139                max,
 464140                layerMask,
 464141                _candidates3D,
 464142                staticStyleOnly: staticTargetsOnly,
 464143                cachePartitionRefresh: cacheTargetPartitions);
 464144            LastQueryCandidateCount = _candidates3D.Count;
 464145            LastMeshTriangleCandidateCount = 0;
 464146            bool captureReducerDiagnostics = _context.Diagnostics.Enabled;
 464147            QueryReducerCounters reducerCounters = default;
 464148            bool found = false;
 464149            PhysicsMixedHit best = default;
 150
 1850151            for (int i = 0; i < _candidates3D.Count; i++)
 152            {
 461153                if (!TrySweepCircleAgainst3DCandidate(
 461154                    _candidates3D[i],
 461155                    start,
 461156                    end,
 461157                    direction2D,
 461158                    length,
 461159                    radius,
 461160                    slabCenterY,
 461161                    halfThickness,
 461162                    direction,
 461163                    excludedCollider,
 461164                    includeTriggers,
 461165                    staticTargetsOnly,
 461166                    captureReducerDiagnostics,
 461167                    ref reducerCounters,
 461168                    out PhysicsMixedHit candidate))
 169                {
 170                    continue;
 171                }
 172
 451173                if (PhysicsHitSelectionPolicy.ShouldReplace(candidate, found, best))
 174                {
 442175                    best = candidate;
 442176                    found = true;
 177                }
 178            }
 179
 464180            hit = found ? best : default;
 464181            EmitMixedSweepDiagnostics(
 464182                GravitasColliderDimension.TwoD,
 464183                GravitasColliderDimension.ThreeD,
 464184                start3D,
 464185                end3D,
 464186                radius,
 464187                layerMask.Bits,
 464188                found,
 464189                reducerCounters.AcceptedHits,
 464190                hit,
 464191                captureReducerDiagnostics,
 464192                reducerCounters);
 464193            return found;
 194        }
 195        finally
 196        {
 464197            EndQuery();
 464198        }
 464199    }
 200
 201    private int SweepCircleAgainst3DAllCore(
 202        Vector2d start,
 203        Vector2d end,
 204        Fixed64 radius,
 205        Fixed64 slabCenterY,
 206        Fixed64 halfThickness,
 207        PhysicsLayerMask layerMask,
 208        SwiftList<PhysicsMixedHit> results,
 209        LSCollider2D? excludedCollider,
 210        bool includeTriggers,
 211        bool staticTargetsOnly,
 212        bool cacheTargetPartitions = false,
 213        bool requireClosingContact = false)
 214    {
 1142215        ChronicleGuard.ThrowIfNull(results, nameof(results));
 1142216        ChronicleGuard.ThrowIfArgument(radius <= Fixed64.Zero, nameof(radius), "Mixed swept circle radius must be greate
 1142217        ChronicleGuard.ThrowIfArgument(halfThickness <= Fixed64.Zero, nameof(halfThickness), "Mixed swept circle half-th
 1142218        if (!staticTargetsOnly)
 619219            ColliderGeometryPolicy.ValidateReach(new Vector2d(radius, halfThickness), nameof(radius));
 220
 1141221        results.Clear();
 1141222        if (!Vector2d.TrySubtract(end, start, out Vector2d segment)
 1141223            || !Vector2d.TryGetMagnitude(segment, out Fixed64 length)
 1141224            || length <= Fixed64.Epsilon)
 225        {
 3226            ResetLastQueryCounters();
 3227            return 0;
 228        }
 229
 1138230        Vector3d start3D = new(start.X, slabCenterY, start.Y);
 1138231        Vector3d end3D = new(end.X, slabCenterY, end.Y);
 1138232        Vector2d direction2D = segment.Normalized;
 1138233        Vector3d direction = new(direction2D.X, Fixed64.Zero, direction2D.Y);
 1138234        CreateCircleSlabSweepBounds(start, end, radius, slabCenterY, halfThickness, out Vector3d min, out Vector3d max);
 235        try
 236        {
 1138237            _context.MixedCollisions.Collect3DCandidatesInMixedBounds(
 1138238                min,
 1138239                max,
 1138240                layerMask,
 1138241                _candidates3D,
 1138242                staticStyleOnly: staticTargetsOnly,
 1138243                cachePartitionRefresh: cacheTargetPartitions);
 1138244            LastQueryCandidateCount = _candidates3D.Count;
 1138245            LastMeshTriangleCandidateCount = 0;
 1138246            bool captureReducerDiagnostics = _context.Diagnostics.Enabled;
 1138247            QueryReducerCounters reducerCounters = default;
 248
 4914249            for (int i = 0; i < _candidates3D.Count; i++)
 250            {
 1319251                if (!TrySweepCircleAgainst3DCandidate(
 1319252                    _candidates3D[i],
 1319253                    start,
 1319254                    end,
 1319255                    direction2D,
 1319256                    length,
 1319257                    radius,
 1319258                    slabCenterY,
 1319259                    halfThickness,
 1319260                    direction,
 1319261                    excludedCollider,
 1319262                    includeTriggers,
 1319263                    staticTargetsOnly,
 1319264                    captureReducerDiagnostics,
 1319265                    ref reducerCounters,
 1319266                    out PhysicsMixedHit candidate,
 1319267                    requireClosingContact))
 268                {
 269                    continue;
 270                }
 271
 1013272                results.Add(candidate);
 273            }
 274
 1138275            PhysicsMixedHitSorter.SortByDistance(results);
 1138276            EmitMixedSweepDiagnostics(
 1138277                GravitasColliderDimension.TwoD,
 1138278                GravitasColliderDimension.ThreeD,
 1138279                start3D,
 1138280                end3D,
 1138281                radius,
 1138282                layerMask.Bits,
 1138283                results.Count > 0,
 1138284                results.Count,
 1138285                results.Count > 0 ? results[0] : default,
 1138286                captureReducerDiagnostics,
 1138287                reducerCounters);
 1138288            return results.Count;
 289        }
 290        finally
 291        {
 1138292            EndQuery();
 1138293        }
 1138294    }
 295
 296}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/Mixed/GravitasQueryMixedService.SweepSphere2D.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasQueryMixedService.SweepSphere2D.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.Diagnostics;
 11using Gravitas.Support;
 12using SwiftCollections;
 13
 14namespace Gravitas.Queries;
 15
 16/// <content>
 17/// Owns mixed 3D-sphere against embedded 2D-slab sweep query behavior.
 18/// </content>
 19public sealed partial class GravitasQueryMixedService
 20{
 21    /// <summary>
 22    /// Sweeps a 3D sphere against embedded 2D mixed slabs and returns the closest hit.
 23    /// </summary>
 24    public bool SweepSphereAgainst2D(
 25        Vector3d start,
 26        Vector3d end,
 27        Fixed64 radius,
 28        PhysicsLayerMask layerMask,
 29        out PhysicsMixedHit hit,
 30        LSCollider? excludedCollider = null,
 31        bool includeTriggers = true)
 32    {
 31033        return SweepSphereAgainst2DClosestCore(
 31034            start,
 31035            end,
 31036            radius,
 31037            layerMask,
 31038            excludedCollider,
 31039            includeTriggers,
 31040            staticTargetsOnly: false,
 31041            cacheTargetPartitions: false,
 31042            out hit);
 43    }
 44
 45    /// <summary>
 46    /// Sweeps a 3D sphere against embedded 2D mixed slabs and writes hits from closest to farthest.
 47    /// </summary>
 48    public int SweepSphereAgainst2DAll(
 49        Vector3d start,
 50        Vector3d end,
 51        Fixed64 radius,
 52        PhysicsLayerMask layerMask,
 53        SwiftList<PhysicsMixedHit> results,
 54        LSCollider? excludedCollider = null,
 55        bool includeTriggers = true)
 56    {
 29257        return SweepSphereAgainst2DAllCore(
 29258            start,
 29259            end,
 29260            radius,
 29261            layerMask,
 29262            results,
 29263            excludedCollider,
 29264            includeTriggers,
 29265            staticTargetsOnly: false);
 66    }
 67
 68    internal int SweepSphereAgainstStatic2DAll(
 69        Vector3d start,
 70        Vector3d end,
 71        Fixed64 radius,
 72        PhysicsLayerMask layerMask,
 73        SwiftList<PhysicsMixedHit> results,
 74        LSCollider? excludedCollider = null,
 75        bool includeTriggers = true,
 76        bool cacheTargetPartitions = false,
 77        bool requireClosingContact = false)
 78    {
 47779        return SweepSphereAgainst2DAllCore(
 47780            start,
 47781            end,
 47782            radius,
 47783            layerMask,
 47784            results,
 47785            excludedCollider,
 47786            includeTriggers,
 47787            staticTargetsOnly: true,
 47788            cacheTargetPartitions,
 47789            requireClosingContact);
 90    }
 91
 92    private bool SweepSphereAgainst2DClosestCore(
 93        Vector3d start,
 94        Vector3d end,
 95        Fixed64 radius,
 96        PhysicsLayerMask layerMask,
 97        LSCollider? excludedCollider,
 98        bool includeTriggers,
 99        bool staticTargetsOnly,
 100        bool cacheTargetPartitions,
 101        out PhysicsMixedHit hit)
 102    {
 310103        ChronicleGuard.ThrowIfArgument(radius <= Fixed64.Zero, nameof(radius), "Mixed swept sphere radius must be greate
 310104        ColliderGeometryPolicy.ValidateReach(radius, nameof(radius));
 105
 309106        if (!Vector3d.TrySubtract(end, start, out Vector3d segment)
 309107            || !Vector3d.TryGetMagnitude(segment, out Fixed64 length)
 309108            || length <= Fixed64.Epsilon)
 109        {
 3110            ResetLastQueryCounters();
 3111            hit = default;
 3112            return false;
 113        }
 114
 306115        Vector3d direction = segment.Normalized;
 306116        CreateSweepBounds(start, end, radius, out Vector3d min, out Vector3d max);
 117        try
 118        {
 306119            _context.MixedCollisions.Collect2DCandidatesInMixedBounds(
 306120                min,
 306121                max,
 306122                layerMask,
 306123                _candidates2D,
 306124                staticStyleOnly: staticTargetsOnly,
 306125                cachePartitionRefresh: cacheTargetPartitions);
 301126            LastQueryCandidateCount = _candidates2D.Count;
 301127            LastMeshTriangleCandidateCount = 0;
 301128            bool captureReducerDiagnostics = _context.Diagnostics.Enabled;
 301129            QueryReducerCounters reducerCounters = default;
 301130            bool found = false;
 301131            PhysicsMixedHit best = default;
 132
 1208133            for (int i = 0; i < _candidates2D.Count; i++)
 134            {
 304135                if (!TrySweepSphereAgainst2DCandidate(
 304136                    start,
 304137                    end,
 304138                    direction,
 304139                    length,
 304140                    radius,
 304141                    _candidates2D[i],
 304142                    excludedCollider,
 304143                    includeTriggers,
 304144                    staticTargetsOnly,
 304145                    captureReducerDiagnostics,
 304146                    ref reducerCounters,
 304147                    out PhysicsMixedHit candidate))
 148                {
 149                    continue;
 150                }
 151
 290152                if (PhysicsHitSelectionPolicy.ShouldReplace(candidate, found, best))
 153                {
 278154                    best = candidate;
 278155                    found = true;
 156                }
 157            }
 158
 300159            hit = found ? best : default;
 300160            EmitMixedSweepDiagnostics(
 300161                GravitasColliderDimension.ThreeD,
 300162                GravitasColliderDimension.TwoD,
 300163                start,
 300164                end,
 300165                radius,
 300166                layerMask.Bits,
 300167                found,
 300168                reducerCounters.AcceptedHits,
 300169                hit,
 300170                captureReducerDiagnostics,
 300171                reducerCounters);
 300172            return found;
 173        }
 174        finally
 175        {
 306176            EndQuery();
 306177        }
 300178    }
 179
 180    private int SweepSphereAgainst2DAllCore(
 181        Vector3d start,
 182        Vector3d end,
 183        Fixed64 radius,
 184        PhysicsLayerMask layerMask,
 185        SwiftList<PhysicsMixedHit> results,
 186        LSCollider? excludedCollider,
 187        bool includeTriggers,
 188        bool staticTargetsOnly,
 189        bool cacheTargetPartitions = false,
 190        bool requireClosingContact = false)
 191    {
 769192        ChronicleGuard.ThrowIfNull(results, nameof(results));
 769193        ChronicleGuard.ThrowIfArgument(radius <= Fixed64.Zero, nameof(radius), "Mixed swept sphere radius must be greate
 769194        if (!staticTargetsOnly)
 292195            ColliderGeometryPolicy.ValidateReach(radius, nameof(radius));
 196
 768197        if (!Vector3d.TrySubtract(end, start, out Vector3d segment)
 768198            || !Vector3d.TryGetMagnitude(segment, out Fixed64 length)
 768199            || length <= Fixed64.Epsilon)
 200        {
 7201            results.Clear();
 7202            ResetLastQueryCounters();
 7203            return 0;
 204        }
 205
 761206        Vector3d direction = segment.Normalized;
 761207        CreateSweepBounds(start, end, radius, out Vector3d min, out Vector3d max);
 208        try
 209        {
 761210            _context.MixedCollisions.Collect2DCandidatesInMixedBounds(
 761211                min,
 761212                max,
 761213                layerMask,
 761214                _candidates2D,
 761215                staticStyleOnly: staticTargetsOnly,
 761216                cachePartitionRefresh: cacheTargetPartitions);
 757217            results.Clear();
 757218            LastQueryCandidateCount = _candidates2D.Count;
 757219            LastMeshTriangleCandidateCount = 0;
 757220            bool captureReducerDiagnostics = _context.Diagnostics.Enabled;
 757221            QueryReducerCounters reducerCounters = default;
 222
 3344223            for (int i = 0; i < _candidates2D.Count; i++)
 224            {
 915225                if (TrySweepSphereAgainst2DCandidate(
 915226                    start,
 915227                    end,
 915228                    direction,
 915229                    length,
 915230                    radius,
 915231                    _candidates2D[i],
 915232                    excludedCollider,
 915233                    includeTriggers,
 915234                    staticTargetsOnly,
 915235                    captureReducerDiagnostics,
 915236                    ref reducerCounters,
 915237                    out PhysicsMixedHit candidate,
 915238                    requireClosingContact))
 239                {
 580240                    results.Add(candidate);
 241                }
 242            }
 243
 757244            PhysicsMixedHitSorter.SortByDistance(results);
 757245            EmitMixedSweepDiagnostics(
 757246                GravitasColliderDimension.ThreeD,
 757247                GravitasColliderDimension.TwoD,
 757248                start,
 757249                end,
 757250                radius,
 757251                layerMask.Bits,
 757252                results.Count > 0,
 757253                results.Count,
 757254                results.Count > 0 ? results[0] : default,
 757255                captureReducerDiagnostics,
 757256                reducerCounters);
 757257            return results.Count;
 258        }
 259        finally
 260        {
 761261            EndQuery();
 761262        }
 757263    }
 264
 265}

Methods/Properties

.ctor(Gravitas.GravitasWorldContext)
SweepSphereAgainst2DBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepSphereAgainst2DRequest>,System.Span`1<Gravitas.Queries.PhysicsMixedHit>)
SweepSphereAgainst2DAllBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepSphereAgainst2DRequest>,SwiftCollections.SwiftList`1<Gravitas.Queries.PhysicsMixedHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
SweepCircleAgainst3DBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepCircleAgainst3DRequest>,System.Span`1<Gravitas.Queries.PhysicsMixedHit>)
SweepCircleAgainst3DAllBatch(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepCircleAgainst3DRequest>,SwiftCollections.SwiftList`1<Gravitas.Queries.PhysicsMixedHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
WriteClosestHit(System.Span`1<Gravitas.Queries.PhysicsMixedHit>,System.Int32,Gravitas.Queries.PhysicsMixedHit,System.Boolean,System.Int32&)
AppendRange(SwiftCollections.SwiftList`1<Gravitas.Queries.PhysicsMixedHit>,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>,System.Int32,System.Int32)
ResetBatchCounters(System.Int32)
AccumulateBatchCounters(System.Int32)
ValidateClosestBatchOutput(System.Int32,System.Span`1<Gravitas.Queries.PhysicsMixedHit>)
ValidateRangeBatchOutput(System.Int32,System.Span`1<Gravitas.Queries.PhysicsQueryHitRange>)
ValidateSweepSphereAgainst2DRequests(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepSphereAgainst2DRequest>)
ValidateSweepCircleAgainst3DRequests(System.ReadOnlySpan`1<Gravitas.Queries.PhysicsSweepCircleAgainst3DRequest>)
TrySweepCircleAgainst3DCollider(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,Gravitas.Colliders.LSCollider2D,Gravitas.Queries.PhysicsMixedHit&,System.Boolean)
TrySweepCircleAgainst3DColliderCore(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,Gravitas.Colliders.LSCollider2D,System.Boolean,Gravitas.Queries.PhysicsMixedHit&)
TrySweepCircleAgainstCuboid(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,Gravitas.Colliders.LSCuboidCollider,Gravitas.Colliders.LSCollider2D,Gravitas.Queries.PhysicsMixedHit&)
TrySweepCircleAgainstCapsule(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,Gravitas.Colliders.LSCapsuleCollider,Gravitas.Colliders.LSCollider2D,Gravitas.Queries.PhysicsMixedHit&)
TrySweepCircleAgainstCylinder(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,Gravitas.Colliders.LSCylinderCollider,Gravitas.Colliders.LSCollider2D,Gravitas.Queries.PhysicsMixedHit&)
BuildCircleAgainstProjectedFiniteSlabHit(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,Gravitas.Colliders.LSCollider,Gravitas.Colliders.LSCollider2D)
TrySweepCircleAgainstCone(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,Gravitas.Colliders.LSConeCollider,Gravitas.Colliders.LSCollider2D,Gravitas.Queries.PhysicsMixedHit&)
TrySweepCircleAgainstMesh(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,Gravitas.Colliders.LSMeshCollider,Gravitas.Colliders.LSCollider2D,System.Boolean,Gravitas.Queries.PhysicsMixedHit&)
TrySweepCircleAgainstCompound3D(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,Gravitas.Colliders.LSCompoundCollider,Gravitas.Colliders.LSCollider2D,System.Boolean,Gravitas.Queries.PhysicsMixedHit&)
TrySweepCircleAgainstSphere(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,Gravitas.Colliders.LSSphereCollider,Gravitas.Colliders.LSCollider2D,Gravitas.Queries.PhysicsMixedHit&)
TrySweepPointInPlane(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64&)
.ctor(Gravitas.GravitasWorldContext)
get_Context()
Reset()
EndQuery()
EmitMixedSweepDiagnostics(Gravitas.Diagnostics.GravitasColliderDimension,Gravitas.Diagnostics.GravitasColliderDimension,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,System.Int32,System.Boolean,System.Int32,Gravitas.Queries.PhysicsMixedHit,System.Boolean,Gravitas.Queries.GravitasQueryMixedService/QueryReducerCounters)
TrySweepSphereAgainst2DCandidate(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider,System.Boolean,System.Boolean,System.Boolean,Gravitas.Queries.GravitasQueryMixedService/QueryReducerCounters&,Gravitas.Queries.PhysicsMixedHit&,System.Boolean)
TrySweepCircleAgainst3DCandidate(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,Gravitas.Colliders.LSCollider2D,System.Boolean,System.Boolean,System.Boolean,Gravitas.Queries.GravitasQueryMixedService/QueryReducerCounters&,Gravitas.Queries.PhysicsMixedHit&,System.Boolean)
TryGetInitialMixedCcdHit(Gravitas.Colliders.LSCollider,Gravitas.Colliders.LSCollider2D,FixedMathSharp.Vector3d,System.Boolean,Gravitas.Queries.PhysicsMixedHit&)
RecordAttempt(Gravitas.Queries.PhysicsQueryReducerKind)
RecordAccepted()
RecordRejected(Gravitas.Queries.PhysicsQueryReducerKind)
TryResolveExactSphereSourceFor2D(Gravitas.Colliders.LSCollider,Gravitas.Colliders.LSCollider2D,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d&,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&)
TrySweepSphereAgainst2D(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCollider2D,Gravitas.Queries.PhysicsMixedHit&,System.Boolean)
TrySweepSphereAgainst2DCore(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCollider2D,System.Boolean,Gravitas.Queries.PhysicsMixedHit&)
TrySweepSphereAgainstCompound2D(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCompoundCollider2D,System.Boolean,Gravitas.Queries.PhysicsMixedHit&)
TrySweepSphereAgainstCapsuleSlab(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCapsuleCollider2D,Gravitas.Queries.PhysicsMixedHit&)
IsSphereOverlappingCapsuleSlabCapCore(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCapsuleCollider2D)
TrySweepSphereAgainstConvexSlab(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCollider2D,Gravitas.Queries.PhysicsMixedHit&)
TrySweepConvexSlabCapFace(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCollider2D,FixedMathSharp.Fixed64,System.Boolean,FixedMathSharp.Vector3d,Gravitas.Queries.GravitasQueryMixedService/SweepCandidate&)
TrySweepConvexSlabSideFaces(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCollider2D,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Queries.GravitasQueryMixedService/SweepCandidate&)
TrySweepConvexSlabEdges(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCollider2D,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Queries.GravitasQueryMixedService/SweepCandidate&)
TrySweepCapsuleSlabCapFace(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCapsuleCollider2D,FixedMathSharp.Fixed64,System.Boolean,FixedMathSharp.Vector3d,Gravitas.Queries.GravitasQueryMixedService/SweepCandidate&)
TrySweepCapsuleSlabSide(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCapsuleCollider2D,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Queries.GravitasQueryMixedService/SweepCandidate&)
TrySweepCapsuleSlabBoundaryEdges(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCapsuleCollider2D,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Queries.GravitasQueryMixedService/SweepCandidate&)
TryKeepCapsuleSlabStraightRimSweep(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Queries.GravitasQueryMixedService/SweepCandidate&)
DoesSphereOverlapConvexSlab(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCollider2D)
TryGetConvexSlabLocalSweep(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,Gravitas.Colliders.LSCollider2D,FixedMathSharp.Vector3d&,FixedMathSharp.Vector3d&)
TrySweepPointAgainstSegmentCapsule3D(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64&)
GetCapDistance(FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64)
TryKeepEarlierSweep(System.Boolean,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,Gravitas.Queries.GravitasQueryMixedService/SweepCandidate&)
TrySweepSphereAgainstCircleSlab(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCircleCollider2D,Gravitas.Queries.PhysicsMixedHit&)
BuildSphereAgainst2DHit(Gravitas.Colliders.LSCollider2D,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Queries.PhysicsQueryReducerKind,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d)
BuildCircleAgainst3DHit(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Queries.PhysicsQueryReducerKind,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCollider2D)
BuildCircleAgainst3DHit(Gravitas.Colliders.LSCollider,FixedMathSharp.Geometry.FixedPointAnchor,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Queries.PhysicsQueryReducerKind,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCollider2D,FixedMathSharp.Vector3d)
Resolve3DTo2DFallback(Gravitas.Colliders.LSCollider2D,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d)
ResetLastQueryCounters()
IsEligible2DTarget(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider,System.Boolean,System.Boolean)
IsEligible3DTarget(Gravitas.Colliders.LSCollider,Gravitas.Colliders.LSCollider2D,System.Boolean,System.Boolean)
CreateSweepBounds(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d&,FixedMathSharp.Vector3d&)
CreateCircleSlabSweepBounds(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d&,FixedMathSharp.Vector3d&)
SweepCircleAgainst3D(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,Gravitas.Queries.PhysicsMixedHit&,Gravitas.Colliders.LSCollider2D,System.Boolean)
SweepCircleAgainst3DAll(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.PhysicsMixedHit>,Gravitas.Colliders.LSCollider2D,System.Boolean)
SweepCircleAgainstStatic3DAll(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.PhysicsMixedHit>,Gravitas.Colliders.LSCollider2D,System.Boolean,System.Boolean,System.Boolean)
SweepCircleAgainst3DClosestCore(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,Gravitas.Colliders.LSCollider2D,System.Boolean,System.Boolean,System.Boolean,Gravitas.Queries.PhysicsMixedHit&)
SweepCircleAgainst3DAllCore(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.PhysicsMixedHit>,Gravitas.Colliders.LSCollider2D,System.Boolean,System.Boolean,System.Boolean,System.Boolean)
SweepSphereAgainst2D(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,Gravitas.Queries.PhysicsMixedHit&,Gravitas.Colliders.LSCollider,System.Boolean)
SweepSphereAgainst2DAll(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.PhysicsMixedHit>,Gravitas.Colliders.LSCollider,System.Boolean)
SweepSphereAgainstStatic2DAll(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.PhysicsMixedHit>,Gravitas.Colliders.LSCollider,System.Boolean,System.Boolean,System.Boolean)
SweepSphereAgainst2DClosestCore(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,Gravitas.Colliders.LSCollider,System.Boolean,System.Boolean,System.Boolean,Gravitas.Queries.PhysicsMixedHit&)
SweepSphereAgainst2DAllCore(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,Gravitas.Support.PhysicsLayerMask,SwiftCollections.SwiftList`1<Gravitas.Queries.PhysicsMixedHit>,Gravitas.Colliders.LSCollider,System.Boolean,System.Boolean,System.Boolean,System.Boolean)