< Summary

Information

Class:	Gravitas.Diagnostics.GravitasDiagnosticSink
Assembly:	Gravitas
File(s):	File 1: /home/runner/work/Gravitas/Gravitas/src/Gravitas/Diagnostics/GravitasDiagnosticSink.cs File 2: /home/runner/work/Gravitas/Gravitas/src/Gravitas/Diagnostics/GravitasDiagnosticSink.Draw.cs

Line coverage

100%

Covered lines:	904
Uncovered lines:	0
Coverable lines:	904
Total lines:	1385
Line coverage:	100%

Branch coverage

100%

Covered branches:	206
Total branches:	206
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: .ctor(...)	100%	1	1	100%
File 1: get_Events()	100%	1	1	100%
File 1: get_DrawCommands()	100%	1	1	100%
File 1: DispatchEventsTo(...)	100%	4	4	100%
File 1: DispatchDrawCommandsTo(...)	100%	4	4	100%
File 1: get_EventCount()	100%	1	1	100%
File 1: get_DrawCommandCount()	100%	1	1	100%
File 1: get_EventCapacity()	100%	1	1	100%
File 1: get_DrawCommandCapacity()	100%	1	1	100%
File 1: Enable(...)	100%	4	4	100%
File 1: Disable()	100%	1	1	100%
File 1: Clear()	100%	1	1	100%
File 1: Reset()	100%	1	1	100%
File 1: EmitForceDelta(...)	100%	2	2	100%
File 1: EmitTorqueDelta(...)	100%	2	2	100%
File 1: EmitLinearVelocityDelta(...)	100%	2	2	100%
File 1: EmitAngularVelocityDelta(...)	100%	2	2	100%
File 1: EmitGroundProbe(...)	100%	8	8	100%
File 1: EmitGroundProbe(...)	100%	8	8	100%
File 1: EmitRayQuery(...)	100%	8	8	100%
File 1: EmitCircleQuery(...)	100%	8	8	100%
File 1: EmitQuerySummary(...)	100%	2	2	100%
File 1: EmitContact(...)	100%	8	8	100%
File 1: EmitResponseImpulse(...)	100%	2	2	100%
File 1: EmitMixedQuery(...)	100%	18	18	100%
File 1: EmitMixedContact(...)	100%	2	2	100%
File 1: EmitMixedResponseImpulse(...)	100%	2	2	100%
File 1: EmitMixedResponseIsland(...)	100%	2	2	100%
File 1: EmitJointRegistered(...)	100%	2	2	100%
File 1: EmitJointRegistered(...)	100%	2	2	100%
File 1: EmitJointRemoved(...)	100%	2	2	100%
File 1: EmitJointRemoved(...)	100%	2	2	100%
File 1: EmitJointImpulse(...)	100%	2	2	100%
File 1: EmitJointImpulse(...)	100%	2	2	100%
File 1: EmitJointLimitReached(...)	100%	2	2	100%
File 1: EmitJointLimitReached(...)	100%	2	2	100%
File 1: EmitRagdollActivated(...)	100%	2	2	100%
File 1: AddEvent(...)	100%	1	1	100%
File 1: AddDrawCommand(...)	100%	1	1	100%
File 1: ResolveDimension(...)	100%	4	4	100%
File 1: ToDiagnosticVector(...)	100%	1	1	100%
File 2: CaptureCollider(...)	100%	16	16	100%
File 2: CaptureMixedCollider(...)	100%	10	10	100%
File 2: CaptureJoint(...)	100%	6	6	100%
File 2: CaptureJoint(...)	100%	4	4	100%
File 2: CaptureLine(...)	100%	2	2	100%
File 2: CaptureRay(...)	100%	4	4	100%
File 2: CapturePoint(...)	100%	2	2	100%
File 2: CaptureMeshTriangles(...)	100%	4	4	100%
File 2: CaptureJointAxis(...)	100%	1	1	100%
File 2: CaptureCompoundParts(...)	100%	14	14	100%
File 2: CaptureCompoundMeshTriangles(...)	100%	4	4	100%
File 2: CaptureMixedCompoundParts(...)	100%	8	8	100%
File 2: CaptureMixedCapsule(...)	100%	10	10	100%
File 2: CaptureMixedPolygon(...)	100%	1	1	100%
File 2: CaptureMixedPolygon(...)	100%	12	12	100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Diagnostics/GravitasDiagnosticSink.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// GravitasDiagnosticSink.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 Gravitas.Colliders;`
	`10`	`using Gravitas.CollisionHandling;`
	`11`	`using Gravitas.Constraints;`
	`12`	`using Gravitas.Queries;`
	`13`	`using SwiftCollections;`
	`14`	`using System;`
	`15`
	`16`	`namespace Gravitas.Diagnostics;`
	`17`
	`18`	`/// <summary>`
	`19`	`/// Context-owned deterministic diagnostics buffer for physics events and debug draw commands.`
	`20`	`/// </summary>`
	`21`	`public sealed partial class GravitasDiagnosticSink`
	`22`	`{`
	`23`	`private readonly GravitasWorldContext _context;`
5083	`24`	`private readonly SwiftList<GravitasDiagnosticEvent> _events = new();`
5083	`25`	`private readonly SwiftList<GravitasDebugDrawCommand> _drawCommands = new();`
	`26`	`private int _eventSequence;`
	`27`	`private int _drawSequence;`
	`28`
5083	`29`	`internal GravitasDiagnosticSink(GravitasWorldContext context)`
	`30`	`{`
5083	`31`	`SwiftThrowHelper.ThrowIfNull(context, nameof(context));`
5083	`32`	`_context = context;`
5083	`33`	`}`
	`34`
	`35`	`/// <summary>`
	`36`	`/// Gets whether this sink records events and draw commands.`
	`37`	`/// </summary>`
	`38`	`public bool Enabled { get; private set; }`
	`39`
	`40`	`/// <summary>`
	`41`	`/// Gets captured diagnostic events for this context.`
	`42`	`/// </summary>`
58	`43`	`public ReadOnlySpan<GravitasDiagnosticEvent> Events => _events.AsReadOnlySpan();`
	`44`
	`45`	`/// <summary>`
	`46`	`/// Gets captured engine-agnostic draw commands for this context.`
	`47`	`/// </summary>`
45	`48`	`public ReadOnlySpan<GravitasDebugDrawCommand> DrawCommands => _drawCommands.AsReadOnlySpan();`
	`49`
	`50`	`/// <summary>`
	`51`	`/// Dispatches captured events in buffer order to a typed diagnostic visitor.`
	`52`	`/// </summary>`
	`53`	`public void DispatchEventsTo(GravitasDiagnosticEventVisitor visitor)`
	`54`	`{`
2	`55`	`if (visitor == null)`
1	`56`	`throw new ArgumentNullException(nameof(visitor));`
	`57`
1	`58`	`ReadOnlySpan<GravitasDiagnosticEvent> events = Events;`
6	`59`	`for (int i = 0; i < events.Length; i++)`
2	`60`	`events[i].DispatchTo(visitor);`
1	`61`	`}`
	`62`
	`63`	`/// <summary>`
	`64`	`/// Dispatches captured draw commands in buffer order to a typed debug draw visitor.`
	`65`	`/// </summary>`
	`66`	`public void DispatchDrawCommandsTo(GravitasDebugDrawCommandVisitor visitor)`
	`67`	`{`
2	`68`	`if (visitor == null)`
1	`69`	`throw new ArgumentNullException(nameof(visitor));`
	`70`
1	`71`	`ReadOnlySpan<GravitasDebugDrawCommand> commands = DrawCommands;`
6	`72`	`for (int i = 0; i < commands.Length; i++)`
2	`73`	`commands[i].DispatchTo(visitor);`
1	`74`	`}`
	`75`
	`76`	`/// <summary>Gets the number of captured diagnostic events.</summary>`
13	`77`	`public int EventCount => _events.Count;`
	`78`
	`79`	`/// <summary>Gets the number of captured debug draw commands.</summary>`
8	`80`	`public int DrawCommandCount => _drawCommands.Count;`
	`81`
3	`82`	`internal int EventCapacity => _events.Capacity;`
	`83`
4	`84`	`internal int DrawCommandCapacity => _drawCommands.Capacity;`
	`85`
	`86`	`/// <summary>`
	`87`	`/// Enables diagnostics and optionally reserves buffer capacity for hot-path capture.`
	`88`	`/// </summary>`
	`89`	`public void Enable(int eventCapacity = 128, int drawCommandCapacity = 128)`
	`90`	`{`
76	`91`	`Enabled = true;`
76	`92`	`if (eventCapacity > 0)`
54	`93`	`_events.EnsureCapacity(eventCapacity);`
76	`94`	`if (drawCommandCapacity > 0)`
34	`95`	`_drawCommands.EnsureCapacity(drawCommandCapacity);`
76	`96`	`}`
	`97`
	`98`	`/// <summary>`
	`99`	`/// Disables diagnostics and clears captured data.`
	`100`	`/// </summary>`
	`101`	`public void Disable()`
	`102`	`{`
