< Summary

Information

Class:	Gravitas.CollisionHandling.CollisionDetection
Assembly:	Gravitas
File(s):	File 1: /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/CollisionDetection.Capsule.cs File 2: /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/CollisionDetection.Compound.cs File 3: /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/CollisionDetection.Cone.cs File 4: /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/CollisionDetection.cs File 5: /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/CollisionDetection.Cuboid.cs File 6: /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/CollisionDetection.Cylinder.cs File 7: /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/CollisionDetection.Mesh.cs File 8: /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/CollisionDetection.Sphere.cs

Line coverage

100%

Covered lines:	777
Uncovered lines:	0
Coverable lines:	777
Total lines:	1346
Line coverage:	100%

Branch coverage

100%

Covered branches:	195
Total branches:	195
Branch coverage:	100%

Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

Method	Branch coverage	Crap Score	Cyclomatic complexity	Line coverage
File 1: DoCapsuleSphereCheck(...)	100%	2	2	100%
File 1: DoCapsulesCheck(...)	100%	2	2	100%
File 1: ResolveCenteredCapsuleFallback(...)	100%	12	12	100%
File 2: DoCompoundCheck(...)	100%	2	2	100%
File 2: DoCompoundOtherCheck(...)	100%	2	2	100%
File 2: DoCompoundCompoundCheck(...)	100%	4	4	100%
File 2: TryBuildCompoundPartContact(...)	100%	4	4	100%
File 2: AddCompoundPartContactsInOwnerOrder(...)	100%	4	4	100%
File 2: OrderPartPairForDetection(...)	100%	2	2	100%
File 2: BoundsOverlapInclusive(...)	100%	10	10	100%
File 3: DoConeSphereCheck(...)	100%	6	6	100%
File 3: DoConeConvexCheck(...)	100%	2	2	100%
File 3: DoMeshConeCheck(...)	100%	6	6	100%
File 3: TryFindMeshConeTriangleContact(...)	100%	12	12	100%
File 3: GetConeConvexColliders(...)	100%	4	4	100%
File 3: OrientNormal(...)	100%	2	2	100%
File 4: DoCollisionCheck(...)	100%	1	1	100%
File 4: DoCollisionCheck(...)	100%	21	21	100%
File 5: DoCuboidSphereCheck(...)	100%	2	2	100%
File 5: DoCuboidCapsuleCheck(...)	100%	2	2	100%
File 5: DoCuboidsCheck(...)	100%	10	10	100%
File 5: CanBuildAxisAlignedManifold(...)	100%	4	4	100%
File 5: TryBuildAxisAlignedCuboidManifold(...)	100%	20	20	100%
File 5: AddAxisAlignedCuboidContacts(...)	100%	10	10	100%
File 5: AddCuboidContact(...)	100%	1	1	100%
File 6: DoCylinderSphereCheck(...)	100%	6	6	100%
File 6: DoCylinderCapsuleCheck(...)	100%	4	4	100%
File 6: DoCylindersCheck(...)	100%	4	4	100%
File 6: DoCuboidCylinderCheck(...)	100%	6	6	100%
File 6: TryAddCylinderCylinderCapContacts(...)	100%	4	4	100%
File 6: TryAddCylinderCylinderCapContact(...)	100%	1	1	100%
File 6: ResolvePenetrationDepth(...)	100%	2	2	100%
File 6: ResolveNormal(...)	100%	2	2	100%
File 6: SetContactInPairOrder(...)	100%	2	2	100%
File 7: DoMeshSphereCheck(...)	100%	1	1	100%
File 7: DoMeshCapsuleCheck(...)	100%	4	4	100%
File 7: DoMeshCuboidCheck(...)	100%	6	6	100%
File 7: DoMeshCylinderCheck(...)	100%	1	1	100%
File 7: DoMeshesCheck(...)	100%	8	8	100%
File 8: DoSpheresCheck(...)	100%	2	2	100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/CollisionDetection.Capsule.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// CollisionDetection.Capsule.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2026–present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`using FixedMathSharp;`
	`9`	`using FixedMathSharp.Geometry;`
	`10`	`using Gravitas.Colliders;`
	`11`
	`12`	`namespace Gravitas.CollisionHandling;`
	`13`
	`14`	`public static partial class CollisionDetection`
	`15`	`{`
	`16`	`#region Capsule`
	`17`
	`18`	`private static bool DoCapsuleSphereCheck(CollisionWorkItem pair)`
	`19`	`{`
211	`20`	`var capsule = (LSCapsuleCollider)pair.ColliderA;`
211	`21`	`var sphere = (LSSphereCollider)pair.ColliderB;`
	`22`
211	`23`	`if (!FixedSegment.TryGetCenteredCapsulesContact(`
211	`24`	`capsule.Center,`
211	`25`	`capsule.Rotation,`
211	`26`	`Vector3d.Up,`
211	`27`	`capsule.AxisLength,`
211	`28`	`capsule.ScaledRadius,`
211	`29`	`sphere.Center,`
211	`30`	`sphere.Rotation,`
211	`31`	`Vector3d.Up,`
211	`32`	`Fixed64.Zero,`
211	`33`	`sphere.ScaledRadius,`
211	`34`	`ResolveCenteredCapsuleFallback(capsule.Center, sphere.Center),`
211	`35`	`out FixedContactAnchors contact))`
	`36`	`{`
1	`37`	`return false;`
	`38`	`}`
	`39`
210	`40`	`pair.Manifold.SetContact(`
210	`41`	`new ContactAnchor(contact.FirstAnchor),`
210	`42`	`new ContactAnchor(contact.SecondAnchor),`
210	`43`	`contact.Depth,`
210	`44`	`contact.Normal,`
210	`45`	`contact.DepthIsClamped);`
210	`46`	`return true;`
	`47`	`}`
	`48`
	`49`	`private static bool DoCapsulesCheck(CollisionWorkItem pair)`
	`50`	`{`
221	`51`	`var capsule1 = (LSCapsuleCollider)pair.ColliderA;`
221	`52`	`var capsule2 = (LSCapsuleCollider)pair.ColliderB;`
	`53`
221	`54`	`if (!FixedSegment.TryGetCenteredCapsulesContact(`
221	`55`	`capsule1.Center,`
221	`56`	`capsule1.Rotation,`
221	`57`	`Vector3d.Up,`
221	`58`	`capsule1.AxisLength,`
221	`59`	`capsule1.ScaledRadius,`
221	`60`	`capsule2.Center,`
221	`61`	`capsule2.Rotation,`
221	`62`	`Vector3d.Up,`
221	`63`	`capsule2.AxisLength,`
221	`64`	`capsule2.ScaledRadius,`
221	`65`	`ResolveCenteredCapsuleFallback(capsule1.Center, capsule2.Center),`
221	`66`	`out FixedContactAnchors contact))`
	`67`	`{`
1	`68`	`return false;`
	`69`	`}`
	`70`
220	`71`	`pair.Manifold.SetContact(`
220	`72`	`new ContactAnchor(contact.FirstAnchor),`
220	`73`	`new ContactAnchor(contact.SecondAnchor),`
220	`74`	`contact.Depth,`
220	`75`	`contact.Normal,`
220	`76`	`contact.DepthIsClamped);`
220	`77`	`return true;`
	`78`	`}`
	`79`
	`80`	`private static Vector3d ResolveCenteredCapsuleFallback(`
	`81`	`Vector3d firstCenter,`
	`82`	`Vector3d secondCenter)`
	`83`	`{`
1504	`84`	`if (secondCenter.X != firstCenter.X)`
1476	`85`	`return secondCenter.X > firstCenter.X ? Vector3d.Right : Vector3d.Left;`
28	`86`	`if (secondCenter.Y != firstCenter.Y)`
3	`87`	`return secondCenter.Y > firstCenter.Y ? Vector3d.Up : Vector3d.Down;`
25	`88`	`if (secondCenter.Z != firstCenter.Z)`
2	`89`	`return secondCenter.Z > firstCenter.Z ? Vector3d.Forward : Vector3d.Backward;`
23	`90`	`return Vector3d.Right;`
	`91`	`}`
	`92`
	`93`	`#endregion`
	`94`
	`95`	`}`

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/CollisionDetection.Compound.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// CollisionDetection.Compound.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2026–present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`using Gravitas.Colliders;`
	`9`	`using System.Runtime.CompilerServices;`
	`10`
	`11`	`namespace Gravitas.CollisionHandling;`
	`12`
	`13`	`public static partial class CollisionDetection`
	`14`	`{`
	`15`	`#region Compound`
	`16`
	`17`	`private static bool DoCompoundCheck(CollisionWorkItem pair)`
	`18`	`{`
