< Summary

Information
Class: Gravitas.CollisionHandling.ContinuousCollisionImpulsePolicy
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Continuous/ContinuousCollisionImpulsePolicy.cs
Line coverage
100%
Covered lines: 67
Uncovered lines: 0
Coverable lines: 67
Total lines: 179
Line coverage: 100%
Branch coverage
100%
Covered branches: 30
Total branches: 30
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
TryResolveVelocityDelta(...)100%22100%
TryResolveVelocityDelta(...)100%22100%
TryResolveVelocityDelta(...)100%88100%
TryResolveVelocityDelta(...)100%66100%
TryResolveSourceNormal(...)100%44100%
TryResolveSourceNormal(...)100%44100%
TryResolveImpactNormal(...)100%22100%
TryResolveImpactNormal(...)100%22100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Continuous/ContinuousCollisionImpulsePolicy.cs

#LineLine coverage
 1//=======================================================================
 2// ContinuousCollisionImpulsePolicy.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using FixedMathSharp;
 9
 10namespace Gravitas.CollisionHandling;
 11
 12/// <summary>
 13/// Resolves impact normals and constrained velocity changes for 2D and 3D CCD response.
 14/// </summary>
 15internal static class ContinuousCollisionImpulsePolicy
 16{
 17    internal static bool TryResolveVelocityDelta(
 18        Vector3d signedNormal,
 19        Fixed64 normalVelocity,
 20        Fixed64 responseFactor,
 21        Fixed64 bodyInverseMass,
 22        Fixed64 constrainedInverseMass,
 23        out Vector3d velocityDelta)
 24    {
 2125        if (bodyInverseMass == Fixed64.Zero)
 26        {
 327            velocityDelta = default;
 328            return true;
 29        }
 30
 1831        bool resolved = Fixed64.TryMultiplyDivide(
 1832            normalVelocity,
 1833            responseFactor,
 1834            bodyInverseMass,
 1835            constrainedInverseMass,
 1836            out Fixed64 speedDelta);
 1837        velocityDelta = signedNormal * speedDelta;
 1838        return resolved;
 39    }
 40
 41    internal static bool TryResolveVelocityDelta(
 42        Vector2d signedNormal,
 43        Fixed64 normalVelocity,
 44        Fixed64 responseFactor,
 45        Fixed64 bodyInverseMass,
 46        Fixed64 constrainedInverseMass,
 47        out Vector2d velocityDelta)
 48    {
 8549        if (bodyInverseMass == Fixed64.Zero)
 50        {
 2451            velocityDelta = default;
 2452            return true;
 53        }
 54
 6155        bool resolved = Fixed64.TryMultiplyDivide(
 6156            normalVelocity,
 6157            responseFactor,
 6158            bodyInverseMass,
 6159            constrainedInverseMass,
 6160            out Fixed64 speedDelta);
 6161        velocityDelta = signedNormal * speedDelta;
 6162        return resolved;
 63    }
 64
 65    internal static bool TryResolveVelocityDelta(
 66        Vector3d normal,
 67        Fixed64 responseSpeed,
 68        Fixed64 bodyInverseMass,
 69        Fixed64 constrainedInverseMass,
 70        out Vector3d velocityDelta)
 71    {
 3818272        if (bodyInverseMass == Fixed64.Zero)
 73        {
 674            velocityDelta = default;
 675            return true;
 76        }
 77
 3817678        if (!Fixed64.TryMultiplyDivide(normal.X, responseSpeed, bodyInverseMass, constrainedInverseMass, out Fixed64 x)
 3817679            || !Fixed64.TryMultiplyDivide(normal.Y, responseSpeed, bodyInverseMass, constrainedInverseMass, out Fixed64 
 3817680            || !Fixed64.TryMultiplyDivide(normal.Z, responseSpeed, bodyInverseMass, constrainedInverseMass, out Fixed64 
 81        {
 1582            velocityDelta = default;
 1583            return false;
 84        }
 85
 3816186        velocityDelta = new Vector3d(x, y, z);
 3816187        return true;
 88    }
 89
 90    internal static bool TryResolveVelocityDelta(
 91        Vector2d normal,
 92        Fixed64 responseSpeed,
 93        Fixed64 bodyInverseMass,
 94        Fixed64 constrainedInverseMass,
 95        out Vector2d velocityDelta)
 96    {
 1906197        if (bodyInverseMass == Fixed64.Zero)
 98        {
 1579099            velocityDelta = default;
 15790100            return true;
 101        }
 102
 3271103        if (!Fixed64.TryMultiplyDivide(normal.X, responseSpeed, bodyInverseMass, constrainedInverseMass, out Fixed64 x)
 3271104            || !Fixed64.TryMultiplyDivide(normal.Y, responseSpeed, bodyInverseMass, constrainedInverseMass, out Fixed64 
 105        {
 14106            velocityDelta = default;
 14107            return false;
 108        }
 109
 3257110        velocityDelta = new Vector2d(x, y);
 3257111        return true;
 112    }
 113
 114    internal static bool TryResolveSourceNormal(
 115        Vector3d normalForSource,
 116        Vector3d sourceDisplacement,
 117        out Vector3d normal)
 118    {
 14119        if (normalForSource.MagnitudeSquared > Fixed64.Epsilon)
 120        {
 12121            normal = normalForSource.Normalized;
 12122            return true;
 123        }
 124
 2125        if (sourceDisplacement.MagnitudeSquared > Fixed64.Epsilon)
 126        {
 1127            normal = -sourceDisplacement.Normalized;
 1128            return true;
 129        }
 130
 1131        normal = Vector3d.Zero;
 1132        return false;
 133    }
 134
 135    internal static bool TryResolveSourceNormal(
 136        Vector2d normalForSource,
 137        Vector2d sourceDisplacement,
 138        out Vector2d normal)
 139    {
 12140        if (normalForSource.MagnitudeSquared > Fixed64.Epsilon)
 141        {
 10142            normal = normalForSource.Normalized;
 10143            return true;
 144        }
 145
 2146        if (sourceDisplacement.MagnitudeSquared > Fixed64.Epsilon)
 147        {
 1148            normal = -sourceDisplacement.Normalized;
 1149            return true;
 150        }
 151
 1152        normal = Vector2d.Zero;
 1153        return false;
 154    }
 155
 156    internal static bool TryResolveImpactNormal(Vector3d normalForSource, out Vector3d normal)
 157    {
 82158        if (normalForSource.MagnitudeSquared > Fixed64.Epsilon)
 159        {
 78160            normal = normalForSource.Normalized;
 78161            return true;
 162        }
 163
 4164        normal = Vector3d.Zero;
 4165        return false;
 166    }
 167
 168    internal static bool TryResolveImpactNormal(Vector2d normalForSource, out Vector2d normal)
 169    {
 89170        if (normalForSource.MagnitudeSquared > Fixed64.Epsilon)
 171        {
 75172            normal = normalForSource.Normalized;
 75173            return true;
 174        }
 175
 14176        normal = Vector2d.Zero;
 14177        return false;
 178    }
 179}