1	`103`	`Enabled = false;`
1	`104`	`Clear();`
1	`105`	`}`
	`106`
	`107`	`/// <summary>`
	`108`	`/// Clears captured data while retaining allocated buffer capacity.`
	`109`	`/// </summary>`
	`110`	`public void Clear()`
	`111`	`{`
42	`112`	`_events.FastClear();`
42	`113`	`_drawCommands.FastClear();`
42	`114`	`_eventSequence = 0;`
42	`115`	`_drawSequence = 0;`
42	`116`	`}`
	`117`
31	`118`	`internal void Reset() => Clear();`
	`119`
	`120`	`internal void EmitForceDelta(SolidBody body, Vector3d force, Vector3d accelerationDelta)`
	`121`	`{`
311	`122`	`if (!Enabled)`
307	`123`	`return;`
	`124`
4	`125`	`AddEvent(`
4	`126`	`GravitasDiagnosticEventKind.ForceDelta,`
4	`127`	`bodyId: body.DynamicId,`
4	`128`	`colliderAId: body.Collider.Id,`
4	`129`	`colliderAType: body.Collider.Shape,`
4	`130`	`vector: force,`
4	`131`	`pointA: accelerationDelta,`
4	`132`	`scalarA: force.Magnitude);`
4	`133`	`}`
	`134`
	`135`	`internal void EmitTorqueDelta(SolidBody body, Vector3d torque)`
	`136`	`{`
102	`137`	`if (!Enabled)`
98	`138`	`return;`
	`139`
4	`140`	`AddEvent(`
4	`141`	`GravitasDiagnosticEventKind.TorqueDelta,`
4	`142`	`bodyId: body.DynamicId,`
4	`143`	`colliderAId: body.Collider.Id,`
4	`144`	`colliderAType: body.Collider.Shape,`
4	`145`	`vector: torque,`
4	`146`	`scalarA: torque.Magnitude);`
4	`147`	`}`
	`148`
	`149`	`internal void EmitLinearVelocityDelta(SolidBody body, Vector3d before, Vector3d after)`
	`150`	`{`
247812	`151`	`if (!Enabled)`
247687	`152`	`return;`
	`153`
125	`154`	`AddEvent(`
125	`155`	`GravitasDiagnosticEventKind.LinearVelocityDelta,`
125	`156`	`bodyId: body.DynamicId,`
125	`157`	`colliderAId: body.Collider.Id,`
125	`158`	`colliderAType: body.Collider.Shape,`
125	`159`	`start: before,`
125	`160`	`end: after,`
125	`161`	`vector: after - before,`
125	`162`	`scalarA: after.Magnitude);`
125	`163`	`}`
	`164`
	`165`	`internal void EmitAngularVelocityDelta(SolidBody body, Vector3d before, Vector3d after)`
	`166`	`{`
240863	`167`	`if (!Enabled)`
240076	`168`	`return;`
	`169`
787	`170`	`AddEvent(`
787	`171`	`GravitasDiagnosticEventKind.AngularVelocityDelta,`
787	`172`	`bodyId: body.DynamicId,`
787	`173`	`colliderAId: body.Collider.Id,`
787	`174`	`colliderAType: body.Collider.Shape,`
787	`175`	`start: before,`
787	`176`	`end: after,`
787	`177`	`vector: after - before,`
787	`178`	`scalarA: after.Magnitude);`
787	`179`	`}`
	`180`
	`181`	`internal void EmitGroundProbe(`
	`182`	`SolidBody body,`
	`183`	`GroundProbeMode mode,`
	`184`	`Vector3d origin,`
	`185`	`Vector3d end,`
	`186`	`Fixed64 radius,`
	`187`	`bool hit,`
	`188`	`Physics3DHit raycastHit)`
	`189`	`{`
8760	`190`	`if (!Enabled)`
8728	`191`	`return;`
	`192`
32	`193`	`Vector3d point = default;`
32	`194`	`bool hasPoint = hit && raycastHit.TryGetPoint(out point);`
32	`195`	`AddEvent(`
32	`196`	`GravitasDiagnosticEventKind.GroundProbe,`
32	`197`	`bodyId: body.DynamicId,`
32	`198`	`colliderAId: body.Collider.Id,`
32	`199`	`colliderBId: raycastHit.Collider?.Id ?? -1,`
32	`200`	`colliderAType: body.Collider.Shape,`
32	`201`	`colliderBType: raycastHit.Collider?.Shape ?? ColliderType.None,`
32	`202`	`start: origin,`
32	`203`	`end: end,`
32	`204`	`pointA: point,`
32	`205`	`hasPointA: hasPoint,`
32	`206`	`vector: raycastHit.Normal,`
32	`207`	`scalarA: radius,`
32	`208`	`scalarB: raycastHit.Distance,`
32	`209`	`dataA: (int)mode,`
32	`210`	`hit: hit);`
32	`211`	`}`
	`212`
	`213`	`internal void EmitGroundProbe(`
	`214`	`SolidBody2D body,`
	`215`	`GroundProbeMode2D mode,`
	`216`	`Vector2d start,`
	`217`	`Vector2d end,`
	`218`	`Fixed64 radius,`
	`219`	`bool hit,`
	`220`	`Physics2DHit raycastHit)`
	`221`	`{`
5233	`222`	`if (!Enabled)`
5195	`223`	`return;`
	`224`
38	`225`	`AddEvent(`
38	`226`	`GravitasDiagnosticEventKind.GroundProbe,`
38	`227`	`bodyId: body.DynamicId,`
38	`228`	`colliderAId: body.Collider.Id,`
38	`229`	`colliderBId: raycastHit.Collider?.Id ?? -1,`
38	`230`	`colliderADimension: GravitasColliderDimension.TwoD,`
38	`231`	`colliderBDimension: raycastHit.Collider == null ? GravitasColliderDimension.None : GravitasColliderDimension`
38	`232`	`colliderA2DType: body.Collider.Shape,`
38	`233`	`colliderB2DType: raycastHit.Collider?.Shape ?? ColliderType2D.None,`
38	`234`	`start: ToDiagnosticVector(start),`
38	`235`	`end: ToDiagnosticVector(end),`
38	`236`	`pointA: ToDiagnosticVector(raycastHit.Point),`
38	`237`	`hasPointA: hit,`
38	`238`	`vector: ToDiagnosticVector(raycastHit.Normal),`
38	`239`	`scalarA: radius,`
38	`240`	`scalarB: raycastHit.Distance,`
38	`241`	`dataA: (int)mode,`
38	`242`	`dataB: (int)GravitasColliderDimension.TwoD,`
38	`243`	`hit: hit);`
38	`244`	`}`
	`245`
	`246`	`internal void EmitRayQuery(`
	`247`	`Vector3d start,`
	`248`	`Vector3d end,`
	`249`	`Fixed64 radius,`
	`250`	`int layerMaskBits,`
	`251`	`bool hit,`
	`252`	`int hitCount,`
	`253`	`Physics3DHit raycastHit)`
	`254`	`{`
15779	`255`	`if (!Enabled)`
15747	`256`	`return;`
	`257`
32	`258`	`Vector3d point = default;`
32	`259`	`bool hasPoint = hit && raycastHit.TryGetPoint(out point);`
32	`260`	`AddEvent(`
32	`261`	`GravitasDiagnosticEventKind.RayQuery,`
32	`262`	`colliderAId: raycastHit.Collider?.Id ?? -1,`
32	`263`	`colliderAType: raycastHit.Collider?.Shape ?? ColliderType.None,`
32	`264`	`start: start,`
32	`265`	`end: end,`
32	`266`	`pointA: point,`
32	`267`	`hasPointA: hasPoint,`
32	`268`	`vector: raycastHit.Normal,`
32	`269`	`scalarA: radius,`
32	`270`	`scalarB: raycastHit.Distance,`
32	`271`	`dataA: layerMaskBits,`
32	`272`	`dataB: hitCount,`
32	`273`	`hit: hit);`
32	`274`	`}`
	`275`
	`276`	`internal void EmitCircleQuery(`
	`277`	`Vector3d center,`
	`278`	`Fixed64 radius,`
	`279`	`Vector3d direction,`
	`280`	`Fixed64 maxDistance,`
	`281`	`int layerMaskBits,`
	`282`	`bool hit,`
	`283`	`int hitCount,`
	`284`	`Physics3DHit raycastHit)`
	`285`	`{`
35	`286`	`if (!Enabled)`
31	`287`	`return;`
	`288`
