< Summary

Information
Class: Gravitas.CollisionHandling.ContinuousCollisionMath
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Continuous/ContinuousCollisionMath.cs
Line coverage
100%
Covered lines: 207
Uncovered lines: 0
Coverable lines: 207
Total lines: 461
Line coverage: 100%
Branch coverage
100%
Covered branches: 78
Total branches: 78
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/Continuous/ContinuousCollisionMath.cs

#LineLine coverage
 1//=======================================================================
 2// ContinuousCollisionMath.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;
 10using FixedMathSharp.Geometry;
 11
 12namespace Gravitas.CollisionHandling;
 13
 14/// <summary>
 15/// Provides motion bounds, interval clipping, and search limits for continuous collision detection.
 16/// </summary>
 17internal static partial class ContinuousCollisionMath
 18{
 19    public const int RotationalIntervalMaxDepth = 12;
 20    public const int RotationalIntervalNodeBudget = 64;
 21
 22    // Pose reconstruction uses normalized fixed-point rotations. Cover both
 23    // absolute operation rounding and its radius-scaled positional effect;
 24    // failure to represent either term keeps the interval unresolved.
 125    private static readonly Fixed64 RotationalMotionUncertainty = Fixed64.Epsilon * 64;
 126    private static readonly Fixed64 RotationalRelativeUncertainty =
 127        FixedMath.CanonicalSinCosErrorBound * 16;
 128    private static readonly Fixed64 ClosestFeatureRelativeUncertainty =
 129        Fixed64.MinIncrement * 128;
 30
 31    public static bool TryResolveRotationalSearchLimit(
 32        RotationalInterval interval,
 33        int processedNodeCount,
 34        bool hasWitness,
 35        Fixed64 witnessTime,
 36        out Fixed64 safeTime,
 37        out Fixed64 contactTime,
 38        out bool retainsWitness)
 39    {
 1196840        bool nodeBudgetExhausted = processedNodeCount >= RotationalIntervalNodeBudget;
 1196841        if (!nodeBudgetExhausted && interval.Depth < RotationalIntervalMaxDepth)
 42        {
 1126443            safeTime = default;
 1126444            contactTime = default;
 1126445            retainsWitness = false;
 1126446            return false;
 47        }
 48
 70449        retainsWitness = hasWitness;
 70450        contactTime = hasWitness ? witnessTime : interval.LowerTime;
 51        // Max depth defines the accepted temporal resolution, so its same-target
 52        // witness may resolve this leaf only when it brackets the leaf itself. A
 53        // global witness from a later interval cannot certify the unresolved gap.
 54        // Hard node-budget exhaustion has no convergence guarantee either.
 70455        bool witnessIsBracketed = hasWitness
 70456            && witnessTime >= interval.LowerTime
 70457            && witnessTime <= interval.UpperTime;
 70458        safeTime = witnessIsBracketed && !nodeBudgetExhausted
 70459            ? witnessTime
 70460            : interval.LowerTime;
 70461        return true;
 62    }
 63
 64    public static bool ShouldContinueRotationalArbiter(
 65        Vector2d displacement,
 66        Fixed64 angularDistance) =>
 367        angularDistance > Fixed64.Epsilon
 368        || displacement.MagnitudeSquared > Fixed64.Epsilon;
 69
 70    public static bool TryResolveRotationalIntervalMotionBound(
 71        Vector2d displacement,
 72        Fixed64 angularDistance,
 73        Fixed64 pivotRadius,
 74        Fixed64 intervalSpan,
 75        out Fixed64 motionBound)
 76    {
 1374777        Vector2d halfIntervalDisplacement = displacement * (intervalSpan * Fixed64.Half);
 1374778        bool linearResolved = Vector2d.TryGetMagnitude(
 1374779            halfIntervalDisplacement,
 1374780            out Fixed64 linearMotion);
 1374781        bool angularResolved = Fixed64.TryMultiplyDivide(
 1374782            angularDistance,
 1374783            pivotRadius,
 1374784            intervalSpan,
 1374785            Fixed64.Two,
 1374786            out Fixed64 angularMotion);
 1374787        bool poseResolved = Fixed64.TryMultiplyDivide(
 1374788            pivotRadius,
 1374789            RotationalRelativeUncertainty,
 1374790            Fixed64.One,
 1374791            out Fixed64 poseUncertainty);
 1374792        bool combined = Fixed64.TryAdd(linearMotion, angularMotion, out motionBound)
 1374793            & Fixed64.TryAdd(motionBound, poseUncertainty, out motionBound)
 1374794            & Fixed64.TryAdd(motionBound, RotationalMotionUncertainty, out motionBound);
 1374795        if (!(linearResolved & angularResolved & poseResolved & combined))
 96        {
 297            motionBound = default;
 298            return false;
 99        }
 100
 13745101        return true;
 102    }
 103
 104    public static bool TryResolveRotationalIntervalMotionBound(
 105        Vector3d displacement,
 106        Fixed64 angularDistance,
 107        Fixed64 pivotRadius,
 108        Fixed64 intervalSpan,
 109        out Fixed64 motionBound)
 110    {
 16481111        Vector3d halfIntervalDisplacement = displacement * (intervalSpan * Fixed64.Half);
 16481112        bool linearResolved = Vector3d.TryGetMagnitude(
 16481113            halfIntervalDisplacement,
 16481114            out Fixed64 linearMotion);
 16481115        bool angularResolved = Fixed64.TryMultiplyDivide(
 16481116            angularDistance,
 16481117            pivotRadius,
 16481118            intervalSpan,
 16481119            Fixed64.Two,
 16481120            out Fixed64 angularMotion);
 16481121        bool poseResolved = Fixed64.TryMultiplyDivide(
 16481122            pivotRadius,
 16481123            RotationalRelativeUncertainty,
 16481124            Fixed64.One,
 16481125            out Fixed64 poseUncertainty);
 16481126        bool combined = Fixed64.TryAdd(linearMotion, angularMotion, out motionBound)
 16481127            & Fixed64.TryAdd(motionBound, poseUncertainty, out motionBound)
 16481128            & Fixed64.TryAdd(motionBound, RotationalMotionUncertainty, out motionBound);
 16481129        if (!(linearResolved & angularResolved & poseResolved & combined))
 130        {
 2131            motionBound = default;
 2132            return false;
 133        }
 134
 16479135        return true;
 136    }
 137
 138    public static bool AreBoundsSeparatedByMoreThan(
 139        FixedBoundArea source,
 140        FixedBoundArea target,
 141        Fixed64 motionBound) =>
 610142        IsAxisGapGreaterThan(source.Min.X, source.Max.X, target.Min.X, target.Max.X, motionBound)
 610143        | IsAxisGapGreaterThan(source.Min.Y, source.Max.Y, target.Min.Y, target.Max.Y, motionBound);
 144
 145    public static bool AreBoundsSeparatedByMoreThan(
 146        FixedBoundBox source,
 147        FixedBoundBox target,
 148        Fixed64 motionBound) =>
 12089149        IsAxisGapGreaterThan(source.Min.X, source.Max.X, target.Min.X, target.Max.X, motionBound)
 12089150        | IsAxisGapGreaterThan(source.Min.Y, source.Max.Y, target.Min.Y, target.Max.Y, motionBound)
 12089151        | IsAxisGapGreaterThan(source.Min.Z, source.Max.Z, target.Min.Z, target.Max.Z, motionBound);
 152
 153    public static bool TrySubtractClosestFeatureUncertainty(
 154        Fixed64 separationGap,
 155        Fixed64 characteristicScale,
 156        out Fixed64 conservativeGap)
 157    {
 6905158        bool inputValid = separationGap > Fixed64.Zero
 6905159            & characteristicScale >= Fixed64.Zero;
 6905160        bool scaled = Fixed64.TryMultiplyDivide(
 6905161            characteristicScale,
 6905162            ClosestFeatureRelativeUncertainty,
 6905163            Fixed64.One,
 6905164            out Fixed64 scaledUncertainty);
 6905165        bool combined = Fixed64.TryAdd(
 6905166            scaledUncertainty,
 6905167            RotationalMotionUncertainty,
 6905168            out Fixed64 uncertainty);
 6905169        bool subtracted = Fixed64.TrySubtract(
 6905170            separationGap,
 6905171            uncertainty,
 6905172            out conservativeGap);
 6905173        if (!(inputValid & scaled & combined & subtracted))
 174        {
 1535175            conservativeGap = default;
 1535176            return false;
 177        }
 178
 5370179        return conservativeGap > Fixed64.Zero;
 180    }
 181
 182    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 183    private static bool IsAxisGapGreaterThan(
 184        Fixed64 sourceMin,
 185        Fixed64 sourceMax,
 186        Fixed64 targetMin,
 187        Fixed64 targetMax,
 188        Fixed64 motionBound)
 189    {
 37487190        if (sourceMax < targetMin)
 6101191            return !Fixed64.TrySubtract(targetMin, sourceMax, out Fixed64 gap)
 6101192                | gap > motionBound;
 193
 31386194        return targetMax < sourceMin
 31386195            & (!Fixed64.TrySubtract(sourceMin, targetMax, out Fixed64 reverseGap)
 31386196                | reverseGap > motionBound);
 197    }
 198
 199    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 200    public static bool IsWithinProxyRadius(
 201        Vector3d displacement,
 202        Fixed64 displacementMagnitudeSquared,
 203        Fixed64 proxyRadius)
 204    {
 16205        Fixed64 proxyRadiusSquared = proxyRadius * proxyRadius;
 16206        if (displacementMagnitudeSquared != Fixed64.MaxValue || proxyRadiusSquared != Fixed64.MaxValue)
 13207            return displacementMagnitudeSquared <= proxyRadiusSquared;
 208
 3209        return Vector3d.TryGetMagnitude(displacement, out Fixed64 displacementMagnitude)
 3210            && displacementMagnitude <= proxyRadius;
 211    }
 212
 213    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 214    public static bool IsWithinProxyRadius(
 215        Vector2d displacement,
 216        Fixed64 displacementMagnitudeSquared,
 217        Fixed64 proxyRadius)
 218    {
 13219        Fixed64 proxyRadiusSquared = proxyRadius * proxyRadius;
 13220        if (displacementMagnitudeSquared != Fixed64.MaxValue || proxyRadiusSquared != Fixed64.MaxValue)
 9221            return displacementMagnitudeSquared <= proxyRadiusSquared;
 222
 4223        return Vector2d.TryGetMagnitude(displacement, out Fixed64 displacementMagnitude)
 4224            && displacementMagnitude <= proxyRadius;
 225    }
 226
 227    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 228    public static Vector3d ResolveContactPointOnTarget(
 229        Vector3d sourceCenter,
 230        Vector3d targetCenter,
 231        Vector3d normalForSource,
 232        Fixed64 targetRadius)
 233    {
 5234        if (normalForSource.MagnitudeSquared > Fixed64.Epsilon)
 3235            return targetCenter + normalForSource * targetRadius;
 236
 2237        Vector3d fallback = sourceCenter - targetCenter;
 2238        return fallback.MagnitudeSquared > Fixed64.Epsilon
 2239            ? targetCenter + fallback.Normalized * targetRadius
 2240            : targetCenter;
 241    }
 242
 243    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 244    public static bool ShouldReplaceContinuousCollisionHit(
 245        Fixed64 candidateSafeTime,
 246        int candidateTargetId,
 247        bool hasCurrent,
 248        Fixed64 currentSafeTime,
 249        int currentTargetId)
 250    {
 680251        if (!hasCurrent)
 656252            return true;
 253
 24254        int timeCompare = candidateSafeTime.CompareTo(currentSafeTime);
 24255        if (timeCompare != 0)
 17256            return timeCompare < 0;
 257
 7258        return candidateTargetId < currentTargetId;
 259    }
 260
 261    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 262    public static void ClipTranslationalTrajectoryInterval(
 263        Fixed64 queryStart,
 264        Fixed64 segmentStart,
 265        Fixed64 segmentEnd,
 266        out Fixed64 overlapStart,
 267        out Fixed64 overlapEnd,
 268        out Fixed64 sourceStartTime,
 269        out Fixed64 sourceEndTime)
 270    {
 606271        overlapStart = FixedMath.Max(queryStart, segmentStart);
 606272        overlapEnd = segmentEnd;
 606273        Fixed64 querySpan = Fixed64.One - queryStart;
 606274        sourceStartTime = FixedMath.Clamp01((overlapStart - queryStart) / querySpan);
 606275        sourceEndTime = FixedMath.Clamp01((overlapEnd - queryStart) / querySpan);
 606276    }
 277
 278    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 279    public static bool IsSupersededTranslationalBoundaryHit(
 280        bool hitAtSegmentEnd,
 281        Fixed64 overlapEnd,
 282        int segmentIndex,
 283        int segmentCount,
 284        Fixed64 successorStart) =>
 596285        hitAtSegmentEnd
 596286        && overlapEnd < Fixed64.One
 596287        && segmentIndex + 1 < segmentCount
 596288        && successorStart == overlapEnd;
 289
 290    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 291    public static bool TryNormalizeTranslationalClosingSpeed(
 292        Fixed64 localClosingSpeed,
 293        Fixed64 sourceIntervalSpan,
 294        out Fixed64 closingSpeed)
 295    {
 416296        if (localClosingSpeed <= Fixed64.Epsilon
 416297            || sourceIntervalSpan <= Fixed64.Zero)
 298        {
 5299            closingSpeed = Fixed64.Zero;
 5300            return false;
 301        }
 302
 411303        closingSpeed = localClosingSpeed / sourceIntervalSpan;
 411304        return true;
 305    }
 306
 307    public static bool TryGetRelativeSphereOverlapDistanceInterval(
 308        Vector3d sourceStart,
 309        Vector3d sourceDisplacement,
 310        Fixed64 sourceRadius,
 311        Vector3d targetStart,
 312        Vector3d targetDisplacement,
 313        Fixed64 targetRadius,
 314        out Fixed64 entryDistance,
 315        out Fixed64 exitDistance,
 316        out Vector3d relativeDisplacement,
 317        out Fixed64 relativeLength,
 318        out Vector3d normalForSource,
 319        out Fixed64 closingSpeed)
 320    {
 324321        entryDistance = Fixed64.Zero;
 324322        exitDistance = Fixed64.Zero;
 324323        relativeDisplacement = Vector3d.Zero;
 324324        normalForSource = Vector3d.Zero;
 324325        closingSpeed = Fixed64.Zero;
 326
 324327        relativeDisplacement = ContinuousCollisionSweepRange.ValidateRelativeDisplacement(
 324328            sourceDisplacement,
 324329            targetDisplacement,
 324330            out relativeLength);
 323331        Vector3d sourceEnd = GetSweepEnd(sourceStart, sourceDisplacement);
 321332        Vector3d targetEnd = GetSweepEnd(targetStart, targetDisplacement);
 321333        if (relativeDisplacement.MagnitudeSquared <= Fixed64.Epsilon
 321334            || !HasUsableCombinedRadius(sourceRadius, targetRadius))
 335        {
 9336            return false;
 337        }
 338
 312339        if (!WideFiniteAxisIntersection.TryGetSphereDirectionDistanceInterval(
 312340                sourceStart,
 312341                relativeDisplacement,
 312342                new FixedBoundSphere(targetStart, targetRadius),
 312343                sourceRadius,
 312344                relativeLength,
 312345                out entryDistance,
 312346                out exitDistance))
 347        {
 17348            return false;
 349        }
 350
 295351        Vector3d sourceImpact = new FixedSegment(sourceStart, sourceEnd)
 295352            .GetPointAtDistance(entryDistance, relativeLength);
 295353        Vector3d targetImpact = new FixedSegment(targetStart, targetEnd)
 295354            .GetPointAtDistance(entryDistance, relativeLength);
 295355        normalForSource = ResolveNormal(targetImpact, sourceImpact, relativeDisplacement);
 295356        closingSpeed = -Vector3d.Dot(relativeDisplacement, normalForSource);
 295357        return true;
 358    }
 359
 360    public static bool TryGetRelativeCircleOverlapDistanceInterval(
 361        Vector2d sourceStart,
 362        Vector2d sourceDisplacement,
 363        Fixed64 sourceRadius,
 364        Vector2d targetStart,
 365        Vector2d targetDisplacement,
 366        Fixed64 targetRadius,
 367        out Fixed64 entryDistance,
 368        out Fixed64 exitDistance,
 369        out Vector2d relativeDisplacement,
 370        out Fixed64 relativeLength,
 371        out Vector2d normalForSource,
 372        out Fixed64 closingSpeed)
 373    {
 319374        entryDistance = Fixed64.Zero;
 319375        exitDistance = Fixed64.Zero;
 319376        relativeDisplacement = Vector2d.Zero;
 319377        normalForSource = Vector2d.Zero;
 319378        closingSpeed = Fixed64.Zero;
 379
 319380        relativeDisplacement = ContinuousCollisionSweepRange.ValidateRelativeDisplacement(
 319381            sourceDisplacement,
 319382            targetDisplacement,
 319383            out relativeLength);
 318384        Vector2d sourceEnd = GetSweepEnd(sourceStart, sourceDisplacement);
 316385        Vector2d targetEnd = GetSweepEnd(targetStart, targetDisplacement);
 316386        if (relativeDisplacement.MagnitudeSquared <= Fixed64.Epsilon
 316387            || !HasUsableCombinedRadius(sourceRadius, targetRadius))
 388        {
 5389            return false;
 390        }
 391
 311392        if (!WideFiniteAxisIntersection.TryGetCircleDirectionDistanceInterval(
 311393                sourceStart,
 311394                relativeDisplacement,
 311395                new FixedBoundCircle(targetStart, targetRadius),
 311396                sourceRadius,
 311397                relativeLength,
 311398                out entryDistance,
 311399                out exitDistance))
 400        {
 22401            return false;
 402        }
 403
 289404        Vector2d sourceImpact = new FixedSegment2d(sourceStart, sourceEnd)
 289405            .GetPointAtDistance(entryDistance, relativeLength);
 289406        Vector2d targetImpact = new FixedSegment2d(targetStart, targetEnd)
 289407            .GetPointAtDistance(entryDistance, relativeLength);
 289408        normalForSource = ResolveNormal(targetImpact, sourceImpact, relativeDisplacement);
 289409        closingSpeed = -Vector2d.Dot(relativeDisplacement, normalForSource);
 289410        return true;
 411    }
 412
 413    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 414    private static bool HasUsableCombinedRadius(Fixed64 sourceRadius, Fixed64 targetRadius)
 415    {
 624416        if (sourceRadius > Fixed64.Epsilon || targetRadius > Fixed64.Epsilon)
 623417            return true;
 418
 1419        return sourceRadius + targetRadius > Fixed64.Epsilon;
 420    }
 421
 422    private static Vector3d GetSweepEnd(
 423        Vector3d start,
 424        Vector3d displacement)
 425    {
 644426        if (!Vector3d.TryAdd(start, displacement, out Vector3d end))
 2427            throw new System.ArgumentOutOfRangeException(nameof(displacement), "Continuous collision endpoint is outside
 428
 642429        return end;
 430    }
 431
 432    private static Vector2d GetSweepEnd(
 433        Vector2d start,
 434        Vector2d displacement)
 435    {
 634436        if (!Vector2d.TryAdd(start, displacement, out Vector2d end))
 2437            throw new System.ArgumentOutOfRangeException(nameof(displacement), "Continuous collision endpoint is outside
 438
 632439        return end;
 440    }
 441
 442    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 443    private static Vector3d ResolveNormal(
 444        Vector3d targetPosition,
 445        Vector3d sourcePosition,
 446        Vector3d relativeDisplacement)
 447    {
 295448        Vector3d normal = Vector3d.GetDirection(targetPosition, sourcePosition);
 295449        return normal != Vector3d.Zero ? normal : -relativeDisplacement.Normalized;
 450    }
 451
 452    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 453    private static Vector2d ResolveNormal(
 454        Vector2d targetPosition,
 455        Vector2d sourcePosition,
 456        Vector2d relativeDisplacement)
 457    {
 289458        Vector2d normal = Vector2d.GetDirection(targetPosition, sourcePosition);
 289459        return normal != Vector2d.Zero ? normal : -relativeDisplacement.Normalized;
 460    }
 461}

Methods/Properties

.cctor()
TryResolveRotationalSearchLimit(Gravitas.CollisionHandling.RotationalInterval,System.Int32,System.Boolean,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64&,FixedMathSharp.Fixed64&,System.Boolean&)
ShouldContinueRotationalArbiter(FixedMathSharp.Vector2d,FixedMathSharp.Fixed64)
TryResolveRotationalIntervalMotionBound(FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64&)
TryResolveRotationalIntervalMotionBound(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64&)
AreBoundsSeparatedByMoreThan(FixedMathSharp.Geometry.FixedBoundArea,FixedMathSharp.Geometry.FixedBoundArea,FixedMathSharp.Fixed64)
AreBoundsSeparatedByMoreThan(FixedMathSharp.Geometry.FixedBoundBox,FixedMathSharp.Geometry.FixedBoundBox,FixedMathSharp.Fixed64)
TrySubtractClosestFeatureUncertainty(FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64&)
IsAxisGapGreaterThan(FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64)
IsWithinProxyRadius(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64)
IsWithinProxyRadius(FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64)
ResolveContactPointOnTarget(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64)
ShouldReplaceContinuousCollisionHit(FixedMathSharp.Fixed64,System.Int32,System.Boolean,FixedMathSharp.Fixed64,System.Int32)
ClipTranslationalTrajectoryInterval(FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64&,FixedMathSharp.Fixed64&,FixedMathSharp.Fixed64&,FixedMathSharp.Fixed64&)
IsSupersededTranslationalBoundaryHit(System.Boolean,FixedMathSharp.Fixed64,System.Int32,System.Int32,FixedMathSharp.Fixed64)
TryNormalizeTranslationalClosingSpeed(FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64&)
TryGetRelativeSphereOverlapDistanceInterval(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64&,FixedMathSharp.Fixed64&,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&)
TryGetRelativeCircleOverlapDistanceInterval(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64&,FixedMathSharp.Fixed64&,FixedMathSharp.Vector2d&,FixedMathSharp.Fixed64&,FixedMathSharp.Vector2d&,FixedMathSharp.Fixed64&)
HasUsableCombinedRadius(FixedMathSharp.Fixed64,FixedMathSharp.Fixed64)
GetSweepEnd(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d)
GetSweepEnd(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d)
ResolveNormal(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d)
ResolveNormal(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d)