< Summary

Information
Class: Gravitas.CollisionHandling.ContactNormalImpulse2D
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Response/2D/ContactNormalImpulse2D.cs
Line coverage
100%
Covered lines: 380
Uncovered lines: 0
Coverable lines: 380
Total lines: 596
Line coverage: 100%
Branch coverage
100%
Covered branches: 90
Total branches: 90
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Response/2D/ContactNormalImpulse2D.cs

#LineLine coverage
 1//=======================================================================
 2// ContactNormalImpulse2D.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using System.Runtime.CompilerServices;
 9using FixedMathSharp;
 10
 11namespace Gravitas.CollisionHandling;
 12
 13
 14
 15
 16
 17/// <summary>
 18/// Calculates allocation-free 2D contact-point normal response without mutating either body.
 19/// </summary>
 20internal static class ContactNormalImpulse2D
 21{
 22    internal static bool TryCalculateVelocityDeltas(
 23        SolidBody2D? bodyA,
 24        Vector2d linearVelocityA,
 25        Fixed64 angularVelocityA,
 26        Vector2d relativeContactPointA,
 27        SolidBody2D? bodyB,
 28        Vector2d linearVelocityB,
 29        Fixed64 angularVelocityB,
 30        Vector2d relativeContactPointB,
 31        Vector2d normal,
 32        Fixed64 restitution,
 33        Fixed64 restitutionVelocityThreshold,
 34        out ContactNormalVelocityDeltaResult2D result)
 35    {
 4836        result = default;
 4837        if (!TryComputeNormalVelocity(
 4838                linearVelocityA,
 4839                angularVelocityA,
 4840                relativeContactPointA,
 4841                linearVelocityB,
 4842                angularVelocityB,
 4843                relativeContactPointB,
 4844                normal,
 4845                out Fixed64 normalVelocity))
 46        {
 147            return false;
 48        }
 4749        if (normalVelocity >= Fixed64.Zero)
 50        {
 251            result = ZeroVelocityDelta(normalVelocity);
 252            return true;
 53        }
 54
 4555        if (!TryComputeDenominator(
 4556                bodyA,
 4557                relativeContactPointA,
 4558                bodyB,
 4559                relativeContactPointB,
 4560                normal,
 4561                out Fixed64 denominator)
 4562            || denominator <= Fixed64.Zero)
 63        {
 1364            return false;
 65        }
 66
 3267        Fixed64 appliedRestitution = normalVelocity < -restitutionVelocityThreshold
 3268            ? restitution
 3269            : Fixed64.Zero;
 3270        Fixed64 responseFactor = -(Fixed64.One + appliedRestitution);
 3271        bool linearAResolved = ContinuousCollisionImpulsePolicy.TryResolveVelocityDelta(
 3272                bodyA?.ProjectLinearMotion(-normal) ?? Vector2d.Zero,
 3273                normalVelocity,
 3274                responseFactor,
 3275                bodyA?.EffectiveInverseMass ?? Fixed64.Zero,
 3276                denominator,
 3277                out Vector2d linearVelocityDeltaA);
 3278        bool angularAResolved = TryResolveAngularVelocityDelta(
 3279                bodyA,
 3280                relativeContactPointA,
 3281                -normal,
 3282                normalVelocity,
 3283                responseFactor,
 3284                denominator,
 3285                out Fixed64 angularVelocityDeltaA);
 3286        bool linearBResolved = ContinuousCollisionImpulsePolicy.TryResolveVelocityDelta(
 3287                bodyB?.ProjectLinearMotion(normal) ?? Vector2d.Zero,
 3288                normalVelocity,
 3289                responseFactor,
 3290                bodyB?.EffectiveInverseMass ?? Fixed64.Zero,
 3291                denominator,
 3292                out Vector2d linearVelocityDeltaB);
 3293        bool angularBResolved = TryResolveAngularVelocityDelta(
 3294                bodyB,
 3295                relativeContactPointB,
 3296                normal,
 3297                normalVelocity,
 3298                responseFactor,
 3299                denominator,
 32100                out Fixed64 angularVelocityDeltaB);
 32101        if (!(linearAResolved
 32102                & angularAResolved
 32103                & linearBResolved
 32104                & angularBResolved))
 105        {
 1106            return false;
 107        }
 108
 31109        result = new ContactNormalVelocityDeltaResult2D(
 31110            normalVelocity,
 31111            linearVelocityDeltaA,
 31112            angularVelocityDeltaA,
 31113            linearVelocityDeltaB,
 31114            angularVelocityDeltaB);
 31115        return true;
 116    }
 117
 118    internal static bool TryCalculateAccumulatedDelta(
 119        SolidBody2D? bodyA,
 120        Vector2d linearVelocityA,
 121        Fixed64 angularVelocityA,
 122        Vector2d relativeContactPointA,
 123        SolidBody2D? bodyB,
 124        Vector2d linearVelocityB,
 125        Fixed64 angularVelocityB,
 126        Vector2d relativeContactPointB,
 127        Vector2d normal,
 128        Fixed64 restitution,
 129        Fixed64 restitutionVelocityThreshold,
 130        Fixed64 accumulatedImpulse,
 131        Fixed64 positiveImpulseScale,
 132        Fixed64 negativeImpulseScale,
 133        out ContactNormalImpulseResult2D result)
 134    {
 16090135        result = default;
 16090136        bool inputsValid =
 16090137            accumulatedImpulse >= Fixed64.Zero
 16090138            & positiveImpulseScale >= Fixed64.Zero
 16090139            & negativeImpulseScale >= Fixed64.Zero;
 16090140        if (!inputsValid)
 3141            return false;
 16087142        if (!TryComputeNormalVelocity(
 16087143                linearVelocityA,
 16087144                angularVelocityA,
 16087145                relativeContactPointA,
 16087146                linearVelocityB,
 16087147                angularVelocityB,
 16087148                relativeContactPointB,
 16087149                normal,
 16087150                out Fixed64 normalVelocity)
 16087151            || !TryComputeDenominator(
 16087152                bodyA,
 16087153                relativeContactPointA,
 16087154                bodyB,
 16087155                relativeContactPointB,
 16087156                normal,
 16087157                out Fixed64 denominator))
 158        {
 41159            return false;
 160        }
 16046161        if (denominator <= Fixed64.Zero)
 162        {
 79163            result = Zero(normalVelocity);
 79164            return true;
 165        }
 166
 15967167        Fixed64 appliedRestitution = normalVelocity < -restitutionVelocityThreshold
 15967168            ? restitution
 15967169            : Fixed64.Zero;
 15967170        Fixed64 responseFactor = -(Fixed64.One + appliedRestitution);
 15967171        Fixed64 impulseScale = normalVelocity < Fixed64.Zero
 15967172            ? positiveImpulseScale
 15967173            : negativeImpulseScale;
 174        Fixed64 impulseScalar;
 15967175        if (!Fixed64.TryMultiplyDivide(
 15967176                normalVelocity,
 15967177                responseFactor,
 15967178                impulseScale,
 15967179                denominator,
 15967180                out Fixed64 scaledImpulse))
 181        {
 6182            if (normalVelocity < Fixed64.Zero)
 4183                return false;
 2184            impulseScalar = -accumulatedImpulse;
 185        }
 15961186        else if (!Fixed64.TryAdd(
 15961187                    accumulatedImpulse,
 15961188                    scaledImpulse,
 15961189                    out Fixed64 accumulated)
 15961190                || !Fixed64.TrySubtract(
 15961191                    FixedMath.Max(Fixed64.Zero, accumulated),
 15961192                    accumulatedImpulse,
 15961193                    out impulseScalar))
 194        {
 1195            return false;
 196        }
 15962197        if (impulseScalar == Fixed64.Zero)
 198        {
 15629199            result = Zero(normalVelocity);
 15629200            return true;
 201        }
 202
 333203        bool linearAResolved = TryComputeLinearVelocityDelta(
 333204            bodyA,
 333205            -normal,
 333206            impulseScalar,
 333207            out Vector2d linearA);
 333208        bool angularAResolved = TryComputeAngularVelocityDelta(
 333209            bodyA,
 333210            relativeContactPointA,
 333211            -normal,
 333212            impulseScalar,
 333213            out Fixed64 angularA);
 333214        bool linearBResolved = TryComputeLinearVelocityDelta(
 333215            bodyB,
 333216            normal,
 333217            impulseScalar,
 333218            out Vector2d linearB);
 333219        bool angularBResolved = TryComputeAngularVelocityDelta(
 333220            bodyB,
 333221            relativeContactPointB,
 333222            normal,
 333223            impulseScalar,
 333224            out Fixed64 angularB);
 333225        if (!(linearAResolved
 333226            & angularAResolved
 333227            & linearBResolved
 333228            & angularBResolved))
 229        {
 1230            return false;
 231        }
 332232        result = new ContactNormalImpulseResult2D(
 332233            normalVelocity,
 332234            impulseScalar,
 332235            linearA,
 332236            angularA,
 332237            linearB,
 332238            angularB);
 332239        return true;
 240    }
 241
 242    internal static bool TryCalculateVelocityDeltasExact(
 243        SolidBody2D? bodyA,
 244        Vector2d linearVelocityA,
 245        Fixed64 angularVelocityA,
 246        in ExactLever3D relativeContactPointA,
 247        SolidBody2D? bodyB,
 248        Vector2d linearVelocityB,
 249        Fixed64 angularVelocityB,
 250        in ExactLever3D relativeContactPointB,
 251        Vector2d normal,
 252        Fixed64 restitution,
 253        Fixed64 restitutionVelocityThreshold,
 254        out ContactNormalVelocityDeltaResult2D result)
 255    {
 34256        result = default;
 34257        if (!ExactContactLever2D.TryGetNormalResponse(
 34258                bodyA,
 34259                linearVelocityA,
 34260                angularVelocityA,
 34261                relativeContactPointA,
 34262                bodyB,
 34263                linearVelocityB,
 34264                angularVelocityB,
 34265                relativeContactPointB,
 34266                normal,
 34267                restitution,
 34268                restitutionVelocityThreshold,
 34269                out ExactNormalResponse3D response))
 270        {
 10271            return false;
 272        }
 273
 24274        bool hasNormalVelocity =
 24275            response.TryGetNormalVelocity(out Fixed64 normalVelocity);
 24276        result = new ContactNormalVelocityDeltaResult2D(
 24277            normalVelocity,
 24278            ExactContactLever2D.ToPlanar(response.FirstLinearVelocityDelta),
 24279            ExactContactLever2D.ToPlanarAngular(response.FirstAngularVelocityDelta),
 24280            ExactContactLever2D.ToPlanar(response.SecondLinearVelocityDelta),
 24281            ExactContactLever2D.ToPlanarAngular(response.SecondAngularVelocityDelta),
 24282            response.IsClosing,
 24283            hasNormalVelocity);
 24284        return true;
 285    }
 286
 287    internal static bool TryCalculateAccumulatedDeltaExact(
 288        SolidBody2D? bodyA,
 289        Vector2d linearVelocityA,
 290        Fixed64 angularVelocityA,
 291        in ExactLever3D relativeContactPointA,
 292        SolidBody2D? bodyB,
 293        Vector2d linearVelocityB,
 294        Fixed64 angularVelocityB,
 295        in ExactLever3D relativeContactPointB,
 296        Vector2d normal,
 297        Fixed64 restitution,
 298        Fixed64 restitutionVelocityThreshold,
 299        Fixed64 accumulatedImpulse,
 300        Fixed64 positiveImpulseScale,
 301        Fixed64 negativeImpulseScale,
 302        out ContactNormalImpulseResult2D result,
 303        in ContactResponseSnapshot impact = default)
 304    {
 370305        result = default;
 370306        if (!ExactContactLever2D.TryGetAccumulatedNormalResponse(
 370307                bodyA,
 370308                linearVelocityA,
 370309                angularVelocityA,
 370310                relativeContactPointA,
 370311                bodyB,
 370312                linearVelocityB,
 370313                angularVelocityB,
 370314                relativeContactPointB,
 370315                normal,
 370316                restitution,
 370317                restitutionVelocityThreshold,
 370318                accumulatedImpulse,
 370319                positiveImpulseScale,
 370320                negativeImpulseScale,
 370321                out ExactNormalResponse3D response, impact))
 322        {
 3323            return false;
 324        }
 325
 367326        bool hasNormalVelocity =
 367327            response.TryGetNormalVelocity(out Fixed64 normalVelocity);
 367328        bool hasAppliedImpulse =
 367329            response.TryGetAppliedImpulse(out Fixed64 appliedImpulse);
 367330        bool hasAccumulatedImpulse =
 367331            response.TryGetAccumulatedImpulse(
 367332                out Fixed64 newAccumulatedImpulse);
 367333        Fixed64 impulseScalar = hasAccumulatedImpulse
 367334            ? newAccumulatedImpulse - accumulatedImpulse
 367335            : -accumulatedImpulse;
 367336        result = new ContactNormalImpulseResult2D(
 367337            normalVelocity,
 367338            impulseScalar,
 367339            appliedImpulse,
 367340            ExactContactLever2D.ToPlanar(response.FirstLinearVelocityDelta),
 367341            ExactContactLever2D.ToPlanarAngular(response.FirstAngularVelocityDelta),
 367342            ExactContactLever2D.ToPlanar(response.SecondLinearVelocityDelta),
 367343            ExactContactLever2D.ToPlanarAngular(response.SecondAngularVelocityDelta),
 367344            hasNormalVelocity,
 367345            hasAppliedImpulse,
 367346            hasAccumulatedImpulse);
 367347        return true;
 348    }
 349
 350    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 351    private static bool TryComputeNormalVelocity(
 352        Vector2d linearVelocityA,
 353        Fixed64 angularVelocityA,
 354        Vector2d relativeContactPointA,
 355        Vector2d linearVelocityB,
 356        Fixed64 angularVelocityB,
 357        Vector2d relativeContactPointB,
 358        Vector2d normal,
 359        out Fixed64 normalVelocity)
 360    {
 16135361        bool angularAResolved = ContactResponseArithmetic3D.TryCross(
 16135362            new Vector3d(
 16135363                Fixed64.Zero,
 16135364                -angularVelocityA,
 16135365                Fixed64.Zero),
 16135366            ExactContactLever2D.ToSpatial(relativeContactPointA),
 16135367            out Vector3d angularA);
 16135368        bool angularBResolved = ContactResponseArithmetic3D.TryCross(
 16135369            new Vector3d(
 16135370                Fixed64.Zero,
 16135371                -angularVelocityB,
 16135372                Fixed64.Zero),
 16135373            ExactContactLever2D.ToSpatial(relativeContactPointB),
 16135374            out Vector3d angularB);
 16135375        bool relativeResolved = Vector3d.TrySubtractSums(
 16135376            ExactContactLever2D.ToSpatial(linearVelocityB),
 16135377            angularB,
 16135378            ExactContactLever2D.ToSpatial(linearVelocityA),
 16135379            angularA,
 16135380            out Vector3d relative);
 16135381        bool projectionResolved = ContactResponseArithmetic3D.TryDot(
 16135382            relative,
 16135383            ExactContactLever2D.ToSpatial(normal),
 16135384            out normalVelocity);
 16135385        if (!(angularAResolved
 16135386            & angularBResolved
 16135387            & relativeResolved
 16135388            & projectionResolved))
 389        {
 4390            normalVelocity = default;
 4391            return false;
 392        }
 16131393        return true;
 394    }
 395
 396    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 397    internal static bool TryComputeDenominator(
 398        SolidBody2D? bodyA,
 399        Vector2d relativeContactPointA,
 400        SolidBody2D? bodyB,
 401        Vector2d relativeContactPointB,
 402        Vector2d normal,
 403        out Fixed64 denominator)
 404    {
 18429405        bool angularAResolved = TryComputeAngularDenominator(
 18429406            bodyA,
 18429407            relativeContactPointA,
 18429408            normal,
 18429409            out Fixed64 angularA);
 18429410        bool angularBResolved = TryComputeAngularDenominator(
 18429411            bodyB,
 18429412            relativeContactPointB,
 18429413            normal,
 18429414            out Fixed64 angularB);
 18429415        bool linearAResolved = TryGetConstrainedInverseMass(
 18429416            bodyA,
 18429417            normal,
 18429418            out Fixed64 linearA);
 18429419        bool linearBResolved = TryGetConstrainedInverseMass(
 18429420            bodyB,
 18429421            normal,
 18429422            out Fixed64 linearB);
 18429423        bool sumResolved = Fixed64.TryAdd(
 18429424                linearA,
 18429425                linearB,
 18429426                out Fixed64 linear)
 18429427            & Fixed64.TryAdd(
 18429428                linear,
 18429429                angularA,
 18429430                out Fixed64 first)
 18429431            & Fixed64.TryAdd(
 18429432                first,
 18429433                angularB,
 18429434                out denominator);
 18429435        if (!(linearAResolved
 18429436            & linearBResolved
 18429437            & angularAResolved
 18429438            & angularBResolved
 18429439            & sumResolved))
 440        {
 42441            denominator = default;
 42442            return false;
 443        }
 18387444        return true;
 445    }
 446
 447    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 448    internal static bool TryComputeAngularDenominator(
 449        SolidBody2D? body,
 450        Vector2d relativeContactPoint,
 451        Vector2d axis,
 452        out Fixed64 denominator)
 453    {
 221209454        if (body?.CanRotate != true)
 455        {
 201210456            denominator = Fixed64.Zero;
 201210457            return true;
 458        }
 459
 19999460        denominator = default;
 19999461        bool crossResolved = ContactResponseArithmetic3D.TryCross(
 19999462                ExactContactLever2D.ToSpatial(relativeContactPoint),
 19999463                ExactContactLever2D.ToSpatial(axis),
 19999464                out Vector3d cross);
 19999465        bool denominatorResolved = crossResolved
 19999466            && Fixed64.TryMultiplyDivide(
 19999467                cross.Y,
 19999468                cross.Y,
 19999469                body.EffectiveInverseMomentOfInertia,
 19999470                Fixed64.One,
 19999471                out denominator);
 19999472        if (!denominatorResolved
 19999473            || (denominator == Fixed64.Zero
 19999474                && cross.Y != Fixed64.Zero
 19999475                && body.EffectiveInverseMomentOfInertia
 19999476                    != Fixed64.Zero))
 477        {
 50478            denominator = default;
 50479            return false;
 480        }
 481
 19949482        return true;
 483    }
 484
 485    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 486    internal static bool TryGetConstrainedInverseMass(
 487        SolidBody2D? body,
 488        Vector2d axis,
 489        out Fixed64 inverseMass)
 490    {
 36880491        if (body == null)
 492        {
 5175493            inverseMass = Fixed64.Zero;
 5175494            return true;
 495        }
 496
 31705497        inverseMass = body.GetConstrainedInverseMass(axis);
 31705498        return inverseMass != Fixed64.Zero
 31705499            || body.EffectiveInverseMass == Fixed64.Zero
 31705500            || body.ProjectLinearMotion(axis) == Vector2d.Zero;
 501    }
 502
 503    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 504    internal static bool TryComputeLinearVelocityDelta(
 505        SolidBody2D? body,
 506        Vector2d signedNormal,
 507        Fixed64 impulseScalar,
 508        out Vector2d velocityDelta) =>
 18587509        ContinuousCollisionImpulsePolicy.TryResolveVelocityDelta(
 18587510            body?.ProjectLinearMotion(signedNormal) ?? Vector2d.Zero,
 18587511            impulseScalar,
 18587512            body?.EffectiveInverseMass ?? Fixed64.Zero,
 18587513            Fixed64.One,
 18587514            out velocityDelta);
 515
 516    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 517    internal static bool TryComputeAngularVelocityDelta(
 518        SolidBody2D? body,
 519        Vector2d relativeContactPoint,
 520        Vector2d signedNormal,
 521        Fixed64 impulseScalar,
 522        out Fixed64 velocityDelta)
 523    {
 18590524        velocityDelta = Fixed64.Zero;
 18590525        if (body?.CanRotate != true)
 17816526            return true;
 527
 774528        Vector3d spatialPoint =
 774529            ExactContactLever2D.ToSpatial(relativeContactPoint);
 774530        Vector3d spatialNormal =
 774531            ExactContactLever2D.ToSpatial(signedNormal);
 774532        return ContactResponseArithmetic3D.TryCross(
 774533                spatialPoint,
 774534                spatialNormal,
 774535                out Vector3d cross)
 774536            && Fixed64.TryMultiplyDivide(
 774537                -cross.Y,
 774538                impulseScalar,
 774539                body.EffectiveInverseMomentOfInertia,
 774540                Fixed64.One,
 774541                out velocityDelta);
 542    }
 543
 544    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 545    private static bool TryResolveAngularVelocityDelta(
 546        SolidBody2D? body,
 547        Vector2d relativeContactPoint,
 548        Vector2d signedNormal,
 549        Fixed64 normalVelocity,
 550        Fixed64 responseFactor,
 551        Fixed64 denominator,
 552        out Fixed64 velocityDelta)
 553    {
 64554        velocityDelta = Fixed64.Zero;
 64555        if (body?.CanRotate != true)
 21556            return true;
 557
 43558        Fixed64 torqueScale = Vector2d.CrossProduct(relativeContactPoint, signedNormal);
 43559        if (torqueScale == Fixed64.Zero)
 30560            return true;
 561
 13562        bool angularScaleResolved = Fixed64.TryMultiplyDivide(
 13563            normalVelocity,
 13564            responseFactor,
 13565            body.EffectiveInverseMomentOfInertia,
 13566            denominator,
 13567            out Fixed64 angularScale);
 13568        bool velocityDeltaResolved = Fixed64.TryMultiplyDivide(
 13569            torqueScale,
 13570            angularScale,
 13571            Fixed64.One,
 13572            out velocityDelta);
 13573        return angularScaleResolved
 13574            & (angularScale != Fixed64.Zero | torqueScale.Abs() <= Fixed64.One)
 13575            & velocityDeltaResolved;
 576    }
 577
 578    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 579    private static ContactNormalImpulseResult2D Zero(Fixed64 normalVelocity) =>
 15708580        new(
 15708581            normalVelocity,
 15708582            Fixed64.Zero,
 15708583            Vector2d.Zero,
 15708584            Fixed64.Zero,
 15708585            Vector2d.Zero,
 15708586            Fixed64.Zero);
 587
 588    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 589    private static ContactNormalVelocityDeltaResult2D ZeroVelocityDelta(Fixed64 normalVelocity) =>
 2590        new(
 2591            normalVelocity,
 2592            Vector2d.Zero,
 2593            Fixed64.Zero,
 2594            Vector2d.Zero,
 2595            Fixed64.Zero);
 596}