4	`289`	`Vector3d point = default;`
4	`290`	`bool hasPoint = hit && raycastHit.TryGetPoint(out point);`
4	`291`	`AddEvent(`
4	`292`	`GravitasDiagnosticEventKind.CircleQuery,`
4	`293`	`colliderAId: raycastHit.Collider?.Id ?? -1,`
4	`294`	`colliderAType: raycastHit.Collider?.Shape ?? ColliderType.None,`
4	`295`	`start: center,`
4	`296`	`end: center + direction * maxDistance,`
4	`297`	`pointA: point,`
4	`298`	`hasPointA: hasPoint,`
4	`299`	`vector: direction,`
4	`300`	`scalarA: radius,`
4	`301`	`scalarB: raycastHit.Distance,`
4	`302`	`dataA: layerMaskBits,`
4	`303`	`dataB: hitCount,`
4	`304`	`hit: hit);`
4	`305`	`}`
	`306`
	`307`	`internal void EmitQuerySummary(`
	`308`	`GravitasColliderDimension sourceDimension,`
	`309`	`GravitasColliderDimension targetDimension,`
	`310`	`Vector3d start,`
	`311`	`Vector3d end,`
	`312`	`int exactReducerAttempts,`
	`313`	`int acceptedHits,`
	`314`	`int fallbackHits,`
	`315`	`int rejectedConservativeCandidates)`
	`316`	`{`
6	`317`	`AddEvent(`
6	`318`	`GravitasDiagnosticEventKind.QuerySummary,`
6	`319`	`colliderADimension: sourceDimension,`
6	`320`	`colliderBDimension: targetDimension,`
6	`321`	`start: start,`
6	`322`	`end: end,`
6	`323`	`scalarA: (Fixed64)fallbackHits,`
6	`324`	`scalarB: (Fixed64)rejectedConservativeCandidates,`
6	`325`	`dataA: exactReducerAttempts,`
6	`326`	`dataB: acceptedHits,`
6	`327`	`hit: fallbackHits > 0 \|\| rejectedConservativeCandidates > 0);`
6	`328`	`}`
	`329`
	`330`	`internal void EmitContact(CollisionPair pair, bool hit)`
	`331`	`{`
2489	`332`	`if (!Enabled)`
2472	`333`	`return;`
	`334`
17	`335`	`bool hasContact = pair.Manifold.HasContact;`
17	`336`	`ManifoldContact contact = hasContact`
17	`337`	`? pair.Manifold.PrimaryContact`
17	`338`	`: default;`
17	`339`	`Vector3d pointA = default;`
17	`340`	`Vector3d pointB = default;`
17	`341`	`bool hasPointA = hasContact && contact.TryGetPointA(out pointA);`
17	`342`	`bool hasPointB = hasContact && contact.TryGetPointB(out pointB);`
	`343`
17	`344`	`AddEvent(`
17	`345`	`GravitasDiagnosticEventKind.Contact,`
17	`346`	`colliderAId: pair.ColliderA.Id,`
17	`347`	`colliderBId: pair.ColliderB.Id,`
17	`348`	`colliderAType: pair.ColliderA.Shape,`
17	`349`	`colliderBType: pair.ColliderB.Shape,`
17	`350`	`pointA: pointA,`
17	`351`	`pointB: pointB,`
17	`352`	`hasPointA: hasPointA,`
17	`353`	`hasPointB: hasPointB,`
17	`354`	`vector: contact.Normal,`
17	`355`	`scalarA: contact.Depth,`
17	`356`	`dataA: pair.Manifold.Count,`
17	`357`	`dataB: contact.DepthIsClamped ? 1 : 0,`
17	`358`	`hit: hit && hasContact);`
17	`359`	`}`
	`360`
	`361`	`internal void EmitResponseImpulse(CollisionPair pair, Vector3d impulse, Fixed64 normalVelocity)`
	`362`	`{`
6826	`363`	`if (!Enabled)`
6813	`364`	`return;`
	`365`
13	`366`	`ManifoldContact contact = pair.Manifold.PrimaryContact;`
13	`367`	`bool hasPointA = contact.TryGetPointA(out Vector3d pointA);`
13	`368`	`bool hasPointB = contact.TryGetPointB(out Vector3d pointB);`
	`369`
13	`370`	`AddEvent(`
13	`371`	`GravitasDiagnosticEventKind.ResponseImpulse,`
13	`372`	`colliderAId: pair.ColliderA.Id,`
13	`373`	`colliderBId: pair.ColliderB.Id,`
13	`374`	`colliderAType: pair.ColliderA.Shape,`
13	`375`	`colliderBType: pair.ColliderB.Shape,`
13	`376`	`pointA: pointA,`
13	`377`	`pointB: pointB,`
13	`378`	`hasPointA: hasPointA,`
13	`379`	`hasPointB: hasPointB,`
13	`380`	`vector: impulse,`
13	`381`	`scalarA: impulse.Magnitude,`
13	`382`	`scalarB: normalVelocity,`
13	`383`	`hit: true);`
13	`384`	`}`
	`385`
	`386`	`internal void EmitMixedQuery(`
	`387`	`Vector3d start,`
	`388`	`Vector3d end,`
	`389`	`Fixed64 radius,`
	`390`	`int layerMaskBits,`
	`391`	`bool hit,`
	`392`	`int hitCount,`
	`393`	`PhysicsMixedHit mixedHit)`
	`394`	`{`
1336	`395`	`if (!Enabled)`
1331	`396`	`return;`
	`397`
5	`398`	`Vector3d point3D = default;`
5	`399`	`Vector3d point2D = default;`
5	`400`	`bool hasPoint3D = hit && mixedHit.TryGetPoint3D(out point3D);`
5	`401`	`bool hasPoint2D = hit && mixedHit.TryGetPoint2D(out point2D);`
5	`402`	`AddEvent(`
5	`403`	`GravitasDiagnosticEventKind.MixedQuery,`
5	`404`	`colliderAId: mixedHit.Collider3D?.Id ?? -1,`
5	`405`	`colliderBId: mixedHit.Collider2D?.Id ?? -1,`
5	`406`	`colliderADimension: mixedHit.Collider3D == null ? GravitasColliderDimension.None : GravitasColliderDimension`
5	`407`	`colliderBDimension: mixedHit.Collider2D == null ? GravitasColliderDimension.None : GravitasColliderDimension`
5	`408`	`colliderAType: mixedHit.Collider3D?.Shape ?? ColliderType.None,`
5	`409`	`colliderB2DType: mixedHit.Collider2D?.Shape ?? ColliderType2D.None,`
5	`410`	`start: start,`
5	`411`	`end: end,`
5	`412`	`pointA: point3D,`
5	`413`	`pointB: point2D,`
5	`414`	`hasPointA: hasPoint3D,`
5	`415`	`hasPointB: hasPoint2D,`
5	`416`	`vector: mixedHit.Normal3DTo2D,`
5	`417`	`scalarA: radius,`
5	`418`	`scalarB: mixedHit.Distance,`
5	`419`	`dataA: layerMaskBits,`
5	`420`	`dataB: hitCount,`
5	`421`	`hit: hit);`
5	`422`	`}`
	`423`
	`424`	`internal void EmitMixedContact(CollisionPairMixed pair, MixedContact contact)`
	`425`	`{`
184	`426`	`if (!Enabled)`
161	`427`	`return;`
	`428`
23	`429`	`bool hasPoint3D = contact.TryGetPoint3D(out Vector3d point3D);`
23	`430`	`bool hasPoint2D = contact.TryGetPoint2D(out Vector3d point2D);`
23	`431`	`AddEvent(`
23	`432`	`GravitasDiagnosticEventKind.MixedContact,`
23	`433`	`colliderAId: pair.Collider3DId,`
23	`434`	`colliderBId: pair.Collider2DId,`
23	`435`	`colliderADimension: GravitasColliderDimension.ThreeD,`
23	`436`	`colliderBDimension: GravitasColliderDimension.TwoD,`
23	`437`	`colliderAType: pair.Collider3D.Shape,`
23	`438`	`colliderB2DType: pair.Collider2D.Shape,`
23	`439`	`pointA: point3D,`
23	`440`	`pointB: point2D,`
23	`441`	`hasPointA: hasPoint3D,`
23	`442`	`hasPointB: hasPoint2D,`
23	`443`	`vector: contact.Normal3DTo2D,`
23	`444`	`scalarA: contact.Depth,`
23	`445`	`dataA: contact.DepthIsClamped ? 1 : 0,`
23	`446`	`hit: true);`
23	`447`	`}`
	`448`
	`449`	`internal void EmitMixedResponseImpulse(`
	`450`	`CollisionPairMixed pair,`
	`451`	`MixedContact contact,`
	`452`	`Vector3d impulse,`
	`453`	`Fixed64 normalVelocity,`
	`454`	`int iteration,`
	`455`	`int iterationLimit)`
	`456`	`{`
110	`457`	`if (!Enabled)`
94	`458`	`return;`
	`459`