13	`19`	`var compoundA = (LSCompoundCollider)pair.ColliderA;`
13	`20`	`if (pair.ColliderB is LSCompoundCollider compoundB)`
	`21`	`{`
3	`22`	`return DoCompoundCompoundCheck(pair, compoundA, compoundB);`
	`23`	`}`
	`24`
10	`25`	`return DoCompoundOtherCheck(pair, compoundA, pair.ColliderB);`
	`26`	`}`
	`27`
	`28`	`private static bool DoCompoundOtherCheck(`
	`29`	`CollisionWorkItem pair,`
	`30`	`LSCompoundCollider compound,`
	`31`	`LSCollider other)`
	`32`	`{`
10	`33`	`bool collided = false;`
50	`34`	`for (int i = 0; i < compound.PartCount; i++)`
	`35`	`{`
15	`36`	`LSCollider part = compound.GetPartCollider(i);`
15	`37`	`collided \|= TryBuildCompoundPartContact(`
15	`38`	`pair,`
15	`39`	`part,`
15	`40`	`featureNamespaceA: i + 1,`
15	`41`	`other,`
15	`42`	`featureNamespaceB: 0);`
	`43`	`}`
	`44`
10	`45`	`return collided;`
	`46`	`}`
	`47`
	`48`	`private static bool DoCompoundCompoundCheck(`
	`49`	`CollisionWorkItem pair,`
	`50`	`LSCompoundCollider compoundA,`
	`51`	`LSCompoundCollider compoundB)`
	`52`	`{`
3	`53`	`bool collided = false;`
16	`54`	`for (int i = 0; i < compoundA.PartCount; i++)`
	`55`	`{`
5	`56`	`LSCollider partA = compoundA.GetPartCollider(i);`
28	`57`	`for (int j = 0; j < compoundB.PartCount; j++)`
	`58`	`{`
9	`59`	`collided \|= TryBuildCompoundPartContact(`
9	`60`	`pair,`
9	`61`	`partA,`
9	`62`	`featureNamespaceA: i + 1,`
9	`63`	`compoundB.GetPartCollider(j),`
9	`64`	`featureNamespaceB: -(j + 1));`
	`65`	`}`
	`66`	`}`
	`67`
3	`68`	`return collided;`
	`69`	`}`
	`70`
	`71`	`private static bool TryBuildCompoundPartContact(`
	`72`	`CollisionWorkItem ownerPair,`
	`73`	`LSCollider first,`
	`74`	`int featureNamespaceA,`
	`75`	`LSCollider second,`
	`76`	`int featureNamespaceB)`
	`77`	`{`
24	`78`	`if (!BoundsOverlapInclusive(first, second))`
11	`79`	`return false;`
	`80`
13	`81`	`OrderPartPairForDetection(`
13	`82`	`first,`
13	`83`	`featureNamespaceA,`
13	`84`	`second,`
13	`85`	`featureNamespaceB,`
13	`86`	`out LSCollider colliderA,`
13	`87`	`out int orderedNamespaceA,`
13	`88`	`out LSCollider colliderB,`
13	`89`	`out int orderedNamespaceB);`
13	`90`	`CollisionType collisionType = ColliderSettings.GetCollisionType(colliderA.Shape, colliderB.Shape);`
13	`91`	`ContactManifold scratch = ownerPair.Context.CollisionScratch.CompoundPartManifold;`
13	`92`	`scratch.BeginUpdate(ownerPair.Context.FrameCount);`
13	`93`	`var partPair = new CollisionWorkItem(ownerPair.Context, colliderA, colliderB, collisionType, scratch);`
13	`94`	`if (!DoCollisionCheck(partPair))`
1	`95`	`return false;`
	`96`
12	`97`	`AddCompoundPartContactsInOwnerOrder(`
12	`98`	`ownerPair,`
12	`99`	`partPair,`
12	`100`	`orderedNamespaceA,`
12	`101`	`orderedNamespaceB);`
12	`102`	`return true;`
	`103`	`}`
	`104`
	`105`	`private static void AddCompoundPartContactsInOwnerOrder(`
	`106`	`CollisionWorkItem ownerPair,`
	`107`	`CollisionWorkItem partPair,`
	`108`	`int featureNamespaceA,`
	`109`	`int featureNamespaceB)`
	`110`	`{`
12	`111`	`bool addInPartOrder = ((LSCompoundCollider)ownerPair.ColliderA).ContainsPartCollider(partPair.ColliderA);`
	`112`
12	`113`	`ContactManifold scratch = partPair.Manifold;`
48	`114`	`for (int i = 0; i < scratch.Count; i++)`
	`115`	`{`
12	`116`	`ManifoldContact contact = scratch[i];`
12	`117`	`if (addInPartOrder)`
	`118`	`{`
11	`119`	`ownerPair.Manifold.AddContact(`
11	`120`	`contact.AnchorA,`
11	`121`	`contact.AnchorB,`
11	`122`	`contact.Depth,`
11	`123`	`contact.Normal,`
11	`124`	`partPair.ColliderA.Material,`
11	`125`	`partPair.ColliderB.Material,`
11	`126`	`contact.DepthIsClamped,`
11	`127`	`featureNamespaceA,`
11	`128`	`featureNamespaceB);`
11	`129`	`continue;`
	`130`	`}`
	`131`
1	`132`	`ownerPair.Manifold.AddContact(`
1	`133`	`contact.AnchorB,`
1	`134`	`contact.AnchorA,`
1	`135`	`contact.Depth,`
1	`136`	`-contact.Normal,`
1	`137`	`partPair.ColliderB.Material,`
1	`138`	`partPair.ColliderA.Material,`
1	`139`	`contact.DepthIsClamped,`
1	`140`	`featureNamespaceB,`
1	`141`	`featureNamespaceA);`
	`142`	`}`
12	`143`	`}`
	`144`
	`145`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`146`	`private static void OrderPartPairForDetection(`
	`147`	`LSCollider first,`
	`148`	`int firstFeatureNamespace,`
	`149`	`LSCollider second,`
	`150`	`int secondFeatureNamespace,`
	`151`	`out LSCollider colliderA,`
	`152`	`out int featureNamespaceA,`
	`153`	`out LSCollider colliderB,`
	`154`	`out int featureNamespaceB)`
	`155`	`{`
13	`156`	`if (first.Priority >= second.Priority)`
	`157`	`{`
11	`158`	`colliderA = first;`
11	`159`	`featureNamespaceA = firstFeatureNamespace;`
11	`160`	`colliderB = second;`
11	`161`	`featureNamespaceB = secondFeatureNamespace;`
11	`162`	`return;`
	`163`	`}`
	`164`
2	`165`	`colliderA = second;`
2	`166`	`featureNamespaceA = secondFeatureNamespace;`
2	`167`	`colliderB = first;`
2	`168`	`featureNamespaceB = firstFeatureNamespace;`
2	`169`	`}`
	`170`
	`171`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`172`	`private static bool BoundsOverlapInclusive(LSCollider colliderA, LSCollider colliderB)`
	`173`	`{`
24	`174`	`return colliderA.BoundsMin.X <= colliderB.BoundsMax.X`
24	`175`	`&& colliderA.BoundsMax.X >= colliderB.BoundsMin.X`
24	`176`	`&& colliderA.BoundsMin.Y <= colliderB.BoundsMax.Y`
24	`177`	`&& colliderA.BoundsMax.Y >= colliderB.BoundsMin.Y`
24	`178`	`&& colliderA.BoundsMin.Z <= colliderB.BoundsMax.Z`
24	`179`	`&& colliderA.BoundsMax.Z >= colliderB.BoundsMin.Z;`
	`180`	`}`
	`181`
	`182`	`#endregion`
	`183`
	`184`	`}`

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/CollisionDetection.Cone.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// CollisionDetection.Cone.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`using FixedMathSharp;`
	`9`	`using FixedMathSharp.Geometry;`
	`10`	`using Gravitas.Colliders;`
	`11`	`using SwiftCollections.Query;`
	`12`	`using System.Runtime.CompilerServices;`
	`13`
	`14`	`namespace Gravitas.CollisionHandling;`
	`15`
	`16`	`public static partial class CollisionDetection`
	`17`	`{`
	`18`	`private static bool DoConeSphereCheck(CollisionWorkItem pair)`
	`19`	`{`
7	`20`	`var cone = (LSConeCollider)pair.ColliderA;`
7	`21`	`var sphere = (LSSphereCollider)pair.ColliderB;`
	`22`
