< Summary

Information
Class: Gravitas.CollisionHandling.ContactNormalImpulseMixed
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Response/Mixed/ContactNormalImpulseMixed.cs
Line coverage
100%
Covered lines: 338
Uncovered lines: 0
Coverable lines: 338
Total lines: 526
Line coverage: 100%
Branch coverage
100%
Covered branches: 74
Total branches: 74
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/Mixed/ContactNormalImpulseMixed.cs

#LineLine coverage
 1//=======================================================================
 2// ContactNormalImpulseMixed.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 mixed 3D/2D contact-point normal response
 19/// without mutating either participant.
 20/// </summary>
 21internal static class ContactNormalImpulseMixed
 22{
 23    internal static bool CanUseCompactResponse(
 24        SolidBody? body3D,
 25        Vector3d linearVelocity3D,
 26        Vector3d angularVelocity3D,
 27        Vector3d relativeContactPoint3D,
 28        SolidBody2D? body2D,
 29        Vector2d linearVelocity2D,
 30        Fixed64 angularVelocity2D,
 31        Vector2d relativeContactPoint2D,
 32        Vector3d axis)
 33    {
 18442934        Vector3d planarLever =
 18442935            ExactContactLever2D.ToSpatial(relativeContactPoint2D);
 18442936        return ContactResponseArithmetic3D.CanUseFastPointVelocity(
 18442937                linearVelocity3D,
 18442938                angularVelocity3D,
 18442939                relativeContactPoint3D,
 18442940                ExactContactLever2D.ToSpatial(linearVelocity2D),
 18442941                new Vector3d(
 18442942                    Fixed64.Zero,
 18442943                    -angularVelocity2D,
 18442944                    Fixed64.Zero),
 18442945                planarLever,
 18442946                axis)
 18442947            && ContactResponseArithmetic3D.CanUseFastAngularResponse(
 18442948                relativeContactPoint3D,
 18442949                axis,
 18442950                body3D?.GetConstrainedInverseInertiaTensor()
 18442951                    ?? Fixed3x3.Zero)
 18442952            && ContactResponseArithmetic3D.CanUseFastAngularResponse(
 18442953                planarLever,
 18442954                axis,
 18442955                ExactContactLever2D.CreateInverseInertia(body2D));
 56    }
 57
 58    internal static bool TryCalculateVelocityDeltas(
 59        SolidBody? body3D,
 60        Vector3d linearVelocity3D,
 61        Vector3d angularVelocity3D,
 62        Vector3d relativeContactPoint3D,
 63        SolidBody2D? body2D,
 64        Vector2d linearVelocity2D,
 65        Fixed64 angularVelocity2D,
 66        Vector2d relativeContactPoint2D,
 67        Vector3d normal,
 68        Fixed64 restitution,
 69        Fixed64 restitutionVelocityThreshold,
 70        out ContactNormalVelocityDeltaResultMixed result)
 71    {
 2672        result = default;
 2673        if (!TryComputeNormalVelocity(
 2674                linearVelocity3D,
 2675                angularVelocity3D,
 2676                relativeContactPoint3D,
 2677                linearVelocity2D,
 2678                angularVelocity2D,
 2679                relativeContactPoint2D,
 2680                normal,
 2681                out Fixed64 normalVelocity))
 82        {
 183            return false;
 84        }
 2585        if (normalVelocity >= Fixed64.Zero)
 86        {
 187            result = ZeroVelocityDelta(normalVelocity);
 188            return true;
 89        }
 90
 2491        if (!TryComputeDenominator(
 2492                body3D,
 2493                relativeContactPoint3D,
 2494                body2D,
 2495                relativeContactPoint2D,
 2496                normal,
 2497                out Fixed64 denominator))
 98        {
 399            return false;
 100        }
 21101        if (denominator <= Fixed64.Zero)
 1102            return false;
 103
 20104        Fixed64 appliedRestitution = normalVelocity < -restitutionVelocityThreshold
 20105            ? restitution
 20106            : Fixed64.Zero;
 20107        Fixed64 responseFactor = -(Fixed64.One + appliedRestitution);
 20108        Vector2d planarNormal = normal.ToVector2d();
 20109        bool linear3DResolved = ContinuousCollisionImpulsePolicy.TryResolveVelocityDelta(
 20110                body3D?.ProjectLinearMotion(-normal) ?? Vector3d.Zero,
 20111                normalVelocity,
 20112                responseFactor,
 20113                body3D?.EffectiveInverseMass ?? Fixed64.Zero,
 20114                denominator,
 20115                out Vector3d linearVelocityDelta3D);
 20116        bool angular3DResolved = TryResolveAngularVelocityDelta3D(
 20117                body3D,
 20118                relativeContactPoint3D,
 20119                -normal,
 20120                normalVelocity,
 20121                responseFactor,
 20122                denominator,
 20123                out Vector3d angularVelocityDelta3D);
 20124        bool linear2DResolved = ContinuousCollisionImpulsePolicy.TryResolveVelocityDelta(
 20125                body2D?.ProjectLinearMotion(planarNormal) ?? Vector2d.Zero,
 20126                normalVelocity,
 20127                responseFactor,
 20128                body2D?.EffectiveInverseMass ?? Fixed64.Zero,
 20129                denominator,
 20130                out Vector2d linearVelocityDelta2D);
 20131        bool angular2DResolved = TryResolveAngularVelocityDelta2D(
 20132                body2D,
 20133                relativeContactPoint2D,
 20134                planarNormal,
 20135                normalVelocity,
 20136                responseFactor,
 20137                denominator,
 20138                out Fixed64 angularVelocityDelta2D);
 20139        if (!(linear3DResolved
 20140                & angular3DResolved
 20141                & linear2DResolved
 20142                & angular2DResolved))
 143        {
 1144            return false;
 145        }
 146
 19147        result = new ContactNormalVelocityDeltaResultMixed(
 19148            normalVelocity,
 19149            linearVelocityDelta3D,
 19150            angularVelocityDelta3D,
 19151            linearVelocityDelta2D,
 19152            angularVelocityDelta2D);
 19153        return true;
 154    }
 155
 156    internal static bool TryCalculateAccumulatedDelta(
 157        SolidBody? body3D,
 158        Vector3d linearVelocity3D,
 159        Vector3d angularVelocity3D,
 160        Vector3d relativeContactPoint3D,
 161        SolidBody2D? body2D,
 162        Vector2d linearVelocity2D,
 163        Fixed64 angularVelocity2D,
 164        Vector2d relativeContactPoint2D,
 165        Vector3d normal,
 166        Fixed64 restitution,
 167        Fixed64 restitutionVelocityThreshold,
 168        Fixed64 accumulatedImpulse,
 169        Fixed64 positiveImpulseScale,
 170        Fixed64 negativeImpulseScale,
 171        out ContactNormalImpulseResultMixed result)
 172    {
 184307173        result = default;
 184307174        bool inputsValid =
 184307175            accumulatedImpulse >= Fixed64.Zero
 184307176            & positiveImpulseScale >= Fixed64.Zero
 184307177            & negativeImpulseScale >= Fixed64.Zero;
 184307178        if (!inputsValid)
 3179            return false;
 184304180        if (!TryComputeNormalVelocity(
 184304181                linearVelocity3D,
 184304182                angularVelocity3D,
 184304183                relativeContactPoint3D,
 184304184                linearVelocity2D,
 184304185                angularVelocity2D,
 184304186                relativeContactPoint2D,
 184304187                normal,
 184304188                out Fixed64 normalVelocity)
 184304189            || !TryComputeDenominator(
 184304190                body3D,
 184304191                relativeContactPoint3D,
 184304192                body2D,
 184304193                relativeContactPoint2D,
 184304194                normal,
 184304195                out Fixed64 denominator))
 196        {
 615197            return false;
 198        }
 183689199        if (denominator <= Fixed64.Zero)
 200        {
 38232201            result = ZeroImpulse(normalVelocity);
 38232202            return true;
 203        }
 204
 145457205        Fixed64 appliedRestitution = normalVelocity < -restitutionVelocityThreshold
 145457206            ? restitution
 145457207            : Fixed64.Zero;
 145457208        Fixed64 responseFactor = -(Fixed64.One + appliedRestitution);
 145457209        Fixed64 impulseScale = normalVelocity < Fixed64.Zero
 145457210            ? positiveImpulseScale
 145457211            : negativeImpulseScale;
 212        Fixed64 impulseScalar;
 145457213        if (!Fixed64.TryMultiplyDivide(
 145457214                normalVelocity,
 145457215                responseFactor,
 145457216                impulseScale,
 145457217                denominator,
 145457218                out Fixed64 scaledImpulse))
 219        {
 46220            if (normalVelocity < Fixed64.Zero)
 44221                return false;
 2222            impulseScalar = -accumulatedImpulse;
 223        }
 145411224        else if (!Fixed64.TryAdd(
 145411225                    accumulatedImpulse,
 145411226                    scaledImpulse,
 145411227                    out Fixed64 accumulated)
 145411228                || !Fixed64.TrySubtract(
 145411229                    FixedMath.Max(Fixed64.Zero, accumulated),
 145411230                    accumulatedImpulse,
 145411231                    out impulseScalar))
 232        {
 1233            return false;
 234        }
 145412235        if (impulseScalar == Fixed64.Zero)
 236        {
 127506237            result = ZeroImpulse(normalVelocity);
 127506238            return true;
 239        }
 240
 17906241        Vector2d planarNormal = normal.ToVector2d();
 17906242        bool impulse3DResolved = ContactResponseArithmetic3D.TryScale(
 17906243            -normal,
 17906244            impulseScalar,
 17906245            out Vector3d impulse3D);
 17906246        bool linear3DResolved =
 17906247            ContactNormalImpulse3D.TryComputeLinearVelocityDelta(
 17906248                body3D,
 17906249                impulse3D,
 17906250                out Vector3d linearVelocityDelta3D);
 17906251        bool angular3DResolved =
 17906252            ContactNormalImpulse3D.TryComputeAngularVelocityDelta(
 17906253                body3D,
 17906254                relativeContactPoint3D,
 17906255                impulse3D,
 17906256                out Vector3d angularVelocityDelta3D);
 17906257        bool linear2DResolved =
 17906258            ContactNormalImpulse2D.TryComputeLinearVelocityDelta(
 17906259                body2D,
 17906260                planarNormal,
 17906261                impulseScalar,
 17906262                out Vector2d linearVelocityDelta2D);
 17906263        bool angular2DResolved =
 17906264            ContactNormalImpulse2D.TryComputeAngularVelocityDelta(
 17906265                body2D,
 17906266                relativeContactPoint2D,
 17906267                planarNormal,
 17906268                impulseScalar,
 17906269                out Fixed64 angularVelocityDelta2D);
 17906270        if (!(impulse3DResolved
 17906271            & linear3DResolved
 17906272            & angular3DResolved
 17906273            & linear2DResolved
 17906274            & angular2DResolved))
 275        {
 2224276            return false;
 277        }
 278
 15682279        result = new ContactNormalImpulseResultMixed(
 15682280            normalVelocity,
 15682281            impulseScalar,
 15682282            linearVelocityDelta3D,
 15682283            angularVelocityDelta3D,
 15682284            linearVelocityDelta2D,
 15682285            angularVelocityDelta2D);
 15682286        return true;
 287    }
 288
 289    internal static bool TryCalculateAccumulatedDeltaExact(
 290        SolidBody? body3D,
 291        Vector3d linearVelocity3D,
 292        Vector3d angularVelocity3D,
 293        in ExactLever3D relativeContactPoint3D,
 294        SolidBody2D? body2D,
 295        Vector2d linearVelocity2D,
 296        Fixed64 angularVelocity2D,
 297        in ExactLever3D relativeContactPoint2D,
 298        Vector3d normal,
 299        Fixed64 restitution,
 300        Fixed64 restitutionVelocityThreshold,
 301        Fixed64 accumulatedImpulse,
 302        Fixed64 positiveImpulseScale,
 303        Fixed64 negativeImpulseScale,
 304        ref ExactContactImpulseState? exactImpulse,
 305        out ContactNormalImpulseResultMixed result,
 306        in ContactResponseSnapshot impact = default)
 307    {
 3244308        result = default;
 3244309        ExactContactResponseOperand3D first =
 3244310            ExactContactLever3D.CreateResponseOperand(
 3244311                body3D,
 3244312                linearVelocity3D,
 3244313                angularVelocity3D,
 3244314                relativeContactPoint3D,
 3244315                -normal);
 3244316        ExactContactResponseOperand3D second =
 3244317            ExactContactLever2D.CreateResponseOperand(
 3244318                body2D,
 3244319                linearVelocity2D,
 3244320                angularVelocity2D,
 3244321                relativeContactPoint2D,
 3244322                normal);
 323        ExactNormalResponse3D response;
 3244324        bool resolved = impact.IsValid
 3244325            ? ExactContactResponseKernel.TryGetAccumulatedNormalResponse(
 3244326                first,
 3244327                second,
 3244328                normal,
 3244329                restitution,
 3244330                restitutionVelocityThreshold,
 3244331                accumulatedImpulse,
 3244332                positiveImpulseScale,
 3244333                negativeImpulseScale,
 3244334                out response, impact, ref exactImpulse)
 3244335            : ExactContactResponseKernel.TryGetAccumulatedNormalResponse(first, second, normal,
 3244336                restitution, restitutionVelocityThreshold, accumulatedImpulse, positiveImpulseScale,
 3244337                negativeImpulseScale, out response);
 3244338        if (!resolved)
 339        {
 12340            return false;
 341        }
 342
 3232343        bool hasNormalVelocity =
 3232344            response.TryGetNormalVelocity(out Fixed64 normalVelocity);
 3232345        bool hasAppliedImpulse =
 3232346            response.TryGetAppliedImpulse(out Fixed64 appliedImpulse);
 3232347        Fixed64 impulseScalar = response.TryGetAccumulatedImpulse(
 3232348                out Fixed64 newAccumulatedImpulse)
 3232349            ? newAccumulatedImpulse - accumulatedImpulse
 3232350            : -accumulatedImpulse;
 3232351        result = new ContactNormalImpulseResultMixed(
 3232352            normalVelocity,
 3232353            impulseScalar,
 3232354            appliedImpulse,
 3232355            response.FirstLinearVelocityDelta,
 3232356            response.FirstAngularVelocityDelta,
 3232357            ExactContactLever2D.ToPlanar(response.SecondLinearVelocityDelta),
 3232358            ExactContactLever2D.ToPlanarAngular(response.SecondAngularVelocityDelta),
 3232359            hasNormalVelocity,
 3232360            hasAppliedImpulse);
 3232361        return true;
 362    }
 363
 364    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 365    private static bool TryComputeNormalVelocity(
 366        Vector3d linearVelocity3D,
 367        Vector3d angularVelocity3D,
 368        Vector3d relativeContactPoint3D,
 369        Vector2d linearVelocity2D,
 370        Fixed64 angularVelocity2D,
 371        Vector2d relativeContactPoint2D,
 372        Vector3d normal,
 373        out Fixed64 normalVelocity) =>
 184330374        ContactNormalImpulse3D.TryComputeNormalVelocity(
 184330375            linearVelocity3D,
 184330376            angularVelocity3D,
 184330377            relativeContactPoint3D,
 184330378            ExactContactLever2D.ToSpatial(linearVelocity2D),
 184330379            new Vector3d(Fixed64.Zero, -angularVelocity2D, Fixed64.Zero),
 184330380            ExactContactLever2D.ToSpatial(relativeContactPoint2D),
 184330381            normal,
 184330382            out normalVelocity);
 383
 384    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 385    private static bool TryComputeDenominator(
 386        SolidBody? body3D,
 387        Vector3d relativeContactPoint3D,
 388        SolidBody2D? body2D,
 389        Vector2d relativeContactPoint2D,
 390        Vector3d normal,
 391        out Fixed64 denominator)
 392    {
 184327393        Vector2d planarNormal = normal.ToVector2d();
 184327394        bool angular3DResolved =
 184327395            ContactNormalImpulse3D.TryComputeAngularDenominator(
 184327396                body3D,
 184327397                relativeContactPoint3D,
 184327398                normal,
 184327399                out Fixed64 angular3D);
 184327400        bool angular2DResolved =
 184327401            ContactNormalImpulse2D.TryComputeAngularDenominator(
 184327402                body2D,
 184327403                relativeContactPoint2D,
 184327404                planarNormal,
 184327405                out Fixed64 angular2D);
 184327406        bool sumResolved = Fixed64.TryAdd(
 184327407                GetConstrainedInverseMass3D(body3D, normal),
 184327408                GetConstrainedInverseMass2D(body2D, normal),
 184327409                out Fixed64 linear)
 184327410            & Fixed64.TryAdd(linear, angular3D, out Fixed64 first)
 184327411            & Fixed64.TryAdd(first, angular2D, out denominator);
 184327412        if (!(angular3DResolved & angular2DResolved & sumResolved))
 413        {
 617414            denominator = default;
 617415            return false;
 416        }
 417
 183710418        return true;
 419    }
 420
 421    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 422    private static Fixed64 GetConstrainedInverseMass3D(SolidBody? body, Vector3d axis) =>
 184327423        body?.GetConstrainedInverseMass(axis) ?? Fixed64.Zero;
 424
 425    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 426    private static Fixed64 GetConstrainedInverseMass2D(SolidBody2D? body, Vector3d axis)
 427    {
 184327428        if (body == null)
 107522429            return Fixed64.Zero;
 430
 76805431        Vector2d planarAxis = axis.ToVector2d();
 76805432        return planarAxis == Vector2d.Zero
 76805433            ? Fixed64.Zero
 76805434            : body.GetConstrainedInverseMass(planarAxis) * planarAxis.MagnitudeSquared;
 435    }
 436
 437    private static bool TryResolveAngularVelocityDelta3D(
 438        SolidBody? body,
 439        Vector3d relativeContactPoint,
 440        Vector3d signedNormal,
 441        Fixed64 normalVelocity,
 442        Fixed64 responseFactor,
 443        Fixed64 denominator,
 444        out Vector3d velocityDelta)
 445    {
 20446        velocityDelta = Vector3d.Zero;
 20447        if (body?.CanRotate != true)
 3448            return true;
 449
 17450        Vector3d response = body.ApplyConstrainedInverseInertia(
 17451            Vector3d.Cross(relativeContactPoint, signedNormal));
 17452        bool xResolved = Fixed64.TryMultiplyDivide(
 17453            response.X,
 17454            normalVelocity,
 17455            responseFactor,
 17456            denominator,
 17457            out Fixed64 x);
 17458        bool yResolved = Fixed64.TryMultiplyDivide(
 17459            response.Y,
 17460            normalVelocity,
 17461            responseFactor,
 17462            denominator,
 17463            out Fixed64 y);
 17464        bool zResolved = Fixed64.TryMultiplyDivide(
 17465            response.Z,
 17466            normalVelocity,
 17467            responseFactor,
 17468            denominator,
 17469            out Fixed64 z);
 17470        velocityDelta = new Vector3d(x, y, z);
 17471        return xResolved & yResolved & zResolved;
 472    }
 473
 474    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 475    private static bool TryResolveAngularVelocityDelta2D(
 476        SolidBody2D? body,
 477        Vector2d relativeContactPoint,
 478        Vector2d signedNormal,
 479        Fixed64 normalVelocity,
 480        Fixed64 responseFactor,
 481        Fixed64 denominator,
 482        out Fixed64 velocityDelta)
 483    {
 20484        velocityDelta = Fixed64.Zero;
 20485        if (body?.CanRotate != true)
 5486            return true;
 487
 15488        Fixed64 torqueScale = Vector2d.CrossProduct(relativeContactPoint, signedNormal);
 15489        if (torqueScale == Fixed64.Zero)
 13490            return true;
 491
 2492        bool angularScaleResolved = Fixed64.TryMultiplyDivide(
 2493            normalVelocity,
 2494            responseFactor,
 2495            body.EffectiveInverseMomentOfInertia,
 2496            denominator,
 2497            out Fixed64 angularScale);
 2498        bool velocityDeltaResolved = Fixed64.TryMultiplyDivide(
 2499            torqueScale,
 2500            angularScale,
 2501            Fixed64.One,
 2502            out velocityDelta);
 2503        return angularScaleResolved
 2504            & (angularScale != Fixed64.Zero | torqueScale.Abs() <= Fixed64.One)
 2505            & velocityDeltaResolved;
 506    }
 507
 508    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 509    private static ContactNormalImpulseResultMixed ZeroImpulse(Fixed64 normalVelocity) =>
 165738510        new(
 165738511            normalVelocity,
 165738512            Fixed64.Zero,
 165738513            Vector3d.Zero,
 165738514            Vector3d.Zero,
 165738515            Vector2d.Zero,
 165738516            Fixed64.Zero);
 517
 518    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 519    private static ContactNormalVelocityDeltaResultMixed ZeroVelocityDelta(Fixed64 normalVelocity) =>
 1520        new(
 1521            normalVelocity,
 1522            Vector3d.Zero,
 1523            Vector3d.Zero,
 1524            Vector2d.Zero,
 1525            Fixed64.Zero);
 526}