16	`460`	`bool hasPoint3D = contact.TryGetPoint3D(out Vector3d point3D);`
16	`461`	`bool hasPoint2D = contact.TryGetPoint2D(out Vector3d point2D);`
16	`462`	`AddEvent(`
16	`463`	`GravitasDiagnosticEventKind.MixedResponseImpulse,`
16	`464`	`colliderAId: pair.Collider3DId,`
16	`465`	`colliderBId: pair.Collider2DId,`
16	`466`	`colliderADimension: GravitasColliderDimension.ThreeD,`
16	`467`	`colliderBDimension: GravitasColliderDimension.TwoD,`
16	`468`	`colliderAType: pair.Collider3D.Shape,`
16	`469`	`colliderB2DType: pair.Collider2D.Shape,`
16	`470`	`pointA: point3D,`
16	`471`	`pointB: point2D,`
16	`472`	`hasPointA: hasPoint3D,`
16	`473`	`hasPointB: hasPoint2D,`
16	`474`	`vector: impulse,`
16	`475`	`scalarA: impulse.Magnitude,`
16	`476`	`scalarB: normalVelocity,`
16	`477`	`dataA: iteration,`
16	`478`	`dataB: iterationLimit,`
16	`479`	`hit: true);`
16	`480`	`}`
	`481`
	`482`	`internal void EmitMixedResponseIsland(`
	`483`	`int rootKey,`
	`484`	`int constraintCount,`
	`485`	`int iterationCount,`
	`486`	`bool reachedIterationLimit)`
	`487`	`{`
13	`488`	`if (!Enabled)`
6	`489`	`return;`
	`490`
7	`491`	`AddEvent(`
7	`492`	`GravitasDiagnosticEventKind.MixedResponseIsland,`
7	`493`	`bodyId: rootKey,`
7	`494`	`dataA: constraintCount,`
7	`495`	`dataB: iterationCount,`
7	`496`	`hit: reachedIterationLimit);`
7	`497`	`}`
	`498`
	`499`	`internal void EmitJointRegistered(Joint3D joint)`
	`500`	`{`
312	`501`	`if (!Enabled)`
307	`502`	`return;`
	`503`
5	`504`	`AddEvent(`
5	`505`	`GravitasDiagnosticEventKind.JointRegistered,`
5	`506`	`jointId: joint.Id,`
5	`507`	`colliderAId: joint.BodyA.Collider.Id,`
5	`508`	`colliderBId: joint.BodyB.Collider.Id,`
5	`509`	`colliderAType: joint.BodyA.Collider.Shape,`
5	`510`	`colliderBType: joint.BodyB.Collider.Shape,`
5	`511`	`dataA: (int)joint.Type,`
5	`512`	`dataB: (int)joint.CollisionPolicy);`
5	`513`	`}`
	`514`
	`515`	`internal void EmitJointRegistered(Joint2D joint)`
	`516`	`{`
195	`517`	`if (!Enabled)`
190	`518`	`return;`
	`519`
5	`520`	`AddEvent(`
5	`521`	`GravitasDiagnosticEventKind.JointRegistered,`
5	`522`	`jointId: joint.Id,`
5	`523`	`colliderAId: joint.BodyA.Collider.Id,`
5	`524`	`colliderBId: joint.BodyB.Collider.Id,`
5	`525`	`colliderADimension: GravitasColliderDimension.TwoD,`
5	`526`	`colliderBDimension: GravitasColliderDimension.TwoD,`
5	`527`	`colliderA2DType: joint.BodyA.Collider.Shape,`
5	`528`	`colliderB2DType: joint.BodyB.Collider.Shape,`
5	`529`	`dataA: (int)joint.Type,`
5	`530`	`dataB: (int)joint.CollisionPolicy);`
5	`531`	`}`
	`532`
	`533`	`internal void EmitJointRemoved(Joint3D joint)`
	`534`	`{`
29	`535`	`if (!Enabled)`
24	`536`	`return;`
	`537`
5	`538`	`AddEvent(`
5	`539`	`GravitasDiagnosticEventKind.JointRemoved,`
5	`540`	`jointId: joint.Id,`
5	`541`	`colliderAId: joint.BodyA.Collider.Id,`
5	`542`	`colliderBId: joint.BodyB.Collider.Id,`
5	`543`	`colliderAType: joint.BodyA.Collider.Shape,`
5	`544`	`colliderBType: joint.BodyB.Collider.Shape,`
5	`545`	`dataA: (int)joint.Type,`
5	`546`	`dataB: (int)joint.CollisionPolicy);`
5	`547`	`}`
	`548`
	`549`	`internal void EmitJointRemoved(Joint2D joint)`
	`550`	`{`
28	`551`	`if (!Enabled)`
23	`552`	`return;`
	`553`
5	`554`	`AddEvent(`
5	`555`	`GravitasDiagnosticEventKind.JointRemoved,`
5	`556`	`jointId: joint.Id,`
5	`557`	`colliderAId: joint.BodyA.Collider.Id,`
5	`558`	`colliderBId: joint.BodyB.Collider.Id,`
5	`559`	`colliderADimension: GravitasColliderDimension.TwoD,`
5	`560`	`colliderBDimension: GravitasColliderDimension.TwoD,`
5	`561`	`colliderA2DType: joint.BodyA.Collider.Shape,`
5	`562`	`colliderB2DType: joint.BodyB.Collider.Shape,`
5	`563`	`dataA: (int)joint.Type,`
5	`564`	`dataB: (int)joint.CollisionPolicy);`
5	`565`	`}`
	`566`
	`567`	`internal void EmitJointImpulse(Joint3D joint, JointSolveMetrics3D metrics)`
	`568`	`{`
48069	`569`	`if (!Enabled)`
47679	`570`	`return;`
	`571`
390	`572`	`AddEvent(`
390	`573`	`GravitasDiagnosticEventKind.JointImpulse,`
390	`574`	`jointId: joint.Id,`
390	`575`	`colliderAId: joint.BodyA.Collider.Id,`
390	`576`	`colliderBId: joint.BodyB.Collider.Id,`
390	`577`	`colliderAType: joint.BodyA.Collider.Shape,`
390	`578`	`colliderBType: joint.BodyB.Collider.Shape,`
390	`579`	`vector: new Vector3d(`
390	`580`	`metrics.MotorImpulseMagnitude,`
390	`581`	`metrics.MotorErrorMagnitude,`
390	`582`	`metrics.AngularLimitErrorMagnitude),`
390	`583`	`scalarA: metrics.AccumulatedImpulseMagnitude,`
390	`584`	`scalarB: metrics.LinearAnchorErrorMagnitude,`
390	`585`	`dataA: metrics.PreparedRowCount,`
390	`586`	`dataB: metrics.ClampedRowCount,`
390	`587`	`hit: metrics.IncrementalImpulseMagnitude > Fixed64.Zero);`
390	`588`	`}`
	`589`
	`590`	`internal void EmitJointImpulse(Joint2D joint, JointSolveMetrics2D metrics)`
	`591`	`{`
576	`592`	`if (!Enabled)`
571	`593`	`return;`
	`594`
5	`595`	`AddEvent(`
5	`596`	`GravitasDiagnosticEventKind.JointImpulse,`
5	`597`	`jointId: joint.Id,`
5	`598`	`colliderAId: joint.BodyA.Collider.Id,`
5	`599`	`colliderBId: joint.BodyB.Collider.Id,`
5	`600`	`colliderADimension: GravitasColliderDimension.TwoD,`
5	`601`	`colliderBDimension: GravitasColliderDimension.TwoD,`
5	`602`	`colliderA2DType: joint.BodyA.Collider.Shape,`
5	`603`	`colliderB2DType: joint.BodyB.Collider.Shape,`
5	`604`	`vector: new Vector3d(`
5	`605`	`metrics.MotorImpulseMagnitude,`
5	`606`	`metrics.MotorErrorMagnitude,`
5	`607`	`metrics.LimitErrorMagnitude),`
5	`608`	`scalarA: metrics.AccumulatedImpulseMagnitude,`
5	`609`	`scalarB: metrics.LinearAnchorErrorMagnitude,`
5	`610`	`dataA: metrics.PreparedRowCount,`
5	`611`	`dataB: metrics.ClampedRowCount,`
5	`612`	`hit: metrics.IncrementalImpulseMagnitude > Fixed64.Zero);`
5	`613`	`}`
	`614`
	`615`	`internal void EmitJointLimitReached(Joint3D joint, Fixed64 limitError)`
	`616`	`{`
89	`617`	`if (!Enabled)`
88	`618`	`return;`
	`619`
1	`620`	`AddEvent(`
1	`621`	`GravitasDiagnosticEventKind.JointLimitReached,`
1	`622`	`jointId: joint.Id,`
1	`623`	`colliderAId: joint.BodyA.Collider.Id,`
1	`624`	`colliderBId: joint.BodyB.Collider.Id,`
1	`625`	`colliderAType: joint.BodyA.Collider.Shape,`
1	`626`	`colliderBType: joint.BodyB.Collider.Shape,`
1	`627`	`scalarB: limitError,`
1	`628`	`dataA: (int)joint.Limits.Kind,`
1	`629`	`hit: limitError != Fixed64.Zero);`
1	`630`	`}`
	`631`
	`632`	`internal void EmitJointLimitReached(Joint2D joint, Fixed64 limitError)`
	`633`	`{`
177	`634`	`if (!Enabled)`
176	`635`	`return;`
	`636`