7	`23`	`if (!FixedSegment.TryGetClosestCenteredFiniteConeSurfaceAnchor(`
7	`24`	`sphere.Center,`
7	`25`	`cone.Center,`
7	`26`	`cone.Rotation,`
7	`27`	`Vector3d.Up,`
7	`28`	`cone.Height,`
7	`29`	`cone.ScaledRadius,`
7	`30`	`Vector3d.Right,`
7	`31`	`out FixedPointAnchor coneAnchor,`
7	`32`	`out Vector3d outwardNormal,`
7	`33`	`out Fixed64 signedDistance))`
	`34`	`{`
1	`35`	`return false;`
	`36`	`}`
6	`37`	`if (signedDistance > sphere.ScaledRadius)`
1	`38`	`return false;`
	`39`
5	`40`	`Vector3d normal = signedDistance < Fixed64.Zero`
5	`41`	`? -outwardNormal`
5	`42`	`: outwardNormal;`
5	`43`	`ResolvePenetrationDepth(`
5	`44`	`sphere.ScaledRadius,`
5	`45`	`signedDistance,`
5	`46`	`out Fixed64 penetrationDepth,`
5	`47`	`out bool depthIsClamped);`
5	`48`	`pair.Manifold.SetContact(`
5	`49`	`new ContactAnchor(coneAnchor),`
5	`50`	`new ContactAnchor(`
5	`51`	`FixedSegment.GetCenteredCapsuleSupportAnchor(`
5	`52`	`sphere.Center,`
5	`53`	`sphere.Rotation,`
5	`54`	`Fixed64.Zero,`
5	`55`	`sphere.ScaledRadius,`
5	`56`	`-normal)),`
5	`57`	`penetrationDepth,`
5	`58`	`normal,`
5	`59`	`depthIsClamped);`
	`60`
5	`61`	`return true;`
	`62`	`}`
	`63`
	`64`	`private static bool DoConeConvexCheck(CollisionWorkItem pair)`
	`65`	`{`
11	`66`	`GetConeConvexColliders(pair, out LSConeCollider cone, out LSCollider convex);`
	`67`
11	`68`	`if (!ConvexColliderSupport.Intersects(cone, convex))`
1	`69`	`return false;`
	`70`
10	`71`	`Vector3d normalConeToConvex = ResolveNormal(convex.Center - cone.Center);`
10	`72`	`normalConeToConvex = normalConeToConvex.Normalized;`
10	`73`	`FixedPointAnchor pointOnCone = ConvexColliderSupport.GetSupportAnchor(`
10	`74`	`cone,`
10	`75`	`normalConeToConvex,`
10	`76`	`Vector3d.Zero);`
10	`77`	`FixedPointAnchor pointOnConvex = ConvexColliderSupport.GetSupportAnchor(`
10	`78`	`convex,`
10	`79`	`-normalConeToConvex,`
10	`80`	`Vector3d.Zero);`
10	`81`	`Fixed64 depth = pointOnCone.ProjectNonNegativeOffsetFrom(`
10	`82`	`pointOnConvex,`
10	`83`	`normalConeToConvex);`
	`84`
10	`85`	`SetContactInPairOrder(`
10	`86`	`pair,`
10	`87`	`cone,`
10	`88`	`new ContactAnchor(pointOnCone),`
10	`89`	`convex,`
10	`90`	`new ContactAnchor(pointOnConvex),`
10	`91`	`depth,`
10	`92`	`normalConeToConvex,`
10	`93`	`depthIsClamped: false);`
10	`94`	`return true;`
	`95`	`}`
	`96`
	`97`	`private static bool DoMeshConeCheck(CollisionWorkItem pair)`
	`98`	`{`
13	`99`	`var mesh = (LSMeshCollider)pair.ColliderA;`
13	`100`	`var cone = (LSConeCollider)pair.ColliderB;`
	`101`
13	`102`	`if (TryFindMeshConeTriangleContact(`
13	`103`	`mesh,`
13	`104`	`cone,`
13	`105`	`pair.Context.CollisionScratch.MeshTriangleCandidatesA,`
13	`106`	`out ContactAnchor meshAnchor,`
13	`107`	`out ContactAnchor coneAnchor,`
13	`108`	`out Vector3d normalMeshToCone,`
13	`109`	`out Fixed64 depth,`
13	`110`	`out bool depthIsClamped))`
	`111`	`{`
7	`112`	`pair.Manifold.SetContact(`
7	`113`	`meshAnchor,`
7	`114`	`coneAnchor,`
7	`115`	`depth,`
7	`116`	`normalMeshToCone,`
7	`117`	`depthIsClamped);`
7	`118`	`return true;`
	`119`	`}`
	`120`
6	`121`	`if (mesh.Mode == MeshColliderMode.Concave \|\| !ConvexColliderSupport.Intersects(mesh, cone))`
4	`122`	`return false;`
	`123`
2	`124`	`normalMeshToCone = ResolveNormal(cone.Center - mesh.Center);`
2	`125`	`FixedPointAnchor pointOnMesh = ConvexColliderSupport.GetSupportAnchor(`
2	`126`	`mesh,`
2	`127`	`normalMeshToCone,`
2	`128`	`Vector3d.Zero);`
2	`129`	`FixedPointAnchor pointOnCone = ConvexColliderSupport.GetSupportAnchor(`
2	`130`	`cone,`
2	`131`	`-normalMeshToCone,`
2	`132`	`Vector3d.Zero);`
2	`133`	`depth = pointOnMesh.ProjectNonNegativeOffsetFrom(`
2	`134`	`pointOnCone,`
2	`135`	`normalMeshToCone);`
	`136`
2	`137`	`pair.Manifold.SetContact(`
2	`138`	`new ContactAnchor(pointOnMesh),`
2	`139`	`new ContactAnchor(pointOnCone),`
2	`140`	`depth,`
2	`141`	`normalMeshToCone);`
2	`142`	`return true;`
	`143`	`}`
	`144`
	`145`	`private static bool TryFindMeshConeTriangleContact(`
	`146`	`LSMeshCollider mesh,`
	`147`	`LSConeCollider cone,`
	`148`	`SwiftCollections.SwiftList<int> triangleBuffer,`
	`149`	`out ContactAnchor meshAnchor,`
	`150`	`out ContactAnchor coneAnchor,`
	`151`	`out Vector3d normalMeshToCone,`
	`152`	`out Fixed64 depth,`
	`153`	`out bool depthIsClamped)`
	`154`	`{`
13	`155`	`meshAnchor = default;`
13	`156`	`coneAnchor = default;`
13	`157`	`normalMeshToCone = Vector3d.Zero;`
13	`158`	`depth = Fixed64.Zero;`
13	`159`	`depthIsClamped = false;`
	`160`
13	`161`	`mesh.GetTrianglesInBounds(new FixedBoundVolume(cone.BoundsMin, cone.BoundsMax), triangleBuffer);`
13	`162`	`bool found = false;`
13	`163`	`Fixed64 bestDepth = Fixed64.MaxValue;`
	`164`
52	`165`	`for (int i = 0; i < triangleBuffer.Count; i++)`
	`166`	`{`
13	`167`	`int triangleIndex = triangleBuffer[i];`
13	`168`	`mesh.Mesh.GetLocalTriangleVertices(`
13	`169`	`triangleIndex,`
13	`170`	`out Vector3d first,`
13	`171`	`out Vector3d second,`
13	`172`	`out Vector3d third);`
13	`173`	`Vector3d windingNormal = mesh.Mesh.GetFaceNormalWorld(triangleIndex);`
13	`174`	`var triangle = new FixedTriangle(first, second, third);`
13	`175`	`var coneCenterAnchor = new FixedPointAnchor(`
13	`176`	`cone.Center,`
13	`177`	`FixedQuaternion.Identity,`
13	`178`	`Vector3d.Zero);`
13	`179`	`if (!coneCenterAnchor.TryGetLocalPointIn(`
13	`180`	`mesh.Mesh.Origin,`
13	`181`	`mesh.Mesh.Rotation,`
13	`182`	`out Vector3d localConeCenter))`
	`183`	`{`
	`184`	`continue;`
	`185`	`}`
	`186`
12	`187`	`Vector3d candidatePointOnMesh =`
12	`188`	`triangle.ClosestPoint(localConeCenter);`
12	`189`	`FixedPointAnchor candidateMeshAnchor =`
12	`190`	`mesh.Mesh.CreatePointAnchor(candidatePointOnMesh);`
12	`191`	`Vector3d candidateNormalMeshToCone =`
12	`192`	`OrientNormal(`
12	`193`	`candidateMeshAnchor,`
12	`194`	`coneCenterAnchor,`
12	`195`	`windingNormal).Normalized;`
	`196`	`FixedPointAnchor candidateConeAnchor;`
	`197`	`Fixed64 candidateDepth;`
	`198`	`bool candidateDepthIsClamped;`
	`199`	`// The closest point belongs to a triangle already admitted into`
	`200`	`// the cone's candidate bounds, so its cone-frame offset is finite.`
