< Summary

Line coverage
100%
Covered lines: 551
Uncovered lines: 0
Coverable lines: 551
Total lines: 943
Line coverage: 100%
Branch coverage
100%
Covered branches: 226
Total branches: 226
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: TryCollide(...)100%11100%
File 1: TryCollide(...)100%11100%
File 1: TryCollidePairCore(...)100%1616100%
File 1: TryCollide(...)100%11100%
File 1: TryCollide(...)100%1919100%
File 1: TryCollide(...)100%3737100%
File 1: HasSurfaceOverlap(...)100%1414100%
File 1: TryCircleCircle(...)100%22100%
File 1: TryCircleCircle(...)100%22100%
File 1: TryCircleConvex(...)100%22100%
File 1: TryCircleConvex(...)100%22100%
File 1: TryCircleConvexReversed(...)100%22100%
File 1: TryCapsuleCircle(...)100%22100%
File 1: TryCapsuleCircle(...)100%22100%
File 1: TryCapsuleCircleReversed(...)100%22100%
File 1: TryCapsuleCapsule(...)100%66100%
File 1: TryCapsuleCapsule(...)100%22100%
File 1: TryCapsuleConvex(...)100%22100%
File 1: TryGetCapsuleConvexContacts(...)100%11100%
File 1: GetConvexVertexOffsets(...)100%44100%
File 1: TryCapsuleConvex(...)100%44100%
File 1: TryCapsuleConvexReversed(...)100%44100%
File 1: TryConvexConvex(...)100%22100%
File 1: TryConvexConvex(...)100%44100%
File 1: TryCompound(...)100%66100%
File 1: TryCompoundCompound(...)100%1010100%
File 1: TryCompoundOther(...)100%1010100%
File 1: TryCompound(...)100%66100%
File 1: TryCompoundCompound(...)100%66100%
File 1: TryCompoundOther(...)100%1212100%
File 1: AddCompoundPartContacts(...)100%44100%
File 1: AddContact(...)100%11100%
File 1: BoundsOverlap(...)100%66100%
File 1: OrientCoincidentCapsuleNormal(...)100%44100%
File 2: DoesPostureCandidatePenetrate(...)100%1414100%
File 2: DoesPostureCandidatePenetrate(...)100%1414100%
File 2: DoesPostureCapsulePenetrate(...)100%44100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/2D/CollisionDetection2D.cs