Methods/Properties

TryCalculateVelocityDeltas(Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.CollisionHandling.ContactNormalVelocityDeltaResult2D&)
TryCalculateAccumulatedDelta(Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.CollisionHandling.ContactNormalImpulseResult2D&)
TryCalculateVelocityDeltasExact(Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,Gravitas.CollisionHandling.ExactLever3D&,Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,Gravitas.CollisionHandling.ExactLever3D&,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.CollisionHandling.ContactNormalVelocityDeltaResult2D&)
TryCalculateAccumulatedDeltaExact(Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,Gravitas.CollisionHandling.ExactLever3D&,Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,Gravitas.CollisionHandling.ExactLever3D&,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.CollisionHandling.ContactNormalImpulseResult2D&,Gravitas.CollisionHandling.ContactResponseSnapshot&)
TryComputeNormalVelocity(FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64&)
TryComputeDenominator(Gravitas.SolidBody2D,FixedMathSharp.Vector2d,Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64&)
TryComputeAngularDenominator(Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64&)
TryGetConstrainedInverseMass(Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64&)
TryComputeLinearVelocityDelta(Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d&)
TryComputeAngularVelocityDelta(Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64&)
TryResolveAngularVelocityDelta(Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64&)
Zero(FixedMathSharp.Fixed64)
ZeroVelocityDelta(FixedMathSharp.Fixed64)