12	`201`	`_ = candidateMeshAnchor.TryGetLocalPointIn(`
12	`202`	`cone.Center,`
12	`203`	`cone.Rotation,`
12	`204`	`out Vector3d localPointInCone);`
12	`205`	`bool closestMeshPointInsideCone =`
12	`206`	`FixedSegment.ContainsPointInCenteredFiniteCone(`
12	`207`	`localPointInCone,`
12	`208`	`Vector3d.Zero,`
12	`209`	`Vector3d.Up,`
12	`210`	`cone.Height,`
12	`211`	`cone.ScaledRadius);`
12	`212`	`if (closestMeshPointInsideCone)`
	`213`	`{`
	`214`	`// Exact containment proves the centered canonical surface`
	`215`	`// offset remains inside the admitted radius and height.`
6	`216`	`_ = FixedSegment.TryGetClosestCenteredFiniteConeSurfaceOffset(`
6	`217`	`localPointInCone,`
6	`218`	`Vector3d.Zero,`
6	`219`	`Vector3d.Up,`
6	`220`	`cone.Height,`
6	`221`	`cone.ScaledRadius,`
6	`222`	`Vector3d.Right,`
6	`223`	`out Vector3d localConePoint,`
6	`224`	`out _,`
6	`225`	`out Fixed64 signedDistance);`
	`226`
6	`227`	`candidateDepth = -signedDistance;`
6	`228`	`candidateDepthIsClamped = false;`
6	`229`	`candidateConeAnchor = new FixedPointAnchor(`
6	`230`	`cone.Center,`
6	`231`	`cone.Rotation,`
6	`232`	`localConePoint);`
	`233`	`}`
6	`234`	`else if (triangle.TryGetCenteredFiniteConeSupportContact(`
6	`235`	`mesh.Mesh.Origin,`
6	`236`	`mesh.Mesh.Rotation,`
6	`237`	`cone.Center,`
6	`238`	`cone.Rotation,`
6	`239`	`cone.Height,`
6	`240`	`cone.ScaledRadius,`
6	`241`	`-candidateNormalMeshToCone,`
6	`242`	`candidateNormalMeshToCone,`
6	`243`	`out FixedContactAnchors contact))`
	`244`	`{`
4	`245`	`candidateMeshAnchor = contact.FirstAnchor;`
4	`246`	`candidateConeAnchor = contact.SecondAnchor;`
4	`247`	`candidateDepth = contact.Depth;`
4	`248`	`candidateDepthIsClamped = contact.DepthIsClamped;`
	`249`	`}`
	`250`	`else`
	`251`	`{`
	`252`	`continue;`
	`253`	`}`
	`254`
10	`255`	`if (found && candidateDepth >= bestDepth)`
	`256`	`continue;`
	`257`
7	`258`	`found = true;`
7	`259`	`bestDepth = candidateDepth;`
7	`260`	`meshAnchor = new ContactAnchor(candidateMeshAnchor);`
7	`261`	`coneAnchor = new ContactAnchor(candidateConeAnchor);`
7	`262`	`normalMeshToCone = candidateNormalMeshToCone;`
7	`263`	`depth = candidateDepth;`
7	`264`	`depthIsClamped = candidateDepthIsClamped;`
	`265`	`}`
	`266`
13	`267`	`return found;`
	`268`	`}`
	`269`
	`270`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`271`	`private static void GetConeConvexColliders(`
	`272`	`CollisionWorkItem pair,`
	`273`	`out LSConeCollider cone,`
	`274`	`out LSCollider convex)`
	`275`	`{`
11	`276`	`if (pair.ColliderA is LSConeCollider coneA && ConvexColliderSupport.IsSupported(pair.ColliderB))`
	`277`	`{`
5	`278`	`cone = coneA;`
5	`279`	`convex = pair.ColliderB;`
5	`280`	`return;`
	`281`	`}`
	`282`
6	`283`	`cone = (LSConeCollider)pair.ColliderB;`
6	`284`	`convex = pair.ColliderA;`
6	`285`	`}`
	`286`
	`287`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`288`	`private static Vector3d OrientNormal(`
	`289`	`in FixedPointAnchor source,`
	`290`	`in FixedPointAnchor target,`
	`291`	`Vector3d normal)`
	`292`	`{`
12	`293`	`Vector3d resolved = normal.Normalized;`
12	`294`	`return source.ProjectNonNegativeOffsetFrom(target, resolved)`
12	`295`	`> Fixed64.Zero`
12	`296`	`? -resolved`
12	`297`	`: resolved;`
	`298`	`}`
	`299`
	`300`	`}`

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/CollisionDetection.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// CollisionDetection.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2026–present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`using Gravitas.Colliders;`
	`9`
	`10`	`namespace Gravitas.CollisionHandling;`
	`11`
	`12`	`/// <summary>Provides deterministic 3D narrow-phase collision checks.</summary>`
	`13`	`public static partial class CollisionDetection`
	`14`	`{`
	`15`	`/// <summary>Rebuilds and tests the contact manifold for a collision pair.</summary>`
	`16`	`public static bool DoCollisionCheck(CollisionPair pair)`
	`17`	`{`
6899	`18`	`pair.Manifold.BeginUpdate(pair.Context.FrameCount);`
6899	`19`	`return DoCollisionCheck(CollisionWorkItem.Create(pair));`
	`20`	`}`
	`21`
	`22`	`internal static bool DoCollisionCheck(CollisionWorkItem pair)`
	`23`	`{`
10052	`24`	`return pair.CollisionType switch`
10052	`25`	`{`
1072	`26`	`CollisionType.Sphere_Sphere => DoSpheresCheck(pair),`
211	`27`	`CollisionType.Capsule_Sphere => DoCapsuleSphereCheck(pair),`
221	`28`	`CollisionType.Capsule_Capsule => DoCapsulesCheck(pair),`
4690	`29`	`CollisionType.Cuboid_Sphere => DoCuboidSphereCheck(pair),`
225	`30`	`CollisionType.AABox_Capsule => DoCuboidCapsuleCheck(pair),`
220	`31`	`CollisionType.OBBox_Capsule => DoCuboidCapsuleCheck(pair),`
708	`32`	`CollisionType.Cuboid_Cuboid => DoCuboidsCheck(pair),`
217	`33`	`CollisionType.Cylinder_Sphere => DoCylinderSphereCheck(pair),`
214	`34`	`CollisionType.Cylinder_Capsule => DoCylinderCapsuleCheck(pair),`
216	`35`	`CollisionType.Cylinder_Cylinder => DoCylindersCheck(pair),`
9	`36`	`CollisionType.Cuboid_Cylinder => DoCuboidCylinderCheck(pair),`
7	`37`	`CollisionType.Cone_Sphere => DoConeSphereCheck(pair),`
11	`38`	`CollisionType.Cone_Convex => DoConeConvexCheck(pair),`
12	`39`	`CollisionType.Mesh_Sphere => DoMeshSphereCheck(pair),`
223	`40`	`CollisionType.Mesh_Capsule => DoMeshCapsuleCheck(pair),`
689	`41`	`CollisionType.Mesh_Cuboid => DoMeshCuboidCheck(pair),`
428	`42`	`CollisionType.Mesh_Cylinder => DoMeshCylinderCheck(pair),`
13	`43`	`CollisionType.Mesh_Cone => DoMeshConeCheck(pair),`
652	`44`	`CollisionType.Mesh_Mesh => DoMeshesCheck(pair),`
13	`45`	`CollisionType.Compound => DoCompoundCheck(pair),`
1	`46`	`_ => false,`
10052	`47`	`};`
	`48`	`}`
	`49`
	`50`	`}`

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/CollisionDetection.Cuboid.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// CollisionDetection.Cuboid.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2026–present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`using FixedMathSharp;`
	`9`	`using FixedMathSharp.Geometry;`
	`10`	`using Gravitas.Colliders;`
	`11`
	`12`	`namespace Gravitas.CollisionHandling;`
	`13`
	`14`	`public static partial class CollisionDetection`
	`15`	`{`
	`16`	`#region Cuboid`
	`17`
	`18`	`private static bool DoCuboidSphereCheck(CollisionWorkItem pair)`
	`19`	`{`