#LineLine coverage
 1//=======================================================================
 2// CollisionDetection2D.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using System;
 9using System.Runtime.CompilerServices;
 10using FixedMathSharp;
 11using FixedMathSharp.Geometry;
 12using Gravitas.Colliders;
 13
 14namespace Gravitas.CollisionHandling;
 15
 16/// <summary>
 17/// Deterministic pure 2D narrow-phase collision checks.
 18/// </summary>
 19/// <content>Owns planar shape dispatch, contact generation and pair-level recovery admission.</content>
 20internal static partial class CollisionDetection2D
 21{
 22    internal static bool TryCollide(LSCollider2D colliderA, LSCollider2D colliderB, out Contact2D contact)
 23    {
 431524        ChronicleGuard.ThrowIfNull(colliderA, nameof(colliderA));
 431525        ChronicleGuard.ThrowIfNull(colliderB, nameof(colliderB));
 26
 431527        CollisionType2D collisionType = ColliderSettings2D.GetCollisionType(colliderA.Shape, colliderB.Shape);
 431528        return TryCollide(new CollisionWorkItem2D(colliderA, colliderB, collisionType), out contact);
 29    }
 30
 31    internal static bool TryCollide(CollisionPair2D pair, ContactManifold2D manifold, long frame)
 32    {
 707033        ChronicleGuard.ThrowIfNull(pair, nameof(pair));
 707034        ChronicleGuard.ThrowIfNull(manifold, nameof(manifold));
 707035        var previous = pair.BeginCollisionLayerUpdate(manifold);
 707036        bool overlaps = TryCollidePairCore(pair, manifold, frame);
 706837        pair.CompleteCollisionLayerUpdate(manifold, previous);
 706838        return overlaps;
 39    }
 40
 41    private static bool TryCollidePairCore(CollisionPair2D pair, ContactManifold2D manifold, long frame)
 42    {
 707043        pair.ClearRecovery();
 707044        bool overlaps = TryCollide(CollisionWorkItem2D.Create(pair), manifold, frame);
 1411745        if (!overlaps || !manifold.NeedsSurfaceRecovery) return overlaps;
 2346        LSCollider2D member = pair.ColliderA.StaticSurface != null ? pair.ColliderA : pair.ColliderB;
 2347        LSCollider2D mover = member == pair.ColliderA ? pair.ColliderB : pair.ColliderA;
 2648        if (mover.Body is not { HasSolverMobility: true }) return overlaps;
 2049        StaticSurface2D surface = member.StaticSurface!;
 50        // Noncarriers retain their overlap events; only the genuine carrier can recover the body.
 2051        if (mover is LSCompoundCollider2D || !surface.TryGetRecovery(mover, out Vector2d center))
 252            throw new InvalidOperationException("Pure 2D static-surface overlap has no exposed response constraint or ce
 1853        pair.SetRecovery(mover, center);
 1854        return true;
 55    }
 56
 57    internal static bool TryCollide(CollisionWorkItem2D item, ContactManifold2D manifold, long frame)
 58    {
 762959        ChronicleGuard.ThrowIfNull(manifold, nameof(manifold));
 762960        manifold.BeginUpdate(frame);
 762961        return TryCollide(item, manifold);
 62    }
 63
 64    internal static bool TryCollide(CollisionWorkItem2D item, out Contact2D contact)
 65    {
 431766        LSCollider2D colliderA = item.ColliderA;
 431767        LSCollider2D colliderB = item.ColliderB;
 431768        if (!BoundsOverlap(colliderA, colliderB))
 69        {
 182670            contact = default;
 182671            return false;
 72        }
 73
 249174        switch (item.CollisionType)
 75        {
 76            case CollisionType2D.Circle_Circle:
 30377                return TryCircleCircle((LSCircleCollider2D)colliderA, (LSCircleCollider2D)colliderB, out contact);
 78            case CollisionType2D.Circle_Convex:
 12079                return TryCircleConvex((LSCircleCollider2D)colliderA, colliderB, out contact);
 80            case CollisionType2D.Convex_Circle:
 81581                bool result = TryCircleConvex((LSCircleCollider2D)colliderB, colliderA, out Contact2D reversed);
 81582                contact = result
 81583                    ? new Contact2D(
 81584                        reversed.AnchorB,
 81585                        reversed.AnchorA,
 81586                        -reversed.Normal,
 81587                        reversed.Depth,
 81588                        reversed.DepthIsClamped)
 81589                    : default;
 81590                return result;
 91            case CollisionType2D.Convex_Convex:
 104092                return TryConvexConvex(colliderA, colliderB, out contact);
 93            case CollisionType2D.Capsule_Circle:
 794                return TryCapsuleCircle((LSCapsuleCollider2D)colliderA, (LSCircleCollider2D)colliderB, out contact);
 95            case CollisionType2D.Circle_Capsule:
 1796                bool circleCapsule = TryCapsuleCircle((LSCapsuleCollider2D)colliderB, (LSCircleCollider2D)colliderA, out
 1797                contact = circleCapsule
 1798                    ? new Contact2D(
 1799                        circleCapsuleReversed.AnchorB,
 17100                        circleCapsuleReversed.AnchorA,
 17101                        -circleCapsuleReversed.Normal,
 17102                        circleCapsuleReversed.Depth,
 17103                        circleCapsuleReversed.DepthIsClamped)
 17104                    : default;
 17105                return circleCapsule;
 106            case CollisionType2D.Capsule_Convex:
 92107                return TryCapsuleConvex((LSCapsuleCollider2D)colliderA, colliderB, out contact);
 108            case CollisionType2D.Convex_Capsule:
 7109                bool convexCapsule = TryCapsuleConvex((LSCapsuleCollider2D)colliderB, colliderA, out Contact2D convexCap
 7110                contact = convexCapsule
 7111                    ? new Contact2D(
 7112                        convexCapsuleReversed.AnchorB,
 7113                        convexCapsuleReversed.AnchorA,
 7114                        -convexCapsuleReversed.Normal,
 7115                        convexCapsuleReversed.Depth,
 7116                        convexCapsuleReversed.DepthIsClamped)
 7117                    : default;
 7118                return convexCapsule;
 119            case CollisionType2D.Capsule_Capsule:
 10120                return TryCapsuleCapsule((LSCapsuleCollider2D)colliderA, (LSCapsuleCollider2D)colliderB, out contact);
 121            case CollisionType2D.Compound:
 79122                return TryCompound(colliderA, colliderB, out contact);
 123            default:
 1124                contact = default;
 1125                return false;
 126        }
 127    }
 128
 129    private static bool TryCollide(CollisionWorkItem2D item, ContactManifold2D manifold)
 130    {
 7774131        LSCollider2D colliderA = item.ColliderA;
 7774132        LSCollider2D colliderB = item.ColliderB;
 7774133        if (!BoundsOverlap(colliderA, colliderB))
 29134            return false;
 135
 7745136        if (!colliderA.IsTrigger && !colliderB.IsTrigger && item.CollisionType != CollisionType2D.Compound)
 137        {
 7530138            StaticSurface2D? surface = colliderB.StaticSurface ?? colliderA.StaticSurface;
 7530139            if (surface != null && (colliderA.StaticSurface == null || colliderB.StaticSurface == null))
 140            {
 3497141                bool reverse = colliderA.StaticSurface != null;
 3960142                if (!HasSurfaceOverlap(reverse ? colliderB : colliderA, reverse ? colliderA : colliderB)) return false;
 3034143                surface.Reduce(reverse ? colliderB : colliderA, reverse ? colliderA : colliderB, manifold, reverse);
 3034144                return true;
 145            }
 146        }
 147
 4248148        return item.CollisionType switch
 4248149        {
 812150            CollisionType2D.Circle_Circle => TryCircleCircle((LSCircleCollider2D)colliderA, (LSCircleCollider2D)collider
 8151            CollisionType2D.Circle_Convex => TryCircleConvex((LSCircleCollider2D)colliderA, colliderB, manifold),
 1054152            CollisionType2D.Convex_Circle => TryCircleConvexReversed((LSCircleCollider2D)colliderB, colliderA, manifold)
 1414153            CollisionType2D.Convex_Convex => TryConvexConvex(colliderA, colliderB, manifold),
 11154            CollisionType2D.Capsule_Circle => TryCapsuleCircle((LSCapsuleCollider2D)colliderA, (LSCircleCollider2D)colli
 4155            CollisionType2D.Circle_Capsule => TryCapsuleCircleReversed((LSCapsuleCollider2D)colliderB, (LSCircleCollider
 14156            CollisionType2D.Capsule_Convex => TryCapsuleConvex((LSCapsuleCollider2D)colliderA, colliderB, manifold),
 790157            CollisionType2D.Convex_Capsule => TryCapsuleConvexReversed((LSCapsuleCollider2D)colliderB, colliderA, manifo
 7158            CollisionType2D.Capsule_Capsule => TryCapsuleCapsule((LSCapsuleCollider2D)colliderA, (LSCapsuleCollider2D)co
 133159            CollisionType2D.Compound => TryCompound(colliderA, colliderB, manifold),
 1160            _ => false
 4248161        };
 162    }
 163
 164    // Declared pieces are committed convex filled polygons. Overlap truth needs
 165    // exact classification, not discarded ordinary normals/depths/anchors.
 166    internal static bool HasSurfaceOverlap(LSCollider2D mover, LSCollider2D member)
 167    {
 4425168        if (!BoundsOverlap(mover, member)) return false;
 7490169        Span<Vector2d> targetBox = stackalloc Vector2d[4], movingBox = stackalloc Vector2d[4];
 3745170        ReadOnlySpan<Vector2d> target = GetConvexVertexOffsets(member, targetBox);
 3745171        if (mover is LSCircleCollider2D or LSCapsuleCollider2D)
 172        {
 3418173            Fixed64 core = mover is LSCapsuleCollider2D capsule ? capsule.AxisLength : Fixed64.Zero;
 3418174            Fixed64 radius = mover is LSCircleCollider2D circle ? circle.ScaledRadius : ((LSCapsuleCollider2D)mover).Sca
 3418175            Vector2d axis = Vector2d.Forward;
 4460176            if (core != Fixed64.Zero) _ = Vector2d.TryRotate(axis, mover.Rotation, out axis);
 3418177            return WideCenteredCapsule2dRelations.DoesCapsuleOverlapConvex(mover.Center, axis, core, radius,
 3418178                member.Center, member.ConvexRotation, target, strict: false);
 179        }
 327180        return WideConvex2dRelations.DoConvexesOverlap(mover.Center, mover.ConvexRotation, GetConvexVertexOffsets(mover,
 327181            member.Center, member.ConvexRotation, target, strict: false);
 182    }
 183
 184    private static bool TryCircleCircle(LSCircleCollider2D colliderA, LSCircleCollider2D colliderB, out Contact2D contac
 185    {
 186        // Circles are zero-core capsules. Keep classification and depth wide,
 187        // and retain exact radial anchor terms rather than rounded offsets.
 188        // A zero core needs no rotated axis; rotation still owns its anchor frame.
 1115189        if (!FixedSegment2d.TryGetCenteredCapsulesContact(
 1115190                colliderA.Center,
 1115191                colliderA.Rotation,
 1115192                Vector2d.Forward,
 1115193                Fixed64.Zero,
 1115194                colliderA.ScaledRadius,
 1115195                colliderB.Center,
 1115196                colliderB.Rotation,
 1115197                Vector2d.Forward,
 1115198                Fixed64.Zero,
 1115199                colliderB.ScaledRadius,
 1115200                Vector2d.Right,
 1115201                out FixedContactAnchors2d fixedContact))
 202        {
 43203            contact = default;
 43204            return false;
 205        }
 206
 1072207        contact = new Contact2D(
 1072208            new ContactAnchor2D(fixedContact.FirstAnchor),
 1072209            new ContactAnchor2D(fixedContact.SecondAnchor),
 1072210            fixedContact.Normal,
 1072211            fixedContact.Depth,
 1072212            fixedContact.DepthIsClamped);
 1072213        return true;
 214    }
 215
 216    private static bool TryCircleCircle(
 217        LSCircleCollider2D colliderA,
 218        LSCircleCollider2D colliderB,
 219        ContactManifold2D manifold)
 220    {
 812221        if (!TryCircleCircle(colliderA, colliderB, out Contact2D contact))
 13222            return false;
 223
 799224        AddContact(manifold, contact, colliderA, colliderB);
 799225        return true;
 226    }
 227
 228    private static bool TryCircleConvex(LSCircleCollider2D circle, LSCollider2D convex, out Contact2D contact)
 229    {
 1997230        Span<Vector2d> convexOffsets = stackalloc Vector2d[4];
 1997231        ReadOnlySpan<Vector2d> convexVertexOffsets =
 1997232            GetConvexVertexOffsets(convex, convexOffsets);
 1997233        if (!FixedConvex2dRelations.TryGetCircleContact(
 1997234                circle.Center,
 1997235                circle.Rotation,
 1997236                circle.ScaledRadius,
 1997237                convex.Center,
 1997238                convex.ConvexRotation,
 1997239                convexVertexOffsets,
 1997240                out FixedPointAnchor2d circleAnchor,
 1997241                out FixedPointAnchor2d convexAnchor,
 1997242                out Vector2d normal,
 1997243                out Fixed64 depth,
 1997244                out bool depthIsClamped))
 245        {
 405246            contact = default;
 405247            return false;
 248        }
 249
 1592250        contact = new Contact2D(
 1592251            new ContactAnchor2D(circleAnchor),
 1592252            new ContactAnchor2D(convexAnchor),
 1592253            normal,
 1592254            depth,
 1592255            depthIsClamped);
 1592256        return true;
 257    }
 258
 259    private static bool TryCircleConvex(
 260        LSCircleCollider2D circle,
 261        LSCollider2D convex,
 262        ContactManifold2D manifold)
 263    {
 8264        if (!TryCircleConvex(circle, convex, out Contact2D contact))
 1265            return false;
 266
 7267        AddContact(manifold, contact, circle, convex);
 7268        return true;
 269    }
 270
 271    private static bool TryCircleConvexReversed(
 272        LSCircleCollider2D circle,
 273        LSCollider2D convex,
 274        ContactManifold2D manifold)
 275    {
 1054276        if (!TryCircleConvex(circle, convex, out Contact2D contact))
 1277            return false;
 278
 1053279        manifold.AddContact(
 1053280            contact.AnchorB,
 1053281            contact.AnchorA,
 1053282            contact.Depth,
 1053283            -contact.Normal,
 1053284            convex.Material,
 1053285            circle.Material,
 1053286            contact.DepthIsClamped);
 1053287        return true;
 288    }
 289
 290    private static bool TryCapsuleCircle(LSCapsuleCollider2D capsule, LSCircleCollider2D circle, out Contact2D contact)
 291    {
 39292        Vector2d fallbackNormal = capsule.GetNormalFromCenteredAxis(circle.Center);
 39293        if (!FixedSegment2d.TryGetCenteredCapsulesContact(
 39294                capsule.Center,
 39295                capsule.Rotation,
 39296                capsule.AxisLength,
 39297                capsule.ScaledRadius,
 39298                circle.Center,
 39299                circle.Rotation,
 39300                Fixed64.Zero,
 39301                circle.ScaledRadius,
 39302                fallbackNormal,
 39303                out FixedContactAnchors2d fixedContact))
 304        {
 4305            contact = default;
 4306            return false;
 307        }
 308
 35309        contact = new Contact2D(
 35310            new ContactAnchor2D(fixedContact.FirstAnchor),
 35311            new ContactAnchor2D(fixedContact.SecondAnchor),
 35312            fixedContact.Normal,
 35313            fixedContact.Depth,
 35314            fixedContact.DepthIsClamped);
 35315        return true;
 316    }
 317
 318    private static bool TryCapsuleCircle(
 319        LSCapsuleCollider2D capsule,
 320        LSCircleCollider2D circle,
 321        ContactManifold2D manifold)
 322    {
 11323        if (!TryCapsuleCircle(capsule, circle, out Contact2D contact))
 1324            return false;
 325
 10326        AddContact(manifold, contact, capsule, circle);
 10327        return true;
 328    }
 329
 330    private static bool TryCapsuleCircleReversed(
 331        LSCapsuleCollider2D capsule,
 332        LSCircleCollider2D circle,
 333        ContactManifold2D manifold)
 334    {
 4335        if (!TryCapsuleCircle(capsule, circle, out Contact2D contact))
 1336            return false;
 337
 3338        manifold.AddContact(
 3339            contact.AnchorB,
 3340            contact.AnchorA,
 3341            contact.Depth,
 3342            -contact.Normal,
 3343            circle.Material,
 3344            capsule.Material,
 3345            contact.DepthIsClamped);
 3346        return true;
 347    }
 348
 349    private static bool TryCapsuleCapsule(LSCapsuleCollider2D colliderA, LSCapsuleCollider2D colliderB, out Contact2D co
 350    {
 17351        Vector2d fallbackNormal = colliderB.AxisLength <= Fixed64.Epsilon
 17352            ? colliderA.GetNormalFromCenteredAxis(colliderB.Center)
 17353            : colliderA.AxisLength <= Fixed64.Epsilon
 17354                ? -colliderB.GetNormalFromCenteredAxis(colliderA.Center)
 17355                : OrientCoincidentCapsuleNormal(colliderB.Center - colliderA.Center);
 17356        if (!FixedSegment2d.TryGetCenteredCapsulesContact(
 17357                colliderA.Center,
 17358                colliderA.Rotation,
 17359                colliderA.AxisLength,
 17360                colliderA.ScaledRadius,
 17361                colliderB.Center,
 17362                colliderB.Rotation,
 17363                colliderB.AxisLength,
 17364                colliderB.ScaledRadius,
 17365                fallbackNormal,
 17366                out FixedContactAnchors2d fixedContact))
 367        {
 2368            contact = default;
 2369            return false;
 370        }
 371
 15372        contact = new Contact2D(
 15373            new ContactAnchor2D(fixedContact.FirstAnchor),
 15374            new ContactAnchor2D(fixedContact.SecondAnchor),
 15375            fixedContact.Normal,
 15376            fixedContact.Depth,
 15377            fixedContact.DepthIsClamped);
 15378        return true;
 379    }
 380
 381    private static bool TryCapsuleCapsule(
 382        LSCapsuleCollider2D colliderA,
 383        LSCapsuleCollider2D colliderB,
 384        ContactManifold2D manifold)
 385    {
 7386        if (!TryCapsuleCapsule(colliderA, colliderB, out Contact2D contact))
 1387            return false;
 388
 6389        AddContact(manifold, contact, colliderA, colliderB);
 6390        return true;
 391    }
 392
 393    private static bool TryCapsuleConvex(LSCapsuleCollider2D capsule, LSCollider2D convex, out Contact2D contact)
 394    {
 99395        Span<FixedPointAnchor2d> capsuleAnchors =
 99396            stackalloc FixedPointAnchor2d[2];
 99397        Span<FixedPointAnchor2d> convexAnchors =
 99398            stackalloc FixedPointAnchor2d[2];
 99399        if (!TryGetCapsuleConvexContacts(
 99400                capsule,
 99401                convex,
 99402                capsuleAnchors,
 99403                convexAnchors,
 99404                out _,
 99405                out Vector2d normal,
 99406                out Fixed64 depth,
 99407                out bool depthIsClamped))
 408        {
 7409            contact = default;
 7410            return false;
 411        }
 412
 92413        contact = new Contact2D(
 92414            new ContactAnchor2D(capsuleAnchors[0]),
 92415            new ContactAnchor2D(convexAnchors[0]),
 92416            normal,
 92417            depth,
 92418            depthIsClamped);
 92419        return true;
 420    }
 421
 422    private static bool TryGetCapsuleConvexContacts(
 423        LSCapsuleCollider2D capsule,
 424        LSCollider2D convex,
 425        Span<FixedPointAnchor2d> capsuleAnchors,
 426        Span<FixedPointAnchor2d> convexAnchors,
 427        out int contactCount,
 428        out Vector2d normal,
 429        out Fixed64 depth,
 430        out bool depthIsClamped)
 431    {
 903432        Span<Vector2d> vertexOffsets = stackalloc Vector2d[4];
 903433        ReadOnlySpan<Vector2d> convexVertexOffsets =
 903434            GetConvexVertexOffsets(convex, vertexOffsets);
 903435        return FixedSegment2d.TryGetCenteredCapsuleConvexContacts(
 903436            capsule.Center,
 903437            capsule.Rotation,
 903438            Vector2d.Forward,
 903439            capsule.AxisLength,
 903440            capsule.ScaledRadius,
 903441            convex.Center,
 903442            convex.ConvexRotation,
 903443            convexVertexOffsets,
 903444            capsuleAnchors,
 903445            convexAnchors,
 903446            out contactCount,
 903447            out normal,
 903448            out depth,
 903449            out depthIsClamped);
 450    }
 451
 452    private static ReadOnlySpan<Vector2d> GetConvexVertexOffsets(
 453        LSCollider2D convex,
 454        Span<Vector2d> scratch)
 455    {
 12077456        if (convex is LSPolygonCollider2D polygon)
 5808457            return polygon.ScaledLocalVertices;
 458
 6269459        int vertexCount = convex.VertexCount;
 62690460        for (int i = 0; i < vertexCount; i++)
 25076461            scratch[i] = convex.GetScaledLocalVertexUnchecked(i);
 6269462        return scratch.Slice(0, vertexCount);
 463    }
 464
 465    private static bool TryCapsuleConvex(
 466        LSCapsuleCollider2D capsule,
 467        LSCollider2D convex,
 468        ContactManifold2D manifold)
 469    {
 14470        Span<FixedPointAnchor2d> capsuleAnchors =
 14471            stackalloc FixedPointAnchor2d[2];
 14472        Span<FixedPointAnchor2d> convexAnchors =
 14473            stackalloc FixedPointAnchor2d[2];
 14474        if (!TryGetCapsuleConvexContacts(
 14475                capsule,
 14476                convex,
 14477                capsuleAnchors,
 14478                convexAnchors,
 14479                out int contactCount,
 14480                out Vector2d normal,
 14481                out Fixed64 depth,
 14482                out bool depthIsClamped))
 483        {
 1484            return false;
 485        }
 486
 68487        for (int i = 0; i < contactCount; i++)
 488        {
 21489            manifold.AddContact(
 21490                new ContactAnchor2D(capsuleAnchors[i]),
 21491                new ContactAnchor2D(convexAnchors[i]),
 21492                depth,
 21493                normal,
 21494                capsule.Material,
 21495                convex.Material,
 21496                depthIsClamped);
 497        }
 13498        return true;
 499    }
 500
 501    private static bool TryCapsuleConvexReversed(
 502        LSCapsuleCollider2D capsule,
 503        LSCollider2D convex,
 504        ContactManifold2D manifold)
 505    {
 790506        Span<FixedPointAnchor2d> capsuleAnchors =
 790507            stackalloc FixedPointAnchor2d[2];
 790508        Span<FixedPointAnchor2d> convexAnchors =
 790509            stackalloc FixedPointAnchor2d[2];
 790510        if (!TryGetCapsuleConvexContacts(
 790511                capsule,
 790512                convex,
 790513                capsuleAnchors,
 790514                convexAnchors,
 790515                out int contactCount,
 790516                out Vector2d normal,
 790517                out Fixed64 depth,
 790518                out bool depthIsClamped))
 519        {
 1520            return false;
 521        }
 522
 3166523        for (int i = 0; i < contactCount; i++)
 524        {
 794525            manifold.AddContact(
 794526                new ContactAnchor2D(convexAnchors[i]),
 794527                new ContactAnchor2D(capsuleAnchors[i]),
 794528                depth,
 794529                -normal,
 794530                convex.Material,
 794531                capsule.Material,
 794532                depthIsClamped);
 533        }
 789534        return true;
 535    }
 536
 537    private static bool TryConvexConvex(LSCollider2D colliderA, LSCollider2D colliderB, out Contact2D contact)
 538    {
 1040539        Span<Vector2d> firstVertexScratch = stackalloc Vector2d[4];
 1040540        Span<Vector2d> secondVertexScratch = stackalloc Vector2d[4];
 1040541        ReadOnlySpan<Vector2d> firstVertexOffsets =
 1040542            GetConvexVertexOffsets(colliderA, firstVertexScratch);
 1040543        ReadOnlySpan<Vector2d> secondVertexOffsets =
 1040544            GetConvexVertexOffsets(colliderB, secondVertexScratch);
 1040545        Span<FixedPointAnchor2d> firstContactAnchors =
 1040546            stackalloc FixedPointAnchor2d[2];
 1040547        Span<FixedPointAnchor2d> secondContactAnchors =
 1040548            stackalloc FixedPointAnchor2d[2];
 1040549        if (!FixedConvex2dRelations.TryGetConvexContacts(
 1040550                colliderA.Center,
 1040551                colliderA.ConvexRotation,
 1040552                firstVertexOffsets,
 1040553                colliderB.Center,
 1040554                colliderB.ConvexRotation,
 1040555                secondVertexOffsets,
 1040556                firstContactAnchors,
 1040557                secondContactAnchors,
 1040558                out _,
 1040559                out Vector2d normal,
 1040560                out Fixed64 depth,
 1040561                out bool depthIsClamped))
 562        {
 6563            contact = default;
 6564            return false;
 565        }
 566
 567        // Keep a matched finite witness pair; support endpoints can lie outside
 568        // the overlap and give sweep/rotational CCD an unrelated lever arm.
 1034569        contact = new Contact2D(
 1034570            new ContactAnchor2D(firstContactAnchors[0]),
 1034571            new ContactAnchor2D(secondContactAnchors[0]),
 1034572            normal,
 1034573            depth,
 1034574            depthIsClamped);
 1034575        return true;
 576    }
 577
 578    private static bool TryConvexConvex(
 579        LSCollider2D colliderA,
 580        LSCollider2D colliderB,
 581        ContactManifold2D manifold)
 582    {
 1414583        Span<Vector2d> firstVertexScratch = stackalloc Vector2d[4];
 1414584        Span<Vector2d> secondVertexScratch = stackalloc Vector2d[4];
 1414585        ReadOnlySpan<Vector2d> firstVertexOffsets =
 1414586            GetConvexVertexOffsets(colliderA, firstVertexScratch);
 1414587        ReadOnlySpan<Vector2d> secondVertexOffsets =
 1414588            GetConvexVertexOffsets(colliderB, secondVertexScratch);
 1414589        Span<FixedPointAnchor2d> firstContactAnchors =
 1414590            stackalloc FixedPointAnchor2d[2];
 1414591        Span<FixedPointAnchor2d> secondContactAnchors =
 1414592            stackalloc FixedPointAnchor2d[2];
 1414593        if (!FixedConvex2dRelations.TryGetConvexContacts(
 1414594                colliderA.Center,
 1414595                colliderA.ConvexRotation,
 1414596                firstVertexOffsets,
 1414597                colliderB.Center,
 1414598                colliderB.ConvexRotation,
 1414599                secondVertexOffsets,
 1414600                firstContactAnchors,
 1414601                secondContactAnchors,
 1414602                out int contactCount,
 1414603                out Vector2d normal,
 1414604                out Fixed64 depth,
 1414605                out bool depthIsClamped))
 606        {
 1607            return false;
 608        }
 609
 8228610        for (int i = 0; i < contactCount; i++)
 611        {
 2701612            manifold.AddContact(
 2701613                new ContactAnchor2D(firstContactAnchors[i]),
 2701614                new ContactAnchor2D(secondContactAnchors[i]),
 2701615                depth,
 2701616                normal,
 2701617                colliderA.Material,
 2701618                colliderB.Material,
 2701619                depthIsClamped);
 620        }
 621
 1413622        return true;
 623    }
 624
 625    private static bool TryCompound(LSCollider2D colliderA, LSCollider2D colliderB, out Contact2D contact)
 626    {
 79627        if (colliderA is LSCompoundCollider2D compoundA)
 628        {
 34629            if (colliderB is LSCompoundCollider2D compoundB)
 31630                return TryCompoundCompound(compoundA, compoundB, out contact);
 631
 3632            return TryCompoundOther(compoundA, colliderB, compoundIsA: true, out contact);
 633        }
 634
 45635        if (colliderB is LSCompoundCollider2D compound)
 44636            return TryCompoundOther(compound, colliderA, compoundIsA: false, out contact);
 637
 1638        contact = default;
 1639        return false;
 640    }
 641
 642    private static bool TryCompoundCompound(
 643        LSCompoundCollider2D compoundA,
 644        LSCompoundCollider2D compoundB,
 645        out Contact2D contact)
 646    {
 31647        bool found = false;
 31648        Contact2D best = default;
 649
 128650        for (int i = 0; i < compoundA.PartCount; i++)
 651        {
 33652            LSCollider2D partA = compoundA.GetPartCollider(i);
 194653            for (int j = 0; j < compoundB.PartCount; j++)
 654            {
 64655                LSCollider2D partB = compoundB.GetPartCollider(j);
 64656                if (!TryCollide(partA, partB, out Contact2D candidate))
 657                    continue;
 658
 21659                if (ContactSelectionPolicy.ShouldReplaceWithDeeper(candidate, found, best))
 660                {
 11661                    best = candidate;
 11662                    found = true;
 663                }
 664            }
 665        }
 666
 31667        if (!found)
 668        {
 20669            contact = default;
 20670            return false;
 671        }
 672
 11673        contact = best;
 11674        return true;
 675    }
 676
 677    private static bool TryCompoundOther(
 678        LSCompoundCollider2D compound,
 679        LSCollider2D other,
 680        bool compoundIsA,
 681        out Contact2D contact)
 682    {
 47683        bool found = false;
 47684        Contact2D best = default;
 685
 278686        for (int i = 0; i < compound.PartCount; i++)
 687        {
 92688            LSCollider2D part = compound.GetPartCollider(i);
 689            Contact2D candidate;
 92690            bool collided = compoundIsA
 92691                ? TryCollide(part, other, out candidate)
 92692                : TryCollide(other, part, out candidate);
 693
 92694            if (!collided)
 695                continue;
 696
 38697            if (ContactSelectionPolicy.ShouldReplaceWithDeeper(candidate, found, best))
 698            {
 27699                best = candidate;
 27700                found = true;
 701            }
 702        }
 703
 47704        if (!found)
 705        {
 21706            contact = default;
 21707            return false;
 708        }
 709
 26710        contact = best;
 26711        return true;
 712    }
 713
 714    private static bool TryCompound(
 715        LSCollider2D colliderA,
 716        LSCollider2D colliderB,
 717        ContactManifold2D manifold)
 718    {
 133719        if (colliderA is LSCompoundCollider2D compoundA)
 720        {
 130721            if (colliderB is LSCompoundCollider2D compoundB)
 4722                return TryCompoundCompound(compoundA, compoundB, manifold);
 723
 126724            return TryCompoundOther(compoundA, colliderB, compoundIsA: true, manifold);
 725        }
 726
 3727        if (colliderB is LSCompoundCollider2D compound)
 2728            return TryCompoundOther(compound, colliderA, compoundIsA: false, manifold);
 729
 1730        return false;
 731    }
 732
 733    private static bool TryCompoundCompound(
 734        LSCompoundCollider2D compoundA,
 735        LSCompoundCollider2D compoundB,
 736        ContactManifold2D manifold)
 737    {
 4738        bool found = false;
 4739        ContactManifold2D scratch = compoundA.PartManifoldScratch;
 22740        for (int i = 0; i < compoundA.PartCount; i++)
 741        {
 7742            LSCollider2D partA = compoundA.GetPartCollider(i);
 32743            for (int j = 0; j < compoundB.PartCount; j++)
 744            {
 9745                LSCollider2D partB = compoundB.GetPartCollider(j);
 9746                CollisionType2D collisionType = ColliderSettings2D.GetCollisionType(partA.Shape, partB.Shape);
 9747                scratch.BeginUpdate(manifold.LastUpdatedFrame);
 9748                if (!TryCollide(new CollisionWorkItem2D(partA, partB, collisionType), scratch))
 749                    continue;
 750
 2751                found = true;
 2752                AddCompoundPartContacts(
 2753                    manifold,
 2754                    scratch,
 2755                    featureNamespaceA: i + 1,
 2756                    featureNamespaceB: -(j + 1));
 757            }
 758        }
 759
 4760        return found;
 761    }
 762
 763    private static bool TryCompoundOther(
 764        LSCompoundCollider2D compound,
 765        LSCollider2D other,
 766        bool compoundIsA,
 767        ContactManifold2D manifold)
 768    {
 128769        bool found = false;
 128770        ContactManifold2D scratch = compound.PartManifoldScratch;
 528771        for (int i = 0; i < compound.PartCount; i++)
 772        {
 136773            LSCollider2D part = compound.GetPartCollider(i);
 136774            LSCollider2D colliderA = compoundIsA ? part : other;
 136775            LSCollider2D colliderB = compoundIsA ? other : part;
 136776            CollisionType2D collisionType = ColliderSettings2D.GetCollisionType(colliderA.Shape, colliderB.Shape);
 136777            scratch.BeginUpdate(manifold.LastUpdatedFrame);
 136778            if (!TryCollide(new CollisionWorkItem2D(colliderA, colliderB, collisionType), scratch))
 779                continue;
 780
 132781            found = true;
 132782            AddCompoundPartContacts(
 132783                manifold,
 132784                scratch,
 132785                featureNamespaceA: compoundIsA ? i + 1 : 0,
 132786                featureNamespaceB: compoundIsA ? 0 : -(i + 1));
 787        }
 788
 128789        return found;
 790    }
 791
 792    private static void AddCompoundPartContacts(
 793        ContactManifold2D destination,
 794        ContactManifold2D source,
 795        int featureNamespaceA,
 796        int featureNamespaceB)
 797    {
 134798        destination.NeedsSurfaceRecovery |= source.NeedsSurfaceRecovery;
 734799        for (int groupIndex = 0; groupIndex < source.GroupCount; groupIndex++)
 800        {
 233801            ref ContactGroup2D group = ref source.GetGroup(groupIndex);
 1170802            for (int i = 0; i < group.Count; i++)
 803            {
 352804                ManifoldContact2D contact = group[i];
 352805                destination.AddContact(
 352806                    contact.AnchorA,
 352807                    contact.AnchorB,
 352808                    contact.Depth,
 352809                    contact.Normal,
 352810                    contact.MaterialA,
 352811                    contact.MaterialB,
 352812                    contact.DepthIsClamped,
 352813                    featureNamespaceA,
 352814                    featureNamespaceB,
 352815                    group.Key);
 816            }
 817        }
 134818    }
 819
 820    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 821    private static void AddContact(
 822        ContactManifold2D manifold,
 823        Contact2D contact,
 824        LSCollider2D colliderA,
 825        LSCollider2D colliderB) =>
 822826        manifold.AddContact(
 822827            contact.AnchorA,
 822828            contact.AnchorB,
 822829            contact.Depth,
 822830            contact.Normal,
 822831            colliderA.Material,
 822832            colliderB.Material,
 822833            contact.DepthIsClamped);
 834
 835    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 836    internal static bool BoundsOverlap(LSCollider2D colliderA, LSCollider2D colliderB) =>
 42981837        colliderA.MinX <= colliderB.MaxX
 42981838        && colliderA.MaxX >= colliderB.MinX
 42981839        && colliderA.MinY <= colliderB.MaxY
 42981840        && colliderA.MaxY >= colliderB.MinY;
 841
 842    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 843    private static Vector2d OrientCoincidentCapsuleNormal(Vector2d direction) =>
 9844        direction.MagnitudeSquared > Fixed64.Epsilon && direction.X < Fixed64.Zero
 9845            ? -Vector2d.Right
 9846            : Vector2d.Right;
 847
 848}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/2D/CollisionDetection2D.PostureClearance.cs

#LineLine coverage
 1//=======================================================================
 2// CollisionDetection2D.PostureClearance.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;
 12
 13namespace Gravitas.CollisionHandling;
 14
 15/// <content>Tests planar circle and capsule posture candidates for exact penetration.</content>
 16internal static partial class CollisionDetection2D
 17{
 18    // The caller has validated the candidate's circle/capsule family and the
 19    // physical pair policy. Clearance uses exact classification, not the
 20    // rounded translation that the ordinary contact solver needs.
 21    internal static bool DoesPostureCandidatePenetrate(LSCollider2D candidate, LSCollider2D other)
 22    {
 6123        if (!BoundsOverlap(candidate, other))
 124            return false;
 25
 6026        Fixed64 axisLength = candidate is LSCapsuleCollider2D capsule
 6027            ? capsule.AxisLength : Fixed64.Zero;
 6028        Fixed64 radius = candidate is LSCircleCollider2D circle
 6029            ? circle.ScaledRadius : ((LSCapsuleCollider2D)candidate).ScaledRadius;
 30
 6031        if (other is LSCompoundCollider2D compound)
 32        {
 33            // Compound definitions contain leaves, not nested compounds.
 9234            for (int i = 0; i < compound.PartCount; i++)
 35            {
 2836                LSCollider2D part = compound.GetPartCollider(i);
 2837                if (BoundsOverlap(candidate, part)
 2838                    && DoesPostureCapsulePenetrate(candidate, candidate.Center, axisLength, radius, part))
 1039                    return true;
 40            }
 1841            return false;
 42        }
 43
 3244        return DoesPostureCapsulePenetrate(candidate, candidate.Center, axisLength, radius, other);
 45    }
 46
 47    // A recovery certificate tests the proposed center without publishing a
 48    // transient collider pose, including polygons and all compound blockers.
 49    internal static bool DoesPostureCandidatePenetrate(LSCollider2D candidate, Vector2d center, LSCollider2D other)
 50    {
 13351        if (other is LSCompoundCollider2D compound)
 52        {
 1853            for (int i = 0; i < compound.PartCount; i++)
 1054                if (DoesPostureCandidatePenetrate(candidate, center, compound.GetPartCollider(i))) return true;
 155            return false;
 56        }
 13057        if (candidate is LSCircleCollider2D circle)
 5858            return DoesPostureCapsulePenetrate(candidate, center, Fixed64.Zero, circle.ScaledRadius, other);
 7259        if (candidate is LSCapsuleCollider2D capsule)
 2460            return DoesPostureCapsulePenetrate(candidate, center, capsule.AxisLength, capsule.ScaledRadius, other);
 9661        Span<Vector2d> scratch = stackalloc Vector2d[4], otherScratch = stackalloc Vector2d[4];
 4862        ReadOnlySpan<Vector2d> vertices = GetConvexVertexOffsets(candidate, scratch);
 4863        if (other is LSCircleCollider2D otherCircle)
 764            return FixedSegment2d.DoesCenteredCapsulePenetrateConvex(other.Center, other.Rotation, Fixed64.Zero,
 765                otherCircle.ScaledRadius, center, candidate.ConvexRotation, vertices);
 4166        if (other is LSCapsuleCollider2D otherCapsule)
 167            return FixedSegment2d.DoesCenteredCapsulePenetrateConvex(other.Center, other.Rotation, otherCapsule.AxisLeng
 168                otherCapsule.ScaledRadius, center, candidate.ConvexRotation, vertices);
 4069        return WideConvex2dRelations.DoConvexesOverlap(center, candidate.ConvexRotation, vertices,
 4070            other.Center, other.ConvexRotation, GetConvexVertexOffsets(other, otherScratch));
 71    }
 72
 73    private static bool DoesPostureCapsulePenetrate(
 74        LSCollider2D candidate, Vector2d center, Fixed64 axisLength, Fixed64 radius, LSCollider2D other)
 75    {
 14276        if (other is LSCircleCollider2D circle)
 77        {
 1878            return FixedSegment2d.DoCenteredCapsulesOverlapStrict(
 1879                center, candidate.Rotation, axisLength, radius,
 1880                circle.Center, circle.Rotation, Fixed64.Zero, circle.ScaledRadius);
 81        }
 12482        if (other is LSCapsuleCollider2D capsule)
 83        {
 1584            return FixedSegment2d.DoCenteredCapsulesOverlapStrict(
 1585                center, candidate.Rotation, axisLength, radius,
 1586                capsule.Center, capsule.Rotation, capsule.AxisLength, capsule.ScaledRadius);
 87        }
 88
 10989        Span<Vector2d> scratch = stackalloc Vector2d[4];
 10990        ReadOnlySpan<Vector2d> vertices = GetConvexVertexOffsets(other, scratch);
 10991        return FixedSegment2d.DoesCenteredCapsulePenetrateConvex(
 10992            center, candidate.Rotation, axisLength, radius,
 10993            other.Center, other.ConvexRotation, vertices);
 94    }
 95}

Methods/Properties

TryCollide(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D,Gravitas.CollisionHandling.Contact2D&)
TryCollide(Gravitas.CollisionPair2D,Gravitas.CollisionHandling.ContactManifold2D,System.Int64)
TryCollidePairCore(Gravitas.CollisionPair2D,Gravitas.CollisionHandling.ContactManifold2D,System.Int64)
TryCollide(Gravitas.CollisionHandling.CollisionWorkItem2D,Gravitas.CollisionHandling.ContactManifold2D,System.Int64)
TryCollide(Gravitas.CollisionHandling.CollisionWorkItem2D,Gravitas.CollisionHandling.Contact2D&)
TryCollide(Gravitas.CollisionHandling.CollisionWorkItem2D,Gravitas.CollisionHandling.ContactManifold2D)
HasSurfaceOverlap(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D)
TryCircleCircle(Gravitas.Colliders.LSCircleCollider2D,Gravitas.Colliders.LSCircleCollider2D,Gravitas.CollisionHandling.Contact2D&)
TryCircleCircle(Gravitas.Colliders.LSCircleCollider2D,Gravitas.Colliders.LSCircleCollider2D,Gravitas.CollisionHandling.ContactManifold2D)
TryCircleConvex(Gravitas.Colliders.LSCircleCollider2D,Gravitas.Colliders.LSCollider2D,Gravitas.CollisionHandling.Contact2D&)
TryCircleConvex(Gravitas.Colliders.LSCircleCollider2D,Gravitas.Colliders.LSCollider2D,Gravitas.CollisionHandling.ContactManifold2D)
TryCircleConvexReversed(Gravitas.Colliders.LSCircleCollider2D,Gravitas.Colliders.LSCollider2D,Gravitas.CollisionHandling.ContactManifold2D)
TryCapsuleCircle(Gravitas.Colliders.LSCapsuleCollider2D,Gravitas.Colliders.LSCircleCollider2D,Gravitas.CollisionHandling.Contact2D&)
TryCapsuleCircle(Gravitas.Colliders.LSCapsuleCollider2D,Gravitas.Colliders.LSCircleCollider2D,Gravitas.CollisionHandling.ContactManifold2D)
TryCapsuleCircleReversed(Gravitas.Colliders.LSCapsuleCollider2D,Gravitas.Colliders.LSCircleCollider2D,Gravitas.CollisionHandling.ContactManifold2D)
TryCapsuleCapsule(Gravitas.Colliders.LSCapsuleCollider2D,Gravitas.Colliders.LSCapsuleCollider2D,Gravitas.CollisionHandling.Contact2D&)
TryCapsuleCapsule(Gravitas.Colliders.LSCapsuleCollider2D,Gravitas.Colliders.LSCapsuleCollider2D,Gravitas.CollisionHandling.ContactManifold2D)
TryCapsuleConvex(Gravitas.Colliders.LSCapsuleCollider2D,Gravitas.Colliders.LSCollider2D,Gravitas.CollisionHandling.Contact2D&)
TryGetCapsuleConvexContacts(Gravitas.Colliders.LSCapsuleCollider2D,Gravitas.Colliders.LSCollider2D,System.Span`1<FixedMathSharp.Geometry.FixedPointAnchor2d>,System.Span`1<FixedMathSharp.Geometry.FixedPointAnchor2d>,System.Int32&,FixedMathSharp.Vector2d&,FixedMathSharp.Fixed64&,System.Boolean&)
GetConvexVertexOffsets(Gravitas.Colliders.LSCollider2D,System.Span`1<FixedMathSharp.Vector2d>)
TryCapsuleConvex(Gravitas.Colliders.LSCapsuleCollider2D,Gravitas.Colliders.LSCollider2D,Gravitas.CollisionHandling.ContactManifold2D)
TryCapsuleConvexReversed(Gravitas.Colliders.LSCapsuleCollider2D,Gravitas.Colliders.LSCollider2D,Gravitas.CollisionHandling.ContactManifold2D)
TryConvexConvex(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D,Gravitas.CollisionHandling.Contact2D&)
TryConvexConvex(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D,Gravitas.CollisionHandling.ContactManifold2D)
TryCompound(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D,Gravitas.CollisionHandling.Contact2D&)
TryCompoundCompound(Gravitas.Colliders.LSCompoundCollider2D,Gravitas.Colliders.LSCompoundCollider2D,Gravitas.CollisionHandling.Contact2D&)
TryCompoundOther(Gravitas.Colliders.LSCompoundCollider2D,Gravitas.Colliders.LSCollider2D,System.Boolean,Gravitas.CollisionHandling.Contact2D&)
TryCompound(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D,Gravitas.CollisionHandling.ContactManifold2D)
TryCompoundCompound(Gravitas.Colliders.LSCompoundCollider2D,Gravitas.Colliders.LSCompoundCollider2D,Gravitas.CollisionHandling.ContactManifold2D)
TryCompoundOther(Gravitas.Colliders.LSCompoundCollider2D,Gravitas.Colliders.LSCollider2D,System.Boolean,Gravitas.CollisionHandling.ContactManifold2D)
AddCompoundPartContacts(Gravitas.CollisionHandling.ContactManifold2D,Gravitas.CollisionHandling.ContactManifold2D,System.Int32,System.Int32)
AddContact(Gravitas.CollisionHandling.ContactManifold2D,Gravitas.CollisionHandling.Contact2D,Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D)
BoundsOverlap(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D)
OrientCoincidentCapsuleNormal(FixedMathSharp.Vector2d)
DoesPostureCandidatePenetrate(Gravitas.Colliders.LSCollider2D,Gravitas.Colliders.LSCollider2D)
DoesPostureCandidatePenetrate(Gravitas.Colliders.LSCollider2D,FixedMathSharp.Vector2d,Gravitas.Colliders.LSCollider2D)
DoesPostureCapsulePenetrate(Gravitas.Colliders.LSCollider2D,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.Colliders.LSCollider2D)