1	`637`	`AddEvent(`
1	`638`	`GravitasDiagnosticEventKind.JointLimitReached,`
1	`639`	`jointId: joint.Id,`
1	`640`	`colliderAId: joint.BodyA.Collider.Id,`
1	`641`	`colliderBId: joint.BodyB.Collider.Id,`
1	`642`	`colliderADimension: GravitasColliderDimension.TwoD,`
1	`643`	`colliderBDimension: GravitasColliderDimension.TwoD,`
1	`644`	`colliderA2DType: joint.BodyA.Collider.Shape,`
1	`645`	`colliderB2DType: joint.BodyB.Collider.Shape,`
1	`646`	`scalarB: limitError,`
1	`647`	`dataA: (int)joint.Limits.Kind,`
1	`648`	`hit: limitError != Fixed64.Zero);`
1	`649`	`}`
	`650`
	`651`	`internal void EmitRagdollActivated(int ragdollId, int linkCount, int jointCount, bool isActive)`
	`652`	`{`
16	`653`	`if (!Enabled)`
11	`654`	`return;`
	`655`
5	`656`	`AddEvent(`
5	`657`	`GravitasDiagnosticEventKind.RagdollActivated,`
5	`658`	`bodyId: ragdollId,`
5	`659`	`dataA: linkCount,`
5	`660`	`dataB: jointCount,`
5	`661`	`hit: isActive);`
5	`662`	`}`
	`663`
	`664`	`private void AddEvent(`
	`665`	`GravitasDiagnosticEventKind kind,`
	`666`	`int bodyId = -1,`
	`667`	`int jointId = -1,`
	`668`	`int colliderAId = -1,`
	`669`	`int colliderBId = -1,`
	`670`	`GravitasColliderDimension colliderADimension = GravitasColliderDimension.None,`
	`671`	`GravitasColliderDimension colliderBDimension = GravitasColliderDimension.None,`
	`672`	`ColliderType colliderAType = ColliderType.None,`
	`673`	`ColliderType colliderBType = ColliderType.None,`
	`674`	`ColliderType2D colliderA2DType = ColliderType2D.None,`
	`675`	`ColliderType2D colliderB2DType = ColliderType2D.None,`
	`676`	`Vector3d start = default,`
	`677`	`Vector3d end = default,`
	`678`	`Vector3d pointA = default,`
	`679`	`Vector3d pointB = default,`
	`680`	`bool hasPointA = false,`
	`681`	`bool hasPointB = false,`
	`682`	`Vector3d vector = default,`
	`683`	`Fixed64 scalarA = default,`
	`684`	`Fixed64 scalarB = default,`
	`685`	`int dataA = 0,`
	`686`	`int dataB = 0,`
	`687`	`bool hit = false)`
	`688`	`{`
1535	`689`	`_events.Add(new GravitasDiagnosticEvent(`
1535	`690`	`_context.FrameCount,`
1535	`691`	`_eventSequence++,`
1535	`692`	`kind,`
1535	`693`	`bodyId,`
1535	`694`	`jointId,`
1535	`695`	`colliderAId,`
1535	`696`	`colliderBId,`
1535	`697`	`ResolveDimension(colliderADimension, colliderAType),`
1535	`698`	`ResolveDimension(colliderBDimension, colliderBType),`
1535	`699`	`colliderAType,`
1535	`700`	`colliderBType,`
1535	`701`	`colliderA2DType,`
1535	`702`	`colliderB2DType,`
1535	`703`	`start,`
1535	`704`	`end,`
1535	`705`	`pointA,`
1535	`706`	`pointB,`
1535	`707`	`hasPointA,`
1535	`708`	`hasPointB,`
1535	`709`	`vector,`
1535	`710`	`scalarA,`
1535	`711`	`scalarB,`
1535	`712`	`dataA,`
1535	`713`	`dataB,`
1535	`714`	`hit));`
1535	`715`	`}`
	`716`
	`717`	`private void AddDrawCommand(`
	`718`	`GravitasDebugDrawKind kind,`
	`719`	`int colliderId = -1,`
	`720`	`ColliderType colliderType = ColliderType.None,`
	`721`	`GravitasColliderDimension colliderDimension = GravitasColliderDimension.None,`
	`722`	`ColliderType2D collider2DType = ColliderType2D.None,`
	`723`	`Vector3d start = default,`
	`724`	`Vector3d end = default,`
	`725`	`Vector3d center = default,`
	`726`	`Vector3d halfExtents = default,`
	`727`	`Vector3d pointA = default,`
	`728`	`Vector3d pointB = default,`
	`729`	`Vector3d pointC = default,`
	`730`	`FixedQuaternion rotation = default,`
	`731`	`Fixed64 radius = default,`
	`732`	`Fixed64 axisLength = default,`
	`733`	`Fixed64 height = default,`
	`734`	`GravitasDiagnosticColor color = default)`
	`735`	`{`
383	`736`	`_drawCommands.Add(new GravitasDebugDrawCommand(`
383	`737`	`_context.FrameCount,`
383	`738`	`_drawSequence++,`
383	`739`	`kind,`
383	`740`	`colliderId,`
383	`741`	`ResolveDimension(colliderDimension, colliderType),`
383	`742`	`colliderType,`
383	`743`	`collider2DType,`
383	`744`	`start,`
383	`745`	`end,`
383	`746`	`center,`
383	`747`	`halfExtents,`
383	`748`	`pointA,`
383	`749`	`pointB,`
383	`750`	`pointC,`
383	`751`	`rotation,`
383	`752`	`radius,`
383	`753`	`axisLength,`
383	`754`	`height,`
383	`755`	`color));`
383	`756`	`}`
	`757`
	`758`	`private static GravitasColliderDimension ResolveDimension(`
	`759`	`GravitasColliderDimension dimension,`
	`760`	`ColliderType colliderType)`
	`761`	`{`
3453	`762`	`if (dimension != GravitasColliderDimension.None)`
231	`763`	`return dimension;`
3222	`764`	`if (colliderType != ColliderType.None)`
2126	`765`	`return GravitasColliderDimension.ThreeD;`
1096	`766`	`return GravitasColliderDimension.None;`
	`767`	`}`
	`768`
152	`769`	`private static Vector3d ToDiagnosticVector(Vector2d value) => new(value.X, Fixed64.Zero, value.Y);`
	`770`	`}`

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Diagnostics/GravitasDiagnosticSink.Draw.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// GravitasDiagnosticSink.Draw.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 Gravitas.Constraints;`
	`12`
	`13`	`namespace Gravitas.Diagnostics;`
	`14`
	`15`	`/// <content>`
	`16`	`/// Provides host-driven collider, joint, and primitive debug draw capture.`
	`17`	`/// </content>`
	`18`	`public sealed partial class GravitasDiagnosticSink`
	`19`	`{`
	`20`	`/// <summary>`
	`21`	`/// Emits an engine-agnostic draw command for the supplied collider shape.`
	`22`	`/// </summary>`
	`23`	`public void CaptureCollider(LSCollider collider, GravitasDiagnosticColor color)`
	`24`	`{`
98	`25`	`if (!Enabled)`
83	`26`	`return;`
	`27`
15	`28`	`SwiftThrowHelper.ThrowIfNull(collider, nameof(collider));`
	`29`	`switch (collider)`
	`30`	`{`
	`31`	`case LSSphereCollider sphere:`
2	`32`	`AddDrawCommand(`
2	`33`	`GravitasDebugDrawKind.WireSphere,`
2	`34`	`sphere.Id,`
2	`35`	`sphere.Shape,`
2	`36`	`center: sphere.Center,`
2	`37`	`radius: sphere.ScaledRadius,`
2	`38`	`color: color);`
2	`39`	`break;`
	`40`	`case LSCapsuleCollider capsule:`
1	`41`	`AddDrawCommand(`
1	`42`	`GravitasDebugDrawKind.WireCapsule,`
1	`43`	`capsule.Id,`
1	`44`	`capsule.Shape,`
1	`45`	`center: capsule.Center,`
1	`46`	`rotation: capsule.Rotation,`
1	`47`	`radius: capsule.ScaledRadius,`
1	`48`	`axisLength: capsule.AxisLength,`
1	`49`	`color: color);`
1	`50`	`break;`
	`51`	`case LSCuboidCollider cuboid:`
1	`52`	`AddDrawCommand(`
1	`53`	`GravitasDebugDrawKind.WireBox,`
1	`54`	`cuboid.Id,`
1	`55`	`cuboid.Shape,`
1	`56`	`center: cuboid.Center,`
1	`57`	`halfExtents: cuboid.OrientedBox.HalfExtents,`
1	`58`	`rotation: cuboid.Rotation,`
1	`59`	`color: color);`
1	`60`	`break;`
	`61`	`case LSCylinderCollider cylinder:`
1	`62`	`AddDrawCommand(`
1	`63`	`GravitasDebugDrawKind.WireCylinder,`
1	`64`	`cylinder.Id,`
1	`65`	`cylinder.Shape,`
1	`66`	`center: cylinder.Center,`
1	`67`	`rotation: cylinder.Rotation,`
1	`68`	`radius: cylinder.ScaledRadius,`
1	`69`	`height: cylinder.Height,`
1	`70`	`color: color);`
1	`71`	`break;`
	`72`	`case LSConeCollider cone:`