4690	`20`	`var cuboid = (LSCuboidCollider)pair.ColliderA;`
4690	`21`	`if (!cuboid.OrientedBox.TryGetSphereContact(`
4690	`22`	`pair.ColliderB.Center,`
4690	`23`	`pair.ColliderB.Rotation,`
4690	`24`	`pair.ColliderB.ScaledRadius,`
4690	`25`	`out FixedContactAnchors contact))`
	`26`	`{`
2007	`27`	`return false;`
	`28`	`}`
	`29`
2683	`30`	`pair.Manifold.SetContact(`
2683	`31`	`new ContactAnchor(contact.FirstAnchor),`
2683	`32`	`new ContactAnchor(contact.SecondAnchor),`
2683	`33`	`contact.Depth,`
2683	`34`	`contact.Normal,`
2683	`35`	`contact.DepthIsClamped);`
2683	`36`	`return true;`
	`37`	`}`
	`38`
	`39`	`private static bool DoCuboidCapsuleCheck(CollisionWorkItem pair)`
	`40`	`{`
445	`41`	`var cuboid = (LSCuboidCollider)pair.ColliderA;`
445	`42`	`var capsule = (LSCapsuleCollider)pair.ColliderB;`
	`43`
445	`44`	`if (!cuboid.OrientedBox.TryGetCenteredCapsuleContact(`
445	`45`	`capsule.Center,`
445	`46`	`capsule.Rotation,`
445	`47`	`Vector3d.Up,`
445	`48`	`capsule.AxisLength,`
445	`49`	`capsule.ScaledRadius,`
445	`50`	`out FixedContactAnchors contact))`
	`51`	`{`
9	`52`	`return false;`
	`53`	`}`
	`54`
436	`55`	`pair.Manifold.SetContact(`
436	`56`	`new ContactAnchor(contact.FirstAnchor),`
436	`57`	`new ContactAnchor(contact.SecondAnchor),`
436	`58`	`contact.Depth,`
436	`59`	`contact.Normal,`
436	`60`	`contact.DepthIsClamped);`
436	`61`	`return true;`
	`62`	`}`
	`63`
	`64`	`/// <summary>`
	`65`	`/// Checks for collisions between two poly-poly colliders.`
	`66`	`/// </summary>`
	`67`	`/// <returns>true if a collision is detected, false otherwise.</returns>`
	`68`	`private static bool DoCuboidsCheck(CollisionWorkItem pair)`
	`69`	`{`
708	`70`	`var cuboidA = (LSCuboidCollider)pair.ColliderA;`
708	`71`	`var cuboidB = (LSCuboidCollider)pair.ColliderB;`
	`72`
708	`73`	`if (cuboidA.Shape == ColliderType.AABox`
708	`74`	`&& cuboidB.Shape == ColliderType.AABox`
708	`75`	`&& CanBuildAxisAlignedManifold(cuboidA)`
708	`76`	`&& CanBuildAxisAlignedManifold(cuboidB))`
	`77`	`{`
241	`78`	`return TryBuildAxisAlignedCuboidManifold(pair, cuboidA, cuboidB);`
	`79`	`}`
	`80`
467	`81`	`if (!cuboidA.OrientedBox.TryGetContact(`
467	`82`	`cuboidB.OrientedBox,`
467	`83`	`out FixedContactAnchors contact))`
	`84`	`{`
5	`85`	`return false;`
	`86`	`}`
	`87`
462	`88`	`pair.Manifold.SetContact(`
462	`89`	`new ContactAnchor(contact.FirstAnchor),`
462	`90`	`new ContactAnchor(contact.SecondAnchor),`
462	`91`	`contact.Depth,`
462	`92`	`contact.Normal,`
462	`93`	`contact.DepthIsClamped);`
462	`94`	`return true;`
	`95`	`}`
	`96`
	`97`	`private static bool CanBuildAxisAlignedManifold(LSCuboidCollider cuboid)`
	`98`	`{`
483	`99`	`Vector3d center = cuboid.Center;`
483	`100`	`Vector3d halfExtents = cuboid.OrientedBox.HalfExtents;`
	`101`	`// The four-point fast path materializes both bounds and subtracts their`
	`102`	`// overlap widths. Wider conceptual boxes use the exact relative path.`
483	`103`	`return Vector3d.TryAdd(center, halfExtents, out _)`
483	`104`	`&& Vector3d.TrySubtract(center, halfExtents, out _)`
483	`105`	`&& Vector3d.TryAdd(halfExtents, halfExtents, out _);`
	`106`	`}`
	`107`
	`108`	`private static bool TryBuildAxisAlignedCuboidManifold(`
	`109`	`CollisionWorkItem pair,`
	`110`	`LSCuboidCollider cuboidA,`
	`111`	`LSCuboidCollider cuboidB)`
	`112`	`{`
241	`113`	`Fixed64 overlapX = FixedMath.Min(cuboidA.BoundsMax.X, cuboidB.BoundsMax.X) - FixedMath.Max(cuboidA.BoundsMin.X,`
241	`114`	`Fixed64 overlapY = FixedMath.Min(cuboidA.BoundsMax.Y, cuboidB.BoundsMax.Y) - FixedMath.Max(cuboidA.BoundsMin.Y,`
241	`115`	`Fixed64 overlapZ = FixedMath.Min(cuboidA.BoundsMax.Z, cuboidB.BoundsMax.Z) - FixedMath.Max(cuboidA.BoundsMin.Z,`
	`116`
241	`117`	`if (overlapX < Fixed64.Zero \|\| overlapY < Fixed64.Zero \|\| overlapZ < Fixed64.Zero)`
2	`118`	`return false;`
	`119`
239	`120`	`Vector3d centerDelta = cuboidB.Center - cuboidA.Center;`
239	`121`	`int axis = 0;`
239	`122`	`Fixed64 depth = overlapX;`
239	`123`	`if (overlapY < depth)`
	`124`	`{`
21	`125`	`axis = 1;`
21	`126`	`depth = overlapY;`
	`127`	`}`
	`128`
239	`129`	`if (overlapZ < depth)`
	`130`	`{`
2	`131`	`axis = 2;`
2	`132`	`depth = overlapZ;`
	`133`	`}`
	`134`
239	`135`	`Vector3d normal = axis switch`
239	`136`	`{`
216	`137`	`0 => new Vector3d(centerDelta.X < Fixed64.Zero ? -Fixed64.One : Fixed64.One, Fixed64.Zero, Fixed64.Zero),`
21	`138`	`1 => new Vector3d(Fixed64.Zero, centerDelta.Y < Fixed64.Zero ? -Fixed64.One : Fixed64.One, Fixed64.Zero),`
2	`139`	`_ => new Vector3d(Fixed64.Zero, Fixed64.Zero, centerDelta.Z < Fixed64.Zero ? -Fixed64.One : Fixed64.One)`
239	`140`	`};`
	`141`
239	`142`	`AddAxisAlignedCuboidContacts(pair.Manifold, cuboidA, cuboidB, axis, depth, normal);`
239	`143`	`return pair.Manifold.HasContact;`
	`144`	`}`
	`145`
	`146`	`private static void AddAxisAlignedCuboidContacts(`
	`147`	`ContactManifold manifold,`
	`148`	`LSCuboidCollider cuboidA,`
	`149`	`LSCuboidCollider cuboidB,`
	`150`	`int axis,`
	`151`	`Fixed64 depth,`
	`152`	`Vector3d normal)`
	`153`	`{`
239	`154`	`Fixed64 minX = FixedMath.Max(cuboidA.BoundsMin.X, cuboidB.BoundsMin.X);`
239	`155`	`Fixed64 maxX = FixedMath.Min(cuboidA.BoundsMax.X, cuboidB.BoundsMax.X);`
239	`156`	`Fixed64 minY = FixedMath.Max(cuboidA.BoundsMin.Y, cuboidB.BoundsMin.Y);`
239	`157`	`Fixed64 maxY = FixedMath.Min(cuboidA.BoundsMax.Y, cuboidB.BoundsMax.Y);`
239	`158`	`Fixed64 minZ = FixedMath.Max(cuboidA.BoundsMin.Z, cuboidB.BoundsMin.Z);`
239	`159`	`Fixed64 maxZ = FixedMath.Min(cuboidA.BoundsMax.Z, cuboidB.BoundsMax.Z);`
	`160`
	`161`	`switch (axis)`
	`162`	`{`
	`163`	`case 0:`
	`164`	`{`