Methods/Properties

CanUseCompactResponse(Gravitas.SolidBody,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,FixedMathSharp.Vector3d)
TryCalculateVelocityDeltas(Gravitas.SolidBody,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.CollisionHandling.ContactNormalVelocityDeltaResultMixed&)
TryCalculateAccumulatedDelta(Gravitas.SolidBody,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.CollisionHandling.ContactNormalImpulseResultMixed&)
TryCalculateAccumulatedDeltaExact(Gravitas.SolidBody,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,Gravitas.CollisionHandling.ExactLever3D&,Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,Gravitas.CollisionHandling.ExactLever3D&,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,Gravitas.CollisionHandling.ExactContactImpulseState&,Gravitas.CollisionHandling.ContactNormalImpulseResultMixed&,Gravitas.CollisionHandling.ContactResponseSnapshot&)
TryComputeNormalVelocity(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64&)
TryComputeDenominator(Gravitas.SolidBody,FixedMathSharp.Vector3d,Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64&)
GetConstrainedInverseMass3D(Gravitas.SolidBody,FixedMathSharp.Vector3d)
GetConstrainedInverseMass2D(Gravitas.SolidBody2D,FixedMathSharp.Vector3d)
TryResolveAngularVelocityDelta3D(Gravitas.SolidBody,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d&)
TryResolveAngularVelocityDelta2D(Gravitas.SolidBody2D,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64&)
ZeroImpulse(FixedMathSharp.Fixed64)
ZeroVelocityDelta(FixedMathSharp.Fixed64)