1	`73`	`AddDrawCommand(`
1	`74`	`GravitasDebugDrawKind.WireCone,`
1	`75`	`cone.Id,`
1	`76`	`cone.Shape,`
1	`77`	`center: cone.Center,`
1	`78`	`rotation: cone.Rotation,`
1	`79`	`radius: cone.ScaledRadius,`
1	`80`	`height: cone.Height,`
1	`81`	`color: color);`
1	`82`	`break;`
	`83`	`case LSCompoundCollider compound:`
4	`84`	`CaptureCompoundParts(compound, color);`
4	`85`	`break;`
	`86`	`case LSMeshCollider mesh:`
3	`87`	`CaptureMeshTriangles(mesh, color);`
	`88`	`break;`
	`89`	`}`
3	`90`	`}`
	`91`
	`92`	`/// <summary>`
	`93`	`/// Emits engine-agnostic draw commands for the finite 2D slab used by mixed 2D/3D collision.`
	`94`	`/// </summary>`
	`95`	`public void CaptureMixedCollider(LSCollider2D collider, GravitasDiagnosticColor color)`
	`96`	`{`
17	`97`	`if (!Enabled)`
1	`98`	`return;`
	`99`
16	`100`	`SwiftThrowHelper.ThrowIfNull(collider, nameof(collider));`
15	`101`	`Vector3d center = new(collider.Center.X, collider.MixedSlabCenterY, collider.Center.Y);`
15	`102`	`Fixed64 height = collider.MixedHalfThickness * 2;`
	`103`	`switch (collider)`
	`104`	`{`
	`105`	`case LSCircleCollider2D circle:`
1	`106`	`AddDrawCommand(`
1	`107`	`GravitasDebugDrawKind.WireCylinder,`
1	`108`	`circle.Id,`
1	`109`	`colliderDimension: GravitasColliderDimension.TwoD,`
1	`110`	`collider2DType: circle.Shape,`
1	`111`	`center: center,`
1	`112`	`radius: circle.ScaledRadius,`
1	`113`	`height: height,`
1	`114`	`color: color);`
1	`115`	`break;`
	`116`	`case LSCapsuleCollider2D capsule:`
5	`117`	`CaptureMixedCapsule(capsule, color, capsule.Id, capsule.Shape);`
5	`118`	`break;`
	`119`	`case LSAABBoxCollider2D box:`
1	`120`	`AddDrawCommand(`
1	`121`	`GravitasDebugDrawKind.WireBox,`
1	`122`	`box.Id,`
1	`123`	`colliderDimension: GravitasColliderDimension.TwoD,`
1	`124`	`collider2DType: box.Shape,`
1	`125`	`center: center,`
1	`126`	`halfExtents: new Vector3d(`
1	`127`	`box.ScaledHalfExtents.X,`
1	`128`	`collider.MixedHalfThickness,`
1	`129`	`box.ScaledHalfExtents.Y),`
1	`130`	`color: color);`
1	`131`	`break;`
	`132`	`case LSCompoundCollider2D compound:`
2	`133`	`CaptureMixedCompoundParts(compound, color);`
2	`134`	`break;`
	`135`	`default:`
6	`136`	`CaptureMixedPolygon(collider, color);`
	`137`	`break;`
	`138`	`}`
6	`139`	`}`
	`140`
	`141`	`/// <summary>`
	`142`	`/// Emits engine-agnostic draw commands for a 3D joint's anchors and active angular axes.`
	`143`	`/// </summary>`
	`144`	`public void CaptureJoint(Joint3D joint, GravitasDiagnosticColor color)`
	`145`	`{`
7	`146`	`if (!Enabled)`
1	`147`	`return;`
	`148`
6	`149`	`SwiftThrowHelper.ThrowIfNull(joint, nameof(joint));`
5	`150`	`SolidBody bodyA = joint.BodyA;`
5	`151`	`SolidBody bodyB = joint.BodyB;`
5	`152`	`FixedQuaternion rotationA = (bodyA.Rotation * joint.LocalFrameA.Rotation).Normalized;`
5	`153`	`FixedQuaternion rotationB = (bodyB.Rotation * joint.LocalFrameB.Rotation).Normalized;`
5	`154`	`Vector3d anchorA = bodyA.Position3d + bodyA.Rotation * joint.LocalFrameA.Position;`
5	`155`	`Vector3d anchorB = bodyB.Position3d + bodyB.Rotation * joint.LocalFrameB.Position;`
5	`156`	`Fixed64 pointRadius = Fixed64.One / (Fixed64)10;`
5	`157`	`Fixed64 axisLength = Fixed64.One;`
	`158`
5	`159`	`AddDrawCommand(`
5	`160`	`GravitasDebugDrawKind.Point,`
5	`161`	`bodyA.Collider.Id,`
5	`162`	`bodyA.Collider.Shape,`
5	`163`	`center: anchorA,`
5	`164`	`radius: pointRadius,`
5	`165`	`color: color);`
5	`166`	`AddDrawCommand(`
5	`167`	`GravitasDebugDrawKind.Point,`
5	`168`	`bodyB.Collider.Id,`
5	`169`	`bodyB.Collider.Shape,`
5	`170`	`center: anchorB,`
5	`171`	`radius: pointRadius,`
5	`172`	`color: color);`
5	`173`	`AddDrawCommand(`
5	`174`	`GravitasDebugDrawKind.Line,`
5	`175`	`bodyA.Collider.Id,`
5	`176`	`bodyA.Collider.Shape,`
5	`177`	`start: anchorA,`
5	`178`	`end: anchorB,`
5	`179`	`color: color);`
	`180`
5	`181`	`switch (joint.Type)`
	`182`	`{`
	`183`	`case JointType3D.Hinge:`
2	`184`	`CaptureJointAxis(anchorA, rotationA * Vector3d.Right, axisLength, bodyA.Collider, color);`
2	`185`	`CaptureJointAxis(anchorB, rotationB * Vector3d.Right, axisLength, bodyB.Collider, color);`
2	`186`	`break;`
	`187`	`case JointType3D.ConeTwist:`
1	`188`	`CaptureJointAxis(anchorA, rotationA * Vector3d.Forward, axisLength, bodyA.Collider, color);`
1	`189`	`CaptureJointAxis(anchorB, rotationB * Vector3d.Forward, axisLength, bodyB.Collider, color);`
1	`190`	`break;`
	`191`	`case JointType3D.Fixed:`
1	`192`	`CaptureJointAxis(anchorA, rotationA * Vector3d.Right, axisLength, bodyA.Collider, color);`
1	`193`	`CaptureJointAxis(anchorA, rotationA * Vector3d.Up, axisLength, bodyA.Collider, color);`
1	`194`	`CaptureJointAxis(anchorA, rotationA * Vector3d.Forward, axisLength, bodyA.Collider, color);`
	`195`	`break;`
	`196`	`}`
1	`197`	`}`
	`198`
	`199`	`/// <summary>`
	`200`	`/// Emits engine-agnostic draw commands for a pure 2D joint's anchors and active planar axis.`
	`201`	`/// </summary>`
	`202`	`public void CaptureJoint(Joint2D joint, GravitasDiagnosticColor color)`
	`203`	`{`
5	`204`	`if (!Enabled)`
1	`205`	`return;`
	`206`
4	`207`	`SwiftThrowHelper.ThrowIfNull(joint, nameof(joint));`
3	`208`	`SolidBody2D bodyA = joint.BodyA;`
3	`209`	`SolidBody2D bodyB = joint.BodyB;`
3	`210`	`Fixed64 y = bodyA.Agent.Transform.WorldPosition.Y;`
3	`211`	`Vector2d anchorA2D = bodyA.Position + Vector2d.Rotate(joint.LocalFrameA.Anchor, bodyA.Rotation);`
3	`212`	`Vector2d anchorB2D = bodyB.Position + Vector2d.Rotate(joint.LocalFrameB.Anchor, bodyB.Rotation);`
3	`213`	`Vector3d anchorA = new(anchorA2D.X, y, anchorA2D.Y);`
3	`214`	`Vector3d anchorB = new(anchorB2D.X, y, anchorB2D.Y);`
3	`215`	`Fixed64 pointRadius = Fixed64.One / (Fixed64)10;`
	`216`
3	`217`	`AddDrawCommand(`
3	`218`	`GravitasDebugDrawKind.Point,`
3	`219`	`bodyA.Collider.Id,`
3	`220`	`colliderDimension: GravitasColliderDimension.TwoD,`
3	`221`	`collider2DType: bodyA.Collider.Shape,`
3	`222`	`center: anchorA,`
3	`223`	`radius: pointRadius,`
3	`224`	`color: color);`
3	`225`	`AddDrawCommand(`
3	`226`	`GravitasDebugDrawKind.Point,`
3	`227`	`bodyB.Collider.Id,`
3	`228`	`colliderDimension: GravitasColliderDimension.TwoD,`
3	`229`	`collider2DType: bodyB.Collider.Shape,`
3	`230`	`center: anchorB,`
3	`231`	`radius: pointRadius,`
3	`232`	`color: color);`
3	`233`	`AddDrawCommand(`
3	`234`	`GravitasDebugDrawKind.Line,`
3	`235`	`bodyA.Collider.Id,`
3	`236`	`colliderDimension: GravitasColliderDimension.TwoD,`
3	`237`	`collider2DType: bodyA.Collider.Shape,`
3	`238`	`start: anchorA,`
3	`239`	`end: anchorB,`
3	`240`	`color: color);`
	`241`