216	`165`	`Fixed64 x = normal.X > Fixed64.Zero ? cuboidA.BoundsMax.X : cuboidA.BoundsMin.X;`
216	`166`	`AddCuboidContact(manifold, new Vector3d(x, minY, minZ), normal, depth);`
216	`167`	`AddCuboidContact(manifold, new Vector3d(x, minY, maxZ), normal, depth);`
216	`168`	`AddCuboidContact(manifold, new Vector3d(x, maxY, minZ), normal, depth);`
216	`169`	`AddCuboidContact(manifold, new Vector3d(x, maxY, maxZ), normal, depth);`
216	`170`	`break;`
	`171`	`}`
	`172`	`case 1:`
	`173`	`{`
21	`174`	`Fixed64 y = normal.Y > Fixed64.Zero ? cuboidA.BoundsMax.Y : cuboidA.BoundsMin.Y;`
21	`175`	`AddCuboidContact(manifold, new Vector3d(minX, y, minZ), normal, depth);`
21	`176`	`AddCuboidContact(manifold, new Vector3d(minX, y, maxZ), normal, depth);`
21	`177`	`AddCuboidContact(manifold, new Vector3d(maxX, y, minZ), normal, depth);`
21	`178`	`AddCuboidContact(manifold, new Vector3d(maxX, y, maxZ), normal, depth);`
21	`179`	`break;`
	`180`	`}`
	`181`	`default:`
	`182`	`{`
2	`183`	`Fixed64 z = normal.Z > Fixed64.Zero ? cuboidA.BoundsMax.Z : cuboidA.BoundsMin.Z;`
2	`184`	`AddCuboidContact(manifold, new Vector3d(minX, minY, z), normal, depth);`
2	`185`	`AddCuboidContact(manifold, new Vector3d(minX, maxY, z), normal, depth);`
2	`186`	`AddCuboidContact(manifold, new Vector3d(maxX, minY, z), normal, depth);`
2	`187`	`AddCuboidContact(manifold, new Vector3d(maxX, maxY, z), normal, depth);`
	`188`	`break;`
	`189`	`}`
	`190`	`}`
2	`191`	`}`
	`192`
	`193`	`private static void AddCuboidContact(ContactManifold manifold, Vector3d pointA, Vector3d normal, Fixed64 depth)`
	`194`	`{`
956	`195`	`Vector3d pointB = pointA - normal * depth;`
956	`196`	`manifold.AddContact(pointA, pointB, depth, normal);`
956	`197`	`}`
	`198`
	`199`	`#endregion`
	`200`
	`201`	`}`

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/CollisionDetection.Cylinder.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// CollisionDetection.Cylinder.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2026–present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`using FixedMathSharp;`
	`9`	`using FixedMathSharp.Geometry;`
	`10`	`using Gravitas.Colliders;`
	`11`	`using System;`
	`12`	`using System.Runtime.CompilerServices;`
	`13`
	`14`	`namespace Gravitas.CollisionHandling;`
	`15`
	`16`	`public static partial class CollisionDetection`
	`17`	`{`
	`18`	`#region Cylinder`
	`19`
	`20`	`private static bool DoCylinderSphereCheck(CollisionWorkItem pair)`
	`21`	`{`
217	`22`	`var cylinder = (LSCylinderCollider)pair.ColliderA;`
217	`23`	`var sphere = (LSSphereCollider)pair.ColliderB;`
	`24`
217	`25`	`if (!FixedSegment.TryGetClosestCenteredFiniteCylinderSurfaceAnchor(`
217	`26`	`sphere.Center,`
217	`27`	`cylinder.Center,`
217	`28`	`cylinder.Rotation,`
217	`29`	`Vector3d.Up,`
217	`30`	`cylinder.Height,`
217	`31`	`cylinder.ScaledRadius,`
217	`32`	`Vector3d.Right,`
217	`33`	`out FixedPointAnchor cylinderAnchor,`
217	`34`	`out Vector3d outwardNormal,`
217	`35`	`out Fixed64 signedDistance))`
	`36`	`{`
1	`37`	`return false;`
	`38`	`}`
216	`39`	`if (signedDistance > sphere.ScaledRadius)`
1	`40`	`return false;`
	`41`
215	`42`	`Vector3d normal = signedDistance < Fixed64.Zero`
215	`43`	`? -outwardNormal`
215	`44`	`: outwardNormal;`
215	`45`	`ResolvePenetrationDepth(`
215	`46`	`sphere.ScaledRadius,`
215	`47`	`signedDistance,`
215	`48`	`out Fixed64 penetrationDepth,`
215	`49`	`out bool depthIsClamped);`
215	`50`	`pair.Manifold.SetContact(`
215	`51`	`new ContactAnchor(cylinderAnchor),`
215	`52`	`new ContactAnchor(`
215	`53`	`FixedSegment.GetCenteredCapsuleSupportAnchor(`
215	`54`	`sphere.Center,`
215	`55`	`sphere.Rotation,`
215	`56`	`Fixed64.Zero,`
215	`57`	`sphere.ScaledRadius,`
215	`58`	`-normal)),`
215	`59`	`penetrationDepth,`
215	`60`	`normal,`
215	`61`	`depthIsClamped);`
	`62`
215	`63`	`return true;`
	`64`	`}`
	`65`
	`66`	`private static bool DoCylinderCapsuleCheck(CollisionWorkItem pair)`
	`67`	`{`
	`68`	`LSCylinderCollider cylinder;`
	`69`	`LSCapsuleCollider capsule;`
214	`70`	`if (pair.ColliderA is LSCylinderCollider cylinderA)`
	`71`	`{`
213	`72`	`cylinder = cylinderA;`
213	`73`	`capsule = (LSCapsuleCollider)pair.ColliderB;`
	`74`	`}`
	`75`	`else`
	`76`	`{`
1	`77`	`cylinder = (LSCylinderCollider)pair.ColliderB;`
1	`78`	`capsule = (LSCapsuleCollider)pair.ColliderA;`
	`79`	`}`
	`80`
214	`81`	`if (!FixedSegment.TryGetCenteredFiniteCylinderCapsuleContact(`
214	`82`	`cylinder.Center,`
214	`83`	`cylinder.Rotation,`
214	`84`	`Vector3d.Up,`
214	`85`	`cylinder.Height,`
214	`86`	`cylinder.ScaledRadius,`
214	`87`	`capsule.Center,`
214	`88`	`capsule.Rotation,`
214	`89`	`Vector3d.Up,`
214	`90`	`capsule.AxisLength,`
214	`91`	`capsule.ScaledRadius,`
214	`92`	`out FixedContactAnchors contact))`
	`93`	`{`
4	`94`	`return false;`
	`95`	`}`
	`96`
210	`97`	`SetContactInPairOrder(`
210	`98`	`pair,`
210	`99`	`cylinder,`
210	`100`	`new ContactAnchor(contact.FirstAnchor),`
210	`101`	`capsule,`
210	`102`	`new ContactAnchor(contact.SecondAnchor),`
210	`103`	`contact.Depth,`
210	`104`	`contact.Normal,`
210	`105`	`contact.DepthIsClamped);`
	`106`
210	`107`	`return true;`
	`108`	`}`
	`109`
	`110`	`private static bool DoCylindersCheck(CollisionWorkItem pair)`
	`111`	`{`
216	`112`	`var cylinderA = (LSCylinderCollider)pair.ColliderA;`
216	`113`	`var cylinderB = (LSCylinderCollider)pair.ColliderB;`
	`114`
216	`115`	`if (!FixedSegment.TryGetCenteredFiniteCylindersContact(`
216	`116`	`cylinderA.Center,`
216	`117`	`cylinderA.Rotation,`
216	`118`	`Vector3d.Up,`
216	`119`	`cylinderA.Height,`
216	`120`	`cylinderA.ScaledRadius,`
216	`121`	`cylinderB.Center,`
216	`122`	`cylinderB.Rotation,`
216	`123`	`Vector3d.Up,`
216	`124`	`cylinderB.Height,`
216	`125`	`cylinderB.ScaledRadius,`
216	`126`	`out FixedContactAnchors contact))`
	`127`	`{`
4	`128`	`return false;`
	`129`	`}`
	`130`
212	`131`	`if (TryAddCylinderCylinderCapContacts(`
212	`132`	`pair,`
212	`133`	`cylinderA,`
212	`134`	`cylinderB,`
212	`135`	`contact))`
	`136`	`{`
3	`137`	`return true;`
	`138`	`}`
	`139`
209	`140`	`pair.Manifold.SetContact(`
209	`141`	`new ContactAnchor(contact.FirstAnchor),`
209	`142`	`new ContactAnchor(contact.SecondAnchor),`
209	`143`	`contact.Depth,`
209	`144`	`contact.Normal,`
209	`145`	`contact.DepthIsClamped);`
	`146`
209	`147`	`return true;`
	`148`	`}`
	`149`
	`150`	`private static bool DoCuboidCylinderCheck(CollisionWorkItem pair)`
	`151`	`{`
9	`152`	`var cuboid = (LSCuboidCollider)pair.ColliderA;`
9	`153`	`var cylinder = (LSCylinderCollider)pair.ColliderB;`
	`154`
9	`155`	`Span<FixedContactLocalPoints> capFaceContacts =`
9	`156`	`stackalloc FixedContactLocalPoints[ContactManifold.MaxContactCount];`
9	`157`	`if (!cuboid.OrientedBox.TryGetCenteredCylinderContact(`
9	`158`	`cylinder.Center,`
9	`159`	`cylinder.Rotation,`
9	`160`	`Vector3d.Up,`
9	`161`	`cylinder.Height,`
9	`162`	`cylinder.ScaledRadius,`
9	`163`	`capFaceContacts,`
9	`164`	`out FixedContactAnchors contact,`
9	`165`	`out int capFaceContactCount))`
	`166`	`{`
4	`167`	`return false;`
	`168`	`}`
	`169`
5	`170`	`if (capFaceContactCount > 0)`
	`171`	`{`
10	`172`	`for (int index = 0; index < capFaceContactCount; index++)`
	`173`	`{`
4	`174`	`FixedContactLocalPoints capContact = capFaceContacts[index];`
4	`175`	`pair.Manifold.AddContact(`
4	`176`	`new ContactAnchor(`
4	`177`	`contact.FirstAnchor.Origin,`
4	`178`	`contact.FirstAnchor.Rotation,`
4	`179`	`capContact.FirstLocalPoint),`
4	`180`	`new ContactAnchor(`
4	`181`	`contact.SecondAnchor.Origin,`
4	`182`	`contact.SecondAnchor.Rotation,`
4	`183`	`capContact.SecondLocalPoint),`
4	`184`	`contact.Depth,`
4	`185`	`contact.Normal,`
4	`186`	`contact.DepthIsClamped);`
	`187`	`}`
1	`188`	`return true;`
	`189`	`}`
	`190`
4	`191`	`pair.Manifold.SetContact(`
4	`192`	`new ContactAnchor(contact.FirstAnchor),`
4	`193`	`new ContactAnchor(contact.SecondAnchor),`
4	`194`	`contact.Depth,`
4	`195`	`contact.Normal,`
4	`196`	`contact.DepthIsClamped);`
4	`197`	`return true;`
	`198`	`}`
	`199`
	`200`	`private static bool TryAddCylinderCylinderCapContacts(`
	`201`	`CollisionWorkItem pair,`
	`202`	`LSCylinderCollider cylinderA,`
	`203`	`LSCylinderCollider cylinderB,`
	`204`	`FixedContactAnchors contact)`
	`205`	`{`
212	`206`	`if (contact.FirstAnchor.LocalDisplacement != Vector3d.Zero`
212	`207`	`\|\| contact.SecondAnchor.LocalDisplacement != Vector3d.Zero)`
	`208`	`{`
209	`209`	`return false;`
	`210`	`}`
	`211`
3	`212`	`CylinderContactGeometry.GetCapBasis(cylinderA, out Vector3d tangentA, out Vector3d tangentB);`
3	`213`	`int initialCount = pair.Manifold.Count;`
3	`214`	`TryAddCylinderCylinderCapContact(pair, cylinderA, cylinderB, tangentA, contact);`
3	`215`	`TryAddCylinderCylinderCapContact(pair, cylinderA, cylinderB, -tangentA, contact);`
3	`216`	`TryAddCylinderCylinderCapContact(pair, cylinderA, cylinderB, tangentB, contact);`
3	`217`	`TryAddCylinderCylinderCapContact(pair, cylinderA, cylinderB, -tangentB, contact);`
3	`218`	`return pair.Manifold.Count > initialCount;`
	`219`	`}`
	`220`
	`221`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`222`	`private static void TryAddCylinderCylinderCapContact(`
	`223`	`CollisionWorkItem pair,`
	`224`	`LSCylinderCollider cylinderA,`
	`225`	`LSCylinderCollider cylinderB,`
	`226`	`Vector3d radialDirection,`
	`227`	`FixedContactAnchors contact)`
	`228`	`{`
12	`229`	`pair.Manifold.AddContact(`
12	`230`	`new ContactAnchor(ConvexColliderSupport.GetSupportAnchor(`
12	`231`	`cylinderA,`
12	`232`	`contact.Normal + radialDirection,`
12	`233`	`Vector3d.Zero)),`
12	`234`	`new ContactAnchor(ConvexColliderSupport.GetSupportAnchor(`
12	`235`	`cylinderB,`
12	`236`	`-contact.Normal + radialDirection,`
12	`237`	`Vector3d.Zero)),`
12	`238`	`contact.Depth,`
12	`239`	`contact.Normal,`
12	`240`	`contact.DepthIsClamped);`
12	`241`	`}`
	`242`
	`243`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`244`	`private static void ResolvePenetrationDepth(`
	`245`	`Fixed64 radius,`
	`246`	`Fixed64 signedDistance,`
	`247`	`out Fixed64 depth,`
	`248`	`out bool depthIsClamped)`
	`249`	`{`
220	`250`	`if (Fixed64.TrySubtract(radius, signedDistance, out depth))`
	`251`	`{`
219	`252`	`depthIsClamped = false;`
219	`253`	`return;`
	`254`	`}`
	`255`
1	`256`	`depth = Fixed64.MaxValue;`
1	`257`	`depthIsClamped = true;`
1	`258`	`}`
	`259`
	`260`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`261`	`private static Vector3d ResolveNormal(Vector3d delta) =>`
12	`262`	`delta.MagnitudeSquared > Fixed64.Epsilon`
12	`263`	`? delta.Normalized`
12	`264`	`: Vector3d.Right;`
	`265`
	`266`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`267`	`private static void SetContactInPairOrder(`
	`268`	`CollisionWorkItem pair,`
	`269`	`LSCollider first,`
	`270`	`ContactAnchor anchorOnFirst,`
	`271`	`LSCollider second,`
	`272`	`ContactAnchor anchorOnSecond,`
	`273`	`Fixed64 depth,`
	`274`	`Vector3d normalFirstToSecond,`
	`275`	`bool depthIsClamped)`
	`276`	`{`
220	`277`	`if (ReferenceEquals(pair.ColliderA, first))`
	`278`	`{`
214	`279`	`pair.Manifold.SetContact(`
214	`280`	`anchorOnFirst,`
214	`281`	`anchorOnSecond,`
214	`282`	`depth,`
214	`283`	`normalFirstToSecond,`
214	`284`	`depthIsClamped);`
214	`285`	`return;`
	`286`	`}`
	`287`
6	`288`	`pair.Manifold.SetContact(`
6	`289`	`anchorOnSecond,`
6	`290`	`anchorOnFirst,`
6	`291`	`depth,`
6	`292`	`-normalFirstToSecond,`
6	`293`	`depthIsClamped);`
6	`294`	`}`
	`295`
	`296`	`#endregion`
	`297`
	`298`	`}`

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/CollisionDetection.Mesh.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// CollisionDetection.Mesh.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2026–present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`using FixedMathSharp;`
	`9`	`using FixedMathSharp.Geometry;`
	`10`	`using Gravitas.Colliders;`
	`11`
	`12`	`namespace Gravitas.CollisionHandling;`
	`13`
	`14`	`public static partial class CollisionDetection`
	`15`	`{`
	`16`	`#region Mesh`
	`17`
	`18`	`private static bool DoMeshSphereCheck(CollisionWorkItem pair)`
	`19`	`{`
12	`20`	`var meshCollider = (LSMeshCollider)pair.ColliderA;`
12	`21`	`var sphere = (LSSphereCollider)pair.ColliderB;`
	`22`
12	`23`	`return MeshTriangleContactGenerator.TryBuildMeshSphereManifold(`
12	`24`	`pair,`
12	`25`	`meshCollider,`
12	`26`	`sphere,`
12	`27`	`pair.Context.CollisionScratch.MeshTriangleCandidatesA);`
	`28`	`}`
	`29`
	`30`	`private static bool DoMeshCapsuleCheck(CollisionWorkItem pair)`
	`31`	`{`
223	`32`	`var mesh = (LSMeshCollider)pair.ColliderA;`
223	`33`	`var capsule = (LSCapsuleCollider)pair.ColliderB;`
	`34`
223	`35`	`if (mesh.Mode == MeshColliderMode.Convex)`
	`36`	`{`