3	`242`	`if (joint.Type != JointType2D.Prismatic)`
2	`243`	`return;`
	`244`
1	`245`	`Vector2d axis2D = Vector2d.Rotate(Vector2d.Right, bodyA.Rotation + joint.LocalFrameA.Angle);`
1	`246`	`Vector3d axis = new(axis2D.X, Fixed64.Zero, axis2D.Y);`
	`247`
1	`248`	`AddDrawCommand(`
1	`249`	`GravitasDebugDrawKind.Ray,`
1	`250`	`bodyA.Collider.Id,`
1	`251`	`colliderDimension: GravitasColliderDimension.TwoD,`
1	`252`	`collider2DType: bodyA.Collider.Shape,`
1	`253`	`start: anchorA,`
1	`254`	`end: anchorA + axis.Normalized,`
1	`255`	`color: color);`
1	`256`	`}`
	`257`
	`258`	`/// <summary>`
	`259`	`/// Emits an engine-agnostic line draw command.`
	`260`	`/// </summary>`
	`261`	`public void CaptureLine(Vector3d start, Vector3d end, GravitasDiagnosticColor color)`
	`262`	`{`
7	`263`	`if (!Enabled)`
1	`264`	`return;`
	`265`
6	`266`	`AddDrawCommand(`
6	`267`	`GravitasDebugDrawKind.Line,`
6	`268`	`start: start,`
6	`269`	`end: end,`
6	`270`	`color: color);`
6	`271`	`}`
	`272`
	`273`	`/// <summary>`
	`274`	`/// Emits an engine-agnostic ray draw command from an origin, direction, and length.`
	`275`	`/// </summary>`
	`276`	`public void CaptureRay(Vector3d origin, Vector3d direction, Fixed64 length, GravitasDiagnosticColor color)`
	`277`	`{`
3	`278`	`if (!Enabled)`
1	`279`	`return;`
	`280`
2	`281`	`Vector3d end = direction.MagnitudeSquared == Fixed64.Zero`
2	`282`	`? origin`
2	`283`	`: origin + direction.Normalized * length;`
	`284`
2	`285`	`AddDrawCommand(`
2	`286`	`GravitasDebugDrawKind.Ray,`
2	`287`	`start: origin,`
2	`288`	`end: end,`
2	`289`	`color: color);`
2	`290`	`}`
	`291`
	`292`	`/// <summary>`
	`293`	`/// Emits an engine-agnostic point draw command.`
	`294`	`/// </summary>`
	`295`	`public void CapturePoint(Vector3d point, Fixed64 radius, GravitasDiagnosticColor color)`
	`296`	`{`
4	`297`	`if (!Enabled)`
1	`298`	`return;`
	`299`
3	`300`	`AddDrawCommand(`
3	`301`	`GravitasDebugDrawKind.Point,`
3	`302`	`center: point,`
3	`303`	`radius: radius,`
3	`304`	`color: color);`
3	`305`	`}`
	`306`
	`307`	`private void CaptureMeshTriangles(LSMeshCollider mesh, GravitasDiagnosticColor color)`
	`308`	`{`
3	`309`	`int triangleCount = mesh.Mesh.TriangleCount;`
522	`310`	`for (int i = 0; i < triangleCount; i++)`
	`311`	`{`
258	`312`	`if (!mesh.Mesh.TryGetTriangleVertices(`
258	`313`	`i,`
258	`314`	`out Vector3d first,`
258	`315`	`out Vector3d second,`
258	`316`	`out Vector3d third))`
	`317`	`{`
	`318`	`continue;`
	`319`	`}`
257	`320`	`AddDrawCommand(`
257	`321`	`GravitasDebugDrawKind.WireTriangle,`
257	`322`	`mesh.Id,`
257	`323`	`mesh.Shape,`
257	`324`	`pointA: first,`
257	`325`	`pointB: second,`
257	`326`	`pointC: third,`
257	`327`	`color: color);`
	`328`	`}`
3	`329`	`}`
	`330`
	`331`	`private void CaptureJointAxis(`
	`332`	`Vector3d anchor,`
	`333`	`Vector3d axis,`
	`334`	`Fixed64 length,`
	`335`	`LSCollider collider,`
	`336`	`GravitasDiagnosticColor color)`
	`337`	`{`
9	`338`	`AddDrawCommand(`
9	`339`	`GravitasDebugDrawKind.Ray,`
9	`340`	`collider.Id,`
9	`341`	`collider.Shape,`
9	`342`	`start: anchor,`
9	`343`	`end: anchor + axis.Normalized * length,`
9	`344`	`color: color);`
9	`345`	`}`
	`346`
	`347`	`private void CaptureCompoundParts(LSCompoundCollider compound, GravitasDiagnosticColor color)`
	`348`	`{`
24	`349`	`for (int i = 0; i < compound.PartCount; i++)`
	`350`	`{`
8	`351`	`LSCollider part = compound.GetPartCollider(i);`
	`352`	`switch (part)`
	`353`	`{`
	`354`	`case LSSphereCollider sphere:`
1	`355`	`AddDrawCommand(`
1	`356`	`GravitasDebugDrawKind.WireSphere,`
1	`357`	`compound.Id,`
1	`358`	`compound.Shape,`
1	`359`	`center: sphere.Center,`
1	`360`	`radius: sphere.ScaledRadius,`
1	`361`	`color: color);`
1	`362`	`break;`
	`363`	`case LSCapsuleCollider capsule:`
1	`364`	`AddDrawCommand(`
1	`365`	`GravitasDebugDrawKind.WireCapsule,`
1	`366`	`compound.Id,`
1	`367`	`compound.Shape,`
1	`368`	`center: capsule.Center,`
1	`369`	`rotation: capsule.Rotation,`
1	`370`	`radius: capsule.ScaledRadius,`
1	`371`	`axisLength: capsule.AxisLength,`
1	`372`	`color: color);`
1	`373`	`break;`
	`374`	`case LSCuboidCollider cuboid:`
1	`375`	`AddDrawCommand(`
1	`376`	`GravitasDebugDrawKind.WireBox,`
1	`377`	`compound.Id,`
1	`378`	`compound.Shape,`
1	`379`	`center: cuboid.Center,`
1	`380`	`halfExtents: cuboid.OrientedBox.HalfExtents,`
1	`381`	`rotation: cuboid.Rotation,`
1	`382`	`color: color);`
1	`383`	`break;`
	`384`	`case LSCylinderCollider cylinder:`
1	`385`	`AddDrawCommand(`
1	`386`	`GravitasDebugDrawKind.WireCylinder,`
1	`387`	`compound.Id,`
1	`388`	`compound.Shape,`
1	`389`	`center: cylinder.Center,`
1	`390`	`rotation: cylinder.Rotation,`
1	`391`	`radius: cylinder.ScaledRadius,`
1	`392`	`height: cylinder.Height,`
1	`393`	`color: color);`
1	`394`	`break;`
	`395`	`case LSConeCollider cone:`
1	`396`	`AddDrawCommand(`
1	`397`	`GravitasDebugDrawKind.WireCone,`
1	`398`	`compound.Id,`
1	`399`	`compound.Shape,`
1	`400`	`center: cone.Center,`
1	`401`	`rotation: cone.Rotation,`
1	`402`	`radius: cone.ScaledRadius,`
1	`403`	`height: cone.Height,`
1	`404`	`color: color);`
1	`405`	`break;`
	`406`	`case LSMeshCollider mesh:`
3	`407`	`CaptureCompoundMeshTriangles(compound, mesh, color);`
	`408`	`break;`
	`409`	`}`
	`410`	`}`
4	`411`	`}`
	`412`
	`413`	`private void CaptureCompoundMeshTriangles(`
	`414`	`LSCompoundCollider compound,`
	`415`	`LSMeshCollider mesh,`
	`416`	`GravitasDiagnosticColor color)`
	`417`	`{`
3	`418`	`int triangleCount = mesh.Mesh.TriangleCount;`
34	`419`	`for (int i = 0; i < triangleCount; i++)`
	`420`	`{`
14	`421`	`if (!mesh.Mesh.TryGetTriangleVertices(`
14	`422`	`i,`
14	`423`	`out Vector3d first,`
14	`424`	`out Vector3d second,`
14	`425`	`out Vector3d third))`
	`426`	`{`
	`427`	`continue;`
	`428`	`}`
13	`429`	`AddDrawCommand(`
13	`430`	`GravitasDebugDrawKind.WireTriangle,`
13	`431`	`compound.Id,`
13	`432`	`compound.Shape,`
13	`433`	`pointA: first,`
13	`434`	`pointB: second,`
13	`435`	`pointC: third,`
13	`436`	`color: color);`
	`437`	`}`