218	`37`	`PhysicsMesh physicsMesh = mesh.Mesh;`
218	`38`	`bool hasContact =`
218	`39`	`FixedConvexHullRelations`
218	`40`	`.TryGetCenteredCapsuleContact(`
218	`41`	`physicsMesh.Origin,`
218	`42`	`physicsMesh.Rotation,`
218	`43`	`physicsMesh.ScaledLocalVertices,`
218	`44`	`physicsMesh.Triangles,`
218	`45`	`physicsMesh.ConvexSatEdgeVertexPairs,`
218	`46`	`capsule.Center,`
218	`47`	`capsule.Rotation,`
218	`48`	`Vector3d.Up,`
218	`49`	`capsule.AxisLength,`
218	`50`	`capsule.ScaledRadius,`
218	`51`	`out FixedContactAnchors contact);`
218	`52`	`if (!hasContact)`
3	`53`	`return false;`
215	`54`	`pair.Manifold.SetContact(`
215	`55`	`new ContactAnchor(contact.FirstAnchor),`
215	`56`	`new ContactAnchor(contact.SecondAnchor),`
215	`57`	`contact.Depth,`
215	`58`	`contact.Normal,`
215	`59`	`contact.DepthIsClamped);`
215	`60`	`return true;`
	`61`	`}`
	`62`
5	`63`	`return MeshTriangleContactGenerator.TryBuildMeshCapsuleManifold(`
5	`64`	`pair,`
5	`65`	`mesh,`
5	`66`	`capsule,`
5	`67`	`pair.Context.CollisionScratch.MeshTriangleCandidatesA);`
	`68`	`}`
	`69`
	`70`	`private static bool DoMeshCuboidCheck(CollisionWorkItem pair)`
	`71`	`{`
689	`72`	`var mesh = (LSMeshCollider)pair.ColliderA;`
689	`73`	`var cuboid = (LSCuboidCollider)pair.ColliderB;`
	`74`
689	`75`	`if (MeshTriangleContactGenerator.TryBuildMeshCuboidManifold(`
689	`76`	`pair,`
689	`77`	`mesh,`
689	`78`	`cuboid,`
689	`79`	`pair.Context.CollisionScratch.MeshTriangleCandidatesA))`
	`80`	`{`
434	`81`	`return true;`
	`82`	`}`
	`83`
255	`84`	`if (mesh.Mode == MeshColliderMode.Concave)`
2	`85`	`return false;`
	`86`
253	`87`	`PhysicsMesh physicsMesh = mesh.Mesh;`
253	`88`	`if (!cuboid.OrientedBox.TryGetConvexHullContact(`
253	`89`	`mesh.Center,`
253	`90`	`physicsMesh.Rotation,`
253	`91`	`physicsMesh.ScaledLocalVertices,`
253	`92`	`physicsMesh.Triangles,`
253	`93`	`physicsMesh.ConvexSatEdgeVertexPairs,`
253	`94`	`out FixedContactAnchors contact))`
	`95`	`{`
42	`96`	`return false;`
	`97`	`}`
	`98`
211	`99`	`pair.Manifold.SetContact(`
211	`100`	`new ContactAnchor(contact.SecondAnchor),`
211	`101`	`new ContactAnchor(contact.FirstAnchor),`
211	`102`	`contact.Depth,`
211	`103`	`-contact.Normal,`
211	`104`	`contact.DepthIsClamped);`
	`105`
211	`106`	`return true;`
	`107`	`}`
	`108`
	`109`	`private static bool DoMeshCylinderCheck(CollisionWorkItem pair)`
	`110`	`{`
428	`111`	`var mesh = (LSMeshCollider)pair.ColliderA;`
428	`112`	`var cylinder = (LSCylinderCollider)pair.ColliderB;`
	`113`
428	`114`	`return MeshTriangleContactGenerator.TryBuildMeshCylinderManifold(`
428	`115`	`pair,`
428	`116`	`mesh,`
428	`117`	`cylinder,`
428	`118`	`pair.Context.CollisionScratch.MeshTriangleCandidatesA);`
	`119`	`}`
	`120`
	`121`	`/// <summary>`
	`122`	`/// Checks if two mesh colliders intersect and sets the contact point if they do.`
	`123`	`/// </summary>`
	`124`	`/// <param name="pair">The pair of colliders to test for collision.</param>`
	`125`	`/// <returns>true if the colliders intersect; otherwise, false.</returns>`
	`126`	`private static bool DoMeshesCheck(CollisionWorkItem pair)`
	`127`	`{`
652	`128`	`var meshA = (LSMeshCollider)pair.ColliderA;`
652	`129`	`var meshB = (LSMeshCollider)pair.ColliderB;`
652	`130`	`if (meshA.Mode == MeshColliderMode.Concave`
652	`131`	`\|\| meshB.Mode == MeshColliderMode.Concave)`
	`132`	`{`
645	`133`	`return MeshTriangleContactGenerator.TryBuildMeshMeshManifold(`
645	`134`	`pair,`
645	`135`	`meshA,`
645	`136`	`meshB,`
645	`137`	`pair.Context.CollisionScratch.MeshTriangleCandidatesA,`
645	`138`	`pair.Context.CollisionScratch.MeshTriangleCandidatesB);`
	`139`	`}`
	`140`
7	`141`	`PhysicsMesh physicsMeshA = meshA.Mesh;`
7	`142`	`PhysicsMesh physicsMeshB = meshB.Mesh;`
7	`143`	`bool hasContact = FixedConvexHullRelations.TryGetContact(`
7	`144`	`meshA.Center,`
7	`145`	`physicsMeshA.Rotation,`
7	`146`	`physicsMeshA.ScaledLocalVertices,`
7	`147`	`physicsMeshA.Triangles,`
7	`148`	`physicsMeshA.ConvexSatEdgeVertexPairs,`
7	`149`	`meshB.Center,`
7	`150`	`physicsMeshB.Rotation,`
7	`151`	`physicsMeshB.ScaledLocalVertices,`
7	`152`	`physicsMeshB.Triangles,`
7	`153`	`physicsMeshB.ConvexSatEdgeVertexPairs,`
7	`154`	`out FixedContactAnchors contact);`
7	`155`	`if (!hasContact)`
4	`156`	`return false;`
3	`157`	`if (contact.Depth <= Fixed64.Zero)`
1	`158`	`return false;`
	`159`
2	`160`	`pair.Manifold.SetContact(`
2	`161`	`new ContactAnchor(contact.FirstAnchor),`
2	`162`	`new ContactAnchor(contact.SecondAnchor),`
2	`163`	`contact.Depth,`
2	`164`	`contact.Normal,`
2	`165`	`contact.DepthIsClamped);`
	`166`
2	`167`	`return true;`
	`168`	`}`
	`169`
	`170`	`#endregion`
	`171`	`}`

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/CollisionDetection.Sphere.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// CollisionDetection.Sphere.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2026–present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`using FixedMathSharp;`
	`9`	`using FixedMathSharp.Geometry;`
	`10`
	`11`	`namespace Gravitas.CollisionHandling;`
	`12`
	`13`	`public static partial class CollisionDetection`
	`14`	`{`
	`15`	`#region Sphere`
	`16`
	`17`	`private static bool DoSpheresCheck(CollisionWorkItem pair)`
	`18`	`{`
1072	`19`	`if (!FixedSegment.TryGetCenteredCapsulesContact(`
1072	`20`	`pair.ColliderA.Center,`
1072	`21`	`pair.ColliderA.Rotation,`
1072	`22`	`Vector3d.Up,`
1072	`23`	`Fixed64.Zero,`
1072	`24`	`pair.ColliderA.ScaledRadius,`
1072	`25`	`pair.ColliderB.Center,`
1072	`26`	`pair.ColliderB.Rotation,`
1072	`27`	`Vector3d.Up,`
1072	`28`	`Fixed64.Zero,`
1072	`29`	`pair.ColliderB.ScaledRadius,`
1072	`30`	`ResolveCenteredCapsuleFallback(pair.ColliderA.Center, pair.ColliderB.Center),`
1072	`31`	`out FixedContactAnchors contact))`
	`32`	`{`
15	`33`	`return false;`
	`34`	`}`
	`35`
1057	`36`	`pair.Manifold.SetContact(`
1057	`37`	`new ContactAnchor(contact.FirstAnchor),`
1057	`38`	`new ContactAnchor(contact.SecondAnchor),`
1057	`39`	`contact.Depth,`
1057	`40`	`contact.Normal,`
1057	`41`	`contact.DepthIsClamped);`
1057	`42`	`return true;`
	`43`	`}`
	`44`
	`45`	`#endregion`
	`46`
	`47`	`}`

Methods/Properties