3	`438`	`}`
	`439`
	`440`	`private void CaptureMixedCompoundParts(LSCompoundCollider2D compound, GravitasDiagnosticColor color)`
	`441`	`{`
12	`442`	`for (int i = 0; i < compound.PartCount; i++)`
	`443`	`{`
4	`444`	`LSCollider2D part = compound.GetPartCollider(i);`
4	`445`	`Vector3d center = new(part.Center.X, part.MixedSlabCenterY, part.Center.Y);`
4	`446`	`Fixed64 height = part.MixedHalfThickness * 2;`
	`447`	`switch (part)`
	`448`	`{`
	`449`	`case LSCircleCollider2D circle:`
1	`450`	`AddDrawCommand(`
1	`451`	`GravitasDebugDrawKind.WireCylinder,`
1	`452`	`compound.Id,`
1	`453`	`colliderDimension: GravitasColliderDimension.TwoD,`
1	`454`	`collider2DType: compound.Shape,`
1	`455`	`center: center,`
1	`456`	`radius: circle.ScaledRadius,`
1	`457`	`height: height,`
1	`458`	`color: color);`
1	`459`	`break;`
	`460`	`case LSCapsuleCollider2D capsule:`
1	`461`	`CaptureMixedCapsule(capsule, color, compound.Id, compound.Shape);`
1	`462`	`break;`
	`463`	`case LSAABBoxCollider2D box:`
1	`464`	`AddDrawCommand(`
1	`465`	`GravitasDebugDrawKind.WireBox,`
1	`466`	`compound.Id,`
1	`467`	`colliderDimension: GravitasColliderDimension.TwoD,`
1	`468`	`collider2DType: compound.Shape,`
1	`469`	`center: center,`
1	`470`	`halfExtents: new Vector3d(`
1	`471`	`box.ScaledHalfExtents.X,`
1	`472`	`box.MixedHalfThickness,`
1	`473`	`box.ScaledHalfExtents.Y),`
1	`474`	`color: color);`
1	`475`	`break;`
	`476`	`default:`
1	`477`	`CaptureMixedPolygon(part, color, compound.Id, compound.Shape);`
	`478`	`break;`
	`479`	`}`
	`480`	`}`
2	`481`	`}`
	`482`
	`483`	`private void CaptureMixedCapsule(`
	`484`	`LSCapsuleCollider2D capsule,`
	`485`	`GravitasDiagnosticColor color,`
	`486`	`int colliderId,`
	`487`	`ColliderType2D colliderType)`
	`488`	`{`
6	`489`	`bool hasFirstEndpoint = FixedSegment2d.TryGetCenteredAxisEndpoint(`
6	`490`	`capsule.Center,`
6	`491`	`capsule.WorldAxis,`
6	`492`	`capsule.AxisLength,`
6	`493`	`positive: false,`
6	`494`	`out Vector2d firstEndpoint);`
6	`495`	`bool hasSecondEndpoint = FixedSegment2d.TryGetCenteredAxisEndpoint(`
6	`496`	`capsule.Center,`
6	`497`	`capsule.WorldAxis,`
6	`498`	`capsule.AxisLength,`
6	`499`	`positive: true,`
6	`500`	`out Vector2d secondEndpoint);`
	`501`
6	`502`	`Fixed64 height = capsule.MixedHalfThickness * 2;`
6	`503`	`if (hasFirstEndpoint)`
	`504`	`{`
5	`505`	`AddDrawCommand(`
5	`506`	`GravitasDebugDrawKind.WireCylinder,`
5	`507`	`colliderId,`
5	`508`	`colliderDimension: GravitasColliderDimension.TwoD,`
5	`509`	`collider2DType: colliderType,`
5	`510`	`center: new Vector3d(firstEndpoint.X, capsule.MixedSlabCenterY, firstEndpoint.Y),`
5	`511`	`radius: capsule.ScaledRadius,`
5	`512`	`height: height,`
5	`513`	`color: color);`
	`514`	`}`
	`515`
6	`516`	`if (hasSecondEndpoint)`
	`517`	`{`
5	`518`	`AddDrawCommand(`
5	`519`	`GravitasDebugDrawKind.WireCylinder,`
5	`520`	`colliderId,`
5	`521`	`colliderDimension: GravitasColliderDimension.TwoD,`
5	`522`	`collider2DType: colliderType,`
5	`523`	`center: new Vector3d(secondEndpoint.X, capsule.MixedSlabCenterY, secondEndpoint.Y),`
5	`524`	`radius: capsule.ScaledRadius,`
5	`525`	`height: height,`
5	`526`	`color: color);`
	`527`	`}`
	`528`
6	`529`	`Fixed64 segmentLength = capsule.AxisLength;`
6	`530`	`if (segmentLength <= Fixed64.Epsilon \|\| !hasFirstEndpoint \|\| !hasSecondEndpoint)`
3	`531`	`return;`
	`532`
3	`533`	`AddDrawCommand(`
3	`534`	`GravitasDebugDrawKind.WireBox,`
3	`535`	`colliderId,`
3	`536`	`colliderDimension: GravitasColliderDimension.TwoD,`
3	`537`	`collider2DType: colliderType,`
3	`538`	`center: new Vector3d(capsule.Center.X, capsule.MixedSlabCenterY, capsule.Center.Y),`
3	`539`	`halfExtents: new Vector3d(`
3	`540`	`capsule.ScaledRadius,`
3	`541`	`capsule.MixedHalfThickness,`
3	`542`	`segmentLength / Fixed64.Two),`
3	`543`	`rotation: FixedQuaternion.FromEulerAngles(Fixed64.Zero, capsule.Rotation, Fixed64.Zero),`
3	`544`	`color: color);`
3	`545`	`}`
	`546`
	`547`	`private void CaptureMixedPolygon(LSCollider2D collider, GravitasDiagnosticColor color) =>`
6	`548`	`CaptureMixedPolygon(collider, color, collider.Id, collider.Shape);`
	`549`
	`550`	`private void CaptureMixedPolygon(`
	`551`	`LSCollider2D collider,`
	`552`	`GravitasDiagnosticColor color,`
	`553`	`int colliderId,`
	`554`	`ColliderType2D colliderType)`
	`555`	`{`
7	`556`	`int vertexCount = collider.VertexCount;`
7	`557`	`bool hasTop = Fixed64.TryAdd(`
7	`558`	`collider.MixedSlabCenterY,`
7	`559`	`collider.MixedHalfThickness,`
7	`560`	`out Fixed64 topY);`
7	`561`	`bool hasBottom = Fixed64.TrySubtract(`
7	`562`	`collider.MixedSlabCenterY,`
7	`563`	`collider.MixedHalfThickness,`
7	`564`	`out Fixed64 bottomY);`
62	`565`	`for (int i = 0; i < vertexCount; i++)`
	`566`	`{`
24	`567`	`if (!collider.TryGetVertex(i, out Vector2d current))`
	`568`	`continue;`
	`569`
20	`570`	`if (hasTop && hasBottom)`
	`571`	`{`
12	`572`	`AddDrawCommand(`
12	`573`	`GravitasDebugDrawKind.Line,`
12	`574`	`colliderId,`
12	`575`	`colliderDimension: GravitasColliderDimension.TwoD,`
12	`576`	`collider2DType: colliderType,`
12	`577`	`start: new Vector3d(current.X, topY, current.Y),`
12	`578`	`end: new Vector3d(current.X, bottomY, current.Y),`
12	`579`	`color: color);`
	`580`	`}`
	`581`
20	`582`	`if (!collider.TryGetVertex(`
20	`583`	`(i + 1) % vertexCount,`
20	`584`	`out Vector2d next))`
	`585`	`{`
	`586`	`continue;`
	`587`	`}`
	`588`
18	`589`	`if (hasTop)`
	`590`	`{`
14	`591`	`AddDrawCommand(`
14	`592`	`GravitasDebugDrawKind.Line,`
14	`593`	`colliderId,`
14	`594`	`colliderDimension: GravitasColliderDimension.TwoD,`
14	`595`	`collider2DType: colliderType,`
14	`596`	`start: new Vector3d(current.X, topY, current.Y),`
14	`597`	`end: new Vector3d(next.X, topY, next.Y),`
14	`598`	`color: color);`
	`599`	`}`
	`600`
18	`601`	`if (hasBottom)`
	`602`	`{`
14	`603`	`AddDrawCommand(`
14	`604`	`GravitasDebugDrawKind.Line,`
14	`605`	`colliderId,`
14	`606`	`colliderDimension: GravitasColliderDimension.TwoD,`
14	`607`	`collider2DType: colliderType,`
14	`608`	`start: new Vector3d(current.X, bottomY, current.Y),`
14	`609`	`end: new Vector3d(next.X, bottomY, next.Y),`
14	`610`	`color: color);`
	`611`	`}`
	`612`	`}`
7	`613`	`}`
	`614`
	`615`	`}`

Methods/Properties